u-attributes 2.1.0 → 2.5.0

data/lib/micro/attributes/diff.rb

@@ -3,15 +3,20 @@
 module Micro::Attributes
   module Diff
     class Changes
-      TO = 'to'.freeze
-      FROM = 'from'.freeze
+      FROM_TO_SYM = [:from, :to].freeze
+      FROM_TO_STR = ['from'.freeze, 'to'.freeze].freeze
       FROM_TO_ERROR = 'pass the attribute name with the :from and :to values'.freeze
 
       attr_reader :from, :to, :differences
 
       def initialize(from:, to:)
-        raise ArgumentError, "expected an instance of #{from.class}" unless to.is_a?(from.class)
-        @from, @to = from, to
+        @from_class = from.class
+
+        @from, @to = from, Kind::Of.(@from_class, to)
+
+        @from_key, @to_key =
+          @from_class.attributes_access == :symbol ? FROM_TO_SYM : FROM_TO_STR
+
         @differences = diff(from.attributes, to.attributes).freeze
       end
 
@@ -27,26 +32,33 @@ module Micro::Attributes
       def changed?(name = nil, from: nil, to: nil)
         if name.nil?
           return present? if from.nil? && to.nil?
+
           raise ArgumentError, FROM_TO_ERROR
         elsif from.nil? && to.nil?
-          differences.has_key?(name.to_s)
+          differences.has_key?(key_transform(name))
         else
-          result = @differences[name.to_s]
-          result ? result[FROM] == from && result[TO] == to : false
+          result = @differences[key_transform(name)]
+          result ? result[@from_key] == from && result[@to_key] == to : false
         end
       end
 
       private
 
-      def diff(from_attributes, to_attributes)
-        @from_attributes, @to_attributes = from_attributes, to_attributes
-        @from_attributes.each_with_object({}) do |(from_key, from_val), acc|
-          to_value = @to_attributes[from_key]
-          acc[from_key] = {FROM => from_val, TO => to_value}.freeze if from_val != to_value
+        def key_transform(key)
+          @from_class.__attribute_key_transform__(key)
+        end
+
+        def diff(from_attributes, to_attributes)
+          @from_attributes, @to_attributes = from_attributes, to_attributes
+
+          @from_attributes.each_with_object({}) do |(from_key, from_val), acc|
+            to_value = @to_attributes[from_key]
+
+            acc[from_key] = {@from_key => from_val, @to_key => to_value}.freeze if from_val != to_value
+          end
         end
-      end
 
-      private_constant :TO, :FROM, :FROM_TO_ERROR
+      private_constant :FROM_TO_SYM, :FROM_TO_STR, :FROM_TO_ERROR
     end
   end
 end

data/lib/micro/attributes/features.rb

@@ -1,111 +1,164 @@
 # frozen_string_literal: true
 
-require 'micro/attributes/with'
-
 module Micro
   module Attributes
+    module With
+    end
+
     module Features
-      extend self
+      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'
 
-      STRICT_INITIALIZE = 'strict_initialize'.freeze
-
-      ALL_VISIBLE = [
-        DIFF = 'diff'.freeze,
-        INITIALIZE = 'initialize'.freeze,
-        ACTIVEMODEL_VALIDATIONS = 'activemodel_validations'.freeze
-      ].sort.freeze
-
-      ALL = (ALL_VISIBLE + [STRICT_INITIALIZE]).sort.freeze
-
-      INVALID_NAME = [
-        'Invalid feature name! Available options: ',
-        ALL_VISIBLE.map { |feature_name| ":#{feature_name}" }.join(', ')
-      ].join
-
-      OPTIONS = {
-        # Features
-        DIFF => With::Diff,
-        INITIALIZE => With::Initialize,
-        STRICT_INITIALIZE => With::StrictInitialize,
-        ACTIVEMODEL_VALIDATIONS => With::ActiveModelValidations,
-        # Combinations
-        'diff:initialize' => With::DiffAndInitialize,
-        'diff:strict_initialize' => With::DiffAndStrictInitialize,
-        'activemodel_validations:diff' => With::ActiveModelValidationsAndDiff,
-        'activemodel_validations:initialize' => With::ActiveModelValidationsAndInitialize,
-        'activemodel_validations:strict_initialize' => With::ActiveModelValidationsAndStrictInitialize,
-        'activemodel_validations:diff:initialize' => With::ActiveModelValidationsAndDiffAndInitialize,
-        'activemodel_validations:diff:strict_initialize' => With::ActiveModelValidationsAndDiffAndStrictInitialize
-      }.freeze
-
-      private_constant :OPTIONS, :INVALID_NAME
+      extend self
 
