datory 1.0.0.rc2 → 1.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad592cd7b60ed42e5e729fc785dfcb148abff2e4966194563d943f9e3f66f60
-  data.tar.gz: 9bffee76ef163ac26529c4a163afa2e1a9cea42da6619381b85d7cd2b5187290
+  metadata.gz: 5ca68aea305e426d629f97a3d8940e016a933e4298e56b7ab7d3f9e495fb515d
+  data.tar.gz: 3589f41e040965dacdbaa9f22d197c837afd96f6a5d34e6b32b93e2043ce2391
 SHA512:
-  metadata.gz: fe6407e48e97f7e2f462e52cc7aba7a1726171f02e9fcd1d774bb36c9b04047abdf7218a3eede1b99023fe38f16d80b7bbec224313ffc229e3695b8bdc6126e3
-  data.tar.gz: ae3835273961a84951d232afccf50851cade4f9efb5f89c44d8d7cdf55b3804ff6ba983580d4025aa4f6fd28fd4f695d1941fb74833015d3a88852712d4332fa
+  metadata.gz: 4b08dcadef0150c3183c5ae1458fdd4de9ddf9a1dd6303c5b7dfa1e104f7c4581826c4876660628879a432263ac4cc87de728d2948a3167dc1dd20c83b6bf176
+  data.tar.gz: a19f50f5e2bfe11d3092292ea2e641f546ba78bd2b2eb8efb50769f42d47753c9a6edd46460a6391b4e389c6dcd662cbaf5510f80aa7fd66ab9cf0f3233bb5f0

data/README.md

