u-attributes 2.0.1 → 2.4.0

data/lib/micro/attributes.rb

@@ -14,7 +14,8 @@ module Micro
       base.extend(::Micro::Attributes.const_get(:Macros))
 
       base.class_eval do
-        private_class_method :__attributes, :__attribute_set, :__attribute_reader
+        private_class_method :__attributes, :__attribute_reader
+        private_class_method :__attribute_assign, :__attributes_data_to_assign
       end
 
       def base.inherited(subclass)
@@ -54,48 +55,96 @@ module Micro
       raise NameError, "undefined attribute `#{name}"
     end
 
+    def defined_attributes
+      @defined_attributes ||= self.class.attributes
+    end
+
     def attributes(*names)
       return __attributes if names.empty?
 
-      names.each_with_object({}) do |name, memo|
-        memo[name] = attribute(name) if attribute?(name)
+      options = names.last.is_a?(Hash) ? names.pop : Kind::Empty::HASH
+
+      names.flatten!
+
+      without_option = Array(options.fetch(:without, Kind::Empty::ARRAY))
+
+      keys = names.empty? ? defined_attributes - without_option.map { |value| __attribute_key(value) } : names - without_option
+
+      data = keys.each_with_object({}) { |key, memo| memo[key] = attribute(key) if attribute?(key) }
+
+      with_option = Array(options.fetch(:with, Kind::Empty::ARRAY))
+
+      unless with_option.empty?
+        extra = with_option.each_with_object({}) { |key, memo| memo[__attribute_key(key)] = public_send(key) }
+
+        data.merge!(extra)
       end
+
+      Utils::Hashes.keys_as(options[:keys_as], data)
     end
 
     protected
 
       def attributes=(arg)
-        hash = Utils.stringify_hash_keys(arg)
+        hash = self.class.__attributes_keys__(arg)
 
-        __attributes_set(hash, self.class.__attributes_data__)
+        __attributes_missing!(hash)
+
+        __attributes_assign(hash)
       end
 
     private
 
-      def __attributes
-        @__attributes ||= {}
+      def extract_attributes_from(other)
+        Utils::ExtractAttribute.from(other, keys: defined_attributes)
       end
 
-      def __attribute_set(name, value)
-        __attributes[name] = instance_variable_set("@#{name}", value) if attribute?(name)
+      def __attribute_key(value)
+        self.class.__attribute_key__(value)
       end
 
-      def __attributes_set(hash, att_data)
-        att_data.each do |key, default|
-          value = hash[key]
+      def __attributes
+        @__attributes ||= {}
+      end
 
-          final_value =
-            if default.respond_to?(:call)
-              callable = default.is_a?(Proc) ? default : default.method(:call)
-              callable.arity > 0 ? callable.call(value) : callable.call
-            else
-              value.nil? ? default : value
-            end
+      FetchValueToAssign = -> (value, default) do
+        if default.is_a?(Proc)
+          default.arity > 0 ? default.call(value) : default.call
+        else
+          value.nil? ? default : value
+        end
+      end
 
-          __attribute_set(key, final_value)
+      def __attributes_assign(hash)
+        self.class.__attributes_data__.each do |name, default|
+          __attribute_assign(name, FetchValueToAssign.(hash[name], default)) if attribute?(name)
         end
 
         __attributes.freeze
       end
+
+      def __attribute_assign(name, value)
+        __attributes[name] = instance_variable_set("@#{name}", value)
+      end
+
+      MISSING_KEYWORD = 'missing keyword'.freeze
+      MISSING_KEYWORDS = 'missing keywords'.freeze
+
+      def __attributes_missing!(hash)
+        required_keys = self.class.__attributes_required__
+
+        return if required_keys.empty?
+
+        missing_keys = required_keys.map { |name| ":#{name}" if !hash.key?(name) }
+        missing_keys.compact!
+
+        return if missing_keys.empty?
+
+        label = missing_keys.size == 1 ? MISSING_KEYWORD : MISSING_KEYWORDS
+
+        raise ArgumentError, "#{label}: #{missing_keys.join(', ')}"
+      end
+
+      private_constant :FetchValueToAssign, :MISSING_KEYWORD, :MISSING_KEYWORDS
   end
 end

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_access(name))
         else
