datory 1.0.0.rc9 → 1.0.0.rc11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 581be089a2e76a9d744e511869da46033d47904a1103343ec447d3d508a41ab8
-  data.tar.gz: d9a70d1d761b4370fb7022401b8a830ab84fbe713c4fd33de4bb84daa73f4101
+  metadata.gz: 0ef2274984450ba2915867f37000b443ffd18a51eeb497adecaaaeae7d0821ae
+  data.tar.gz: ddab73410ef68b0a65f02ed24f9e7177ea43f6779015aa9f5208d4583f8f2882
 SHA512:
-  metadata.gz: 59cccc7dd3abea33e60cc44be7ee1f9406dccff627ff560cdd76c1e5cff66ec6d255df87d666637745efe9e13630c5f668ff9b6454472deb6a16653740401ca2
-  data.tar.gz: dc3d890966553c776ea4b5a0269c75bc8690f9b591d0f18538d81bade8b8facd9670a750626d096edb359313964c66aa10b2318ebe1517d10e591a7c796ae691
+  metadata.gz: 0c794e11db75f222df975ddf31d0e0c9ff2c37ed7dc33e9c6707a5addfd53c12265f45b8808a3c5d7eebbf426674ccf8442bc3f74ec367ee4f67467ed8e0ea51
+  data.tar.gz: 235ed83fe57e9db74fb93803e83820ecba0aea31a673ede0ae6b485a8d4c219394cf1cd0ceb04efd06048e554039105a05538fda8eb520404f9eaf7bb904c1fd

data/lib/datory/attributes/attribute.rb

@@ -10,7 +10,22 @@ module Datory
         @options = options
       end
 
-      def input_options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def input_serialization_options
+        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 (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,9 +38,9 @@ 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)
         }
@@ -37,7 +52,30 @@ module Datory
         hash
       end
 
-      def output_options # rubocop:disable Metrics/MethodLength
+      def output_serialization_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 (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 (format = options.fetch(:format, nil)).present?
+          hash[:format] = format
+        end
+
+        hash
+      end
+
+      def output_deserialization_options # rubocop:disable Metrics/MethodLength
         hash = {
           consists_of: if (consists_of_type = options.fetch(:consists_of, false)) == Hash
                          Datory::Result

data/lib/datory/attributes/collection.rb

@@ -13,6 +13,10 @@ module Datory
       def names
         map(&:name)
       end
+
+      def internal_names
+        map { |attribute| attribute.options.fetch(:to, attribute.name) }
+      end
     end
   end
 end

data/lib/datory/attributes/descriptor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    class Descriptor
+      def self.describe(...)
+        new.describe(...)
+      end
+
+      def describe(service_class_name:, collection_of_attributes:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        headings = []
+        rows = []
+
+        headings << "Attribute"
+        headings << "From"
+        headings << "To"
+        headings << "As"
+
+        collection_of_attributes.each do |attribute|
+          row = []
+
+          row << attribute.name
+
+          from_type = attribute.options.fetch(:from)
+
+          row << from_type
+          row << attribute.options.fetch(:to, attribute.name)
+          row << attribute.options.fetch(:as, attribute.options.fetch(:include, from_type))
+
+          rows << row
+        end
+
+        Datory::Console.print_table(title: service_class_name, headings: headings.uniq, rows: rows)
+      end
+    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/{tools → deserialization}/service_factory.rb

@@ -2,7 +2,7 @@
 
 module Datory
   module Attributes
-    module Tools
+    module Deserialization
       class ServiceFactory
         def self.create(...)
           new(...).create
@@ -13,50 +13,39 @@ module Datory
           @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)
 
+          class_sample = create_service_class
+
+          @model_class.const_set(ServiceBuilder::SERVICE_CLASS_NAME, class_sample)
+        end
+
+        def create_service_class # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           collection_of_attributes = @collection_of_attributes
 
-          class_sample = Class.new(Datory::Service::Builder) do
+          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
+              input attribute.name, **attribute.input_deserialization_options
 
-              output input_internal_name, **attribute.output_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)
 
-                option_as = attribute.options.fetch(:as, nil)
+                type_as = attribute.options.fetch(:as, nil)
 
-                value = Datory::Utils.transform_value_with(value, option_as)
+                value = Datory::Utils.transform_value_with(:d, value, type_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

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
 
         ########################################################################

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Datory
+  module Attributes
+    module Serialization
+      class Model
+        def self.prepare(...)
+          new.prepare(...)
+        end
+
+        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)
+
+            instance_variable_set(:"@#{key}", value)
+
+            if value.is_a?(Array)
+              value.map! { |item| Datory::Attributes::Serialization::Model.prepare(item) }
+              instance_variable_set(:"@#{key}", value)
+            elsif value.is_a?(Hash)
+              instance_variable_set(:"@#{key}", Datory::Attributes::Serialization::Model.prepare(value))
+            else
+              instance_variable_set(:"@#{key}", value)
+            end
+          end
+
+          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
+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)
@@ -39,7 +39,7 @@ module Datory
                   output_formatter.call(value: value)
                 elsif [Date, Time, DateTime].include?(value.class)
                   value.to_s
-                elsif ActiveSupport::Duration == value.class
+                elsif value.instance_of?(ActiveSupport::Duration)
                   value.iso8601
                 else
                   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,52 @@
+# 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 # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          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
+            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/console.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module Datory
+  class Console
+    def self.print_table(headings:, rows:, title: nil)
+      table = Terminal::Table.new(
+        title: title,
+        headings: headings,
+        rows: rows,
+        style: { border_x: "~", border_i: "~" }
+      )
+
+      new(table.to_s).print
+    end
+
+    def initialize(text)
+      @text = text
+    end
+
+    def print
+      puts @text
+    end
+  end
+end

data/lib/datory/context/callable.rb

@@ -4,10 +4,19 @@ module Datory
   module Context
     module Callable
       def serialize(model)
-        Datory::Attributes::Serialization::Serializator.serialize(
-          model: model,
-          collection_of_attributes: collection_of_attributes
-        )
+        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)
@@ -16,32 +25,54 @@ module Datory
             deserialize(json_item)
           end
         else
+          context = send(:new)
           hash = JSON.parse(json.to_json)
-          build(**hash)
+
+          _deserialize(context, **hash)
         end
+      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(
-          :_build!,
+          :_serialize,
+          model: model,
+          collection_of_attributes: collection_of_attributes
+        )
+      end
+
+      def _deserialize(context, **attributes)
+        context.send(
+          :_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/utils.rb

@@ -4,7 +4,7 @@ module Datory
   module Utils
     module_function
 
-    TRANSFORMATIONS = {
+    D_TRANSFORMATIONS = {
       Symbol => ->(value) { value.to_sym },
       String => ->(value) { value.to_s },
       Integer => ->(value) { value.to_i },
@@ -15,10 +15,27 @@ module Datory
       ActiveSupport::Duration => ->(value) { ActiveSupport::Duration.parse(value) }
     }.freeze
 
-    private_constant :TRANSFORMATIONS
+    private_constant :D_TRANSFORMATIONS
 
-    def transform_value_with(value, type)
-      TRANSFORMATIONS.fetch(type, ->(v) { v }).call(value)
+    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

data/lib/datory/version.rb

@@ -5,7 +5,7 @@ module Datory
     MAJOR = 1
     MINOR = 0
     PATCH = 0
-    PRE = "rc9"
+    PRE = "rc11"
 
     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.rc9
+  version: 1.0.0.rc11
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,6 +58,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.5.0.rc6
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -198,16 +212,22 @@ files:
 - lib/datory.rb
 - 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
 - lib/datory/context/callable.rb
 - lib/datory/context/dsl.rb
 - lib/datory/context/workspace.rb
 - lib/datory/engine.rb
+- lib/datory/exceptions.rb
 - lib/datory/result.rb
 - lib/datory/service/base.rb
 - lib/datory/service/builder.rb