@@ -36,10 +36,10 @@ UserDto.deserialize(json)
 ```ruby
 class UserDto < Datory::Base
   string :id
-  string :firstname, as: :first_name
-  string :lastname, as: :last_name
+  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, output: ->(value:) { value.to_s }
 
   one :login, include: UserLoginDto
 

data/lib/datory/attributes/dsl.rb

@@ -29,42 +29,47 @@ module Datory
           collection_of_attributes << Attribute.new(name, **options)
         end
 
+        def symbol(name, **options)
+          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)
+        def one(name, include:, to: nil)
+          attribute(name, to: to.presence || name, from: Hash, include: include)
         end
 
-        def many(name, include:, as: nil)
-          attribute(name, as: as.presence || name, type: Array, consists_of: Hash, include: include)
+        def many(name, include:, to: nil)
+          attribute(name, to: to.presence || name, from: Array, consists_of: Hash, include: include)
         end
 
         def collection_of_attributes

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

@@ -0,0 +1,52 @@
+module Datory
+  module Attributes
+    module Serialization
+      class Serializator
+        def self.serialize(model:, collection_of_attributes:)
+          new(collection_of_attributes: collection_of_attributes).serialize(model: model)
+        end
+
+        def initialize(collection_of_attributes:)
+          @collection_of_attributes = collection_of_attributes
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def serialize(model:)
+          if [Set, Array].include?(model.class)
+            model.map do |nested_model|
+              serialize(model: nested_model)
+            end
+          else
+            @collection_of_attributes.to_h do |attribute|
+              internal_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 =
+                if include_class.present?
+                  type = attribute.options.fetch(:type, nil)
+
+                  if [Set, Array].include?(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 [Date, Time, DateTime].include?(value.class)
+                  value.to_s
+                else
+                  value
+                end
+
+              [attribute.name, value]
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Tools
+      class ServiceBuilder
+        SERVICE_CLASS_NAME = "Builder"
+
+        def self.build!(...)
+          new(...).build!
+        end
+
+        def initialize(context, incoming_attributes, collection_of_attributes)
+          @context = context
+          @incoming_attributes = incoming_attributes
+          @collection_of_attributes = collection_of_attributes
+        end
+
+        def build!
+          ServiceFactory.create(@context.class, @collection_of_attributes)
+
+          builder_class.call!(**@incoming_attributes)
+        end
+
+        private
+
+        def builder_class
+          "#{@context.class.name}::#{SERVICE_CLASS_NAME}".constantize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# 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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        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(:to, attribute.name)
+
+              input attribute.name,
+                    as: input_internal_name,
+                    type: attribute.options.fetch(:from),
+                    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?
+
+                      from_type = attribute.options.fetch(:from, nil)
+
+                      if [Set, Array].include?(from_type)
+                        value.map { |item| include_class.build(**item) }
+                      else
+                        include_class.build(**value)
+                      end
+                    end)
+
+              output input_internal_name,
+                     consists_of: if (consists_of_type = attribute.options.fetch(:consists_of, false)) == Hash
+                                    Datory::Result
+                                  else
+                                    consists_of_type
+                                  end,
+                     type: if (from_type = attribute.options.fetch(:from)) == Hash
+                             Datory::Result
+                           elsif (option_as = attribute.options.fetch(:as, nil)).present?
+                             option_as
+                           else
+                             from_type
+                           end
+
+              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)
+
+                if [Date, Time, DateTime].include?(option_as)
+                  value = option_as.parse(value)
+                elsif option_as == String
+                  value = value.to_s
+                elsif option_as == Integer
+                  value = value.to_i
+                elsif option_as == Float
+                  value = value.to_f
+                end
+
+                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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      end
+    end
+  end
+end

data/lib/datory/attributes/workspace.rb

@@ -3,76 +3,12 @@
 module Datory
   module Attributes
     module Workspace
-      class ServiceFactory
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def self.create(model_class, class_name, collection_of_attributes)
-          return if model_class.const_defined?(class_name)
-
-          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
-
-              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))
-              end
-            end
-          end
-
-          model_class.const_set(class_name, class_sample)
-        end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      end
-
       private
 
       def build!(incoming_attributes:, collection_of_attributes:, **)
         super
 
-        builder_class_name = "GBuilder"
-
-        ServiceFactory.create(self.class, builder_class_name, collection_of_attributes)
-
-        builder_class = "#{self.class.name}::#{builder_class_name}".constantize
-
-        builder_class.call!(**incoming_attributes)
-
-        # Tools::Unnecessary.find!(self, attributes, collection_of_attributes)
-        # Tools::Rules.check!(self, collection_of_attributes)
-        # Tools::Validation.validate!(self, attributes, collection_of_attributes)
+        Tools::ServiceBuilder.build!(self, incoming_attributes, collection_of_attributes)
       end
     end
   end

data/lib/datory/context/callable.rb

@@ -3,42 +3,12 @@
 module Datory
   module Context
     module Callable
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def serialize(model)
-        if [Set, Array].include?(model.class)
-          model.map do |model_item|
-            serialize(model_item)
-          end
-        else
-          collection_of_attributes.to_h do |attribute|
-            internal_name = attribute.options.fetch(:as, attribute.name)
-            include_class = attribute.options.fetch(:include, nil)
-            output_formatter = attribute.options.fetch(:output, nil)
-
-            value = model.public_send(internal_name)
-
-            value =
-              if include_class.present?
-                type = attribute.options.fetch(:type, nil)
-
-                if [Set, Array].include?(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 [Date, Time, DateTime].include?(value.class)
-                value.to_s
-              else
-                value
-              end
-
-            [attribute.name, value]
-          end
-        end
+        Datory::Attributes::Serialization::Serializator.serialize(
+          model: model,
+          collection_of_attributes: collection_of_attributes
+        )
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def deserialize(json)
         if [Set, Array].include?(json.class)

data/lib/datory/version.rb

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

data/lib/datory.rb

@@ -4,7 +4,7 @@ require "zeitwerk"
 
 require "active_support/all"
 
-require "uri"
+require "servactory"
 
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datory
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.0.0.rc4
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-21 00:00:00.000000000 Z
+date: 2024-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -48,16 +48,16 @@ dependencies:
   name: servactory
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 2.5.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: 2.5.0.rc2
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -199,6 +199,9 @@ files:
 - lib/datory/attributes/attribute.rb
 - lib/datory/attributes/collection.rb
 - lib/datory/attributes/dsl.rb
+- lib/datory/attributes/serialization/serializator.rb
+- lib/datory/attributes/tools/service_builder.rb
+- lib/datory/attributes/tools/service_factory.rb
 - lib/datory/attributes/workspace.rb
 - lib/datory/base.rb
 - lib/datory/context/callable.rb