datory 1.0.0.rc11 → 1.0.0.rc13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef2274984450ba2915867f37000b443ffd18a51eeb497adecaaaeae7d0821ae
-  data.tar.gz: ddab73410ef68b0a65f02ed24f9e7177ea43f6779015aa9f5208d4583f8f2882
+  metadata.gz: ad1cc00d4916767ce4e99d5cd52cde2f9640c4ea536f602e0ade8e5008b61820
+  data.tar.gz: 012e57a2c905b6de960fb1cd32e1719f1f876c630cc77b37ea7e8ee31427dae8
 SHA512:
-  metadata.gz: 0c794e11db75f222df975ddf31d0e0c9ff2c37ed7dc33e9c6707a5addfd53c12265f45b8808a3c5d7eebbf426674ccf8442bc3f74ec367ee4f67467ed8e0ea51
-  data.tar.gz: 235ed83fe57e9db74fb93803e83820ecba0aea31a673ede0ae6b485a8d4c219394cf1cd0ceb04efd06048e554039105a05538fda8eb520404f9eaf7bb904c1fd
+  metadata.gz: 271166881cb4e4e5b673d05ed180b2a09e0523aab2739d9c8127894981b34d5d37486a74aaa029524f13dbb03206dbf924c96f7983f28a985738e41ae96b64f2
+  data.tar.gz: 0b5a6b6cbbf3db6f505ebf629ff33e2bd57f72d7840295cc35660fcba5f8ee497db538fb699b75a8db2676f6064bc67aa0533c78049dd958cb1a1e0573b6e559

data/README.md

@@ -44,7 +44,7 @@ class UserDto < Datory::Base
   string :phone
   string :website
 
-  string :birthDate, to: :birth_date, as: Date
+  date :birthDate, to: :birth_date
 
   one :login, include: UserLoginDto
   one :company, include: UserCompanyDto
@@ -62,16 +62,139 @@ class UserLoginDto < Datory::Base
   
   string :md5
   string :sha1
+
+  duration :lifetime
   
-  string :registered_at, as: DateTime
+  datetime :registered_at
 end
 ```
 
+## Attribute declaration
+
+### Basic
+
+#### attribute
+
+```ruby
+attribute :firstname, from: String, to: :first_name, as: String
+```
+
+#### string
+
+```ruby
+string :first_name
+```
+
+#### integer
+
+```ruby
+integer :attempts, min: 1, max: 10
+```
+
+#### float
+
+```ruby
+float :interest_rate
+```
+
+### Helpers
+
+#### uuid
+
+It will also check that the value matches the UUID format.
+
+```ruby
+uuid :id
+```
+
+#### money
+
+It will prepare two attributes `*_cents` and `*_currency`.
+
+```ruby
+money :price
+```
+
+#### duration
+
+```ruby
+duration :lifetime
+```
+
+#### date
+
+```ruby
+date :birth_date
+```
+
+#### time
+
+```ruby
+time :registered_at
+```
+
+#### datetime
+
+```ruby
+datetime :registered_at
+```
+
+### Nesting
+
+#### one
+
+```ruby
+one :company, include: UserCompanyDto
+```
+
+#### many
+
+```ruby
+many :addresses, include: UserAddressDto
+```
+
+## Object information
+
+### Info
+
+```ruby
+UserDto.info
+```
+
+```
+#<Datory::Info::Result:0x000000011eecd7d0 @attributes={:id=>{:from=>{:name=>:id, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>:uuid}, :to=>{:name=>:id, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>:uuid, :required=>true, :include=>nil}}, :firstname=>{:from=>{:name=>:firstname, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:first_name, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :lastname=>{:from=>{:name=>:lastname, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:last_name, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :email=>{:from=>{:name=>:email, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:email, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :phone=>{:from=>{:name=>:phone, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:phone, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :website=>{:from=>{:name=>:website, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:website, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :birthDate=>{:from=>{:name=>:birthDate, :type=>String, :min=>nil, :max=>nil, :consists_of=>false, :format=>:date}, :to=>{:name=>:birth_date, :type=>Date, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>nil}}, :login=>{:from=>{:name=>:login, :type=>Hash, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:login, :type=>[Datory::Result, Hash], :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>Usual::Example1::UserLogin}}, :company=>{:from=>{:name=>:company, :type=>Hash, :min=>nil, :max=>nil, :consists_of=>false, :format=>nil}, :to=>{:name=>:company, :type=>[Datory::Result, Hash], :min=>nil, :max=>nil, :consists_of=>false, :format=>nil, :required=>true, :include=>Usual::Example1::UserCompany}}, :addresses=>{:from=>{:name=>:addresses, :type=>Array, :min=>nil, :max=>nil, :consists_of=>[Datory::Result, Hash], :format=>nil}, :to=>{:name=>:addresses, :type=>Array, :min=>nil, :max=>nil, :consists_of=>[Datory::Result, Hash], :format=>nil, :required=>true, :include=>Usual::Example1::UserAddress}}}>
+```
+
+### Describe
+
+```ruby
+UserDto.describe
+```
+
+```
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+|                                         UserDto                                         |
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+| Attribute | From   | To         | As                     | Include                      |
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+| id        | String | id         | String                 |                              |
+| firstname | String | first_name | String                 |                              |
+| lastname  | String | last_name  | String                 |                              |
+| email     | String | email      | String                 |                              |
+| phone     | String | phone      | String                 |                              |
+| website   | String | website    | String                 |                              |
+| birthDate | String | birth_date | Date                   |                              |
+| login     | Hash   | login      | [Datory::Result, Hash] | Usual::Example1::UserLogin   |
+| company   | Hash   | company    | [Datory::Result, Hash] | Usual::Example1::UserCompany |
+| addresses | Array  | addresses  | Array                  | Usual::Example1::UserAddress |
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
+
 ## Contributing
 
 This project is intended to be a safe, welcoming space for collaboration. 
 Contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct. 
