u-attributes 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01dbce30afd7d116e15ea5985e5012d86f2bd110b017394151086df322e9b7ed
-  data.tar.gz: 4004e27e835cc216807b2fb2781a15911c16f2ba20e509b7c36188a8b6021f95
+  metadata.gz: 484a7b770e8ae7dd141c7538e2bc50c1b82beb63e24ee53dd9f9445cbd91f057
+  data.tar.gz: 3d555771a3deba711dc4995cd12674461b94c82e65ccbdd9bba215d354adaa52
 SHA512:
-  metadata.gz: ca177ca900f63a07901366612f5ef545512db4e8f9b48bea6482403af6346324784910fa9dca963e681449a1d3b583b173317890b76e8a2e03fd46b58af32006
-  data.tar.gz: 44372485364d637906d1dad476fc58a98cf228c33e252012af320e7e1da36b82db3943eb635ed34dff211908088f6fc8fe3c2de8a1b9a418f62f8e8b3e1596ed
+  metadata.gz: fc5f65eb1a10c5172f0b6a1fa5296f4470e024fa42559cfe0d64d89d0a07c0c203ae28ce1b66afae741669a8073b1c6cbb7d05d5373874946afefca6620d7874
+  data.tar.gz: db8895b0a85d803de7ec04f81fc83fb98eac4b487ed4224e7fb7b6bda3d66293758ce416341dddbd40ae630dfb96d4d26cdd380990a3fca2580df931b459311a

data/README.md

@@ -85,7 +85,7 @@ gem 'u-attributes'
 
 | u-attributes   | branch  | ruby     |  activemodel  |
 | -------------- | ------- | -------- | ------------- |
-| 2.5.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.6.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
 | 1.2.0          | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
 > **Note**: The activemodel is an optional dependency, this module [can be enabled](#activemodelvalidation-extension) to validate the attributes.

data/lib/micro/attributes.rb

@@ -15,7 +15,7 @@ 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
 
@@ -38,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)
@@ -53,10 +53,12 @@ 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
+    def defined_attributes(option = nil)
+      return self.class.attributes_by_visibility if option == :by_visibility
+
       @defined_attributes ||= self.class.attributes
     end
 
@@ -107,6 +109,12 @@ module Micro
         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
@@ -115,26 +123,38 @@ module Micro
         @__attributes ||= {}
       end
 
-      FetchValueToAssign = -> (value, default, keep_proc = false) do
-        if default.is_a?(Proc) && !keep_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, attribute_data|
-          __attribute_assign(name, hash[name], attribute_data) if attribute?(name)
+          __attribute_assign(name, hash[name], attribute_data) if attribute?(name, true)
         end
 
         __attributes.freeze
       end
 
       def __attribute_assign(name, initialize_value, attribute_data)
-        value_to_assign = FetchValueToAssign.(initialize_value, attribute_data[0])
+        value_to_assign = FetchValueToAssign.(initialize_value, attribute_data)
+
+        ivar_value = instance_variable_set("@#{name}", value_to_assign)
 
-        __attributes[name] = 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/features/accept.rb

@@ -38,7 +38,7 @@ module Micro::Attributes
         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_to_assign = FetchValueToAssign.(initialize_value, attribute_data, KeepProc.(validation_data))
 
           value = __attributes[key] = instance_variable_set("@#{key}", value_to_assign)
 

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,6 +65,22 @@ module Micro
         :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
@@ -28,8 +98,14 @@ 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, opt, hasnt_default)
@@ -40,91 +116,63 @@ module Micro
         nil
       end
 
-      module Options
-        PERMITTED = [
-          :default, :required,
-          :validate, :validates, # activemodel_validations
-          :accept, :reject, :allow_nil, :rejection_message # 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
-      end
-
-      def __attributes_data_to_assign(name, opt)
+      def __attributes_data_to_assign(name, opt, visibility_index)
         hasnt_default = !opt.key?(:default)
 
+        default = hasnt_default ? __attributes_required_add(name, opt, hasnt_default) : opt[:default]
+
         [
-          hasnt_default ? __attributes_required_add(name, opt, hasnt_default) : opt[:default],
-          Options.for_accept(opt)
+          default,
+          Options.for_accept(opt),
+          opt[:freeze],
+          Options.visibility_name_from_index(visibility_index)
         ]
       end
 
-      def __attributes
-        @__attributes ||= Set.new
-      end
-
-      def __attribute_reader(name)
-        __attributes.add(name)
-
-        attr_reader(name)
-      end
+      def __call_after_attribute_assign__(attr_name, options); end
 
       def __attribute_assign(key, can_overwrite, opt)
         name = __attribute_key_check__(__attribute_key_transform__(key))
 
         Options.check(opt)
 
-        has_attribute = attribute?(name)
+        has_attribute = attribute?(name, true)
+
+        visibility_index = Options.visibility_index(opt)
 
-        __attribute_reader(name) unless has_attribute
+        __attribute_reader(name, visibility_index) unless has_attribute
 
-        __attributes_data__[name] = __attributes_data_to_assign(name, opt) if can_overwrite || !has_attribute
+        if can_overwrite || !has_attribute
+          __attributes_data__[name] = __attributes_data_to_assign(name, opt, visibility_index)
+        end
 
         __call_after_attribute_assign__(name, opt)
       end
 
-      def __call_after_attribute_assign__(attr_name, options); end
-
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_set_after_inherit__(arg)
         arg.each do |key, val|
-          opt = if default = val[0]
-            requ_key, requ_val = val[1]
+          opt = {}
 
-            hash = requ_key ? { requ_key => requ_val } : {}
-            hash[:default] = default
-            hash
-          end
+          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_transform__(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)
@@ -148,6 +196,14 @@ module Micro
         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

data/lib/micro/attributes/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Attributes
-    VERSION = '2.5.0'.freeze
+    VERSION = '2.6.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-22 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind