Merge pull request #167 from code0-tech/fix-generic-mappers

Fix GenericType and add some specs

Author: raphael-goetz

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

@@ -223,7 +223,10 @@ def from_hash(config)
         end
 
         if config.key?(:generic_mappers)
-          self.generic_mappers = config.fetch(:generic_mappers).map { |mapper_config| GenericMapper.from_hash(mapper_config) }
+          self.generic_mappers.clear
+          config[:generic_mappers].each do |mapper_config|
+            self.generic_mappers << GenericMapper.from_hash(mapper_config)
+          end
         end
 
         self
@@ -245,8 +248,11 @@ def to_h
 
       def from_hash(config)
         self.target = config[:target]
-        self.source = config[:source].map do |source|
-          DataTypeIdentifier.from_hash(source)
+        if config.key?(:source)
+          self.source.clear
+          config[:source].each do |source|
+            self.source << DataTypeIdentifier.from_hash(source)
+          end
         end
 
         if config.key?(:generic_combinations)

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

@@ -3,7 +3,38 @@
 Tucana.load_protocol(:shared)
 
 RSpec.describe Tucana::Shared::DefinitionDataTypeRule do
-  describe "#create" do
+  describe '#from_hash' do
+    context 'GenericType#from_hash' do
+      it do
+        generic_type = Tucana::Shared::GenericType.new.from_hash({
+          data_type_identifier: 'SomeIdentifier',
+          generic_mappers: [
+             {
+            source: [{ data_type_identifier: 'SomeType' }],
+            target: 'T',
+            generic_combinations: [:AND]
+          }
+          ]
+        })
+
+        expect(generic_type).not_to be_nil
+      end
+    end
+    context 'GenericMapper#from_hash' do
+      context 'when type is :map_to_generic_type' do
+        it do
+          generic_mapper = Tucana::Shared::GenericMapper.new.from_hash({
+            source: [{ data_type_identifier: 'SomeType' }],
+            target: 'T',
+            generic_combinations: [:AND]
+          })
+
+          expect(generic_mapper.to_s).to eq("<Tucana::Shared::GenericMapper: source: [<Tucana::Shared::DataTypeIdentifier: data_type_identifier: \"SomeType\">], target: \"T\", generic_combinations: [:AND]>")
+        end
+      end
+    end
+  end
+  describe '#create' do
     context 'DataTypeIdentifier#to_h' do
       context 'generic_key' do
         it do
@@ -37,75 +68,76 @@
       end
     end
 
-    context "with :contains_key variant" do
-      it "sets the contains_key field" do
-        config = { key: "test_key", data_type_identifier: { data_type_identifier: "test_type" } }
+    context 'with :contains_key variant' do
+      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)
       end
     end
 
-    context "with :contains_type variant" do
-      it "sets the contains_type field" do
-        config = { data_type_identifier: { data_type_identifier: "test_type" } }
+    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)
       end
     end
 
-    context "with :item_of_collection variant" do
-      it "sets the item_of_collection field" do
+    context 'with :item_of_collection variant' do
+      it 'sets the item_of_collection field' do
         config = { items: %w[item1 item2] }
         rule = described_class.create(:item_of_collection, config)
         expect(rule.item_of_collection).to be_a(Tucana::Shared::DataTypeItemOfCollectionRuleConfig)
       end
     end
 
-    context "with :number_range variant" do
-      it "sets the number_range field" do
+    context 'with :number_range variant' do
+      it 'sets the number_range field' do
         config = { from: 1, to: 10 }
         rule = described_class.create(:number_range, config)
         expect(rule.number_range).to be_a(Tucana::Shared::DataTypeNumberRangeRuleConfig)
       end
     end
 
-    context "with :regex variant" do
-      it "sets the regex field" do
-        config = { pattern: "\\d+" }
+    context 'with :regex variant' do
+      it 'sets the regex field' do
+        config = { pattern: '\\d+' }
         rule = described_class.create(:regex, config)
         expect(rule.regex).to be_a(Tucana::Shared::DataTypeRegexRuleConfig)
       end
     end
 
-    context "with :input_types variant" do
-      it "sets the input_types field" do
-        config = { input_types: [{ data_type_identifier: { data_type_identifier: "test_type" }, input_identifier: "test_input" }] }
+    context 'with :input_types variant' do
+      it 'sets the input_types field' do
+        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)
       end
     end
 
-    context "with :return_type variant" do
-      it "sets the return_type field" do
-        config = { data_type_identifier: { data_type_identifier: "test_type" } }
+    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)
       end
     end
 
-    context "with :parent_type variant" do
-      it "sets the parent_type field" do
-        config = { parent_type: { data_type_identifier: "test_type" } }
+    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)
       end
     end
 
-    context "with unknown variant" do
-      it "raises UnexpectedRuleType error" do
-        expect {
+    context 'with unknown variant' do
+      it 'raises UnexpectedRuleType error' do
+        expect do
           described_class.create(:unknown, {})
-        }.to raise_error(Tucana::Shared::UnexpectedRuleType, "Unknown rule type unknown")
+        end.to raise_error(Tucana::Shared::UnexpectedRuleType, 'Unknown rule type unknown')
       end
     end
   end