datory 1.0.0.rc3 → 1.0.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8562a68170d39d6d97a80eceae372d7f043cbb08db2890faa2d6d22a792748bf
-  data.tar.gz: 89ef0b5c9a73289a3567e01202a9a83beeaefee6db2f084168c6e755da4e3044
+  metadata.gz: 6f0d3dcd343bb011dc9a4f364a9d62b14deaa0920c48495a48c36ed23d08143e
+  data.tar.gz: c299b7365488894f8467c094f3e11445fde073eab82b14d45ff63c284a98f67f
 SHA512:
-  metadata.gz: 3c6ed842a16e265979fc1d5ebc4b517390884bac7118500d39cc48d6b180c7c842b08cadfdf853db111b2a56a8c016cbcbf9654d4b290272399f461d9eec48ba
-  data.tar.gz: 6428856321dd65efb127aca09955e5e34eb1d3cff3cdc2f8da0fd669e4556582ecef976919b60f6808ce84a602a9dc60f332ffcc42b0421c613b0dc43d1ff429
+  metadata.gz: b7a458af89e5be1b6ca35f1064da7deb50a8da75751cce60d4c7bf5b93cc559c20ab6ea13156667e2be8e0d984ebebef82c2bc1a08f5c2f6fc7bccca9d9d6dfd
+  data.tar.gz: abaf617dcbcaf4d8e6661cca45fb39ec17d1f69f656f2afc85ee42ccf3beb197c56c60acc07a82d0818d4a5af425b8b2e080bbdecf76815fadb966d08ed70706

data/README.md

@@ -35,11 +35,11 @@ UserDto.deserialize(json)
 
 ```ruby
 class UserDto < Datory::Base
-  string :id
-  string :firstname, as: :first_name
-  string :lastname, as: :last_name
+  uuid :id
+  string :firstname, to: :first_name
+  string :lastname, to: :last_name
   string :email
-  string :birthDate, as: :birth_date, output: ->(value:) { value.to_s }
+  string :birthDate, to: :birth_date, as: Date
 
   one :login, include: UserLoginDto
 
@@ -59,7 +59,7 @@ class UserLoginDto < Datory::Base
   string :password
   string :md5
   string :sha1
-  string :registered
+  string :registered, to: :registered_at, as: DateTime
 end
 ```
 

data/lib/datory/attributes/attribute.rb

@@ -9,6 +9,56 @@ module Datory
         @name = name
         @options = options
       end
+
+      def input_options # rubocop:disable Metrics/MethodLength, 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.build(**item) }
+            else
+              include_class.build(**value)
+            end
+          end)
+        }
+
+        if (format = options.fetch(:format, nil)).present?
+          hash[:format] = format
+        end
+
+        hash
+      end
+
+      def output_options # rubocop:disable Metrics/MethodLength
+        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
+        }
+
+        if (format = options.fetch(:format, nil)).present?
+          hash[:format] = format
+        end
+
+        hash
+      end
     end
   end
 end

data/lib/datory/attributes/dsl.rb

@@ -17,60 +17,65 @@ module Datory
 
         private
 
-        def singular(value)
-          @singular = value
+        def attribute(name, **options)
+          collection_of_attributes << Attribute.new(name, **options)
         end
 
-        def plural(value)
-          @plural = value
+        ########################################################################
+
+        def one(name, include:, to: nil)
+          attribute(name, to: to.presence || name, from: Hash, include: include)
         end
 
-        def attribute(name, **options)
-          collection_of_attributes << Attribute.new(name, **options)
+        def many(name, include:, to: nil)
+          attribute(name, to: to.presence || name, from: Array, consists_of: Hash, include: include)
+        end
+
+        ########################################################################
+
+        def uuid(name, **options)
+          options = options.merge(format: :uuid)
+          string(name, **options)
         end
 
+        ########################################################################
+
         def symbol(name, **options)
-          options = options.merge(type: Symbol)
+          options = options.merge(from: Symbol)
           attribute(name, **options)
         end
 
         def string(name, **options)
-          options = options.merge(type: String)
+          options = options.merge(from: String)
           attribute(name, **options)
         end
 
         def integer(name, **options)
-          options = options.merge(type: Integer)
+          options = options.merge(from: Integer)
           attribute(name, **options)
         end
 
         def float(name, **options)
