u-attributes 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f90839cb67a0501e1ef44a5f06a324103063c87e929549377f885504bda5d8a
-  data.tar.gz: fd77058f7e514644a8363d460ad33ad76885648e32b5d9b02e22e592ffbf3ffe
+  metadata.gz: 62c6ad9683f0824be6a32648028f25a97ba88a10c7fbdd0b9a2ccfbfe275961b
+  data.tar.gz: d110a1b4220af76a7f14753cb1ca5067428f06db026466e095d54a22ee46f86f
 SHA512:
-  metadata.gz: 27401e952c4f5611ec5443df546d4c2c67f0af7aa40606a8e0f128ae37dc167747d0ba4c94008d993d65c886d4e1d66c6ef3472556ecfa353903779f51b4fe23
-  data.tar.gz: d05025bd7442681e14fa8f970fb166898ec9af4a344b8912e10c57f559830833bebe05ccacea85332ef9c88437adabc60152967f8b0b38d01f38f1cc6a7c1257
+  metadata.gz: 24703dcd81aa785fe00b77a741434ad84600243f4bb132d2bbbce2b5a310d4f2b931c2b6ea41e311a2bcf07876296bd03d8e6c39a92905bc9a4f745fdb30a094
+  data.tar.gz: 8172811ddaf44a3099e66f63cea5aed99d5c1a63a77944dc1e98c16fa0378603498fbdfe0c77f7220244c8d7b977801a75bd01facc875fb05f0bd1aed0171cc5

data/README.md

