datory 1.0.0.rc11 → 1.0.0.rc12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef2274984450ba2915867f37000b443ffd18a51eeb497adecaaaeae7d0821ae
-  data.tar.gz: ddab73410ef68b0a65f02ed24f9e7177ea43f6779015aa9f5208d4583f8f2882
+  metadata.gz: 198bd72a333d4fa2fe2ee18935d586ab10f6185c7b51c6cb94f2627f5698fb52
+  data.tar.gz: 6aa7c4bf85587d02a38e79de2135c83bed01be5153a644c0892433887dd1b982
 SHA512:
-  metadata.gz: 0c794e11db75f222df975ddf31d0e0c9ff2c37ed7dc33e9c6707a5addfd53c12265f45b8808a3c5d7eebbf426674ccf8442bc3f74ec367ee4f67467ed8e0ea51
-  data.tar.gz: 235ed83fe57e9db74fb93803e83820ecba0aea31a673ede0ae6b485a8d4c219394cf1cd0ceb04efd06048e554039105a05538fda8eb520404f9eaf7bb904c1fd
+  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,7 @@ module Datory
         @options = options
       end
 
-      def input_serialization_options
+      def input_serialization_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         hash = {
           as: options.fetch(:to, name),
           type: options.fetch(:as, options.fetch(:from)),
@@ -18,6 +18,14 @@ module Datory
           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
@@ -45,6 +53,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
@@ -52,7 +68,7 @@ module Datory
         hash
       end
 
-      def output_serialization_options # rubocop:disable Metrics/MethodLength
+      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
@@ -68,6 +84,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
@@ -75,7 +99,7 @@ module Datory
         hash
       end
 
-      def output_deserialization_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
@@ -91,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
@@ -17,6 +17,20 @@ module Datory
       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

@@ -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,10 +23,13 @@ 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

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) # 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/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,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 = "rc11"
+    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.rc11
+  version: 1.0.0.rc12
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-26 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
@@ -228,11 +228,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 +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/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