datory 1.0.0.rc12 → 1.0.0.rc14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 198bd72a333d4fa2fe2ee18935d586ab10f6185c7b51c6cb94f2627f5698fb52
-  data.tar.gz: 6aa7c4bf85587d02a38e79de2135c83bed01be5153a644c0892433887dd1b982
+  metadata.gz: 7c1b9b4a2fbe194c484a57960111c07b2285db29c889406a9e6e29571866b4f0
+  data.tar.gz: ecafad6097d0ba8867b2aa5b332c4c7d91e959728cf24393eb9356131c5fe437
 SHA512:
-  metadata.gz: ed216465c59651df53b3170a9381a058a26b5dcaa48058b20300eae6111f9ef582b198391f3813f49e886759c18844a621c4b1a77d9d4a131080fda9ed2e5608
-  data.tar.gz: df02fd6e1eabc40683e506052d448aa9f563f857a52fc48972482b30e962a6571801f9c816ca805bbe1fed8b1acf4c8310d6784374281ecfeb075c1d182480ab
+  metadata.gz: 97dfe2487f3fb9859d4cbde74f4473d5c2c993ac91f6804afc2bf7d1441d871b90c5400c0911691231587e258db6047cd880289c7449feafaf93af8a0fd82a00
+  data.tar.gz: 9bf01b58328bbe3c6c5822523c34d8383aacf8aa21736a64da8435730f553a8dfa3bf8a147a4e07bb5b86c2b872ab23973f013058802be28f2d443e7678ef185

data/README.md

@@ -22,13 +22,25 @@ gem "datory"
 ```ruby
 user = User.find(...)
 
-UserDto.serialize(user)
+UserDto.serialize(user) # => { ... }
+```
+
+For serialization, the `form` method is also available.
+This prepares a `Form` object, which has a set of additional methods such as `valid?` and `invalid?`.
+
+```ruby
+form = UserDto.form(user)
+
+form.valid? # => true
+form.invalid? # => false
+
+form.serialize # => { ... }
 ```
 
 #### Deserialize
 
 ```ruby
-UserDto.deserialize(json)
+UserDto.deserialize(json) # => Datory::Result
 ```
 
 #### Examples
@@ -44,7 +56,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,8 +74,10 @@ class UserLoginDto < Datory::Base
   
   string :md5
   string :sha1
+
+  duration :lifetime
   