-          options = options.merge(type: Float)
+          options = options.merge(from: Float)
           attribute(name, **options)
         end
 
         def date(name, **options)
-          options = options.merge(type: Date)
+          options = options.merge(from: Date)
           attribute(name, **options)
         end
 
         def time(name, **options)
-          options = options.merge(type: Time)
+          options = options.merge(from: Time)
           attribute(name, **options)
         end
 
         def datetime(name, **options)
-          options = options.merge(type: DateTime)
+          options = options.merge(from: DateTime)
           attribute(name, **options)
         end
 
-        def one(name, include:, as: nil)
-          attribute(name, as: as.presence || name, type: Hash, include: include)
-        end
-
-        def many(name, include:, as: nil)
-          attribute(name, as: as.presence || name, type: Array, consists_of: Hash, include: include)
-        end
+        ########################################################################
 
         def collection_of_attributes
           @collection_of_attributes ||= Collection.new

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datory
   module Attributes
     module Serialization
@@ -18,7 +20,7 @@ module Datory
             end
           else
             @collection_of_attributes.to_h do |attribute|
-              internal_name = attribute.options.fetch(:as, attribute.name)
+              internal_name = attribute.options.fetch(:to, attribute.name)
               include_class = attribute.options.fetch(:include, nil)
               output_formatter = attribute.options.fetch(:output, nil)
 

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

@@ -13,52 +13,30 @@ module Datory
           @collection_of_attributes = collection_of_attributes
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # 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| # rubocop:disable Metrics/BlockLength
-              input_internal_name = attribute.options.fetch(:as, attribute.name)
-
-              input attribute.name,
-                    as: input_internal_name,
-                    type: attribute.options.fetch(:type),
-                    required: attribute.options.fetch(:required, true),
-                    consists_of: attribute.options.fetch(:consists_of, false),
-                    prepare: (lambda do |value:|
-                      include_class = attribute.options.fetch(:include, nil)
-                      return value unless include_class.present?
-
-                      type = attribute.options.fetch(:type, nil)
-
-                      if [Set, Array].include?(type)
-                        value.map { |item| include_class.build(**item) }
-                      else
-                        include_class.build(**value)
-                      end
-                    end)
-
-              output input_internal_name,
-                     consists_of: (
-                       if (type = attribute.options.fetch(:consists_of, false)) == Hash
-                         Datory::Result
-                       else
-                         type
-                       end
-                     ),
-                     type: if (type = attribute.options.fetch(:type)) == Hash
-                             Datory::Result
-                           else
-                             type
-                           end
+            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
-                outputs.public_send(:"#{input_internal_name}=", inputs.public_send(input_internal_name))
+                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
 
@@ -78,7 +56,7 @@ module Datory
 
           @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
       end
     end
   end

data/lib/datory/service/base.rb

@@ -13,6 +13,14 @@ module Datory
         failure_class Datory::Service::Exceptions::Failure
 
         result_class Datory::Result
+
+        input_option_helpers [
+          Servactory::ToolKit::DynamicOptions::Format.use
+        ]
+
+        output_option_helpers [
+          Servactory::ToolKit::DynamicOptions::Format.use
+        ]
       end
     end
   end

data/lib/datory/utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Datory
+  module Utils
+    module_function
+
+    TRANSFORMATIONS = {
+      Date => ->(value) { Date.parse(value) },
+      Time => ->(value) { Time.parse(value) },
+      DateTime => ->(value) { DateTime.parse(value) },
+      Symbol => ->(value) { value.to_sym },
+      String => ->(value) { value.to_s },
+      Integer => ->(value) { value.to_i },
+      Float => ->(value) { value.to_f }
+    }.freeze
+
+    private_constant :TRANSFORMATIONS
+
+    def transform_value_with(value, type)
+      TRANSFORMATIONS.fetch(type, ->(v) { v }).call(value)
+    end
+  end
+end

data/lib/datory/version.rb

@@ -5,7 +5,7 @@ module Datory
     MAJOR = 1
     MINOR = 0
     PATCH = 0
-    PRE = "rc3"
+    PRE = "rc5"
 
     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.rc3
+  version: 1.0.0.rc5
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-04-24 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.rc2
+        version: 2.5.0.rc5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.0.rc2
+        version: 2.5.0.rc5
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -211,6 +211,7 @@ files:
 - 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: