u-attributes 1.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b3e7bb30f3fc6eb465c26378b99146dc3762f191f8554220bad22fd760cd21
-  data.tar.gz: 3c8de349ac5e966911877ca5c71f00ac5471f8b838323dd52b85a59e05b686a1
+  metadata.gz: d105f8057ad000b717972d8b2b5624d3f5d7608256f82402878ae0929c6462c7
+  data.tar.gz: 20f7b0132c445194fb3189b81c7c29c482a2fbeffdb1574444f833ede5619308
 SHA512:
-  metadata.gz: 14fbd07d3cbc6e31293417dba289b8bd91e0c4c1de7d74692f9b5498f7e016dcb4463ef70f0e6ff94e703e6e87ea514bbbd4ad36cf566367d2785533578f2e0c
-  data.tar.gz: ca9669124566003aad1d5cc520b9dcab7ec866a170b2561908a49eb8c236746352827e7fe65354584cd42120435ba7dde4723046dc6fc8d124491db000a885d1
+  metadata.gz: 7d5e1d415a6b94dfa9c90aad9f8700829696d1e1b2fa054d6bf62c9eac477f618604c59695b55c3a18dd2405b28c4af63c886057f2ef740cba747f19b2273706
+  data.tar.gz: 4493325bbeed30c82c13690ad35d87926a9913b3b33d18cc0ef2dedae8eca2e976fc43d2485bb65715b2cb6c51bc383dfd8b0c59b50885bd5099624b568455d6

data/.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock

data/.travis.sh

@@ -20,5 +20,12 @@ ACTIVEMODEL_VERSION='5.0' bundle exec rake test
 ACTIVEMODEL_VERSION='5.1' bundle update
 ACTIVEMODEL_VERSION='5.1' bundle exec rake test
 
-ACTIVEMODEL_VERSION='5.2' bundle update
-ACTIVEMODEL_VERSION='5.2' bundle exec rake test
+if [[ ! $ruby_v =~ '2.2.0' ]]; then
+  ACTIVEMODEL_VERSION='5.2' bundle update
+  ACTIVEMODEL_VERSION='5.2' bundle exec rake test
+fi
+
+if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
+  ACTIVEMODEL_VERSION='6.0' bundle update
+  ACTIVEMODEL_VERSION='6.0' bundle exec rake test
+fi

data/.travis.yml

@@ -8,6 +8,7 @@ rvm:
 - 2.4.0
 - 2.5.0
 - 2.6.0
+- 2.7.0
 
 cache: bundler
 
@@ -20,9 +21,9 @@ install: bundle install --jobs=3 --retry=3
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
-  - "./cc-test-reporter before-build"
+  - './cc-test-reporter before-build'
 
-script: "./.travis.sh"
+script: './.travis.sh'
 
 after_success:
-  - "./cc-test-reporter after-build -t simplecov"
+  - './cc-test-reporter after-build -t simplecov'

data/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'u-case', '~> 4.0'
+
 activemodel_version = ENV.fetch('ACTIVEMODEL_VERSION', '6.1')
 
 activemodel = case activemodel_version
@@ -10,7 +12,7 @@ activemodel = case activemodel_version
               when '5.0' then '5.0.7'
               when '5.1' then '5.1.7'
               when '5.2' then '5.2.3'
-              when '6.0' then '6.0.0.rc1'
+              when '6.0' then '6.0.0'
               end
 
 if activemodel_version < '6.1'
@@ -18,9 +20,16 @@ if activemodel_version < '6.1'
   gem 'activesupport', activemodel, require: false
 end
 
+simplecov_version =
+  case RUBY_VERSION
+  when /\A2.[23]/ then '~> 0.17.1'
+  when /\A2.4/ then '~> 0.18.5'
+  else '~> 0.19'
+  end
+
 group :test do
   gem 'minitest', activemodel_version < '4.1' ? '~> 4.2' : '~> 5.0'
-  gem 'simplecov', require: false
+  gem 'simplecov', simplecov_version, require: false
 end
 
 # Specify your gem's dependencies in u-attributes.gemspec

data/LICENSE.txt

@@ -3,7 +3,7 @@ The MIT License (MIT)
 Copyright (c) 2019 Rodrigo Serradura
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
+of this software and associated documentation files (the 'Software'), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
@@ -12,7 +12,7 @@ furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

data/README.md