-      def all
-        @all ||= self.with(ALL)
+      module Name
+        ALL = [
+          DIFF = 'diff'.freeze,
+          ACCEPT = 'accept'.freeze,
+          INITIALIZE = 'initialize'.freeze,
+          KEYS_AS_SYMBOL = 'keys_as_symbol'.freeze,
+          ACTIVEMODEL_VALIDATIONS = 'activemodel_validations'.freeze
+        ].sort.freeze
       end
 
-      def with(args)
-        valid_names!(args) do |names|
-          delete_initialize_if_has_strict_initialize(names)
-
-          OPTIONS.fetch(names.sort.join(':'))
+      module Options
+        KEYS = [
+          DIFF = 'Diff'.freeze,
+          INIT = 'Initialize'.freeze,
+          ACCEPT = 'Accept'.freeze,
+          INIT_STRICT = 'InitializeStrict'.freeze,
+          ACCEPT_STRICT = 'AcceptStrict'.freeze,
+          KEYS_AS_SYMBOL = 'KeysAsSymbol'.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
+
+        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
-      end
 
-      def without(args)
-        valid_names!(args) do |names_to_exclude|
-          names = except_options(names_to_exclude)
-          names.empty? ? ::Micro::Attributes : self.with(names)
+        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
-      end
 
-      private
+        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
+            str = String(arg)
 
-        def fetch_feature_name(name)
-          return name unless name.is_a?(Hash)
+            name = str == ACTIVEMODEL_VALIDATION ? Name::ACTIVEMODEL_VALIDATIONS : str
 
-          STRICT_INITIALIZE if name[:initialize] == :strict
+            KEYS_TO_MODULES.key?(name) ? name : NAMES_TO_KEYS[name]
+          end
         end
 
-        def normalize_names(args)
-          names = Array(args).dup
+        INVALID_NAME = [
+          'Invalid feature name! Available options: ',
+          Name::ALL.map { |feature_name| ":#{feature_name}" }.join(', ')
+        ].join
+
+        def self.fetch_keys(args)
+          keys = Array(args).dup.map { |name| fetch_key(name) }
 
-          last_feature = fetch_feature_name(names.pop)
+          raise ArgumentError, INVALID_NAME if keys.empty? || !(keys - KEYS).empty?
 
-          features = names.empty? ? [last_feature] : names + [last_feature]
-          features.map! { |name| name.to_s.downcase }
-          features.uniq
+          yield(keys)
         end
 
-        def valid_names?(names)
-          names.all? { |name| ALL.include?(name) }
+        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 valid_names!(args)
-          names = normalize_names(args)
+        def self.without_keys(keys_to_exclude)
+          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
 
-          raise ArgumentError, INVALID_NAME if names.empty? || !valid_names?(names)
+        def self.fetch_module_by_keys(combination)
+          key = BuildKey.call(combination)
 
-          yield(names)
+          KEYS_TO_MODULES.fetch(key)
         end
 
-        def an_initialize?(name)
-          name == INITIALIZE || name == STRICT_INITIALIZE
-        end
+        private_constant :KEYS_TO_FEATURES, :NAMES_TO_KEYS, :INVALID_NAME
+        private_constant :INIT_INIT_STRICT, :ACCEPT_ACCEPT_STRICT, :BuildKey
+      end
+
+      def all
+        @all ||= self.with(Options::KEYS)
+      end
 
-        def delete_initialize_if_has_strict_initialize(names)
-          return unless names.include?(STRICT_INITIALIZE)
+      def with(names)
+        Options.fetch_keys(names) do |keys|
+          Options.remove_base_if_has_strict(keys)
 
-          names.delete_if { |name| name == INITIALIZE }
+          Options.fetch_module_by_keys(keys)
         end
+      end
 
-        def except_options(names_to_exclude)
-          (ALL - names_to_exclude).tap do |names|
-            names.delete_if { |name| an_initialize?(name) } if names_to_exclude.include?(INITIALIZE)
+      def without(names)
+        Options.fetch_keys(names) do |keys|
+          keys_to_fetch = Options.without_keys(keys)
 
-            delete_initialize_if_has_strict_initialize(names)
-          end
+          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