datory 1.0.0.rc3 → 1.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8562a68170d39d6d97a80eceae372d7f043cbb08db2890faa2d6d22a792748bf
-  data.tar.gz: 89ef0b5c9a73289a3567e01202a9a83beeaefee6db2f084168c6e755da4e3044
+  metadata.gz: 5ca68aea305e426d629f97a3d8940e016a933e4298e56b7ab7d3f9e495fb515d
+  data.tar.gz: 3589f41e040965dacdbaa9f22d197c837afd96f6a5d34e6b32b93e2043ce2391
 SHA512:
-  metadata.gz: 3c6ed842a16e265979fc1d5ebc4b517390884bac7118500d39cc48d6b180c7c842b08cadfdf853db111b2a56a8c016cbcbf9654d4b290272399f461d9eec48ba
-  data.tar.gz: 6428856321dd65efb127aca09955e5e34eb1d3cff3cdc2f8da0fd669e4556582ecef976919b60f6808ce84a602a9dc60f332ffcc42b0421c613b0dc43d1ff429
+  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

@@ -30,46 +30,46 @@ module Datory
         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)
+        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

@@ -18,7 +18,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

@@ -21,20 +21,20 @@ module Datory
 
           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_internal_name = attribute.options.fetch(:to, attribute.name)
 
               input attribute.name,
                     as: input_internal_name,
-                    type: attribute.options.fetch(:type),
+                    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?
 
-                      type = attribute.options.fetch(:type, nil)
+                      from_type = attribute.options.fetch(:from, nil)
 
-                      if [Set, Array].include?(type)
+                      if [Set, Array].include?(from_type)
                         value.map { |item| include_class.build(**item) }
                       else
                         include_class.build(**value)
@@ -42,23 +42,37 @@ module Datory
                     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
+                     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
-                             type
+                             from_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))
+                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
 

data/lib/datory/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datory
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc3
+  version: 1.0.0.rc4
 platform: ruby
 authors:
 - Anton Sokolov