@@ -1,74 +1,99 @@
-[![Gem](https://img.shields.io/gem/v/u-attributes.svg?style=flat-square)](https://rubygems.org/gems/u-attributes)
-[![Build Status](https://travis-ci.com/serradura/u-attributes.svg?branch=master)](https://travis-ci.com/serradura/u-attributes)
-[![Maintainability](https://api.codeclimate.com/v1/badges/b562e6b877a9edf4dbf6/maintainability)](https://codeclimate.com/github/serradura/u-attributes/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/b562e6b877a9edf4dbf6/test_coverage)](https://codeclimate.com/github/serradura/u-attributes/test_coverage)
-
-μ-attributes (Micro::Attributes)
-================================
-
-This gem allows defining read-only attributes, that is, your objects will have only getters to access their attributes data.
-
-## Table of contents
-- [μ-attributes (Micro::Attributes)](#%ce%bc-attributes-microattributes)
-  - [Table of contents](#table-of-contents)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [How to require?](#how-to-require)
-    - [How to define attributes?](#how-to-define-attributes)
-    - [How to define multiple attributes?](#how-to-define-multiple-attributes)
-    - [How to define attributes with a constructor to assign them?](#how-to-define-attributes-with-a-constructor-to-assign-them)
-    - [How to inherit the attributes?](#how-to-inherit-the-attributes)
-    - [How to query the attributes?](#how-to-query-the-attributes)
-  - [Built-in extensions](#built-in-extensions)
-    - [ActiveModel::Validations extension](#activemodelvalidations-extension)
+<p align="center">
+  <img src="./assets/u-attributes_logo_v1.png" alt='Create "immutable" objects. No setters, just getters!'>
+
+  <p align="center"><i>Create "immutable" objects. No setters, just getters!</i></p>
+  <br>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/ruby-2.2+-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
+
+  <a href="https://rubygems.org/gems/u-attributes">
+    <img alt="Gem" src="https://img.shields.io/gem/v/u-attributes.svg?style=flat-square">
+  </a>
+
+  <a href="https://travis-ci.com/serradura/u-attributes">
+    <img alt="Build Status" src="https://travis-ci.com/serradura/u-attributes.svg?branch=main">
+  </a>
+
+  <a href="https://codeclimate.com/github/serradura/u-attributes/maintainability">
+    <img alt="Maintainability" src="https://api.codeclimate.com/v1/badges/b562e6b877a9edf4dbf6/maintainability">
+  </a>
+
+  <a href="https://codeclimate.com/github/serradura/u-attributes/test_coverage">
+    <img alt="Test Coverage" src="https://api.codeclimate.com/v1/badges/b562e6b877a9edf4dbf6/test_coverage">
+  </a>
+</p>
+
+This gem allows you to define "immutable" objects, and your objects will have only getters and no setters.
+So, if you change [[1](#with_attribute)] [[2](#with_attributes)] some object attribute, you will have a new object instance. That is, you transform the object instead of modifying it.
+
+# Table of contents <!-- omit in toc -->
+- [Installation](#installation)
+- [Compatibility](#compatibility)
+- [Usage](#usage)
+  - [How to define attributes?](#how-to-define-attributes)
+    - [`Micro::Attributes#attributes=`](#microattributesattributes)
+      - [How to extract attributes from an object or hash?](#how-to-extract-attributes-from-an-object-or-hash)
+      - [Is it possible to define an attribute as required?](#is-it-possible-to-define-an-attribute-as-required)
+    - [`Micro::Attributes#attribute`](#microattributesattribute)
+    - [`Micro::Attributes#attribute!`](#microattributesattribute-1)
+  - [How to define multiple attributes?](#how-to-define-multiple-attributes)
+  - [`Micro::Attributes.with(:initialize)`](#microattributeswithinitialize)
+    - [`#with_attribute()`](#with_attribute)
+    - [`#with_attributes()`](#with_attributes)
+  - [Defining default values to the attributes](#defining-default-values-to-the-attributes)
+  - [The strict initializer](#the-strict-initializer)
+  - [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)
+- [Built-in extensions](#built-in-extensions)
+  - [Picking specific features](#picking-specific-features)
+    - [`Micro::Attributes.with`](#microattributeswith)
+    - [`Micro::Attributes.without`](#microattributeswithout)
+  - [Picking all the features](#picking-all-the-features)
+  - [Extensions](#extensions)
+    - [`ActiveModel::Validation` extension](#activemodelvalidation-extension)
+      - [`.attribute()` options](#attribute-options)
     - [Diff extension](#diff-extension)
     - [Initialize extension](#initialize-extension)
-    - [Strict initialize extension](#strict-initialize-extension)
-  - [Development](#development)
-  - [Contributing](#contributing)
-  - [License](#license)
-  - [Code of Conduct](#code-of-conduct)
+      - [Strict mode](#strict-mode)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+- [Code of Conduct](#code-of-conduct)
 
-## Installation
+# Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's Gemfile and `bundle install`:
 
 ```ruby
 gem 'u-attributes'
 ```
 
-And then execute:
+# Compatibility
 
-    $ bundle
+| u-attributes   | branch  | ruby     |  activemodel  |
+| -------------- | ------- | -------- | ------------- |
+| 2.1.0          | main    | >= 2.2.0 | >= 3.2, < 6.1 |
+| 1.2.0          | v1.x    | >= 2.2.0 | >= 3.2, < 6.1 |
 
-Or install it yourself as:
+> **Note**: The activemodel is an optional dependency, this module [can be enabled](#activemodelvalidation-extension) to validate the attributes.
 
-    $ gem install u-attributes
+[⬆️ Back to Top](#table-of-contents-)
 
-## Usage
+# Usage
 
-### How to require?
-```ruby
-# Bundler will do it automatically, but if you desire to do a manual require.
-# Use one of the following options:
-
-require 'micro/attributes'
-
-# or
+## How to define attributes?
 
-require 'u-attributes'
-```
+By default, you must define the class constructor.
 
-### How to define attributes?
 ```ruby
-
-# By default you must to define the class constructor.
-
 class Person
   include Micro::Attributes
 
-  attribute :name
   attribute :age
+  attribute :name
 
   def initialize(name: 'John Doe', age:)
     @name, @age = name, age
@@ -77,26 +102,28 @@ end
 
 person = Person.new(age: 21)
 
-puts person.name # John Doe
-puts person.age  # 21
+person.age  # 21
+person.name # John Doe
 
-# By design, the attributes expose only reader methods (getters).
-# If you try to call a setter, you will see a NoMethodError.
+# By design the attributes are always exposed as reader methods (getters).
+# If you try to call a setter you will see a NoMethodError.
 #
 # person.name = 'Rodrigo'
-# NoMethodError (undefined method `name=' for #<Person:0x0000... @name="John Doe", @age=21>)
+# NoMethodError (undefined method `name=' for #<Person:0x0000... @name='John Doe', @age=21>)
+```
 
-#------------------#
-# self.attributes= #
-#------------------#
+[⬆️ Back to Top](#table-of-contents-)
 
-# This protected method is added to make easier the assignment in a constructor.
+### `Micro::Attributes#attributes=`
 
+This is a protected method to make easier the assignment in a constructor. e.g.
+
+```ruby
 class Person
   include Micro::Attributes
 
-  attribute :name, 'John Doe' # .attribute() accepts a second arg as its default value
   attribute :age
+  attribute :name, default: 'John Doe'
 
   def initialize(options)
     self.attributes = options
@@ -105,46 +132,115 @@ end
 
 person = Person.new(age: 20)
 
-puts person.name # John Doe
-puts person.age  # 20
+person.age  # 20
+person.name # John Doe
+```
 
-#--------------#
-# #attribute() #
-#--------------#
-#
-# Use the #attribute() method with a valid attribute name to get its value
+#### How to extract attributes from an object or hash?
 
-puts person.attribute(:name) # John Doe
-puts person.attribute('age') # 20
-puts person.attribute('foo') # nil
+You can extract attributes using the `extract_attributes_from` method, it will try to fetch attributes from the
+object using either the `object[attribute_key]` accessor or the reader method `object.attribute_key`.
 
-#
-# If you pass a block, it will be executed only if the attribute is valid.
+```ruby
+class Person
+  include Micro::Attributes
+
+  attribute :age
+  attribute :name, default: 'John Doe'
+
+  def initialize(user:)
+    self.attributes = extract_attributes_from(user)
+  end
+end
+
+# extracting from an object
+
+class User
+  attr_accessor :age, :name
+end
+
+user = User.new
+user.age = 20
+
+person = Person.new(user: user)
+
+person.age  # 20
+person.name # John Doe
+
+# extracting from a hash
+
+another_person = Person.new(user: { age: 55, name: 'Julia Not Roberts' })
+
+another_person.age  # 55
+another_person.name # Julia Not Roberts
+```
+
+#### Is it possible to define an attribute as required?
+
+You only need to use the `required: true` option.
+
+But to this work, you need to assign the attributes using the [`#attributes=`](#microattributesattributes) method or the extensions: [initialize](#initialize-extension), [activemodel_validations](#activemodelvalidation-extension).
+
+```ruby
+class Person
+  include Micro::Attributes
+
+  attribute :age
+  attribute :name, required: true
+
+  def initialize(attributes)
+    self.attributes = attributes
+  end
+end
 
+Person.new(age: 32) # ArgumentError (missing keyword: :name)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### `Micro::Attributes#attribute`
+
+Use this method with a valid attribute name to get its value.
+
+```ruby
+person = Person.new(age: 20)
+
+person.attribute('age') # 20
+person.attribute(:name) # John Doe
+person.attribute('foo') # nil
+```
+
+If you pass a block, it will be executed only if the attribute was valid.
+
+```ruby
 person.attribute(:name) { |value| puts value } # John Doe
 person.attribute('age') { |value| puts value } # 20
-person.attribute('foo') { |value| puts value } # !! Nothing happened, because of the attribute not exists.
+person.attribute('foo') { |value| puts value } # !! Nothing happened, because of the attribute doesn't exist.
+```
 
-#---------------#
-# #attribute!() #
-#---------------#
-#
-# Works like the #attribute() method, but will raise an exception when the attribute not exist.
+[⬆️ Back to Top](#table-of-contents-)
 
-puts person.attribute!('foo')                   # NameError (undefined attribute `foo)
-person.attribute!('foo') { |value| puts value } # NameError (undefined attribute `foo)
-```
+### `Micro::Attributes#attribute!`
 
-### How to define multiple attributes?
+Works like the `#attribute` method, but it will raise an exception when the attribute doesn't exist.
 
 ```ruby
+person.attribute!('foo')                   # NameError (undefined attribute `foo)
 
-# Use .attributes with a list of attribute names.
+person.attribute!('foo') { |value| value } # NameError (undefined attribute `foo)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## How to define multiple attributes?
 
+Use `.attributes` with a list of attribute names.
+
+```ruby
 class Person
   include Micro::Attributes
 
-  attributes :age, name: 'John Doe' # Use a hash to define attributes with default values
+  attributes :age, :name
 
   def initialize(options)
     self.attributes = options
@@ -153,89 +249,133 @@ end
 
 person = Person.new(age: 32)
 
-puts person.name # 'John Doe'
-puts person.age  # 32
+person.name # nil
+person.age  # 32
 ```
 
-### How to define attributes with a constructor to assign them?
-A: Use `Micro::Attributes.to_initialize`
+> **Note:** This method can't define default values. To do this, use the `#attribute()` method.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## `Micro::Attributes.with(:initialize)`
+
+Use `Micro::Attributes.with(:initialize)` to define a constructor to assign the attributes. e.g.
 
 ```ruby
 class Person
-  include Micro::Attributes.to_initialize
+  include Micro::Attributes.with(:initialize)
 
-  attributes :age, name: 'John Doe'
+  attribute :age, required: true
+  attribute :name, default: 'John Doe'
 end
 
 person = Person.new(age: 18)
 
-puts person.name # John Doe
-puts person.age  # 18
+person.age  # 18
+person.name # John Doe
+```
 
-##############################################
-# Assigning new values to get a new instance #
-##############################################
+This extension enables two methods for your objects.
+The `#with_attribute()` and `#with_attributes()`.
 
-#-------------------#
-# #with_attribute() #
-#-------------------#
+### `#with_attribute()`
 
+```ruby
 another_person = person.with_attribute(:age, 21)
 
-puts another_person.name           # John Doe
-puts another_person.age            # 21
-puts another_person.equal?(person) # false
+another_person.age            # 21
+another_person.name           # John Doe
+another_person.equal?(person) # false
+```
 
-#--------------------#
-# #with_attributes() #
-#--------------------#
-#
-# Use it to assign multiple attributes
+### `#with_attributes()`
 
+Use it to assign multiple attributes
+```ruby
 other_person = person.with_attributes(name: 'Serradura', age: 32)
 
-puts other_person.name           # Serradura
-puts other_person.age            # 32
-puts other_person.equal?(person) # false
+other_person.age            # 32
+other_person.name           # Serradura
+other_person.equal?(person) # false
+```
 
-# If you pass a value different of a Hash, an ArgumentError will be raised.
-#
-# Person.new(1)
-# ArgumentError (argument must be a Hash)
+If you pass a value different of a Hash, a Kind::Error will be raised.
 
-#--------------------#
-# Strict initializer #
-#--------------------#
+```ruby
+Person.new(1) # Kind::Error (1 expected to be a kind of Hash)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## Defining default values to the attributes
+
+To do this, you only need make use of the `default:` keyword. e.g.
+
+```ruby
+class Person
+  include Micro::Attributes.with(:initialize)
+
+  attribute :age
+  attribute :name, default: 'John Doe'
+end
+```
+
+There are 3 different strategies to define default values.
+1. Pass a regular object, like in the previous example.
+2. Pass a `proc`/`lambda`, and if it has an argument you will receive the attribute value to do something before assign it.
+3. Pass a **callable**, that is, a `class`, `module` or `instance` which responds to the `call` method. The behavior will be like the previous item (`proc`/`lambda`).
+
+```ruby
+class Person
+  include Micro::Attributes.with(:initialize)
+
+  attribute :age, default: -> age { age&.to_i }
+  attribute :name, default: -> name { String(name || 'John Doe').strip }
+end
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## The strict initializer
+
+Use `.with(initialize: :strict)` to forbids an instantiation without all the attribute keywords.
 
-# Use .to_initialize! to forbids an instantiation without all keywords.
+In other words, it is equivalent to you define all the attributes using the [`required: true` option](#is-it-possible-to-define-an-attribute-as-required).
 
+```ruby
 class StrictPerson
-  include Micro::Attributes.to_initialize!
+  include Micro::Attributes.with(initialize: :strict)
 
-  attributes :age, name: 'John Doe'
+  attribute :age
+  attribute :name, default: 'John Doe'
 end
 
-StrictPerson.new({})
+StrictPerson.new({}) # ArgumentError (missing keyword: :age)
+```
 
-# The code above will raise:
-# ArgumentError (missing keyword: :age)
+An attribute with a default value can be omitted.
 
+``` ruby
 person_without_age = StrictPerson.new(age: nil)
 
-p person_without_age.name # "John Doe"
-p person_without_age.age  # nil
-
-# Except for this validation when initializing,
-# the `to_initialize!` method will works in the same ways of `to_initialize`.
+person_without_age.age  # nil
+person_without_age.name # 'John Doe'
 ```
 
-### How to inherit the attributes?
+> **Note:** Except for this validation the `.with(initialize: :strict)` method will works in the same ways of `.with(:initialize)`.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## Is it possible to inherit the attributes?
+
+Yes. e.g.
 
 ```ruby
 class Person
-  include Micro::Attributes.to_initialize
+  include Micro::Attributes.with(:initialize)
 
-  attributes :age, name: 'John Doe'
+  attribute :age
+  attribute :name, default: 'John Doe'
 end
 
 class Subclass < Person # Will preserve the parent class attributes
@@ -244,42 +384,48 @@ end
 
 instance = Subclass.new({})
 
-puts instance.name              # John Doe
-puts instance.respond_to?(:age) # true
-puts instance.respond_to?(:foo) # true
+instance.name              # John Doe
+instance.respond_to?(:age) # true
+instance.respond_to?(:foo) # true
+```
+
+[⬆️ Back to Top](#table-of-contents-)
 
-#---------------------------------#
-# .attribute!() or .attributes!() #
-#---------------------------------#
+### `.attribute!()`
 
-# The methods above allow redefining the attributes default data
+This method allows us to redefine the attributes default data that was defined in the parent class. e.g.
 
+```ruby
 class AnotherSubclass < Person
-  attribute! :name, 'Alfa'
+  attribute! :name, default: 'Alfa'
 end
 
 alfa_person = AnotherSubclass.new({})
 
-p alfa_person.name # "Alfa"
-p alfa_person.age  # nil
+alfa_person.name # 'Alfa'
+alfa_person.age  # nil
 
 class SubSubclass < Subclass
-  attributes! name: 'Beta', age: 0
+  attribute! :age, default: 0
+  attribute! :name, default: 'Beta'
 end
 
 beta_person = SubSubclass.new({})
 
-p beta_person.name # "Beta"
-p beta_person.age  # 0
+beta_person.name # 'Beta'
+beta_person.age  # 0
 ```
 
-### How to query the attributes?
+[⬆️ Back to Top](#table-of-contents-)
+
+## How to query the attributes?
 
 ```ruby
 class Person
   include Micro::Attributes
 
-  attributes :age, name: 'John Doe'
+  attribute :age
+  attribute :name, default: 'John Doe'
 
   def initialize(options)
     self.attributes = options
@@ -290,140 +436,122 @@ end
 # .attributes() #
 #---------------#
 
-p Person.attributes # ["name", "age"]
+Person.attributes # ['name', 'age']
 
 #---------------#
 # .attribute?() #
 #---------------#
 
-puts Person.attribute?(:name)  # true
-puts Person.attribute?('name') # true
-puts Person.attribute?('foo') # false
-puts Person.attribute?(:foo)  # false
+Person.attribute?(:name)  # true
+Person.attribute?('name') # true
+Person.attribute?('foo') # false
+Person.attribute?(:foo)  # false
 
 # ---
 
 person = Person.new(age: 20)
 
+#---------------------#
+# #defined_attributes #
+#---------------------#
+
+person.defined_attributes # ['name', 'age']
+
 #---------------#
 # #attribute?() #
 #---------------#
 
-puts person.attribute?(:name)  # true
-puts person.attribute?('name') # true
-puts person.attribute?('foo') # false
-puts person.attribute?(:foo)  # false
+person.attribute?(:name)  # true
+person.attribute?('name') # true
+person.attribute?('foo') # false
+person.attribute?(:foo)  # false
 
 #---------------#
 # #attributes() #
 #---------------#
 
-p person.attributes                   # {"age"=>20, "name"=>"John Doe"}
-p Person.new(name: 'John').attributes # {"age"=>nil, "name"=>"John"}
-```
+person.attributes                   # {'age'=>20, 'name'=>'John Doe'}
+Person.new(name: 'John').attributes # {'age'=>nil, 'name'=>'John'}
 
-## Built-in extensions
+#---------------------#
+# #attributes(*names) #
+#---------------------#
 
-You can use the method `Micro::Attributes.features()` or `Micro::Attributes.with()` to combine and require only the features that better fit your needs.
+# Slices the attributes to include only the given keys.
+# Returns a hash containing the given keys (in their types).
 
-But, if you desire...
-1. only one feature, use the `Micro::Attributes.feature()` method.
-2. except one or more features, use the `Micro::Attributes.without()` method.
+person.attributes(:age)             # {age: 20}
+person.attributes(:age, :name)      # {age: 20, name: 'John Doe'}
+person.attributes('age', 'name')    # {'age'=>20, 'name'=>'John Doe'}
+```
 
-```ruby
-#===========================#
-# Loading specific features #
-#===========================#
+[⬆️ Back to Top](#table-of-contents-)
 
-class Job
-  include Micro::Attributes.feature(:diff)
+# Built-in extensions
 
-  attribute :id
-  attribute :state, 'sleeping'
+You can use the method `Micro::Attributes.with()` to combine and require only the features that better fit your needs.
 
-  def initialize(options)
-    self.attributes = options
-  end
-end
+But, if you desire except one or more features, use the `Micro::Attributes.without()` method.
 
-#======================#
-# Loading all features #
-#         ---          #
-#======================#
+## Picking specific features
 
-class Job
-  include Micro::Attributes.features
+### `Micro::Attributes.with`
 
-  attributes :id, state: 'sleeping'
-end
+```ruby
+Micro::Attributes.with(:initialize)
 
-# Note:
-# If `Micro::Attributes.features()` be invoked without arguments, a module with all features will be returned.
+Micro::Attributes.with(initialize: :strict)
 
-#----------------------------------------------------------------------------#
-# Using the .with() method alias and adding the strict initialize extension. #
-#----------------------------------------------------------------------------#
-class Job
-  include Micro::Attributes.with(:strict_initialize, :diff)
+Micro::Attributes.with(:diff, :initialize)
 
-  attributes :id, state: 'sleeping'
-end
+Micro::Attributes.with(:diff, initialize: :strict)
 
-# Note:
-# The method `Micro::Attributes.with()` will raise an exception if no arguments/features were declared.
-#
-# class Job
-#   include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: diff, initialize, activemodel_validations)
-# end
+Micro::Attributes.with(:activemodel_validations)
 
-#===================================#
-# Alternatives to the methods above #
-#===================================#
+Micro::Attributes.with(:activemodel_validations, :diff)
 
-#---------------------------------------#
-# Via Micro::Attributes.to_initialize() #
-#---------------------------------------#
-class Job
-  include Micro::Attributes.to_initialize(diff: true, activemodel_validations: true)
+Micro::Attributes.with(:activemodel_validations, :diff, initialize: :strict)
+```
 
-  # Same of `include Micro::Attributes.with(:initialize, :diff, :activemodel_validations)`
-end
+The method `Micro::Attributes.with()` will raise an exception if no arguments/features were declared.
 
-#----------------------------------------#
-# Via Micro::Attributes.to_initialize!() #
-#----------------------------------------#
+```ruby
 class Job
-  include Micro::Attributes.to_initialize!(diff: false, activemodel_validations: true)
-
-  # Same of `include Micro::Attributes.with(:strict_initialize, :activemodel_validations)`
+  include Micro::Attributes.with() # ArgumentError (Invalid feature name! Available options: :activemodel_validations, :diff, :initialize)
 end
+```
 
-#=====================================#
-# Loading except one or more features #
-#         -----                       #
-#=====================================#
+### `Micro::Attributes.without`
 
-class Job
-  include Micro::Attributes.without(:diff)
+Picking *except* one or more features
 
-  attributes :id, state: 'sleeping'
-end
+```ruby
+Micro::Attributes.without(:diff) # will load :activemodel_validations and initialize: :strict
+
+Micro::Attributes.without(initialize: :strict) # will load :activemodel_validations and :diff
+```
 
-# Note:
-# The method `Micro::Attributes.without()` returns `Micro::Attributes` if all features extensions were used.
+## Picking all the features
+
+```ruby
+Micro::Attributes.with_all_features
 ```
 
-### ActiveModel::Validations extension
+[⬆️ Back to Top](#table-of-contents-)
 
-If your application uses ActiveModel as a dependency (like a regular Rails app). You will be enabled to use the `actimodel_validations` extension.
+## Extensions
+
+### `ActiveModel::Validation` extension
+
+If your application uses ActiveModel as a dependency (like a regular Rails app). You will be enabled to use the `activemodel_validations` extension.
 
 ```ruby
 class Job
-  # include Micro::Attributes.with(:initialize, :activemodel_validations)
-  # include Micro::Attributes.features(:initialize, :activemodel_validations)
-  include Micro::Attributes.to_initialize(activemodel_validations: true)
+  include Micro::Attributes.with(:activemodel_validations)
+
+  attribute :id
+  attribute :state, default: 'sleeping'
 
-  attributes :id, state: 'sleeping'
   validates! :id, :state, presence: true
 end
 
@@ -431,10 +559,31 @@ Job.new({}) # ActiveModel::StrictValidationFailed (Id can't be blank)
 
 job = Job.new(id: 1)
 
-p job.id    # 1
-p job.state # "sleeping"
+job.id    # 1
+job.state # 'sleeping'
+```
+
+#### `.attribute()` options
+
+You can use the `validate` or `validates` options to define your attributes. e.g.
+
+```ruby
+class Job
+  include Micro::Attributes.with(:activemodel_validations)
+
+  attribute :id, validates: { presence: true }
+  attribute :state, validate: :must_be_a_filled_string
+
+  def must_be_a_filled_string
+    return if state.is_a?(String) && state.present?
+
+    errors.add(:state, 'must be a filled string')
+  end
+end
 ```
 
+[⬆️ Back to Top](#table-of-contents-)
+
 ### Diff extension
 
 Provides a way to track changes in your object attributes.
@@ -443,21 +592,20 @@ Provides a way to track changes in your object attributes.
 require 'securerandom'
 
 class Job
-  # include Micro::Attributes.with(:initialize, :diff)
-  # include Micro::Attributes.to_initialize(diff: true)
-  include Micro::Attributes.features(:initialize, :diff)
+  include Micro::Attributes.with(:initialize, :diff)
 
-  attributes :id, state: 'sleeping'
+  attribute :id
+  attribute :state, default: 'sleeping'
 end
 
 job = Job.new(id: SecureRandom.uuid())
 
-p job.id    # A random UUID generated from SecureRandom.uuid(). e.g: "e68bcc74-b91c-45c2-a904-12f1298cc60e"
-p job.state # "sleeping"
+job.id    # A random UUID generated from SecureRandom.uuid(). e.g: 'e68bcc74-b91c-45c2-a904-12f1298cc60e'
+job.state # 'sleeping'
 
 job_running = job.with_attribute(:state, 'running')
 
-p job_running.state # "running"
+job_running.state # 'running'
 
 job_changes = job.diff_attributes(job_running)
 
@@ -465,50 +613,49 @@ job_changes = job.diff_attributes(job_running)
 # #present?, #blank?, #empty? #
 #-----------------------------#
 
-p job_changes.present? # true
-p job_changes.blank?   # false
-p job_changes.empty?   # false
+job_changes.present? # true
+job_changes.blank?   # false
+job_changes.empty?   # false
 
 #-----------#
 # #changed? #
 #-----------#
-p job_changes.changed? # true
+job_changes.changed? # true
 
-p job_changes.changed?(:id)    # false
+job_changes.changed?(:id)    # false
 
-p job_changes.changed?(:state) # true
-p job_changes.changed?(:state, from: 'sleeping', to: 'running') # true
+job_changes.changed?(:state) # true
+job_changes.changed?(:state, from: 'sleeping', to: 'running') # true
 
 #----------------#
 # #differences() #
 #----------------#
-p job_changes.differences # {"state"=> {"from" => "sleeping", "to" => "running"}}
+job_changes.differences # {'state'=> {'from' => 'sleeping', 'to' => 'running'}}
 ```
 
+[⬆️ Back to Top](#table-of-contents-)
+
 ### Initialize extension
 
 1. Creates a constructor to assign the attributes.
-2. Adds methods to build new instances when some data was assigned.
+2. Add methods to build new instances when some data was assigned.
 
 ```ruby
 class Job
-  # include Micro::Attributes.with(:initialize)
-  # include Micro::Attributes.feature(:initialize)
-  # include Micro::Attributes.features(:initialize)
-  include Micro::Attributes.to_initialize
+  include Micro::Attributes.with(:initialize)
 
   attributes :id, :state
 end
 
 job_null = Job.new({})
 
-p job.id    # nil
-p job.state # nil
+job.id    # nil
+job.state # nil
 
 job = Job.new(id: 1, state: 'sleeping')
 
-p job.id    # 1
-p job.state # "sleeping"
+job.id    # 1
+job.state # 'sleeping'
 
 ##############################################
 # Assigning new values to get a new instance #
@@ -520,9 +667,9 @@ p job.state # "sleeping"
 
 new_job = job.with_attribute(:state, 'running')
 
-puts new_job.id          # 1
-puts new_job.state       # running
-puts new_job.equal?(job) # false
+new_job.id          # 1
+new_job.state       # running
+new_job.equal?(job) # false
 
 #--------------------#
 # #with_attributes() #
@@ -532,12 +679,14 @@ puts new_job.equal?(job) # false
 
 other_job = job.with_attributes(id: 2, state: 'killed')
 
-puts other_job.id          # 2
-puts other_job.state       # killed
-puts other_job.equal?(job) # false
+other_job.id          # 2
+other_job.state       # killed
+other_job.equal?(job) # false
 ```
 
-### Strict initialize extension
+[⬆️ Back to Top](#table-of-contents-)
+
+#### Strict mode
 
 1. Creates a constructor to assign the attributes.
 2. Adds methods to build new instances when some data was assigned.
@@ -545,16 +694,13 @@ puts other_job.equal?(job) # false
 
 ```ruby
 class Job
-  # include Micro::Attributes.with(:strict_initialize)
-  # include Micro::Attributes.feature(:strict_initialize)
-  # include Micro::Attributes.features(:strict_initialize)
-  include Micro::Attributes.to_initialize!
+  include Micro::Attributes.with(initialize: :strict)
 
   attributes :id, :state
 end
-#----------------------------------------------------------------------------#
-# The strict_initialize extension will require all the keys when initialize. #
-#----------------------------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# The strict initialize mode will require all the keys when initialize. #
+#-----------------------------------------------------------------------#
 
 Job.new({})
 
@@ -567,34 +713,33 @@ Job.new({})
 
 job_null = Job.new(id: nil, state: nil)
 
-p job.id    # nil
-p job.state # nil
+job.id    # nil
+job.state # nil
 
 job = Job.new(id: 1, state: 'sleeping')
 
-p job.id    # 1
-p job.state # "sleeping"
+job.id    # 1
+job.state # 'sleeping'
+```
 
+> **Note**: This extension works like the `initialize` extension. So, look at its section to understand all of the other features.
 
-# Note:
-#   This extension works like the `initialize` extension.
-#   So, look at its section to understand all the other features.
-```
+[⬆️ Back to Top](#table-of-contents-)
 
-## Development
+# 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.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Contributing
+# Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/serradura/u-attributes. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-## License
+# License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## Code of Conduct
+# Code of Conduct
 
-Everyone interacting in the Micro::Attributes project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/serradura/u-attributes/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Micro::Attributes project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/serradura/u-attributes/blob/main/CODE_OF_CONDUCT.md).