u-attributes 2.4.0 → 2.8.0

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,16 +9,16 @@ module Micro::Attributes
           :symbol
         end
 
-        def __attribute_access__(value)
-          Kind::Of.(::Symbol, value)
+        def __attribute_key_check__(value)
+          Kind::Symbol[value]
         end
 
-        def __attribute_key__(value)
+        def __attribute_key_transform__(value)
           value
         end
 
-        def __attributes_keys__(hash)
-          Utils::Hashes.kind(hash)
+        def __attributes_keys_transform__(hash)
+          Kind::Hash[hash]
         end
       end
 

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/macros.rb

@@ -3,6 +3,60 @@
 module Micro
   module Attributes
     module Macros
+      module Options
+        PERMITTED = [
+          :default, :required, :freeze, :protected, :private, # for all
+          :validate, :validates,                              # for ext: activemodel_validations
+          :accept, :reject, :allow_nil, :rejection_message    # for ext: 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
+
+        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
+
+        ALL = 0
+        PUBLIC = 1
+        PRIVATE = 2
+        PROTECTED = 3
+        REQUIRED = 4
+
+        def self.visibility_index(opt)
+          return PRIVATE if opt[:private]
+          return PROTECTED if opt[:protected]
+          PUBLIC
+        end
+
+        VISIBILITY_NAMES = { PUBLIC => :public, PRIVATE => :private, PROTECTED => :protected }.freeze
+
+        def self.visibility_name_from_index(visibility_index)
+          VISIBILITY_NAMES[visibility_index]
+        end
+
+        def self.private?(visibility); visibility == PRIVATE; end
+        def self.protected?(visibility); visibility == PROTECTED; end
+      end
+
       def attributes_are_all_required?
         false
       end
@@ -11,15 +65,31 @@ module Micro
         :indifferent
       end
 
-      def __attribute_access__(value)
+      def __attributes_groups
+        @__attributes_groups ||= [
+          Set.new, # all
+          Set.new, # public
+          [],      # private
+          [],      # protected
+          Set.new, # required
+        ]
+      end
+
+      def __attributes; __attributes_groups[Options::ALL]; end
+
+      def __attributes_public; __attributes_groups[Options::PUBLIC]; end
+
+      def __attributes_required__; __attributes_groups[Options::REQUIRED]; end
+
+      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
 
@@ -28,62 +98,97 @@ module Micro
         @__attributes_data__ ||= {}
       end
 
-      def __attributes_required__
-        @__attributes_required__ ||= Set.new
+      def __attribute_reader(name, visibility_index)
+        attr_reader(name)
+
+        __attributes.add(name)
+        __attributes_groups[visibility_index] << name
+
+        private(name) if Options.private?(visibility_index)
+        protected(name) if Options.protected?(visibility_index)
       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)
+      def __attributes_data_to_assign(name, opt, visibility_index)
+        hasnt_default = !opt.key?(:default)
 
-        hasnt_default ? __attributes_required_add(name, options[:required], hasnt_default) : options[:default]
-      end
+        default = hasnt_default ? __attributes_required_add(name, opt, hasnt_default) : opt[:default]
 
-      def __attributes
-        @__attributes ||= Set.new
+        [
+          default,
+          Options.for_accept(opt),
+          opt[:freeze],
+          Options.visibility_name_from_index(visibility_index)
+        ]
       end
 
-      def __attribute_reader(name)
-        __attributes.add(name)
+      def __call_after_attribute_assign__(attr_name, options); end
 
-        attr_reader(name)
-      end
+      def __attribute_assign(key, can_overwrite, opt)
+        name = __attribute_key_check__(__attribute_key_transform__(key))
 
-      def __attribute_assign(key, can_overwrite, options)
-        name = __attribute_access__(__attribute_key__(key))
-        has_attribute = attribute?(name)
+        Options.check(opt)
 
-        __attribute_reader(name) unless has_attribute
+        has_attribute = attribute?(name, true)
 
-        __attributes_data__[name] = __attributes_data_to_assign(name, options) if can_overwrite || !has_attribute
+        visibility_index = Options.visibility_index(opt)
 
-        __call_after_attribute_assign__(name, options)
-      end
+        __attribute_reader(name, visibility_index) unless has_attribute
 
-      def __call_after_attribute_assign__(attr_name, options); end
+        if can_overwrite || !has_attribute
+          __attributes_data__[name] = __attributes_data_to_assign(name, opt, visibility_index)
+        end
+
+        __call_after_attribute_assign__(name, opt)
+      end
 
       # 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 = {}
+
+          default = val[0]
+          accept_key, accept_val = val[1]
+          freeze, visibility = val[2], val[3]
+
+          opt[:default] = default if default
+          opt[accept_key] = accept_val if accept_key
+          opt[:freeze] = freeze if freeze
+          opt[visibility] = true if visibility != :public
+
+          __attribute_assign(key, true, opt || Kind::Empty::HASH)
         end
       end
 
-      def attribute?(name)
-        __attributes.member?(__attribute_key__(name))
+      def attribute?(name, include_all = false)
+        key = __attribute_key_transform__(name)
+
+        return __attributes.member?(key) if include_all
+
+        __attributes_public.member?(key)
       end
 
       def attribute(name, options = Kind::Empty::HASH)
         __attribute_assign(name, false, options)
       end
 
+      RaiseKindError = ->(expected, given) do
+        if (util = Kind.const_get(:KIND, false)) && util.respond_to?(:error!)
+          util.error!(expected, given)
+        else
+          raise Kind::Error.new(expected, given, label: nil)
+        end
+      end
+
+      private_constant :RaiseKindError
+
       def attributes(*args)
         return __attributes.to_a if args.empty?
 
@@ -96,11 +201,19 @@ module Micro
           if arg.is_a?(String) || arg.is_a?(Symbol)
             __attribute_assign(arg, false, options)
           else
-            raise Kind::Error.new('String/Symbol'.freeze, arg)
+            RaiseKindError.call('String/Symbol'.freeze, arg)
           end
         end
       end
 
+      def attributes_by_visibility
+        {
+          public: __attributes_groups[Options::PUBLIC].to_a,
+          private: __attributes_groups[Options::PRIVATE].dup,
+          protected: __attributes_groups[Options::PROTECTED].dup
+        }
+      end
+
       # NOTE: can't be renamed! It is used by u-case v4.
       module ForSubclasses
         WRONG_NUMBER_OF_ARGS = 'wrong number of arguments (given 0, expected 1 or more)'.freeze
@@ -112,7 +225,7 @@ module Micro
         private_constant :WRONG_NUMBER_OF_ARGS
       end
 
-      private_constant :ForSubclasses
+      private_constant :Options, :ForSubclasses
     end
 
     private_constant :Macros