u-attributes 2.1.0 → 2.5.0

data/lib/micro/attributes/features/activemodel_validations.rb

@@ -3,13 +3,45 @@
 module Micro::Attributes
   module Features
     module ActiveModelValidations
-      def self.included(base)
-        begin
-          require 'active_model'
+      module Standard
+        private def __call_after_attributes_assign
+          run_validations!
+        end
+      end
 
-          base.send(:include, ::ActiveModel::Validations)
-          base.extend(ClassMethods)
-        rescue LoadError
+      module CheckActivemodelValidationErrors
+        private def __check_activemodel_validation_errors
+          return if errors.blank?
+
+          errors_hash = errors.to_hash
+
+          defined_attributes.each do |key|
+            value = Utils::Hashes.assoc(errors_hash, key)
+
+            @__attributes_errors[key] = value.join(', ') if value.present?
+          end
+        end
+      end
+
+      module WithAccept
+        include CheckActivemodelValidationErrors
+
+        private def __call_after_attributes_assign
+          run_validations! unless attributes_errors?
+
+          __check_activemodel_validation_errors
+        end
+      end
+
+      module WithAcceptStrict
+        include CheckActivemodelValidationErrors
+
+        private def __call_after_attributes_assign
+          __raise_error_if_found_attributes_errors if attributes_errors?
+
+          run_validations!
+
+          __check_activemodel_validation_errors
         end
       end
 
@@ -18,15 +50,27 @@ module Micro::Attributes
           validate, validates = options.values_at(:validate, :validates)
 
           self.validate(validate) if validate
-          self.validates(attr_name, validates) if validates
+          self.validates(attr_name, validates.dup) if validates
         end
       end
 
-      private
+      def self.included(base)
+        begin
+          require 'active_model'
+
+          base.send(:include, ::ActiveModel::Validations)
+          base.extend(ClassMethods)
 
-        def __call_after_micro_attribute
-          run_validations! if respond_to?(:run_validations!, true)
+          case
+          when base <= Features::Accept::Strict then base.send(:include, WithAcceptStrict)
+          when base <= Features::Accept then base.send(:include, WithAccept)
+          else base.send(:include, Standard)
+          end
+        rescue LoadError
         end
+      end
+
+      private_constant :Standard, :CheckActivemodelValidationErrors, :WithAccept, :WithAcceptStrict
     end
   end
 end

data/lib/micro/attributes/features/initialize.rb

@@ -7,22 +7,17 @@ module Micro::Attributes
         base.class_eval(<<-RUBY)
           def initialize(arg)
             self.attributes = arg
-            __call_after_micro_attribute
           end
         RUBY
       end
 
-      def with_attribute(key, val)
-        self.class.new(attributes.merge(key => val))
-      end
-
       def with_attributes(arg)
         self.class.new(attributes.merge(arg))
       end
 
-      private
-
-        def __call_after_micro_attribute; end
+      def with_attribute(key, val)
+        with_attributes(key => val)
+      end
     end
   end
 end

data/lib/micro/attributes/features/keys_as_symbol.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Micro::Attributes
+  module Features
+    module KeysAsSymbol
+
+      module ClassMethods
+        def attributes_access
+          :symbol
+        end
+
+        def __attribute_key_check__(value)
+          Kind::Of.(::Symbol, value)
+        end
+
+        def __attribute_key_transform__(value)
+          value
+        end
+
+        def __attributes_keys_transform__(hash)
+          Utils::Hashes.kind(hash)
+        end
+      end
+
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/micro/attributes/macros.rb

@@ -7,6 +7,22 @@ module Micro
         false
       end
 
+      def attributes_access
+        :indifferent
+      end
+
+      def __attribute_key_check__(value)
+        value
+      end
+
+      def __attribute_key_transform__(value)
+        value.to_s
+      end
+
+      def __attributes_keys_transform__(hash)
+        Utils::Hashes.stringify_keys(hash)
+      end
+
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_data__
         @__attributes_data__ ||= {}
@@ -16,18 +32,54 @@ module Micro
         @__attributes_required__ ||= Set.new
       end
 
-      def __attributes_required_add(name, is_required, hasnt_default)
-        if is_required || (attributes_are_all_required? && hasnt_default)
+      def __attributes_required_add(name, opt, hasnt_default)
+        if opt[:required] || (attributes_are_all_required? && hasnt_default)
           __attributes_required__.add(name)
         end
 
         nil
       end
 
