u-attributes 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31b9f3d0195fc8b0f865279a79a54bd9beb8b0644d3f1b4371b6aa4163264024
-  data.tar.gz: '048e8c549d655980eee398e8ae445a7eb6900143f98c8e04449d5e2c82f0c9e6'
+  metadata.gz: 2f90839cb67a0501e1ef44a5f06a324103063c87e929549377f885504bda5d8a
+  data.tar.gz: fd77058f7e514644a8363d460ad33ad76885648e32b5d9b02e22e592ffbf3ffe
 SHA512:
-  metadata.gz: 3a776e02b0708d566156ce8adc7d0ad5813a7c752f8f19615eeea734b46ee34995d69a8cab263ed1e1ffbba64140eee4a630ff18fdcb6cf54cd5fb0a404d6fe8
-  data.tar.gz: 4e7869905c50b2f0ea288f404900c3c2b645ca3c8cad6404c2d8aa8913a0ad87874b43288c8f408e1a23252d9ab114fa8664a6a21914f71c2ffbf4ee04bb3d68
+  metadata.gz: 27401e952c4f5611ec5443df546d4c2c67f0af7aa40606a8e0f128ae37dc167747d0ba4c94008d993d65c886d4e1d66c6ef3472556ecfa353903779f51b4fe23
+  data.tar.gz: d05025bd7442681e14fa8f970fb166898ec9af4a344b8912e10c57f559830833bebe05ccacea85332ef9c88437adabc60152967f8b0b38d01f38f1cc6a7c1257

data/README.md

