u-attributes 2.2.0 → 2.7.0

data/lib/micro/attributes.rb

@@ -15,7 +15,8 @@ module Micro
 
       base.class_eval do
         private_class_method :__attributes, :__attribute_reader
-        private_class_method :__attribute_assign, :__attributes_data_to_assign
+        private_class_method :__attribute_assign, :__attributes_groups
+        private_class_method :__attributes_required_add, :__attributes_data_to_assign
       end
 
       def base.inherited(subclass)
@@ -37,8 +38,8 @@ module Micro
       Features.all
     end
 
-    def attribute?(name)
-      self.class.attribute?(name)
+    def attribute?(name, include_all = false)
+      self.class.attribute?(name, include_all)
     end
 
     def attribute(name)
@@ -52,59 +53,108 @@ module Micro
     def attribute!(name, &block)
       attribute(name) { |name| return block ? block[name] : name }
 
-      raise NameError, "undefined attribute `#{name}"
+      raise NameError, __attribute_access_error_message(name)
+    end
+
+    def defined_attributes(option = nil)
+      return self.class.attributes_by_visibility if option == :by_visibility
+
+      @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
-    end
 
-    def defined_attributes
-      @defined_attributes ||= self.class.attributes
+      Utils::Hashes.keys_as(options[:keys_as], data)
     end
 
     protected
 
       def attributes=(arg)
-        hash = Utils::Hashes.stringify_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_access_error_message(name)
+        return "tried to access a private attribute `#{name}" if attribute?(name, true)
+
+        "undefined attribute `#{name}"
+      end
+
+      def __attribute_key(value)
+        self.class.__attribute_key_transform__(value)
+      end
+
       def __attributes
         @__attributes ||= {}
       end
 
-      FetchValueToAssign = -> (value, default) do
-        if default.is_a?(Proc)
-          default.arity > 0 ? default.call(value) : default.call
-        else
-          value.nil? ? default : value
-        end
+      FetchValueToAssign = -> (value, attribute_data, keep_proc = false) do
+        default = attribute_data[0]
+
+        value_to_assign =
+          if default.is_a?(Proc) && !keep_proc
+            default.arity > 0 ? default.call(value) : default.call
+          else
+            value.nil? ? default : value
+          end
+
+        return value_to_assign unless to_freeze = attribute_data[2]
+        return value_to_assign.freeze if to_freeze == true
+        return value_to_assign.dup.freeze if to_freeze == :after_dup
+        return value_to_assign.clone.freeze if to_freeze == :after_clone
+
+        raise NotImplementedError
       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, true)
         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)
+
+        ivar_value = instance_variable_set("@#{name}", value_to_assign)
+
+        __attributes[name] = ivar_value if attribute_data[3] == :public
       end
 
       MISSING_KEYWORD = 'missing keyword'.freeze

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