-  string :registered_at, as: DateTime
+  datetime :registered_at
 end
 ```
 
@@ -160,7 +174,7 @@ 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}}>
+#<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

data/lib/datory/attributes/attribute.rb

@@ -2,130 +2,105 @@
 
 module Datory
   module Attributes
-    class Attribute # rubocop:disable Metrics/ClassLength
-      attr_reader :name, :options
+    class Attribute
+      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 # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      ##########################################################################
+
+      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 (min = options.fetch(:min, nil)).present?
-          hash[:min] = min
-        end
+        hash[:min] = to.min if to.min.present?
 
-        if (max = options.fetch(:max, nil)).present?
-          hash[:max] = max
-        end
+        hash[:max] = to.max if to.max.present?
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        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?
-
-            from_type = options.fetch(:from, nil)
-
-            if [Set, Array].include?(from_type)
-              value.map { |item| include_class.deserialize(**item) }
-            else
-              include_class.deserialize(**value)
-            end
-          end)
+          consists_of: to.consists_of == Hash ? Datory::Result : from.consists_of,
+          type: to.type == Datory::Result ? Hash : from.type
         }
 
-        if (min = options.fetch(:min, nil)).present?
-          hash[:min] = min
-        end
+        hash[:min] = from.min if from.min.present?
 
-        if (max = options.fetch(:max, nil)).present?
-          hash[:max] = max
-        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, Metrics/AbcSize, Metrics/PerceivedComplexity
+      ##########################################################################
+
+      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 (min = options.fetch(:min, nil)).present?
-          hash[:min] = min
-        end
+        hash[:min] = from.min if from.min.present?
 
-        if (max = options.fetch(:max, nil)).present?
-          hash[:max] = max
-        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_deserialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+      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 (min = options.fetch(:min, nil)).present?
-          hash[:min] = min
-        end
+        hash[:min] = to.min if to.min.present?
 
-        if (max = options.fetch(:max, nil)).present?
-          hash[:max] = max
-        end
+        hash[:max] = to.max if to.max.present?
 
-        if (format = options.fetch(:format, nil)).present?
-          hash[:format] = format
-        end
+        hash[:format] = to.format if to.format.present?
 
         hash
       end

data/lib/datory/attributes/collection.rb

@@ -15,12 +15,12 @@ module Datory
       end
 
       def internal_names
-        map { |attribute| attribute.options.fetch(:to, attribute.name) }
+        map { |attribute| attribute.to.name }
       end
 
-      def include_exist?
-        @include_exist ||= filter do |attribute| # rubocop:disable Performance/Count
-          include_class = attribute.options.fetch(:include, nil)
+      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?
 

data/lib/datory/attributes/descriptor.rb

@@ -15,21 +15,18 @@ module Datory
         headings << "From"
         headings << "To"
         headings << "As"
-        headings << "Include" if collection_of_attributes.include_exist?
+        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)
-          include = attribute.options.fetch(:include, from_type)
-
-          row << from_type
-          row << attribute.options.fetch(:to, attribute.name)
-          row << attribute.options.fetch(:as, include)
-
-          row << (include if include <= Datory::Base) if collection_of_attributes.include_exist?
+          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/dsl.rb

@@ -60,22 +60,22 @@ module Datory
         end
 
         def duration(name, **options)
-          options = options.merge(from: String, as: ActiveSupport::Duration) # TODO: Add `format: :duration`
+          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) # TODO: Add `format: :date`
+          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) # TODO: Add `format: :time`
+          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) # TODO: Add `format: :datetime`
+          options = options.merge(from: String, as: DateTime, format: { from: :datetime })
           string(name, **options)
         end
 

data/lib/datory/attributes/form.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    class Form
+      def initialize(context, model)
+        @context = context
+        @model = model
+      end
+
+      def serialize
+        @serialize ||= @context.serialize(@model)
+      end
+
+      def valid?
+        serialize
+
+        true
+      rescue Datory::Exceptions::SerializationError
+        false
+      end
+
+      def invalid?
+        !valid?
+      end
+    end
+  end
+end

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/context/callable.rb

@@ -3,6 +3,10 @@
 module Datory
   module Context
     module Callable
+      def form(model)
+        Datory::Attributes::Form.new(self, model)
+      end
+
       def serialize(model) # rubocop:disable Metrics/MethodLength
         if [Set, Array].include?(model.class)
           model.map do |model_item|

data/lib/datory/info/dsl.rb

@@ -8,21 +8,16 @@ module Datory
       end
 
       module ClassMethods
-        def info # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def info # rubocop:disable Metrics/MethodLength
           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]
+              [
+                attribute.from.name,
+                {
+                  from: attribute.from.info,
+                  to: attribute.to.info
+                }
+              ]
             end
           )
         end

data/lib/datory/service/builder.rb

@@ -29,8 +29,8 @@ module Datory
       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)
+        serialized_name = attribute.from.name
+        deserialized_name = attribute.to.name
         method_name = :"assign_#{serialized_name}_output"
 
         input deserialized_name, **attribute.input_serialization_options
@@ -49,8 +49,8 @@ module Datory
       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)
+        serialized_name = attribute.from.name
+        deserialized_name = attribute.to.name
         method_name = :"assign_#{deserialized_name}_output"
 
         input serialized_name, **attribute.input_deserialization_options
@@ -62,9 +62,7 @@ module Datory
         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)
+          value = TRANSFORMATIONS.fetch(:DESERIALIZATION).fetch(attribute.to.type, ->(v) { v }).call(value)
 
           outputs.public_send(:"#{deserialized_name}=", value)
         end

data/lib/datory/version.rb

@@ -5,7 +5,7 @@ module Datory
     MAJOR = 1
     MINOR = 0
     PATCH = 0
-    PRE = "rc12"
+    PRE = "rc14"
 
     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.rc12
+  version: 1.0.0.rc14
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-28 00:00:00.000000000 Z
+date: 2024-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -216,6 +216,10 @@ files:
 - lib/datory/attributes/deserialization/service_builder.rb
 - lib/datory/attributes/deserialization/service_factory.rb
 - lib/datory/attributes/dsl.rb
+- lib/datory/attributes/form.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