@@ -47,6 +47,15 @@ So, if you change [[1](#with_attribute)] [[2](#with_attributes)] some object att
   - [Is it possible to inherit the attributes?](#is-it-possible-to-inherit-the-attributes)
     - [`.attribute!()`](#attribute)
   - [How to query the attributes?](#how-to-query-the-attributes)
+    - [`.attributes`](#attributes)
+    - [`.attribute?()`](#attribute-1)
+    - [`#attribute?()`](#attribute-2)
+    - [`#attributes()`](#attributes-1)
+      - [`#attributes(keys_as:)`](#attributeskeys_as)
+      - [`#attributes(*names)`](#attributesnames)
+      - [`#attributes([names])`](#attributesnames-1)
+      - [`#attributes(with:, without)`](#attributeswith-without)
+    - [`#defined_attributes`](#defined_attributes)
 - [Built-in extensions](#built-in-extensions)
   - [Picking specific features](#picking-specific-features)
     - [`Micro::Attributes.with`](#microattributeswith)
@@ -75,7 +84,7 @@ gem 'u-attributes'
 
 | u-attributes   | branch  | ruby     |  activemodel  |
 | -------------- | ------- | -------- | ------------- |
-| 2.2.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 2.3.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.
@@ -419,69 +428,152 @@ beta_person.age  # 0
 
 ## How to query the attributes?
 
+All of the methods that will be explained can be used with any of the built-in extensions.
+
+**PS:** We will use the class below for all of the next examples.
+
 ```ruby
 class Person
   include Micro::Attributes
 
   attribute :age
-  attribute :name, default: 'John Doe'
+  attribute :first_name, default: 'John'
+  attribute :last_name, default: 'Doe'
 
   def initialize(options)
     self.attributes = options
   end
+
+  def name
+    "#{first_name} #{last_name}"
+  end
 end
+```
 
-#---------------#
-# .attributes() #
-#---------------#
+### `.attributes`
 
-Person.attributes # ['name', 'age']
+Listing all the class attributes.
 
-#---------------#
-# .attribute?() #
-#---------------#
+```ruby
+Person.attributes # ["age", "first_name", "last_name"]
+```
 
-Person.attribute?(:name)  # true
-Person.attribute?('name') # true
-Person.attribute?('foo') # false
-Person.attribute?(:foo)  # false
+### `.attribute?()`
 
-# ---
+Checking the existence of some attribute.
 
-person = Person.new(age: 20)
+```ruby
+Person.attribute?(:first_name)  # true
+Person.attribute?('first_name') # true
 
-#---------------------#
-# #defined_attributes #
-#---------------------#
+Person.attribute?('foo') # false
+Person.attribute?(:foo)  # false
+```
 
-person.defined_attributes # ['name', 'age']
+### `#attribute?()`
 
-#---------------#
-# #attribute?() #
-#---------------#
+Checking the existence of some attribute in an instance.
+
+```ruby
+person = Person.new(age: 20)
 
 person.attribute?(:name)  # true
 person.attribute?('name') # true
+
 person.attribute?('foo') # false
 person.attribute?(:foo)  # false
+```
+
+### `#attributes()`
+
+Fetching all the attributes with their values.
+
+```ruby
+person1 = Person.new(age: 20)
+person1.attributes # {"age"=>20, "first_name"=>"John", "last_name"=>"Doe"}
+
+person2 = Person.new(first_name: 'Rodrigo', last_name: 'Rodrigues')
+person2.attributes # {"age"=>nil, "first_name"=>"Rodrigo", "last_name"=>"Rodrigues"}
+```
+
+#### `#attributes(keys_as:)`
+
+Use the `keys_as:` option with `Symbol` or `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"}
 
-#---------------#
-# #attributes() #
-#---------------#
+person2 = Person.new(first_name: 'Rodrigo', last_name: 'Rodrigues')
+person2.attributes(keys_as: String) # {"age"=>nil, "first_name"=>"Rodrigo", "last_name"=>"Rodrigues"}
+```
 
-person.attributes                   # {'age'=>20, 'name'=>'John Doe'}
-Person.new(name: 'John').attributes # {'age'=>nil, 'name'=>'John'}
+#### `#attributes(*names)`
 
-#---------------------#
-# #attributes(*names) #
-#---------------------#
+Slices the attributes to include only the given keys (in their types).
 
-# Slices the attributes to include only the given keys.
-# Returns a hash containing the given keys (in their types).
+```ruby
+person = Person.new(age: 20)
+
+person.attributes(:age)               # {:age => 20}
+person.attributes(:age, :first_name)  # {:age => 20, :first_name => "John"}
+person.attributes('age', 'last_name') # {"age" => 20, "last_name" => "Doe"}
+
+person.attributes(:age, 'last_name') # {:age => 20, "last_name" => "Doe"}
+
+# You could also use the keys_as: option to ensure the same type for all of the hash keys.
+
+person.attributes(:age, 'last_name', keys_as: Symbol) # {:age=>20, :last_name=>"Doe"}
+```
+
+#### `#attributes([names])`
+
+As the previous example, this methods accepts a list of keys to slice the attributes.
+
+```ruby
+person = Person.new(age: 20)
+
+person.attributes([:age])               # {:age => 20}
+person.attributes([:age, :first_name])  # {:age => 20, :first_name => "John"}
+person.attributes(['age', 'last_name']) # {"age" => 20, "last_name" => "Doe"}
+
+person.attributes([:age, 'last_name']) # {:age => 20, "last_name" => "Doe"}
+
+# You could also use the keys_as: option to ensure the same type for all of the hash keys.
+
+person.attributes([:age, 'last_name'], keys_as: Symbol) # {:age=>20, :last_name=>"Doe"}
+```
+
+#### `#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.
+
+```ruby
+person = Person.new(age: 20)
+
+person.attributes(without: :age)               # {"first_name"=>"John", "last_name"=>"Doe"}
+person.attributes(without: [:age, :last_name]) # {"first_name"=>"John"}
+
+person.attributes(with: [:name], without: [:first_name, :last_name]) # {"age"=>20, "name"=>"John Doe"}
+
+# To achieves the same output of the previous example, use the attribute names to slice only them.
+
+person.attributes(:age, with: [:name]) # {:age=>20, "name"=>"John Doe"}
+
+# You could also use the keys_as: option to ensure the same type for all of the hash keys.
+
+person.attributes(:age, with: [:name], keys_as: Symbol) # {:age=>20, :name=>"John Doe"}
+```
+
+### `#defined_attributes`
+
+Listing all the available attributes.
+
+```ruby
+person = Person.new(age: 20)
 
-person.attributes(:age)             # {age: 20}
-person.attributes(:age, :name)      # {age: 20, name: 'John Doe'}
-person.attributes('age', 'name')    # {'age'=>20, 'name'=>'John Doe'}
+person.defined_attributes # ["age", "first_name", "last_name"]
 ```
 
 [⬆️ Back to Top](#table-of-contents-)

data/lib/micro/attributes.rb

@@ -55,16 +55,32 @@ module Micro
       raise NameError, "undefined attribute `#{name}"
     end
 
+    def defined_attributes
+      @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(&:to_s) : 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) }
+
+        data.merge!(extra)
       end
-    end
 
-    def defined_attributes
-      @defined_attributes ||= self.class.attributes
+      Utils::Hashes.keys_as(options[:keys_as], data)
     end
 
     protected

data/lib/micro/attributes/utils.rb

@@ -12,6 +12,24 @@ module Micro::Attributes
         hash.each_with_object({}) { |(key, val), memo| memo[key.to_s] = val }
       end
 
+      def self.symbolize_keys(arg)
+        hash = Kind::Of.(::Hash, arg)
+
+        return hash if hash.empty?
+        return hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys)
+
+        hash.each_with_object({}) { |(key, val), memo| memo[key.to_sym] = val }
+      end
+
+      def self.keys_as(type, hash)
+        return Kind::Of.(::Hash, hash) unless type
+
+        return symbolize_keys(hash) if type == Symbol
+        return stringify_keys(hash) if type == String
+
+        raise ArgumentError, 'first argument must be the class String or Symbol'.freeze
+      end
+
       def self.get(hash, key)
         value = hash[key.to_s]
 

data/lib/micro/attributes/version.rb

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

metadata

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