-          result = @differences[name.to_s]
-          result ? result[FROM] == from && result[TO] == to : false
+          result = @differences[key_access(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_access(key)
+          @from_class.__attribute_key__(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

@@ -7,105 +7,100 @@ module Micro
     module Features
       extend self
 
-      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
-
-      def all
-        @all ||= self.with(ALL)
+      module Name
+        ALL = [
+          DIFF = 'diff'.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 = 'Init'.freeze,
+          INIT_STRICT = 'InitStrict'.freeze,
+          KEYS_AS_SYMBOL = 'KeysAsSymbol'.freeze,
+          AM_VALIDATIONS = 'AMValidations'.freeze
+        ].sort.freeze
+
+        NAMES_TO_KEYS = {
+          Name::DIFF => DIFF,
+          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
+
+        def self.fetch_key(arg)
+          if arg.is_a?(Hash)
+            INIT_STRICT if arg[:initialize] == :strict
+          else
+            name = String(arg)
+
+            return name if KEYS_TO_MODULES.key?(name)
+
+            NAMES_TO_KEYS[name]
+          end
         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)
-        end
-      end
+        INVALID_NAME = [
+          'Invalid feature name! Available options: ',
+          Name::ALL.map { |feature_name| ":#{feature_name}" }.join(', ')
+        ].join
 
-      private
+        def self.fetch_keys(args)
+          keys = Array(args).dup.map { |name| fetch_key(name) }
 
-        def fetch_feature_name(name)
-          return name unless name.is_a?(Hash)
+          raise ArgumentError, INVALID_NAME if keys.empty? || !(keys - KEYS).empty?
 
-          STRICT_INITIALIZE if name[:initialize] == :strict
+          yield(keys)
         end
 
-        def normalize_names(args)
-          names = Array(args).dup
-
-          last_feature = fetch_feature_name(names.pop)
-
-          features = names.empty? ? [last_feature] : names + [last_feature]
-          features.map! { |name| name.to_s.downcase }
-          features.uniq
+        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)
         end
 
-        def valid_names?(names)
-          names.all? { |name| ALL.include?(name) }
+        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
         end
 
-        def valid_names!(args)
-          names = normalize_names(args)
-
-          raise ArgumentError, INVALID_NAME if names.empty? || !valid_names?(names)
+        def self.fetch_module_by_keys(keys)
+          keys.delete_if { |key| key == INIT } if keys.include?(INIT_STRICT)
 
-          yield(names)
-        end
+          option = keys.sort.join('_')
 
-        def an_initialize?(name)
-          name == INITIALIZE || name == STRICT_INITIALIZE
+          KEYS_TO_MODULES.fetch(option) { With.const_get(option, false) }
         end
+      end
 
-        def delete_initialize_if_has_strict_initialize(names)
-          return unless names.include?(STRICT_INITIALIZE)
+      def all
+        @all ||= self.with(Options::KEYS)
+      end
 
-          names.delete_if { |name| name == INITIALIZE }
+      def with(names)
+        Options.fetch_keys(names) do |keys|
+          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 = Options.without_keys(keys)
 
-            delete_initialize_if_has_strict_initialize(names)
-          end
+          keys.empty? ? ::Micro::Attributes : Options.fetch_module_by_keys(keys)
         end
+      end
     end
   end
 end

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

@@ -14,11 +14,11 @@ module Micro::Attributes
       end
 
       module ClassMethods
-        def __call_after_attribute_set__(attr_name, options)
+        def __call_after_attribute_assign__(attr_name, options)
           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
 

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

@@ -4,35 +4,15 @@ module Micro::Attributes
   module Features
     module Initialize
       module Strict
-        MISSING_KEYWORD = 'missing keyword'.freeze
-        MISSING_KEYWORDS = 'missing keywords'.freeze
-
-        protected def attributes=(arg)
-          arg_hash = Utils.stringify_hash_keys(arg)
-          att_data = self.class.__attributes_data__
-
-          attributes_missing!(ref: att_data, arg: arg_hash)
-
-          __attributes_set(arg_hash, att_data)
-        end
-
-        private def attributes_missing!(ref:, arg:)
-          missing_keys = attributes_missing(ref, arg)
-
-          return if missing_keys.empty?
-
-          label = missing_keys.size == 1 ? MISSING_KEYWORD : MISSING_KEYWORDS
-
-          raise ArgumentError, "#{label}: #{missing_keys.join(', ')}"
-        end
-
-        private def attributes_missing(ref, arg)
-          ref.each_with_object([]) do |(key, val), memo|
-            memo << ":#{key}" if val.nil? && !arg.has_key?(key)
+        module ClassMethods
+          def attributes_are_all_required?
+            true
           end
         end
 
-        private_constant :MISSING_KEYWORD, :MISSING_KEYWORDS
+        def self.included(base)
+          base.send(:extend, ClassMethods)
+        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_access__(value)
+          Kind::Of.(::Symbol, value)
+        end
+
+        def __attribute_key__(value)
+          value
+        end
+
+        def __attributes_keys__(hash)
+          Utils::Hashes.kind(hash)
+        end
+      end
+
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+    end
+  end
+end