@@ -54,7 +54,7 @@ So, if you change [[1](#with_attribute)] [[2](#with_attributes)] some object att
       - [`#attributes(keys_as:)`](#attributeskeys_as)
       - [`#attributes(*names)`](#attributesnames)
       - [`#attributes([names])`](#attributesnames-1)
-      - [`#attributes(with:, without)`](#attributeswith-without)
+      - [`#attributes(with:, without:)`](#attributeswith-without)
     - [`#defined_attributes`](#defined_attributes)
 - [Built-in extensions](#built-in-extensions)
   - [Picking specific features](#picking-specific-features)
@@ -67,6 +67,7 @@ So, if you change [[1](#with_attribute)] [[2](#with_attributes)] some object att
     - [Diff extension](#diff-extension)
     - [Initialize extension](#initialize-extension)
       - [Strict mode](#strict-mode)
+    - [Keys as symbol extension](#keys-as-symbol-extension)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -84,7 +85,7 @@ gem 'u-attributes'
 
 | u-attributes   | branch  | ruby     |  activemodel  |
 | -------------- | ------- | -------- | ------------- |
-| 2.3.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.4.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.
@@ -498,14 +499,17 @@ person2.attributes # {"age"=>nil, "first_name"=>"Rodrigo", "last_name"=>"Rodrigu
 
 #### `#attributes(keys_as:)`
 
-Use the `keys_as:` option with `Symbol` or `String` to transform the attributes hash keys.
+Use the `keys_as:` option with `Symbol`/`:symbol` or `String`/`:string` to transform the attributes hash keys.
 
 ```ruby
 person1 = Person.new(age: 20)
-person1.attributes(keys_as: Symbol) # {:age=>20, :first_name=>"John", :last_name=>"Doe"}
-
 person2 = Person.new(first_name: 'Rodrigo', last_name: 'Rodrigues')
+
+person1.attributes(keys_as: Symbol) # {:age=>20, :first_name=>"John", :last_name=>"Doe"}
 person2.attributes(keys_as: String) # {"age"=>nil, "first_name"=>"Rodrigo", "last_name"=>"Rodrigues"}
+
+person1.attributes(keys_as: :symbol) # {:age=>20, :first_name=>"John", :last_name=>"Doe"}
+person2.attributes(keys_as: :string) # {"age"=>nil, "first_name"=>"Rodrigo", "last_name"=>"Rodrigues"}
 ```
 
 #### `#attributes(*names)`
@@ -544,7 +548,7 @@ person.attributes([:age, 'last_name']) # {:age => 20, "last_name" => "Doe"}
 person.attributes([:age, 'last_name'], keys_as: Symbol) # {:age=>20, :last_name=>"Doe"}
 ```
 
-#### `#attributes(with:, without)`
+#### `#attributes(with:, without:)`
 
 Use the `with:` option to include any method value of the instance inside of the hash, and,
 you can use the `without:` option to exclude one or more attribute keys from the final hash.
@@ -591,24 +595,30 @@ But, if you desire except one or more features, use the `Micro::Attributes.witho
 ```ruby
 Micro::Attributes.with(:initialize)
 
-Micro::Attributes.with(initialize: :strict)
+Micro::Attributes.with(:initialize, :keys_as_symbol)
+
+Micro::Attributes.with(:keys_as_symbol, initialize: :strict)
 
 Micro::Attributes.with(:diff, :initialize)
 
 Micro::Attributes.with(:diff, initialize: :strict)
 
+Micro::Attributes.with(:diff, :keys_as_symbol, initialize: :strict)
+
 Micro::Attributes.with(:activemodel_validations)
 
 Micro::Attributes.with(:activemodel_validations, :diff)
 
 Micro::Attributes.with(:activemodel_validations, :diff, initialize: :strict)
+
+Micro::Attributes.with(:activemodel_validations, :diff, :keys_as_symbol, initialize: :strict)
 ```
 
 The method `Micro::Attributes.with()` will raise an exception if no arguments/features were declared.
 
 ```ruby
 class Job
-  include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: :activemodel_validations, :diff, :initialize)
+  include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: :activemodel_validations, :diff, :initialize, :keys_as_symbol)
 end
 ```
 
@@ -617,15 +627,19 @@ end
 Picking *except* one or more features
 
 ```ruby
-Micro::Attributes.without(:diff) # will load :activemodel_validations and initialize: :strict
+Micro::Attributes.without(:diff) # will load :activemodel_validations, :keys_as_symbol and initialize: :strict
 
-Micro::Attributes.without(initialize: :strict) # will load :activemodel_validations and :diff
+Micro::Attributes.without(initialize: :strict) # will load :activemodel_validations, :diff and :keys_as_symbol
 ```
 
 ## Picking all the features
 
 ```ruby
 Micro::Attributes.with_all_features
+
+# This method returns the same of:
+
+Micro::Attributes.with(:activemodel_validations, :diff, :keys_as_symbol, initialize: :strict)
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
@@ -817,6 +831,40 @@ job.state # 'sleeping'
 
 [⬆️ Back to Top](#table-of-contents-)
 
+### Keys as symbol extension
+
+Disables the indifferent access requiring the declaration/usage of the attributes as symbols.
+
+The advantage of this extension over the default behavior is because it avoids an unnecessary allocation in memory of strings. All the keys are transformed into strings in the indifferent access mode, but, with this extension, this typecasting will be avoided. So, it has a better performance and reduces the usage of memory/Garbage collector, but gives for you the responsibility to always use symbols to set/access the attributes.
+
+```ruby
+class Job
+  include Micro::Attributes.with(:initialize, :keys_as_symbol)
+
+  attribute :id
+  attribute :state, default: 'sleeping'
+end
+
+job = Job.new(id: 1)
+
+job.attributes # {:id => 1, :state => "sleeping"}
+
+job.attribute?(:id) # true
+job.attribute?('id') # false
+
+job.attribute(:id) # 1
+job.attribute('id') # nil
+
+job.attribute!(:id) # 1
+job.attribute!('id') # NameError (undefined attribute `id)
+```
+
+As you could see in the previous example only symbols will work to do something with the attributes.
+
+This extension also changes the `diff extension` making everything (arguments, outputs) working only with symbols.
+
+[⬆️ Back to Top](#table-of-contents-)
+
 # Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/micro/attributes.rb

@@ -68,14 +68,14 @@ module Micro
 
       without_option = Array(options.fetch(:without, Kind::Empty::ARRAY))
 
-      keys = names.empty? ? defined_attributes - without_option.map(&:to_s) : names - without_option
+      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[key.to_s] = public_send(key) }
+        extra = with_option.each_with_object({}) { |key, memo| memo[__attribute_key(key)] = public_send(key) }
 
         data.merge!(extra)
       end
@@ -86,7 +86,7 @@ module Micro
     protected
 
       def attributes=(arg)
-        hash = Utils::Hashes.stringify_keys(arg)
+        hash = self.class.__attributes_keys__(arg)
 
         __attributes_missing!(hash)
 
@@ -99,6 +99,10 @@ module Micro
         Utils::ExtractAttribute.from(other, keys: defined_attributes)
       end
 
+      def __attribute_key(value)
+        self.class.__attribute_key__(value)
+      end
+
       def __attributes
         @__attributes ||= {}
       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/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

data/lib/micro/attributes/macros.rb

@@ -7,6 +7,22 @@ module Micro
         false
       end
 
+      def attributes_access
+        :indifferent
+      end
+
+      def __attribute_access__(value)
+        value
+      end
+
+      def __attribute_key__(value)
+        value.to_s
+      end
+
+      def __attributes_keys__(hash)
+        Utils::Hashes.stringify_keys(hash)
+      end
+
       # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_data__
         @__attributes_data__ ||= {}
@@ -41,7 +57,7 @@ module Micro
       end
 
       def __attribute_assign(key, can_overwrite, options)
-        name = key.to_s
+        name = __attribute_access__(__attribute_key__(key))
         has_attribute = attribute?(name)
 
         __attribute_reader(name) unless has_attribute
@@ -61,7 +77,7 @@ module Micro
       end
 
       def attribute?(name)
-        __attributes.member?(name.to_s)
+        __attributes.member?(__attribute_key__(name))
       end
 
       def attribute(name, options = Kind::Empty::HASH)

data/lib/micro/attributes/utils.rb

@@ -3,8 +3,12 @@
 module Micro::Attributes
   module Utils
     module Hashes
+      def self.kind(hash)
+        Kind::Of.(::Hash, hash)
+      end
+
       def self.stringify_keys(arg)
-        hash = Kind::Of.(::Hash, arg)
+        hash = kind(arg)
 
         return hash if hash.empty?
         return hash.transform_keys(&:to_s) if hash.respond_to?(:transform_keys)
@@ -13,7 +17,7 @@ module Micro::Attributes
       end
 
       def self.symbolize_keys(arg)
-        hash = Kind::Of.(::Hash, arg)
+        hash = kind(arg)
 
         return hash if hash.empty?
         return hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys)
@@ -22,15 +26,15 @@ module Micro::Attributes
       end
 
       def self.keys_as(type, hash)
-        return Kind::Of.(::Hash, hash) unless type
+        return kind(hash) unless type
 
-        return symbolize_keys(hash) if type == Symbol
-        return stringify_keys(hash) if type == String
+        return symbolize_keys(hash) if type == Symbol || type == :symbol
+        return stringify_keys(hash) if type == String || type == :string
 
-        raise ArgumentError, 'first argument must be the class String or Symbol'.freeze
+        raise ArgumentError, 'argument must be one of these values: :symbol, :string, Symbol, String'.freeze
       end
 
-      def self.get(hash, key)
+      def self.assoc(hash, key)
         value = hash[key.to_s]
 
         value.nil? ? hash[key.to_sym] : value
@@ -41,7 +45,7 @@ module Micro::Attributes
       def self.call(object, key:)
         return object.public_send(key) if object.respond_to?(key)
 
-        Hashes.get(object, key) if object.respond_to?(:[])
+        Hashes.assoc(object, key) if object.respond_to?(:[])
       end
 
       def self.from(object, keys:)

data/lib/micro/attributes/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Attributes
-    VERSION = '2.3.0'.freeze
+    VERSION = '2.4.0'.freeze
   end
 end

data/lib/micro/attributes/with.rb

@@ -3,8 +3,10 @@
 require 'micro/attributes/features/diff'
 require 'micro/attributes/features/initialize'
 require 'micro/attributes/features/initialize/strict'
+require 'micro/attributes/features/keys_as_symbol'
 require 'micro/attributes/features/activemodel_validations'
 
+
 module Micro
   module Attributes
     module With
@@ -25,76 +27,156 @@ module Micro
         end
       end
 
-      module ActiveModelValidations
+      module StrictInitialize
         def self.included(base)
           base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
         end
       end
 
-      module StrictInitialize
+      module KeysAsSymbol
+        def self.included(base)
+          base.send(:include, ::Micro::Attributes)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module ActiveModelValidations
         def self.included(base)
           base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
         end
       end
 
       #
       # Combinations
       #
-      module DiffAndInitialize
+      module AMValidations_Diff
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
+          base.send(:include, ActiveModelValidations)
           base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module DiffAndStrictInitialize
+      module AMValidations_Diff_Init
         def self.included(base)
-          base.send(:include, DiffAndInitialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module ActiveModelValidationsAndDiff
+      module AMValidations_Diff_Init_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, ActiveModelValidations)
           base.send(:include, ::Micro::Attributes::Features::Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
         end
       end
 
-      module ActiveModelValidationsAndInitialize
+      module AMValidations_Diff_InitStrict
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, AMValidations_Diff_Init)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
         end
       end
 
-      module ActiveModelValidationsAndStrictInitialize
+      module AMValidations_Diff_InitStrict_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ActiveModelValidationsAndInitialize)
+          base.send(:include, AMValidations_Diff_Init)
           base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
         end
       end
 
-      module ActiveModelValidationsAndDiffAndInitialize
+      module AMValidations_Diff_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, AMValidations_Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_Init
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+        end
+      end
+
+      module AMValidations_Init_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, AMValidations_Init)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_InitStrict
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+        end
+      end
+
+      module AMValidations_InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, AMValidations_InitStrict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_Init
+        def self.included(base)
+          base.send(:include, Initialize)
           base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module ActiveModelValidationsAndDiffAndStrictInitialize
+      module Diff_Init_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ActiveModelValidationsAndDiffAndInitialize)
+          base.send(:include, Diff_Init)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_InitStrict
+        def self.included(base)
+          base.send(:include, Diff_Init)
           base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
         end
       end
+
+      module Diff_InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Diff_InitStrict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Init_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Initialize)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, StrictInitialize)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
     end
   end
 end

data/u-attributes.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets)/}) }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-07 00:00:00.000000000 Z
+date: 2020-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -76,7 +76,6 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- assets/u-attributes_logo_v1.png
 - bin/console
 - bin/setup
 - lib/micro/attributes.rb
@@ -86,6 +85,7 @@ files:
 - lib/micro/attributes/features/diff.rb
 - lib/micro/attributes/features/initialize.rb
 - lib/micro/attributes/features/initialize/strict.rb
+- lib/micro/attributes/features/keys_as_symbol.rb
 - lib/micro/attributes/macros.rb
 - lib/micro/attributes/utils.rb
 - lib/micro/attributes/version.rb