datory 1.0.0.rc10 → 1.0.0.rc12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e6931d46c3dd6929ceb0e0954c116eda8a1af5e8e04126adbec8a12a9505afd
-  data.tar.gz: cc93ae958f1d03eac21840ef6219bead651fbf78d00bb8a09f9f3adbf431fe69
+  metadata.gz: 198bd72a333d4fa2fe2ee18935d586ab10f6185c7b51c6cb94f2627f5698fb52
+  data.tar.gz: 6aa7c4bf85587d02a38e79de2135c83bed01be5153a644c0892433887dd1b982
 SHA512:
-  metadata.gz: 4f93c7d0bfb210d5b7f71fe0334f9e5d92aaa4d2d915ea7b1c9e116734ac46e863cb59405a95c8ba30c355dd712b830d03db6901bd9a740cc179bf4722c25cc3
-  data.tar.gz: d94430f29e119f6e64601c4f3c9258a4b9e8f4e9168edf416e7f6c12628d510158a639ecd1e101e38e79eb7c7439ad84422c2a0f5ae22b977b8eee6e4109c1bc
+  metadata.gz: ed216465c59651df53b3170a9381a058a26b5dcaa48058b20300eae6111f9ef582b198391f3813f49e886759c18844a621c4b1a77d9d4a131080fda9ed2e5608
+  data.tar.gz: df02fd6e1eabc40683e506052d448aa9f563f857a52fc48972482b30e962a6571801f9c816ca805bbe1fed8b1acf4c8310d6784374281ecfeb075c1d182480ab

data/README.md

@@ -67,11 +67,132 @@ class UserLoginDto < Datory::Base
 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:0x00000001069c45d0 @attributes={:id=>{:from=>String, :to=>:id, :as=>String, :include=>nil}, :firstname=>{:from=>String, :to=>:first_name, :as=>String, :include=>nil}, :lastname=>{:from=>String, :to=>:last_name, :as=>String, :include=>nil}, :email=>{:from=>String, :to=>:email, :as=>String, :include=>nil}, :phone=>{:from=>String, :to=>:phone, :as=>String, :include=>nil}, :website=>{:from=>String, :to=>:website, :as=>String, :include=>nil}, :birthDate=>{:from=>String, :to=>:birth_date, :as=>Date, :include=>nil}, :login=>{:from=>Hash, :to=>:login, :as=>[Datory::Result, Hash], :include=>Usual::Example1::UserLogin}, :company=>{:from=>Hash, :to=>:company, :as=>[Datory::Result, Hash], :include=>Usual::Example1::UserCompany}, :addresses=>{:from=>Array, :to=>:addresses, :as=>Array, :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

@@ -2,7 +2,7 @@
 
 module Datory
   module Attributes
-    class Attribute
+    class Attribute # rubocop:disable Metrics/ClassLength
       attr_reader :name, :options
 
       def initialize(name, **options)
@@ -10,7 +10,30 @@ module Datory
         @options = options
       end
 
-      def input_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def input_serialization_options # rubocop:disable Metrics/MethodLength, 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)
+        }
+
+        if (min = options.fetch(:min, nil)).present?
+          hash[:min] = min
+        end
+
+        if (max = options.fetch(:max, nil)).present?
+          hash[:max] = max
+        end
+
+        if (format = options.fetch(:format, nil)).present?
+          hash[:format] = format
+        end
+
+        hash
+      end
+
+      def input_deserialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         hash = {
           as: options.fetch(:to, name),
           type: options.fetch(:from),
@@ -23,13 +46,52 @@ module Datory
             from_type = options.fetch(:from, nil)
 
             if [Set, Array].include?(from_type)
-              value.map { |item| include_class.build(**item) }
+              value.map { |item| include_class.deserialize(**item) }
             else
-              include_class.build(**value)
+              include_class.deserialize(**value)
             end
           end)
         }
 
+        if (min = options.fetch(:min, nil)).present?
+          hash[:min] = min
+        end
+
+        if (max = options.fetch(:max, nil)).present?
+          hash[:max] = max
+        end
+
+        if (format = options.fetch(:format, nil)).present?
+          hash[:format] = format
+        end
+
+        hash
+      end
+
+      def output_serialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+        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
+        }
+
+        if (min = options.fetch(:min, nil)).present?
+          hash[:min] = min
+        end
+
+        if (max = options.fetch(:max, nil)).present?
+          hash[:max] = max
+        end
+
         if (format = options.fetch(:format, nil)).present?
           hash[:format] = format
         end
