u-attributes 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62c6ad9683f0824be6a32648028f25a97ba88a10c7fbdd0b9a2ccfbfe275961b
-  data.tar.gz: d110a1b4220af76a7f14753cb1ca5067428f06db026466e095d54a22ee46f86f
+  metadata.gz: 01dbce30afd7d116e15ea5985e5012d86f2bd110b017394151086df322e9b7ed
+  data.tar.gz: 4004e27e835cc216807b2fb2781a15911c16f2ba20e509b7c36188a8b6021f95
 SHA512:
-  metadata.gz: 24703dcd81aa785fe00b77a741434ad84600243f4bb132d2bbbce2b5a310d4f2b931c2b6ea41e311a2bcf07876296bd03d8e6c39a92905bc9a4f745fdb30a094
-  data.tar.gz: 8172811ddaf44a3099e66f63cea5aed99d5c1a63a77944dc1e98c16fa0378603498fbdfe0c77f7220244c8d7b977801a75bd01facc875fb05f0bd1aed0171cc5
+  metadata.gz: ca177ca900f63a07901366612f5ef545512db4e8f9b48bea6482403af6346324784910fa9dca963e681449a1d3b583b173317890b76e8a2e03fd46b58af32006
+  data.tar.gz: 44372485364d637906d1dad476fc58a98cf228c33e252012af320e7e1da36b82db3943eb635ed34dff211908088f6fc8fe3c2de8a1b9a418f62f8e8b3e1596ed

data/README.md

@@ -85,7 +85,7 @@ gem 'u-attributes'
 
 | u-attributes   | branch  | ruby     |  activemodel  |
 | -------------- | ------- | -------- | ------------- |
-| 2.4.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.5.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
 | 1.2.0          | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
 > **Note**: The activemodel is an optional dependency, this module [can be enabled](#activemodelvalidation-extension) to validate the attributes.
@@ -618,7 +618,7 @@ The method `Micro::Attributes.with()` will raise an exception if no arguments/fe
 
 ```ruby
 class Job
-  include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: :activemodel_validations, :diff, :initialize, :keys_as_symbol)
+  include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: :accept, :activemodel_validations, :diff, :initialize, :keys_as_symbol)
 end
 ```
 

data/lib/micro/attributes.rb

@@ -16,6 +16,7 @@ module Micro
       base.class_eval do
         private_class_method :__attributes, :__attribute_reader
         private_class_method :__attribute_assign, :__attributes_data_to_assign
+        private_class_method :__attributes_required_add, :__attributes_data_to_assign
       end
 
       def base.inherited(subclass)
@@ -86,29 +87,36 @@ module Micro
     protected
 
       def attributes=(arg)
-        hash = self.class.__attributes_keys__(arg)
+        hash = self.class.__attributes_keys_transform__(arg)
 
         __attributes_missing!(hash)
 
+        __call_before_attributes_assign
         __attributes_assign(hash)
+        __call_after_attributes_assign
+
+        __attributes
       end
 
     private
 
+      def __call_before_attributes_assign; end
+      def __call_after_attributes_assign; end
+
       def extract_attributes_from(other)
         Utils::ExtractAttribute.from(other, keys: defined_attributes)
       end
 
       def __attribute_key(value)
-        self.class.__attribute_key__(value)
+        self.class.__attribute_key_transform__(value)
       end
 
       def __attributes
         @__attributes ||= {}
       end
 
-      FetchValueToAssign = -> (value, default) do
-        if default.is_a?(Proc)
+      FetchValueToAssign = -> (value, default, keep_proc = false) do
+        if default.is_a?(Proc) && !keep_proc
           default.arity > 0 ? default.call(value) : default.call
         else
           value.nil? ? default : value
@@ -116,15 +124,17 @@ module Micro
       end
 
       def __attributes_assign(hash)
-        self.class.__attributes_data__.each do |name, default|
-          __attribute_assign(name, FetchValueToAssign.(hash[name], default)) if attribute?(name)
+        self.class.__attributes_data__.each do |name, attribute_data|
+          __attribute_assign(name, hash[name], attribute_data) if attribute?(name)
         end
 
         __attributes.freeze
       end
 
-      def __attribute_assign(name, value)
-        __attributes[name] = instance_variable_set("@#{name}", value)
+      def __attribute_assign(name, initialize_value, attribute_data)
+        value_to_assign = FetchValueToAssign.(initialize_value, attribute_data[0])
+
+        __attributes[name] = instance_variable_set("@#{name}", value_to_assign)
       end
 
       MISSING_KEYWORD = 'missing keyword'.freeze

data/lib/micro/attributes/diff.rb

@@ -35,17 +35,17 @@ module Micro::Attributes
 
           raise ArgumentError, FROM_TO_ERROR
         elsif from.nil? && to.nil?
-          differences.has_key?(key_access(name))
+          differences.has_key?(key_transform(name))
         else
-          result = @differences[key_access(name)]
+          result = @differences[key_transform(name)]
           result ? result[@from_key] == from && result[@to_key] == to : false
         end
       end
 
       private
 
-        def key_access(key)
-          @from_class.__attribute_key__(key)
+        def key_transform(key)
+          @from_class.__attribute_key_transform__(key)
         end
 
         def diff(from_attributes, to_attributes)

data/lib/micro/attributes/features.rb

@@ -1,15 +1,25 @@
 # frozen_string_literal: true
 
-require 'micro/attributes/with'
-
 module Micro
   module Attributes
+    module With
+    end
+
     module Features
+      require 'micro/attributes/features/diff'
+      require 'micro/attributes/features/accept'
+      require 'micro/attributes/features/accept/strict'
+      require 'micro/attributes/features/initialize'
+      require 'micro/attributes/features/initialize/strict'
+      require 'micro/attributes/features/keys_as_symbol'
+      require 'micro/attributes/features/activemodel_validations'
+
       extend self
 
       module Name
         ALL = [
           DIFF = 'diff'.freeze,
+          ACCEPT = 'accept'.freeze,
           INITIALIZE = 'initialize'.freeze,
           KEYS_AS_SYMBOL = 'keys_as_symbol'.freeze,
           ACTIVEMODEL_VALIDATIONS = 'activemodel_validations'.freeze
@@ -19,36 +29,74 @@ module Micro
       module Options
         KEYS = [
           DIFF = 'Diff'.freeze,
-          INIT = 'Init'.freeze,
-          INIT_STRICT = 'InitStrict'.freeze,
+          INIT = 'Initialize'.freeze,
+          ACCEPT = 'Accept'.freeze,
+          INIT_STRICT = 'InitializeStrict'.freeze,
+          ACCEPT_STRICT = 'AcceptStrict'.freeze,
           KEYS_AS_SYMBOL = 'KeysAsSymbol'.freeze,
-          AM_VALIDATIONS = 'AMValidations'.freeze
+          AM_VALIDATIONS = 'ActiveModelValidations'.freeze
         ].sort.freeze
 
+        KEYS_TO_FEATURES = {
+          DIFF => Features::Diff,
+          INIT => Features::Initialize,
+          ACCEPT => Features::Accept,
+          INIT_STRICT => Features::Initialize::Strict,
+          ACCEPT_STRICT => Features::Accept::Strict,
+          KEYS_AS_SYMBOL => Features::KeysAsSymbol,
+          AM_VALIDATIONS => Features::ActiveModelValidations
+        }.freeze
+
         NAMES_TO_KEYS = {
           Name::DIFF => DIFF,
+          Name::ACCEPT => ACCEPT,
           Name::INITIALIZE => INIT,
           Name::KEYS_AS_SYMBOL => KEYS_AS_SYMBOL,
           Name::ACTIVEMODEL_VALIDATIONS => AM_VALIDATIONS
         }.freeze
 
-        KEYS_TO_MODULES = {
-          DIFF => With::Diff,
-          INIT => With::Initialize,
-          INIT_STRICT => With::StrictInitialize,
-          KEYS_AS_SYMBOL => With::KeysAsSymbol,
-          AM_VALIDATIONS => With::ActiveModelValidations
-        }.freeze
+        INIT_INIT_STRICT = "#{INIT}_#{INIT_STRICT}".freeze
+        ACCEPT_ACCEPT_STRICT = "#{ACCEPT}_#{ACCEPT_STRICT}".freeze
+
+        BuildKey = -> combination do
+          combination.sort.join('_')
+            .sub(INIT_INIT_STRICT, INIT_STRICT)
+            .sub(ACCEPT_ACCEPT_STRICT, ACCEPT_STRICT)
+        end
+
+        KEYS_TO_MODULES = begin
+          combinations = (1..KEYS.size).map { |n| KEYS.combination(n).to_a }.flatten(1).sort_by { |i| "#{i.size}#{i.join}" }
+          combinations.delete_if { |combination| combination.include?(INIT_STRICT) && !combination.include?(INIT) }
+          combinations.delete_if { |combination| combination.include?(ACCEPT_STRICT) && !combination.include?(ACCEPT) }
+          combinations.each_with_object({}) do |combination, features|
+            included = [
+              'def self.included(base)',
+              '  base.send(:include, ::Micro::Attributes)',
+              combination.map { |key| "  base.send(:include, ::#{KEYS_TO_FEATURES[key].name})" },
+              'end'
+            ].flatten.join("\n")
+
+            key = BuildKey.call(combination)
+
+            With.const_set(key, Module.new.tap { |mod| mod.instance_eval(included) })
+
+            features[key] = With.const_get(key, false)
+          end.freeze
+        end
+
+        ACTIVEMODEL_VALIDATION = 'activemodel_validation'.freeze
 
         def self.fetch_key(arg)
           if arg.is_a?(Hash)
+            return ACCEPT_STRICT if arg[:accept] == :strict
+
             INIT_STRICT if arg[:initialize] == :strict
           else
-            name = String(arg)
+            str = String(arg)
 
-            return name if KEYS_TO_MODULES.key?(name)
+            name = str == ACTIVEMODEL_VALIDATION ? Name::ACTIVEMODEL_VALIDATIONS : str
 
-            NAMES_TO_KEYS[name]
+            KEYS_TO_MODULES.key?(name) ? name : NAMES_TO_KEYS[name]
           end
         end
 
@@ -65,23 +113,26 @@ module Micro
           yield(keys)
         end
 
-        def self.remove_init_keys(keys, if_has_init_in:)
-          keys.delete_if { |key| key == INIT || key == INIT_STRICT } if if_has_init_in.include?(INIT)
+        def self.remove_base_if_has_strict(keys)
+          keys.delete_if { |key| key == INIT } if keys.include?(INIT_STRICT)
+          keys.delete_if { |key| key == ACCEPT } if keys.include?(ACCEPT_STRICT)
         end
 
         def self.without_keys(keys_to_exclude)
-          (KEYS - keys_to_exclude).tap do |keys|
-            remove_init_keys(keys, if_has_init_in: keys_to_exclude)
-          end
+          keys = (KEYS - keys_to_exclude)
+          keys.delete_if { |key| key == INIT || key == INIT_STRICT } if keys_to_exclude.include?(INIT)
+          keys.delete_if { |key| key == ACCEPT || key == ACCEPT_STRICT } if keys_to_exclude.include?(ACCEPT)
+          keys
         end
 
-        def self.fetch_module_by_keys(keys)
-          keys.delete_if { |key| key == INIT } if keys.include?(INIT_STRICT)
-
-          option = keys.sort.join('_')
+        def self.fetch_module_by_keys(combination)
+          key = BuildKey.call(combination)
 
-          KEYS_TO_MODULES.fetch(option) { With.const_get(option, false) }
+          KEYS_TO_MODULES.fetch(key)
         end
+
+        private_constant :KEYS_TO_FEATURES, :NAMES_TO_KEYS, :INVALID_NAME
+        private_constant :INIT_INIT_STRICT, :ACCEPT_ACCEPT_STRICT, :BuildKey
       end
 
       def all
@@ -90,17 +141,24 @@ module Micro
 
       def with(names)
         Options.fetch_keys(names) do |keys|
+          Options.remove_base_if_has_strict(keys)
+
           Options.fetch_module_by_keys(keys)
         end
       end
 
       def without(names)
         Options.fetch_keys(names) do |keys|
-          keys = Options.without_keys(keys)
+          keys_to_fetch = Options.without_keys(keys)
 
-          keys.empty? ? ::Micro::Attributes : Options.fetch_module_by_keys(keys)
+          return ::Micro::Attributes if keys_to_fetch.empty?
+
+          Options.fetch_module_by_keys(keys_to_fetch)
         end
       end
+
+      private_constant :Name
     end
+
   end
 end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Micro::Attributes
+  module Features
+    module Accept
+      def attributes_errors
+        @__attributes_errors
+      end
+
+      def attributes_errors?
+        !@__attributes_errors.empty?
+      end
+
+      def rejected_attributes
+        @__rejected_attributes ||= attributes_errors.keys
+      end
+
+      def accepted_attributes
+        @__accepted_attributes ||= defined_attributes - rejected_attributes
+      end
+
+      def rejected_attributes?
+        attributes_errors?
+      end
+
+      def accepted_attributes?
+        !rejected_attributes?
+      end
+
+      private
+
+        def __call_before_attributes_assign
+          @__attributes_errors = {}
+        end
+
+        KeepProc = -> validation_data { validation_data[0] == :accept && validation_data[1] == Proc }
+
+        def __attribute_assign(key, initialize_value, attribute_data)
+          validation_data = attribute_data[1]
+
+          value_to_assign = FetchValueToAssign.(initialize_value, attribute_data[0], KeepProc.(validation_data))
+
+          value = __attributes[key] = instance_variable_set("@#{key}", value_to_assign)
+
+          __attribute_accept_or_reject(key, value, validation_data) if !validation_data.empty?
+        end
+
+        def __attribute_accept_or_reject(key, value, validation_data)
+          context = Context.with(key, value, validation_data)
+
+          error_msg = context.rejection_message(Validate.call(context))
+
+          @__attributes_errors[key] = error_msg if error_msg
+        end
+
+        Context = Struct.new(:key, :value, :validation, :expected, :allow_nil, :rejection) do
+          def self.with(key, value, data)
+            new(key, value, data[0], data[1], data[2], data[3])
+          end
+
+          def allow_nil?
+            allow_nil && value.nil?
+          end
+
+          def accept?
+            validation == :accept
+          end
+
+          def rejection_message(default_msg)
+            return unless default_msg
+
+            return default_msg unless rejection || expected.respond_to?(:rejection_message)
+
+            rejection_msg = rejection || expected.rejection_message
+
+            return rejection_msg unless rejection_msg.is_a?(Proc)
+
+            rejection_msg.arity == 0 ? rejection_msg.call : rejection_msg.call(key)
+          end
+        end
+
+        module Validate
+          module Callable
+            MESSAGE = 'is invalid'.freeze
+
+            def self.call?(exp); exp.respond_to?(:call); end
+            def self.call(exp, val); exp.call(val); end
+            def self.accept_failed(_exp); MESSAGE; end
+            def self.reject_failed(_exp); MESSAGE; end
+          end
+
+          module KindOf
+            def self.call?(exp); exp.is_a?(Class) || exp.is_a?(Module); end
+            def self.call(exp, val); val.kind_of?(exp); end
+            def self.accept_failed(exp); "expected to be a kind of #{exp}"; end
+            def self.reject_failed(exp); "expected to not be a kind of #{exp}"; end
+          end
+
+          module Predicate
+            QUESTION_MARK = '?'.freeze
+
+            def self.call?(exp); exp.is_a?(Symbol) && exp.to_s.end_with?(QUESTION_MARK); end
+            def self.call(exp, val); val.public_send(exp); end
+            def self.accept_failed(exp); "expected to be #{exp}"; end
+            def self.reject_failed(exp); "expected to not be #{exp}"; end
+          end
+
+          def self.with(expected)
+            return Callable if Callable.call?(expected)
+            return KindOf if KindOf.call?(expected)
+            return Predicate if Predicate.call?(expected)
+          end
+
+          def self.call(context)
+            return if context.allow_nil?
+
+            validate = self.with(expected = context.expected)
+
+            return unless validate
+
+            truthy = validate.call(expected, context.value)
+
+            return truthy ? nil : validate.accept_failed(expected) if context.accept?
+
+            validate.reject_failed(expected) if truthy
+          end
+        end
+
+        private_constant :KeepProc, :Context, :Validate
+    end
+  end
+end

data/lib/micro/attributes/features/accept/strict.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Micro::Attributes
+  module Features
+    module Accept
+
+      module Strict
+        ATTRIBUTES_REJECTED = "One or more attributes were rejected. Errors:\n".freeze
+
+        def __call_after_attributes_assign
+          return unless attributes_errors?
+
+          __raise_error_if_found_attributes_errors
+        end
+
+        def __raise_error_if_found_attributes_errors
+          raise ArgumentError, [
+            ATTRIBUTES_REJECTED,
+            attributes_errors.map { |key, msg| "* #{key.inspect} #{msg}" }.join("\n")
+          ].join
+        end
+      end
+
+    end
+  end
+end

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
 
@@ -22,11 +54,23 @@ module Micro::Attributes
         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

@@ -9,15 +9,15 @@ module Micro::Attributes
           :symbol
         end
 
-        def __attribute_access__(value)
+        def __attribute_key_check__(value)
           Kind::Of.(::Symbol, value)
         end
 
-        def __attribute_key__(value)
+        def __attribute_key_transform__(value)
           value
         end
 
-        def __attributes_keys__(hash)
+        def __attributes_keys_transform__(hash)
           Utils::Hashes.kind(hash)
         end
       end

data/lib/micro/attributes/macros.rb

@@ -11,15 +11,15 @@ module Micro
         :indifferent
       end
 
-      def __attribute_access__(value)
+      def __attribute_key_check__(value)
         value
       end
 
-      def __attribute_key__(value)
+      def __attribute_key_transform__(value)
         value.to_s
       end
 
-      def __attributes_keys__(hash)
+      def __attributes_keys_transform__(hash)
         Utils::Hashes.stringify_keys(hash)
       end
 
@@ -32,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
 
-        hasnt_default ? __attributes_required_add(name, options[:required], hasnt_default) : options[:default]
+        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
+
+        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
@@ -56,15 +92,18 @@ module Micro
         attr_reader(name)
       end
 
-      def __attribute_assign(key, can_overwrite, options)
-        name = __attribute_access__(__attribute_key__(key))
+      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
@@ -72,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?(__attribute_key__(name))
+        __attributes.member?(__attribute_key_transform__(name))
       end
 
       def attribute(name, options = Kind::Empty::HASH)
@@ -112,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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-12 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -81,6 +81,8 @@ files:
 - 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
@@ -89,7 +91,6 @@ files:
 - 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,182 +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/keys_as_symbol'
-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 StrictInitialize
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module KeysAsSymbol
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module ActiveModelValidations
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-        end
-      end
-
-      #
-      # Combinations
-      #
-      module AMValidations_Diff
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module AMValidations_Diff_Init
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module AMValidations_Diff_Init_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_Diff_InitStrict
-        def self.included(base)
-          base.send(:include, AMValidations_Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module AMValidations_Diff_InitStrict_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, AMValidations_Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_Diff_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, AMValidations_Diff)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_Init
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-        end
-      end
-
-      module AMValidations_Init_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, AMValidations_Init)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_InitStrict
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module AMValidations_InitStrict_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, AMValidations_InitStrict)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module Diff_Init
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module Diff_Init_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module Diff_InitStrict
-        def self.included(base)
-          base.send(:include, Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module Diff_InitStrict_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, Diff_InitStrict)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module Diff_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, Diff)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module Init_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module InitStrict_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, StrictInitialize)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-    end
-  end
-end