-We recommend reading the [contributing guide](./website/docs/CONTRIBUTING.md) as well.
+We recommend reading the [contributing guide](./CONTRIBUTING.md) as well.
 
 ## License
 

data/lib/datory/attributes/attribute.rb

@@ -3,97 +3,104 @@
 module Datory
   module Attributes
     class Attribute
-      attr_reader :name, :options
+      attr_reader :from, :to
 
-      def initialize(name, **options)
-        @name = name
-        @options = options
+      def initialize(name, **options) # rubocop:disable Metrics/MethodLength
+        @from = Options::From.new(
+          name: name,
+          type: options.fetch(:from),
+          consists_of: options.fetch(:consists_of, false),
+          min: options.fetch(:min, nil),
+          max: options.fetch(:max, nil),
+          format: options.fetch(:format, nil)
+        )
+
+        @to = Options::To.new(
+          name: options.fetch(:to, name),
+          type: options.fetch(:as, @from.type),
+          # TODO: It is necessary to implement NilClass support for optional
+          required: options.fetch(:required, true),
+          consists_of: @from.consists_of,
+          min: @from.min,
+          max: @from.max,
+          format: options.fetch(:format, nil),
+          include_class: options.fetch(:include, nil)
+        )
       end
 
-      def input_serialization_options
+      ##########################################################################
+
+      def input_serialization_options # rubocop:disable Metrics/AbcSize
         hash = {
-          as: options.fetch(:to, name),
-          type: options.fetch(:as, options.fetch(:from)),
-          required: options.fetch(:required, true),
-          consists_of: options.fetch(:consists_of, false)
+          as: to.name,
+          type: to.type,
+          required: to.required,
+          consists_of: to.consists_of
         }
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        hash[:min] = to.min if to.min.present?
+
+        hash[:max] = to.max if to.max.present?
+
+        hash[:format] = to.format if to.format.present?
 
         hash
       end
 
-      def input_deserialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def output_serialization_options # rubocop:disable Metrics/AbcSize
         hash = {
-          as: options.fetch(:to, name),
-          type: options.fetch(:from),
-          required: options.fetch(:required, true),
-          consists_of: options.fetch(:consists_of, false),
-          prepare: (lambda do |value:|
-            include_class = options.fetch(:include, nil)
-            return value unless include_class.present?
+          consists_of: to.consists_of == Hash ? Datory::Result : from.consists_of,
+          type: to.type == Datory::Result ? Hash : from.type
+        }
 
-            from_type = options.fetch(:from, nil)
+        hash[:min] = from.min if from.min.present?
 
-            if [Set, Array].include?(from_type)
-              value.map { |item| include_class.deserialize(**item) }
-            else
-              include_class.deserialize(**value)
-            end
-          end)
-        }
+        hash[:max] = from.max if from.max.present?
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        hash[:format] = from.format if from.format.present?
 
         hash
       end
 
