u-attributes 2.2.0 → 2.7.0

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, 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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Micro::Attributes
+  module Features
+    module KeysAsSymbol
+
+      module ClassMethods
+        def attributes_access
+          :symbol
+        end
+
+        def __attribute_key_check__(value)
+          Kind::Symbol[value]
+        end
+
+        def __attribute_key_transform__(value)
+          value
+        end
+
+        def __attributes_keys_transform__(hash)
+          Kind::Hash[hash]
+        end
+      end
+
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/micro/attributes/macros.rb

@@ -3,65 +3,176 @@
 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
 
+      def attributes_access
+        :indifferent
+      end
+
+      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_transform__(value)
+        value.to_s
+      end
+
+      def __attributes_keys_transform__(hash)
+        Utils::Hashes.stringify_keys(hash)
+      end
+
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_data__
         @__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 = key.to_s
-        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?(name.to_s)
+      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)
@@ -80,11 +191,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)
+            Kind::KIND.error!('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
@@ -96,7 +215,7 @@ module Micro
         private_constant :WRONG_NUMBER_OF_ARGS
       end
 
-      private_constant :ForSubclasses
+      private_constant :Options, :ForSubclasses
     end
 
     private_constant :Macros