Remove definition and execution rule separation in ruby helpers

Author: Taucher2003

build/ruby/lib/tucana/shared/shared.data_type.rb

@@ -36,21 +36,21 @@ def rule_config
       def create(variant, config)
         case variant
         when :contains_key
-          self.contains_key = DefinitionDataTypeContainsKeyRuleConfig.new(config)
+          self.contains_key = DataTypeContainsKeyRuleConfig.new(config)
         when :contains_type
-          self.contains_type = DefinitionDataTypeContainsTypeRuleConfig.new(config)
+          self.contains_type = DataTypeContainsTypeRuleConfig.new(config)
         when :item_of_collection
           self.item_of_collection = DataTypeItemOfCollectionRuleConfig.from_hash(config)
         when :number_range
           self.number_range = DataTypeNumberRangeRuleConfig.new(config)
         when :regex
           self.regex = DataTypeRegexRuleConfig.new(config)
         when :input_types
-          self.input_types = DefinitionDataTypeInputTypesRuleConfig.new(config)
+          self.input_types = DataTypeInputTypesRuleConfig.new(config)
         when :return_type
-          self.return_type = DefinitionDataTypeReturnTypeRuleConfig.new(config)
+          self.return_type = DataTypeReturnTypeRuleConfig.new(config)
         when :parent_type
-          self.parent_type = DefinitionDataTypeParentTypeRuleConfig.from_hash(config)
+          self.parent_type = DataTypeParentTypeRuleConfig.from_hash(config)
         else
           raise UnexpectedRuleType, "Unknown rule type #{variant}"
         end
@@ -63,7 +63,7 @@ def self.create(variant, config)
       end
     end
 
-    DefinitionDataTypeContainsKeyRuleConfig.class_eval do
+    DataTypeContainsKeyRuleConfig.class_eval do
       def to_h
         {
           key: self.key,
@@ -79,7 +79,7 @@ def self.from_hash(config)
       end
     end
 
-    DefinitionDataTypeContainsTypeRuleConfig.class_eval do
+    DataTypeContainsTypeRuleConfig.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier.to_h,
@@ -121,7 +121,7 @@ def to_h
       end
     end
 
-    DefinitionDataTypeInputTypesRuleConfig.class_eval do
+    DataTypeInputTypesRuleConfig.class_eval do
       def to_h
         {
           input_types: self.input_types.map { |input_type| input_type.to_h }
@@ -135,7 +135,7 @@ def self.from_hash(hash)
       end
     end
 
-    DefinitionDataTypeInputTypesRuleConfig::DataTypeInputType.class_eval do
+    DataTypeInputTypesRuleConfig::DataTypeInputType.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier,
@@ -151,7 +151,7 @@ def self.from_hash(config)
       end
     end
 
-    DefinitionDataTypeReturnTypeRuleConfig.class_eval do
+    DataTypeReturnTypeRuleConfig.class_eval do
       def to_h
         {
           data_type_identifier: self.data_type_identifier,
@@ -163,7 +163,7 @@ def self.from_hash(config)
       end
     end
 
-    DefinitionDataTypeParentTypeRuleConfig.class_eval do
+    DataTypeParentTypeRuleConfig.class_eval do
       def to_h
         {
           parent_type: self.parent_type,

build/ruby/spec/tucana/shared/shared.data_type_spec.rb

@@ -72,15 +72,15 @@
       it 'sets the contains_key field' do
         config = { key: 'test_key', data_type_identifier: { data_type_identifier: 'test_type' } }
         rule = described_class.create(:contains_key, config)
-        expect(rule.contains_key).to be_a(Tucana::Shared::DefinitionDataTypeContainsKeyRuleConfig)
+        expect(rule.contains_key).to be_a(Tucana::Shared::DataTypeContainsKeyRuleConfig)
       end
     end
 
     context 'with :contains_type variant' do
       it 'sets the contains_type field' do
         config = { data_type_identifier: { data_type_identifier: 'test_type' } }
         rule = described_class.create(:contains_type, config)
-        expect(rule.contains_type).to be_a(Tucana::Shared::DefinitionDataTypeContainsTypeRuleConfig)
+        expect(rule.contains_type).to be_a(Tucana::Shared::DataTypeContainsTypeRuleConfig)
       end
     end
 
@@ -113,23 +113,23 @@
         config = { input_types: [{ data_type_identifier: { data_type_identifier: 'test_type' },
                                    input_identifier: 'test_input' }] }
         rule = described_class.create(:input_types, config)
-        expect(rule.input_types).to be_a(Tucana::Shared::DefinitionDataTypeInputTypesRuleConfig)
+        expect(rule.input_types).to be_a(Tucana::Shared::DataTypeInputTypesRuleConfig)
       end
     end
 
     context 'with :return_type variant' do
       it 'sets the return_type field' do
         config = { data_type_identifier: { data_type_identifier: 'test_type' } }
         rule = described_class.create(:return_type, config)
-        expect(rule.return_type).to be_a(Tucana::Shared::DefinitionDataTypeReturnTypeRuleConfig)
+        expect(rule.return_type).to be_a(Tucana::Shared::DataTypeReturnTypeRuleConfig)
       end
     end
 
     context 'with :parent_type variant' do
       it 'sets the parent_type field' do
         config = { parent_type: { data_type_identifier: 'test_type' } }
         rule = described_class.create(:parent_type, config)
-        expect(rule.parent_type).to be_a(Tucana::Shared::DefinitionDataTypeParentTypeRuleConfig)
+        expect(rule.parent_type).to be_a(Tucana::Shared::DataTypeParentTypeRuleConfig)
       end
     end