-      def output_serialization_options # rubocop:disable Metrics/MethodLength
+      ##########################################################################
+
+      def input_deserialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         hash = {
-          consists_of: if (consists_of_type = options.fetch(:consists_of, false)) == Hash
-                         Datory::Result
-                       else
-                         consists_of_type
-                       end,
-          type: if (as_type = options.fetch(:as, options.fetch(:from))) == Datory::Result
-                  Hash
-                elsif (from_type = options.fetch(:from)).present?
-                  from_type
-                else
-                  as_type
-                end
+          as: to.name,
+          type: from.type,
+          required: to.required,
+          consists_of: from.consists_of,
+          prepare: (lambda do |value:|
+            return value unless to.include_class.present?
+
+            if [Set, Array].include?(from.type)
+              value.map { |item| to.include_class.deserialize(**item) }
+            else
+              to.include_class.deserialize(**value)
+            end
+          end)
         }
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        hash[:min] = from.min if from.min.present?
+
+        hash[:max] = from.max if from.max.present?
+
+        hash[:format] = from.format if from.format.present?
 
         hash
       end
 
-      def output_deserialization_options # rubocop:disable Metrics/MethodLength
+      def output_deserialization_options # rubocop:disable Metrics/AbcSize
         hash = {
-          consists_of: if (consists_of_type = options.fetch(:consists_of, false)) == Hash
-                         Datory::Result
-                       else
-                         consists_of_type
-                       end,
-          type: if (from_type = options.fetch(:from)) == Hash
-                  Datory::Result
-                elsif (option_as = options.fetch(:as, nil)).present?
-                  option_as
-                else
-                  from_type
-                end
+          consists_of: from.consists_of == Hash ? Datory::Result : to.consists_of,
+          type: from.type == Hash ? Datory::Result : to.type
         }
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        hash[:min] = to.min if to.min.present?
+
+        hash[:max] = to.max if to.max.present?
+
+        hash[:format] = to.format if to.format.present?
 
         hash
       end

data/lib/datory/attributes/collection.rb

@@ -4,7 +4,7 @@ module Datory
   module Attributes
     class Collection
       extend Forwardable
-      def_delegators :@collection, :<<, :each, :map, :to_h, :merge
+      def_delegators :@collection, :<<, :each, :map, :filter, :to_h, :merge
 
       def initialize(collection = Set.new)
         @collection = collection
@@ -15,7 +15,21 @@ module Datory
       end
 
       def internal_names
-        map { |attribute| attribute.options.fetch(:to, attribute.name) }
+        map { |attribute| attribute.to.name }
+      end
+
+      def include_class_exist?
+        @include_class_exist ||= filter do |attribute| # rubocop:disable Performance/Count
+          include_class = attribute.to.include_class
+
+          next false if include_class.nil?
+
+          if [Set, Array].include?(include_class)
+            include_class.any? { |item| item <= Datory::Base }
+          else
+            include_class <= Datory::Base
+          end
+        end.size.positive?
       end
     end
   end

data/lib/datory/attributes/descriptor.rb

@@ -15,17 +15,18 @@ module Datory
         headings << "From"
         headings << "To"
         headings << "As"
+        headings << "Include" if collection_of_attributes.include_class_exist?
 
         collection_of_attributes.each do |attribute|
           row = []
 
-          row << attribute.name
+          include_class = attribute.to.include_class.presence || attribute.from.type
 
-          from_type = attribute.options.fetch(:from)
-
-          row << from_type
-          row << attribute.options.fetch(:to, attribute.name)
-          row << attribute.options.fetch(:as, attribute.options.fetch(:include, from_type))
+          row << attribute.from.name
+          row << attribute.from.type
+          row << attribute.to.name
+          row << attribute.to.type
+          row << (include_class if include_class <= Datory::Base) if collection_of_attributes.include_class_exist?
 
           rows << row
         end

data/lib/datory/attributes/deserialization/service_factory.rb

@@ -21,28 +21,12 @@ module Datory
           @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
         end
 
-        def create_service_class # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def create_service_class
           collection_of_attributes = @collection_of_attributes
 
           Class.new(Datory::Service::Builder) do
             collection_of_attributes.each do |attribute|