-      def __attributes_data_to_assign(name, options)
-        hasnt_default = !options.key?(:default)
+      module Options
+        PERMITTED = [
+          :default, :required,
+          :validate, :validates, # activemodel_validations
+          :accept, :reject, :allow_nil, :rejection_message # accept
+        ].freeze
+
+        INVALID_MESSAGE = [
+          "Found one or more invalid options: %{invalid_options}\n\nThe valid ones are: ",
+          PERMITTED.map { |key| ":#{key}" }.join(', ')
+        ].join.freeze
+
+        def self.check(opt)
+          invalid_keys = opt.keys - PERMITTED
+
+          return if invalid_keys.empty?
+
+          invalid_options = { invalid_options: invalid_keys.inspect.tr('[', '').tr(']', '') }
+
+          raise ArgumentError, (INVALID_MESSAGE % invalid_options)
+        end
 
-        hasnt_default ? __attributes_required_add(name, options[:required], hasnt_default) : options[:default]
+        def self.for_accept(opt)
+          allow_nil = opt[:allow_nil]
+          rejection_message = opt[:rejection_message]
+
+          return [:accept, opt[:accept], allow_nil, rejection_message] if opt.key?(:accept)
+          return [:reject, opt[:reject], allow_nil, rejection_message] if opt.key?(:reject)
+
+          Kind::Empty::ARRAY
+        end
+      end
+
+      def __attributes_data_to_assign(name, opt)
+        hasnt_default = !opt.key?(:default)
+
+        [
+          hasnt_default ? __attributes_required_add(name, opt, hasnt_default) : opt[:default],
+          Options.for_accept(opt)
+        ]
       end
 
       def __attributes
@@ -40,15 +92,18 @@ module Micro
         attr_reader(name)
       end
 
-      def __attribute_assign(key, can_overwrite, options)
-        name = key.to_s
+      def __attribute_assign(key, can_overwrite, opt)
+        name = __attribute_key_check__(__attribute_key_transform__(key))
+
+        Options.check(opt)
+
         has_attribute = attribute?(name)
 
         __attribute_reader(name) unless has_attribute
 
-        __attributes_data__[name] = __attributes_data_to_assign(name, options) if can_overwrite || !has_attribute
+        __attributes_data__[name] = __attributes_data_to_assign(name, opt) if can_overwrite || !has_attribute
 
-        __call_after_attribute_assign__(name, options)
+        __call_after_attribute_assign__(name, opt)
       end
 
       def __call_after_attribute_assign__(attr_name, options); end
@@ -56,12 +111,20 @@ module Micro
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_set_after_inherit__(arg)
         arg.each do |key, val|
-          __attribute_assign(key, true, val ? { default: val } : {})
+          opt = if default = val[0]
+            requ_key, requ_val = val[1]
+
+            hash = requ_key ? { requ_key => requ_val } : {}
+            hash[:default] = default
+            hash
+          end
+
+          __attribute_assign(key, true, opt || Kind::Empty::HASH)
         end
       end
 
       def attribute?(name)
-        __attributes.member?(name.to_s)
+        __attributes.member?(__attribute_key_transform__(name))
       end
 
       def attribute(name, options = Kind::Empty::HASH)
@@ -72,9 +135,13 @@ module Micro
         return __attributes.to_a if args.empty?
 
         args.flatten!
+
+        options =
+          args.size > 1 && args.last.is_a?(::Hash) ? args.pop : Kind::Empty::HASH
+
         args.each do |arg|
           if arg.is_a?(String) || arg.is_a?(Symbol)
-            __attribute_assign(arg, false, Kind::Empty::HASH)
+            __attribute_assign(arg, false, options)
           else
             raise Kind::Error.new('String/Symbol'.freeze, arg)
           end
@@ -92,7 +159,7 @@ module Micro
         private_constant :WRONG_NUMBER_OF_ARGS
       end
 
-      private_constant :ForSubclasses
+      private_constant :Options, :ForSubclasses
     end
 
     private_constant :Macros

data/lib/micro/attributes/utils.rb

@@ -1,25 +1,58 @@
 # frozen_string_literal: true
 