@@ -37,7 +99,7 @@ module Datory
         hash
       end
 
-      def output_options # rubocop:disable Metrics/MethodLength
+      def output_deserialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
         hash = {
           consists_of: if (consists_of_type = options.fetch(:consists_of, false)) == Hash
                          Datory::Result
@@ -53,6 +115,14 @@ module Datory
                 end
         }
 
+        if (min = options.fetch(:min, nil)).present?
+          hash[:min] = min
+        end
+
+        if (max = options.fetch(:max, nil)).present?
+          hash[:max] = max
+        end
+
         if (format = options.fetch(:format, nil)).present?
           hash[:format] = format
         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
@@ -13,6 +13,24 @@ module Datory
       def names
         map(&:name)
       end
+
+      def internal_names
+        map { |attribute| attribute.options.fetch(:to, attribute.name) }
+      end
+
+      def include_exist?
+        @include_exist ||= filter do |attribute| # rubocop:disable Performance/Count
+          include_class = attribute.options.fetch(:include, nil)
+
+          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
 end

data/lib/datory/attributes/descriptor.rb

@@ -7,7 +7,7 @@ module Datory
         new.describe(...)
       end
 
-      def describe(collection_of_attributes:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def describe(service_class_name:, collection_of_attributes:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         headings = []
         rows = []
 
@@ -15,6 +15,7 @@ module Datory
         headings << "From"
         headings << "To"
         headings << "As"
+        headings << "Include" if collection_of_attributes.include_exist?
 
         collection_of_attributes.each do |attribute|
           row = []
@@ -22,15 +23,18 @@ module Datory
           row << attribute.name
 
           from_type = attribute.options.fetch(:from)
+          include = attribute.options.fetch(:include, from_type)
 
           row << from_type
           row << attribute.options.fetch(:to, attribute.name)
-          row << attribute.options.fetch(:as, attribute.options.fetch(:include, from_type))
+          row << attribute.options.fetch(:as, include)
+
+          row << (include if include <= Datory::Base) if collection_of_attributes.include_exist?
 
           rows << row
         end
 
-        Datory::Console.print_table(headings.uniq, rows)
+        Datory::Console.print_table(title: service_class_name, headings: headings.uniq, rows: rows)
       end
     end
   end

data/lib/datory/attributes/{tools → deserialization}/service_builder.rb

@@ -2,9 +2,9 @@
 
 module Datory
   module Attributes
-    module Tools
+    module Deserialization
       class ServiceBuilder
-        SERVICE_CLASS_NAME = "Builder"
+        SERVICE_CLASS_NAME = "DBuilder"
 
         def self.build!(...)
           new(...).build!

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Deserialization
+      class ServiceFactory
+        def self.create(...)
+          new(...).create
+        end
+
+        def initialize(model_class, collection_of_attributes)
+          @model_class = model_class
+          @collection_of_attributes = collection_of_attributes
+        end
+
+        def create
+          return if @model_class.const_defined?(ServiceBuilder::SERVICE_CLASS_NAME)
+
+          class_sample = create_service_class
+
+          @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
+        end
+
+        def create_service_class
+          collection_of_attributes = @collection_of_attributes
+
+          Class.new(Datory::Service::Builder) do
+            collection_of_attributes.each do |attribute|
+              prepare_deserialization_data_for(attribute)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datory/attributes/dsl.rb

@@ -24,11 +24,24 @@ module Datory
         ########################################################################
 
         def one(name, include:, to: nil)
-          attribute(name, to: to.presence || name, from: Hash, include: include)
+          attribute(
+            name,
+            to: to.presence || name,
+            from: Hash,
+            include: include,
+            as: [Datory::Result, Hash]
+          )
         end
 
         def many(name, include:, to: nil)
-          attribute(name, to: to.presence || name, from: Array, consists_of: Hash, include: include)
+          attribute(
+            name,
+            to: to.presence || name,
+            from: Array,
+            consists_of: [Datory::Result, Hash],
+            include: include,
+            as: Array
+          )
         end
 
         ########################################################################
@@ -38,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) # TODO: Add `format: :duration`
+          string(name, **options)
+        end
+
+        def date(name, **options)
+          options = options.merge(from: String, as: Date) # TODO: Add `format: :date`
+          string(name, **options)
+        end
+
+        def time(name, **options)
+          options = options.merge(from: String, as: Time) # TODO: Add `format: :time`
+          string(name, **options)
+        end
+
+        def datetime(name, **options)
+          options = options.merge(from: String, as: DateTime) # TODO: Add `format: :datetime`
+          string(name, **options)
+        end
+
         ########################################################################
 
         def string(name, **options)

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

@@ -8,22 +8,26 @@ module Datory
           new.prepare(...)
         end
 
-        def prepare(data) # rubocop:disable Metrics/MethodLength
-          if data.is_a?(Array)
-            data.map do |item|
-              if item.is_a?(Hash)
-                build(item)
-              else
-                item
-              end
-            end
-          elsif data.is_a?(Hash)
+        def self.to_hash(...)
+          new.to_hash(...)
+        end
+
+        def prepare(data)
+          if data.is_a?(Hash)
             build(data)
           else
             data
           end
         end
 
+        def to_hash(data)
+          if data.is_a?(Datory::Attributes::Serialization::Model)
+            parse(data)
+          else
+            data
+          end
+        end
+
         def build(attributes = {}) # rubocop:disable Metrics/MethodLength
           attributes.each do |key, value|
             self.class.send(:attr_accessor, key)
@@ -42,6 +46,23 @@ module Datory
 
           self
         end
+
+        def parse(data) # rubocop:disable Metrics/MethodLength
+          data.instance_variables.to_h do |key|
+            value = data.instance_variable_get(key)
+
+            value =
+              if value.is_a?(Array)
+                value.map! { |item| Datory::Attributes::Serialization::Model.to_hash(item) }
+              elsif value.is_a?(Datory::Attributes::Serialization::Model)
+                Datory::Attributes::Serialization::Model.to_hash(value)
+              else
+                value
+              end
+
+            [key.to_s.delete_prefix("@").to_sym, value]
+          end
+        end
       end
     end
   end

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

@@ -20,17 +20,17 @@ module Datory
             end
           else
             @collection_of_attributes.to_h do |attribute|
-              internal_name = attribute.options.fetch(:to, attribute.name)
+              attribute.options.fetch(:to, attribute.name)
               include_class = attribute.options.fetch(:include, nil)
               output_formatter = attribute.options.fetch(:output, nil)
 
-              value = model.public_send(internal_name)
+              value = model.public_send(attribute.name)
 
               value =
                 if include_class.present?
-                  type = attribute.options.fetch(:type, nil)
+                  from_type = attribute.options.fetch(:from)
 
-                  if [Set, Array].include?(type)
+                  if [Set, Array].include?(from_type)
                     value.map { |item| include_class.serialize(item) }
                   else
                     include_class.serialize(value)

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Serialization
+      class ServiceBuilder
+        SERVICE_CLASS_NAME = "SBuilder"
+
+        def self.build!(...)
+          new(...).build!
+        end
+
+        def initialize(context, model, collection_of_attributes)
+          @context = context
+          @model = model
+          @collection_of_attributes = collection_of_attributes
+        end
+
+        def build!
+          ServiceFactory.create(@context.class, @collection_of_attributes)
+
+          attributes = Datory::Attributes::Serialization::Model.to_hash(@model)
+
+          unnecessary_attributes = attributes.keys.difference(@collection_of_attributes.internal_names)
+
+          unnecessary_attributes.each do |key|
+            attributes.delete(key)
+          end
+
+          builder_class.call!(**attributes)
+        end
+
+        private
+
+        def builder_class
+          "#{@context.class.name}::#{SERVICE_CLASS_NAME}".constantize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Serialization
+      class ServiceFactory
+        def self.create(...)
+          new(...).create
+        end
+
+        def initialize(model_class, collection_of_attributes)
+          @model_class = model_class
+          @collection_of_attributes = collection_of_attributes
+        end
+
+        def create
+          return if @model_class.const_defined?(ServiceBuilder::SERVICE_CLASS_NAME)
+
+          class_sample = create_service_class
+
+          @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
+        end
+
+        def create_service_class
+          collection_of_attributes = @collection_of_attributes
+
+          Class.new(Datory::Service::Builder) do
+            collection_of_attributes.each do |attribute|
+              prepare_serialization_data_for(attribute)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datory/attributes/workspace.rb

@@ -5,10 +5,29 @@ module Datory
     module Workspace
       private
 
-      def build!(incoming_attributes:, collection_of_attributes:, **)
+      def serialize(model:, collection_of_attributes:)
         super
 
-        Tools::ServiceBuilder.build!(self, incoming_attributes, collection_of_attributes)
+        model = Serialization::ServiceBuilder.build!(self, model, collection_of_attributes)
+
+        Serialization::Serializator.serialize(
+          model: model,
+          collection_of_attributes: collection_of_attributes
+        )
+      end
+
+      def deserialize(incoming_attributes:, collection_of_attributes:)
+        super
+
+        Deserialization::ServiceBuilder.build!(self, incoming_attributes, collection_of_attributes)
+      end
+
+      def to_model(attributes:)
+        super
+
+        attributes.each do |attribute_name, attribute_value|
+          define_singleton_method(attribute_name) { attribute_value }
+        end
       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/console.rb

@@ -4,8 +4,9 @@ require "terminal-table"
 
 module Datory
   class Console
-    def self.print_table(headings, rows)
+    def self.print_table(headings:, rows:, title: nil)
       table = Terminal::Table.new(
+        title: title,
         headings: headings,
         rows: rows,
         style: { border_x: "~", border_i: "~" }

data/lib/datory/context/callable.rb

@@ -3,63 +3,76 @@
 module Datory
   module Context
     module Callable
-      def serialize(model)
-        model = Datory::Attributes::Serialization::Model.prepare(model)
-
-        Datory::Attributes::Serialization::Serializator.serialize(
-          model: model,
-          collection_of_attributes: collection_of_attributes
-        )
+      def serialize(model) # rubocop:disable Metrics/MethodLength
+        if [Set, Array].include?(model.class)
+          model.map do |model_item|
+            serialize(model_item)
+          end
+        else
+          context = send(:new)
+          model = Datory::Attributes::Serialization::Model.prepare(model)
+          _serialize(context, model)
+        end
+      rescue Datory::Service::Exceptions::Input,
+             Datory::Service::Exceptions::Internal,
+             Datory::Service::Exceptions::Output => e
+        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)
           end
         else
+          context = send(:new)
           hash = JSON.parse(json.to_json)
-          build(**hash)
-        end
-      end
-
-      def to_model(**attributes)
-        context = send(:new)
 
-        attributes.each do |attribute_name, attribute_value|
-          context.define_singleton_method(attribute_name) { attribute_value }
+          _deserialize(context, **hash)
         end
-
-        context
+      rescue Datory::Service::Exceptions::Input,
+             Datory::Service::Exceptions::Internal,
+             Datory::Service::Exceptions::Output => e
+        raise Datory::Exceptions::DeserializationError.new(message: e.message)
       end
 
-      # def build!(attributes = {})
-      #   context = send(:new)
-      #
-      #   _build!(context, **attributes)
-      # end
-
-      def build(attributes = {})
+      def to_model(**attributes)
         context = send(:new)
 
-        _build!(context, **attributes)
+        _to_model(context, **attributes)
       end
 
       def describe
         Datory::Attributes::Descriptor.describe(
+          service_class_name: name,
           collection_of_attributes: collection_of_attributes
         )
       end
 
       private
 
-      def _build!(context, **attributes)
+      def _serialize(context, model)
+        context.send(
+          :_serialize,
+          model: model,
+          collection_of_attributes: collection_of_attributes
+        )
+      end
+
+      def _deserialize(context, **attributes)
         context.send(
-          :_build!,
+          :_deserialize,
           incoming_attributes: attributes.symbolize_keys,
           collection_of_attributes: collection_of_attributes
         )
       end
+
+      def _to_model(context, **attributes)
+        context.send(
+          :_to_model,
+          attributes: attributes
+        )
+      end
     end
   end
 end

data/lib/datory/context/workspace.rb

@@ -16,24 +16,39 @@ module Datory
       attr_reader :incoming_attributes,
                   :collection_of_attributes
 
-      def _build!(
-        incoming_attributes:,
-        collection_of_attributes:
-      )
-        build!(
+      def _serialize(model:, collection_of_attributes:)
+        serialize(
+          model: model,
+          collection_of_attributes: collection_of_attributes
+        )
+      end
+
+      def _deserialize(incoming_attributes:, collection_of_attributes:)
+        deserialize(
           incoming_attributes: incoming_attributes,
           collection_of_attributes: collection_of_attributes
         )
       end
 
-      def build!(
-        incoming_attributes:,
-        collection_of_attributes:,
-        **
-      )
+      def _to_model(attributes:)
+        to_model(
+          attributes: attributes
+        )
+      end
+
+      def serialize(model:, collection_of_attributes:, **)
+        @model = model
+        @collection_of_attributes = collection_of_attributes
+      end
+
+      def deserialize(incoming_attributes:, collection_of_attributes:, **)
         @incoming_attributes = incoming_attributes
         @collection_of_attributes = collection_of_attributes
       end
+
+      def to_model(attributes:)
+        @attributes = attributes
+      end
     end
   end
 end

data/lib/datory/exceptions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Datory
+  module Exceptions
+    class SerializationError < Datory::Service::Exceptions::Input; end
+    class DeserializationError < Datory::Service::Exceptions::Input; end
+  end
+end

data/lib/datory/info/dsl.rb

@@ -0,0 +1,32 @@
+# 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, Metrics/AbcSize
+          Datory::Info::Result.new(
+            attributes: collection_of_attributes.to_h do |attribute|
+              type_from = attribute.options.fetch(:from)
+
+              options = {
+                from: type_from,
+                to: attribute.options.fetch(:to, attribute.name),
+                as: attribute.options.fetch(:as, type_from),
+                min: attribute.options.fetch(:min, nil),
+                max: attribute.options.fetch(:max, nil),
+                include: attribute.options.fetch(:include, nil)
+              }
+
+              [attribute.name, options]
+            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,72 @@
 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.name
+        deserialized_name = attribute.options.fetch(:to, serialized_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.name
+        deserialized_name = attribute.options.fetch(:to, serialized_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)
+
+          type_as = attribute.options.fetch(:as, nil)
+
+          value = TRANSFORMATIONS.fetch(:DESERIALIZATION).fetch(type_as, ->(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 = "rc10"
+    PRE = "rc12"
 
     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.rc10
+  version: 1.0.0.rc12
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-25 00:00:00.000000000 Z
+date: 2024-04-28 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
@@ -213,11 +213,13 @@ files:
 - lib/datory/attributes/attribute.rb
 - lib/datory/attributes/collection.rb
 - lib/datory/attributes/descriptor.rb
+- lib/datory/attributes/deserialization/service_builder.rb
+- lib/datory/attributes/deserialization/service_factory.rb
 - lib/datory/attributes/dsl.rb
 - lib/datory/attributes/serialization/model.rb
 - lib/datory/attributes/serialization/serializator.rb
-- lib/datory/attributes/tools/service_builder.rb
-- lib/datory/attributes/tools/service_factory.rb
+- lib/datory/attributes/serialization/service_builder.rb
+- lib/datory/attributes/serialization/service_factory.rb
 - lib/datory/attributes/workspace.rb
 - lib/datory/base.rb
 - lib/datory/console.rb
@@ -225,11 +227,13 @@ files:
 - lib/datory/context/dsl.rb
 - 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:
@@ -256,7 +260,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/attributes/tools/service_factory.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Datory
-  module Attributes
-    module Tools
-      class ServiceFactory
-        def self.create(...)
-          new(...).create
-        end
-
-        def initialize(model_class, collection_of_attributes)
-          @model_class = model_class
-          @collection_of_attributes = collection_of_attributes
-        end
-
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        def create
-          return if @model_class.const_defined?(ServiceBuilder::SERVICE_CLASS_NAME)
-
-          collection_of_attributes = @collection_of_attributes
-
-          class_sample = 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_options
-
-              output input_internal_name, **attribute.output_options
-
-              make :"assign_#{input_internal_name}_output"
-
-              define_method(:"assign_#{input_internal_name}_output") do
-                value = inputs.public_send(input_internal_name)
-
-                option_as = attribute.options.fetch(:as, nil)
-
-                value = Datory::Utils.transform_value_with(value, option_as)
-
-                outputs.public_send(:"#{input_internal_name}=", value)
-              end
-            end
-
-            # output :model, type: Class
-
-            # make :assign_model_name
-
-            # def assign_model_name
-            #   model_class_name_array = self.class.name.split("::")
-            #   model_class_name_array.pop
-            #   model_class_name = model_class_name_array.join("::")
-            #   model_class = model_class_name.constantize
-            #
-            #   outputs.model = model_class
-            # end
-          end
-
-          @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
-        end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-      end
-    end
-  end
-end

data/lib/datory/utils.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Datory
-  module Utils
-    module_function
-
-    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 :TRANSFORMATIONS
-
-    def transform_value_with(value, type)
-      TRANSFORMATIONS.fetch(type, ->(v) { v }).call(value)
-    end
-  end
-end