Fix data_type_identifier to_h

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

@@ -177,11 +177,13 @@ def self.from_hash(config)
 
     DataTypeIdentifier.class_eval do
       def to_h
-        {
-          data_type_identifier: self.data_type_identifier,
-          generic_type: self.generic_type ? self.generic_type.to_h : nil,
-          generic_key: self.generic_key,
-        }
+        if !self.data_type_identifier.empty?
+          return { data_type_identifier: self.data_type_identifier }
+        elsif !self.generic_type.nil?
+          return { generic_type: self.generic_type.to_h }
+        elsif !self.generic_key.nil?
+          return { generic_key: self.generic_key }
+        end
       end
 
       def from_hash(config)
@@ -210,18 +212,18 @@ def self.from_hash(config)
     GenericType.class_eval do
       def to_h
         {
-          data_type_identifier: self.data_type_identifier.to_h,
-          generic_mapper: self.generic_mapper ? self.generic_mapper.to_h : nil,
+          data_type_identifier: self.data_type_identifier,
+          generic_mappers: self.generic_mappers.map(&:to_h),
         }
       end
 
       def from_hash(config)
         if config.key?(:data_type_identifier)
-          self.data_type_identifier = DataTypeIdentifier.from_hash(config.fetch(:data_type_identifier))
+          self.data_type_identifier = config.fetch(:data_type_identifier)
         end
 
-        if config.key?(:generic_mapper)
-          self.generic_mapper = GenericMapper.from_hash(config.fetch(:generic_mapper))
+        if config.key?(:generic_mappers)
+          self.generic_mappers = config.fetch(:generic_mappers).map { |mapper_config| GenericMapper.from_hash(mapper_config) }
         end
 
         self
@@ -235,24 +237,17 @@ def self.from_hash(config)
     GenericMapper.class_eval do
       def to_h
         {
-          data_type_identifier: self.data_type_identifier.to_h,
-          generic_key: self.generic_key,
-          source: self.source,
+          target: self.target,
+          source: self.source.to_h,
+          generic_combinations: self.generic_combinations.map(&:to_h),
         }
       end
 
       def from_hash(config)
-        if config.keys.intersection([:data_type_identifier, :generic_key]).count > 1
-          raise UnexpectedType, "Cannot have more than one type"
-        end
-
-        if config.key?(:data_type_identifier)
-          self.data_type_identifier = DataTypeIdentifier.from_hash(config.fetch(:data_type_identifier))
-        elsif config.key?(:generic_key)
-          self.generic_key = config.fetch(:generic_key)
-        end
-
-        self.source = config[:source]
+        self.target = config[:target]
+        self.source = DataTypeIdentifier.from_hash(config.fetch(:source))
+        self.generic_combinations = config.fetch(:generic_combinations, [])
+        self
       end
 
       def self.from_hash(config)

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

@@ -4,6 +4,39 @@
 
 RSpec.describe Tucana::Shared::DefinitionDataTypeRule do
   describe "#create" do
+    context 'DataTypeIdentifier#to_h' do
+      context 'generic_key' do
+        it do
+          expect(Tucana::Shared::DataTypeIdentifier.new(generic_key: 'T').to_h)
+            .to eq({ generic_key: 'T' })
+        end
+      end
+      context 'identifier' do
+        it do
+          expect(Tucana::Shared::DataTypeIdentifier.new(data_type_identifier: 'MyType').to_h)
+            .to eq({ data_type_identifier: 'MyType' })
+        end
+      end
+      context 'generic_type' do
+        it do
+          generic_type = Tucana::Shared::GenericType.new(
+            data_type_identifier: 'some_identifier',
+            generic_mappers: []
+          )
+
+          data_type_identifier = Tucana::Shared::DataTypeIdentifier.new(generic_type: generic_type)
+
+          expect(data_type_identifier.to_h)
+            .to eq({
+                     generic_type: {
+                       data_type_identifier: 'some_identifier',
+                       generic_mappers: []
+                     }
+                   })
+        end
+      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" } }