-              input_internal_name = attribute.options.fetch(:to, attribute.name)
-
-              input attribute.name, **attribute.input_deserialization_options
-
-              output input_internal_name, **attribute.output_deserialization_options
-
-              make :"assign_#{input_internal_name}_output"
-
-              define_method(:"assign_#{input_internal_name}_output") do
-                value = inputs.public_send(input_internal_name)
-
-                type_as = attribute.options.fetch(:as, nil)
-
-                value = Datory::Utils.transform_value_with(:d, value, type_as)
-
-                outputs.public_send(:"#{input_internal_name}=", value)
-              end
+              prepare_deserialization_data_for(attribute)
             end
           end
         end

data/lib/datory/attributes/dsl.rb

@@ -51,6 +51,34 @@ module Datory
           string(name, **options)
         end
 
+        def money(name, **options)
+          options_for_cents = options.merge(from: Integer)
+          options_for_currency = options.merge(from: [Symbol, String])
+
+          attribute(:"#{name}_cents", **options_for_cents)
+          attribute(:"#{name}_currency", **options_for_currency)
+        end
+
+        def duration(name, **options)
+          options = options.merge(from: String, as: ActiveSupport::Duration, format: { from: :duration })
+          string(name, **options)
+        end
+
+        def date(name, **options)
+          options = options.merge(from: String, as: Date, format: { from: :date })
+          string(name, **options)
+        end
+
+        def time(name, **options)
+          options = options.merge(from: String, as: Time, format: { from: :time })
+          string(name, **options)
+        end
+
+        def datetime(name, **options)
+          options = options.merge(from: String, as: DateTime, format: { from: :datetime })
+          string(name, **options)
+        end
+
         ########################################################################
 
         def string(name, **options)

data/lib/datory/attributes/options/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Options
+      class Base
+        attr_reader :name, :type, :consists_of, :min, :max, :format
+
+        def initialize(name:, type:, consists_of:, min:, max:, format:)
+          @name = name
+          @type = type
+          @consists_of = consists_of
+          @min = min
+          @max = max
+          @format = format
+        end
+
+        def info
+          {
+            name: name,
+            type: type,
+            min: min,
+            max: max,
+            consists_of: consists_of,
+            format: format
+          }
+        end
+      end
+    end
+  end
+end

data/lib/datory/attributes/options/from.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Options
+      class From < Base
+        def initialize(name:, type:, consists_of:, min:, max:, format:)
+          format = format.fetch(:from, nil) if format.is_a?(Hash)
+
+          super(name: name, type: type, consists_of: consists_of, min: min, max: max, format: format)
+        end
+      end
+    end
+  end
+end