-module Micro
-  module Attributes
-    module Utils
-      def self.stringify_hash_keys(arg)
-        hash = Kind::Of.(::Hash, arg)
+module Micro::Attributes
+  module Utils
+    module Hashes
+      def self.kind(hash)
+        Kind::Of.(::Hash, hash)
+      end
+
+      def self.stringify_keys(arg)
+        hash = kind(arg)
 
         return hash if hash.empty?
+        return hash.transform_keys(&:to_s) if hash.respond_to?(:transform_keys)
 
-        if hash.respond_to?(:transform_keys)
-          hash.transform_keys { |key| key.to_s }
-        else
-          hash.each_with_object({}) { |(key, val), memo| memo[key.to_s] = val }
-        end
+        hash.each_with_object({}) { |(key, val), memo| memo[key.to_s] = val }
+      end
+
+      def self.symbolize_keys(arg)
+        hash = kind(arg)
+
+        return hash if hash.empty?
+        return hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys)
+
+        hash.each_with_object({}) { |(key, val), memo| memo[key.to_sym] = val }
+      end
+
+      def self.keys_as(type, hash)
+        return kind(hash) unless type
+
+        return symbolize_keys(hash) if type == Symbol || type == :symbol
+        return stringify_keys(hash) if type == String || type == :string
+
+        raise ArgumentError, 'argument must be one of these values: :symbol, :string, Symbol, String'.freeze
+      end
+
+      def self.assoc(hash, key)
+        value = hash[key.to_s]
+
+        value.nil? ? hash[key.to_sym] : value
       end
+    end
+
+    module ExtractAttribute
+      def self.call(object, key:)
+        return object.public_send(key) if object.respond_to?(key)
 
-      HashAccess = -> (hash, key) {
-        return hash[key.to_s] unless hash[key.to_s].nil?
+        Hashes.assoc(object, key) if object.respond_to?(:[])
+      end
 
-        hash[key.to_sym]
-      }
+      def self.from(object, keys:)
+        Kind::Of.(::Array, keys).each_with_object({}) do |key, memo|
+          memo[key] = call(object, key: key)
+        end
+      end
     end
   end
 end

data/lib/micro/attributes/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Attributes
-    VERSION = '2.1.0'.freeze
+    VERSION = '2.5.0'.freeze
   end
 end

data/u-attributes.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets)/}) }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-23 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -76,20 +76,21 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- assets/u-attributes_logo_v1.png
 - bin/console
 - bin/setup
 - lib/micro/attributes.rb
 - lib/micro/attributes/diff.rb
 - lib/micro/attributes/features.rb
+- lib/micro/attributes/features/accept.rb
+- lib/micro/attributes/features/accept/strict.rb
 - lib/micro/attributes/features/activemodel_validations.rb
 - lib/micro/attributes/features/diff.rb
 - lib/micro/attributes/features/initialize.rb
 - lib/micro/attributes/features/initialize/strict.rb
+- lib/micro/attributes/features/keys_as_symbol.rb
 - lib/micro/attributes/macros.rb
 - lib/micro/attributes/utils.rb
 - lib/micro/attributes/version.rb
-- lib/micro/attributes/with.rb
 - lib/u-attributes.rb
 - test.sh
 - u-attributes.gemspec

data/lib/micro/attributes/with.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'micro/attributes/features/diff'
-require 'micro/attributes/features/initialize'
-require 'micro/attributes/features/initialize/strict'
-require 'micro/attributes/features/activemodel_validations'
-
-module Micro
-  module Attributes
-    module With
-      #
-      # Features
-      #
-      module Diff
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module Initialize
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-        end
-      end
-
-      module ActiveModelValidations
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-        end
-      end
-
-      module StrictInitialize
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      #
-      # Combinations
-      #
-      module DiffAndInitialize
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module DiffAndStrictInitialize
-        def self.included(base)
-          base.send(:include, DiffAndInitialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module ActiveModelValidationsAndDiff
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module ActiveModelValidationsAndInitialize
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-        end
-      end
-
-      module ActiveModelValidationsAndStrictInitialize
-        def self.included(base)
-          base.send(:include, ActiveModelValidationsAndInitialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module ActiveModelValidationsAndDiffAndInitialize
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module ActiveModelValidationsAndDiffAndStrictInitialize
-        def self.included(base)
-          base.send(:include, ActiveModelValidationsAndDiffAndInitialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-    end
-  end
-end