data/lib/datory/attributes/options/to.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Options
+      class To < Base
+        attr_reader :required, :include_class
+
+        def initialize(name:, type:, required:, consists_of:, min:, max:, format:, include_class:)
+          @required = required
+          @include_class = include_class
+
+          format = format.fetch(:to, nil) if format.is_a?(Hash)
+
+          super(name: name, type: type, consists_of: consists_of, min: min, max: max, format: format)
+        end
+
+        def info
+          super.merge(
+            required: required,
+            include: include_class
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datory/attributes/serialization/serializator.rb

@@ -20,23 +20,20 @@ module Datory
             end
           else
             @collection_of_attributes.to_h do |attribute|
-              attribute.options.fetch(:to, attribute.name)
-              include_class = attribute.options.fetch(:include, nil)
-              output_formatter = attribute.options.fetch(:output, nil)
+              include_class = attribute.to.include_class
+              # output_formatter = attribute.options.fetch(:output, nil) # TODO
 
-              value = model.public_send(attribute.name)
+              value = model.public_send(attribute.from.name)
 
               value =
                 if include_class.present?
-                  from_type = attribute.options.fetch(:from)
-
-                  if [Set, Array].include?(from_type)
+                  if [Set, Array].include?(attribute.from.type)
                     value.map { |item| include_class.serialize(item) }
                   else
                     include_class.serialize(value)
                   end
-                elsif output_formatter.is_a?(Proc)
-                  output_formatter.call(value: value)
+                # elsif output_formatter.is_a?(Proc) # TODO
+                #   output_formatter.call(value: value)
                 elsif [Date, Time, DateTime].include?(value.class)
                   value.to_s
                 elsif value.instance_of?(ActiveSupport::Duration)
@@ -45,7 +42,7 @@ module Datory
                   value
                 end
 
-              [attribute.name, value]
+              [attribute.from.name, value]
             end
           end
         end

data/lib/datory/attributes/serialization/service_factory.rb

@@ -21,28 +21,12 @@ module Datory
           @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
         end
 
-        def create_service_class # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def create_service_class
           collection_of_attributes = @collection_of_attributes
 
           Class.new(Datory::Service::Builder) do
             collection_of_attributes.each do |attribute|
-              input_internal_name = attribute.options.fetch(:to, attribute.name)
-
-              input input_internal_name, **attribute.input_serialization_options
-
-              output attribute.name, **attribute.output_serialization_options
-
-              make :"assign_#{attribute.name}_output"
-
-              define_method(:"assign_#{attribute.name}_output") do
-                value = inputs.public_send(input_internal_name)
-
-                from_type = attribute.options.fetch(:from)
-
-                value = Datory::Utils.transform_value_with(:s, value, from_type)
-
-                outputs.public_send(:"#{attribute.name}=", value)
-              end
+              prepare_serialization_data_for(attribute)
             end
           end
         end

data/lib/datory/base.rb

@@ -2,6 +2,7 @@
 
 module Datory
   class Base
+    include Info::DSL
     include Context::DSL
     include Attributes::DSL
   end

data/lib/datory/context/callable.rb

@@ -3,7 +3,7 @@
 module Datory
   module Context
     module Callable
-      def serialize(model)
+      def serialize(model) # rubocop:disable Metrics/MethodLength
         if [Set, Array].include?(model.class)
           model.map do |model_item|
             serialize(model_item)
@@ -19,7 +19,7 @@ module Datory
         raise Datory::Exceptions::SerializationError.new(message: e.message)
       end
 
-      def deserialize(json)
+      def deserialize(json) # rubocop:disable Metrics/MethodLength
         if [Set, Array].include?(json.class)
           json.map do |json_item|
             deserialize(json_item)

data/lib/datory/info/dsl.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datory
+  module Info
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def info # rubocop:disable Metrics/MethodLength
+          Datory::Info::Result.new(
+            attributes: collection_of_attributes.to_h do |attribute|
+              [
+                attribute.from.name,
+                {
+                  from: attribute.from.info,
+                  to: attribute.to.info
+                }
+              ]
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datory/info/result.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Datory
+  module Info
+    class Result
+      attr_reader :attributes
+
+      def initialize(attributes:)
+        @attributes = attributes
+      end
+    end
+  end
+end

data/lib/datory/service/base.rb

@@ -15,11 +15,15 @@ module Datory
         result_class Datory::Result
 
         input_option_helpers [
-          Servactory::ToolKit::DynamicOptions::Format.use
+          Servactory::ToolKit::DynamicOptions::Format.use,
+          Servactory::ToolKit::DynamicOptions::Min.use,
+          Servactory::ToolKit::DynamicOptions::Max.use
         ]
 
         output_option_helpers [
-          Servactory::ToolKit::DynamicOptions::Format.use
+          Servactory::ToolKit::DynamicOptions::Format.use,
+          Servactory::ToolKit::DynamicOptions::Min.use,
+          Servactory::ToolKit::DynamicOptions::Max.use
         ]
 
         predicate_methods_enabled false

data/lib/datory/service/builder.rb

@@ -3,6 +3,70 @@
 module Datory
   module Service
     class Builder < Base
+      TRANSFORMATIONS = {
+        SERIALIZATION: {
+          Symbol => ->(value) { value.to_sym },
+          String => ->(value) { value.to_s },
+          Integer => ->(value) { value.to_i },
+          Float => ->(value) { value.to_f },
+          Date => ->(value) { value.to_s },
+          Time => ->(value) { value.to_s },
+          DateTime => ->(value) { value.to_s },
+          ActiveSupport::Duration => ->(value) { value.iso8601 }
+        },
+        DESERIALIZATION: {
+          Symbol => ->(value) { value.to_sym },
+          String => ->(value) { value.to_s },
+          Integer => ->(value) { value.to_i },
+          Float => ->(value) { value.to_f },
+          Date => ->(value) { Date.parse(value) },
+          Time => ->(value) { Time.parse(value) },
+          DateTime => ->(value) { DateTime.parse(value) },
+          ActiveSupport::Duration => ->(value) { ActiveSupport::Duration.parse(value) }
+        }
+      }.freeze
+
+      private_constant :TRANSFORMATIONS
+
+      def self.prepare_serialization_data_for(attribute) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        serialized_name = attribute.from.name
+        deserialized_name = attribute.to.name
+        method_name = :"assign_#{serialized_name}_output"
+
+        input deserialized_name, **attribute.input_serialization_options
+
+        output serialized_name, **attribute.output_serialization_options
+
+        make method_name
+
+        define_method(method_name) do
+          value = inputs.public_send(deserialized_name)
+
+          value = TRANSFORMATIONS.fetch(:SERIALIZATION).fetch(value.class, ->(v) { v }).call(value)
+
+          outputs.public_send(:"#{serialized_name}=", value)
+        end
+      end
+
+      def self.prepare_deserialization_data_for(attribute) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        serialized_name = attribute.from.name
+        deserialized_name = attribute.to.name
+        method_name = :"assign_#{deserialized_name}_output"
+
+        input serialized_name, **attribute.input_deserialization_options
+
+        output deserialized_name, **attribute.output_deserialization_options
+
+        make method_name
+
+        define_method(method_name) do
+          value = inputs.public_send(deserialized_name)
+
+          value = TRANSFORMATIONS.fetch(:DESERIALIZATION).fetch(attribute.to.type, ->(v) { v }).call(value)
+
+          outputs.public_send(:"#{deserialized_name}=", value)
+        end
+      end
     end
   end
 end

data/lib/datory/version.rb

@@ -5,7 +5,7 @@ module Datory
     MAJOR = 1
     MINOR = 0
     PATCH = 0
-    PRE = "rc11"
+    PRE = "rc13"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datory
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc11
+  version: 1.0.0.rc13
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.0.rc6
+        version: 2.5.0.rc7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.0.rc6
+        version: 2.5.0.rc7
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -216,6 +216,9 @@ files:
 - lib/datory/attributes/deserialization/service_builder.rb
 - lib/datory/attributes/deserialization/service_factory.rb
 - lib/datory/attributes/dsl.rb
+- lib/datory/attributes/options/base.rb
+- lib/datory/attributes/options/from.rb
+- lib/datory/attributes/options/to.rb
 - lib/datory/attributes/serialization/model.rb
 - lib/datory/attributes/serialization/serializator.rb
 - lib/datory/attributes/serialization/service_builder.rb
@@ -228,11 +231,12 @@ files:
 - lib/datory/context/workspace.rb
 - lib/datory/engine.rb
 - lib/datory/exceptions.rb
+- lib/datory/info/dsl.rb
+- lib/datory/info/result.rb
 - lib/datory/result.rb
 - lib/datory/service/base.rb
 - lib/datory/service/builder.rb
 - lib/datory/service/exceptions.rb
-- lib/datory/utils.rb
 - lib/datory/version.rb
 homepage: https://github.com/servactory/datory
 licenses:
@@ -259,7 +263,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: A set of tools for building reliable services of any complexity

data/lib/datory/utils.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Datory
-  module Utils
-    module_function
-
-    D_TRANSFORMATIONS = {
-      Symbol => ->(value) { value.to_sym },
-      String => ->(value) { value.to_s },
-      Integer => ->(value) { value.to_i },
-      Float => ->(value) { value.to_f },
-      Date => ->(value) { Date.parse(value) },
-      Time => ->(value) { Time.parse(value) },
-      DateTime => ->(value) { DateTime.parse(value) },
-      ActiveSupport::Duration => ->(value) { ActiveSupport::Duration.parse(value) }
-    }.freeze
-
-    private_constant :D_TRANSFORMATIONS
-
-    S_TRANSFORMATIONS = {
-      Symbol => ->(value, _type) { value.to_sym },
-      String => ->(value, _type) { value.to_s },
-      Integer => ->(value, _type) { value.to_i },
-      Float => ->(value, _type) { value.to_f },
-      Date => ->(value, _type) { value.to_s },
-      Time => ->(value, _type) { value.to_s },
-      DateTime => ->(value, _type) { value.to_s },
-      ActiveSupport::Duration => ->(value, _type) { value.iso8601 }
-    }.freeze
-
-    private_constant :S_TRANSFORMATIONS
-
-    def transform_value_with(format, value, type)
-      if format == :d
-        D_TRANSFORMATIONS.fetch(type, ->(v) { v }).call(value)
-      else
-        S_TRANSFORMATIONS.fetch(value.class, ->(v, _type) { v }).call(value, type)
-      end
-    end
-  end
-end