alba 0.5.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89b4df7ce18a63e20cee9e87bd2855ef9c4735c4f6e4e1ef55433c5ba0a2fbd0
-  data.tar.gz: 63fa94fa17cdf3f5bfeef5f2e7b0d6efeec1fd06ad8d5386fb389fea3db0343a
+  metadata.gz: e8427c3365aa48ba76f97799757e5e32ae2f746d3b63c67d58e7c7ddadd17bae
+  data.tar.gz: c995206962d4a041032b76113a2f053e48f50f787af12c491437ff98c55d4d2e
 SHA512:
-  metadata.gz: 063d913715faa3917df5658d798ceb1619b9a2aef1dc0875c92c1592b3d3f9025bec60a364ebe0d54fb0769e18ba78f5786caa288159d304dfeca7ab00149d2b
-  data.tar.gz: 66aed62d355cd6fd8527ad4da27c53c9c42bf98606586a562b84dc377e6041125653d9669cf77c14427b4a1796b6c7abd7e6b2861323bac51fde28bfe05a7e7a
+  metadata.gz: b513dea8cfa68bf09e76114c3d6e14bd77a381f94ad9342c8692034069240c114b9eac95bf071662905de14efe269ac606a7cb2b50ec4107fa393391ed5ddf9d
+  data.tar.gz: e44bc0f25be1342ea9424c3919c62cd40b1917eac62f6bf612cd7979ead6db5521200eae4d7ef9a795ee373145c4fb5c846886bc1869916fd744596ac57aecbc

data/.rubocop.yml

@@ -4,6 +4,7 @@ inherit_gem:
   rubocop-sensible: 'config/rubocop.yml'
 
 require:
+  - rubocop-minitest
   - rubocop-performance
 
 AllCops:
@@ -11,17 +12,45 @@ AllCops:
     - 'Rakefile'
     - 'alba.gemspec'
   NewCops: enable
+  EnabledByDefault: true
+
+# Oneline comment is not valid so until it gets valid, we disable it
+Bundler/GemComment:
+  Enabled: false
+
+Layout/ClassStructure:
+  Enabled: true
 
 Layout/SpaceInsideHashLiteralBraces:
   EnforcedStyle: no_space
 
+Layout/MultilineAssignmentLayout:
+  EnforcedStyle: same_line
+
+Lint/ConstantResolution:
+  Enabled: false
+
+Metrics/ClassLength:
+  Exclude:
+    - 'test/alba_test.rb'
+
 Metrics/MethodLength:
-  Max: 20
+  Max: 15
 
-Naming/PredicateName:
-  AllowedMethods:
-    - 'has_one'
-    - 'has_many'
+Style/ConstantVisibility:
+  Enabled: false
+
+Style/Copyright:
+  Enabled: false
+
+Style/DocumentationMethod:
+  Enabled: false
 
 Style/FrozenStringLiteralComment:
   Enabled: false
+
+Style/InlineComment:
+  Enabled: false
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: false

data/.travis.yml

@@ -2,5 +2,8 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.6.5
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
+  - truffleruby
 before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -3,9 +3,12 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in alba.gemspec
 gemspec
 
-gem 'coveralls', require: false
-gem 'minitest', '~> 5.0'
-gem 'rake', '~> 13.0'
-gem 'rubocop', '>= 0.79.0', require: false
-gem 'rubocop-performance', '~> 1.7.1', require: false
-gem 'rubocop-sensible', '~> 0.3.0', require: false
+gem 'activesupport', require: false # For backend
+gem 'coveralls', require: false # For test coverage
+gem 'minitest', '~> 5.0' # For test
+gem 'oj', '~> 3.10', platforms: :ruby # For backend
+gem 'rake', '~> 13.0' # For test and automation
+gem 'rubocop', '>= 0.79.0', require: false # For lint
+gem 'rubocop-minitest', '~> 0.10.1', require: false # For lint
+gem 'rubocop-performance', '~> 1.7.1', require: false # For lint
+gem 'rubocop-sensible', '~> 0.3.0', require: false # For lint

data/Gemfile.lock

@@ -1,12 +1,20 @@
 PATH
   remote: .
   specs:
-    alba (0.5.0)
+    alba (0.10.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (6.0.3.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
     ast (2.4.1)
+    bigdecimal (2.0.0)
+    concurrent-ruby (1.1.6)
     coveralls (0.8.23)
       json (>= 1.8, < 3)
       simplecov (~> 0.16.1)
@@ -14,8 +22,12 @@ GEM
       thor (>= 0.19.4, < 2.0)
       tins (~> 1.6)
     docile (1.3.2)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
     json (2.3.1)
     minitest (5.14.1)
+    oj (3.10.12)
+      bigdecimal (>= 1.0, < 3)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
@@ -23,17 +35,19 @@ GEM
     rake (13.0.1)
     regexp_parser (1.7.1)
     rexml (3.2.4)
-    rubocop (0.88.0)
+    rubocop (0.89.1)
       parallel (~> 1.10)
       parser (>= 2.7.1.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.7)
       rexml
-      rubocop-ast (>= 0.1.0, < 1.0)
+      rubocop-ast (>= 0.3.0, < 1.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (0.2.0)
-      parser (>= 2.7.0.1)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    rubocop-minitest (0.10.1)
+      rubocop (>= 0.87)
     rubocop-performance (1.7.1)
       rubocop (>= 0.82.0)
     rubocop-sensible (0.3.0)
@@ -48,19 +62,26 @@ GEM
     term-ansicolor (1.7.1)
       tins (~> 1.0)
     thor (1.0.1)
+    thread_safe (0.3.6)
     tins (1.25.0)
       sync
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
     unicode-display_width (1.7.0)
+    zeitwerk (2.4.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
   alba!
   coveralls
   minitest (~> 5.0)
+  oj (~> 3.10)
   rake (~> 13.0)
   rubocop (>= 0.79.0)
+  rubocop-minitest (~> 0.10.1)
   rubocop-performance (~> 1.7.1)
   rubocop-sensible (~> 0.3.0)
 

data/README.md

@@ -1,10 +1,27 @@
+[![Gem Version](https://badge.fury.io/rb/alba.svg)](https://badge.fury.io/rb/alba)
 [![Build Status](https://travis-ci.com/okuramasafumi/alba.svg?branch=master)](https://travis-ci.com/okuramasafumi/alba)
 [![Coverage Status](https://coveralls.io/repos/github/okuramasafumi/alba/badge.svg?branch=master)](https://coveralls.io/github/okuramasafumi/alba?branch=master)
 [![Maintainability](https://api.codeclimate.com/v1/badges/fdab4cc0de0b9addcfe8/maintainability)](https://codeclimate.com/github/okuramasafumi/alba/maintainability)
 
 # Alba
 
-`Alba` is a stupid, fast and easy to use JSON serializer.
+`Alba` is the fastest JSON serializer for Ruby.
+
+# Why yet another JSON serializer?
+
+We know that there are several other JSON serializers for Ruby around, but none of them made us satisfied.
+
+Alba has some advantages over other JSON serializers which we've wanted to have.
+
+## Easy to understand
+
+DSL is great. It makes the coding experience natural and intuitive. However, remembering lots of DSL requires us a lot of effort. Unfortunately, most of the existing libraries have implemented their features via DSL and it's not easy to understand how they behave entirely. Alba's core DSL are only four (`attributes`, `attribute`, `one` and `many`) so it's easy to understand how to use.
+
+Alba is also understandable internally. The codebase is much smaller than the alternatives. In fact, it's less than 300 lines of code. Look at the code on [GitHub](https://github.com/okuramasafumi/alba/tree/master/lib) and you'll be surprised how simple it is!
+
+## Performance
+
+Alba is faster than most of the alternatives. We have a [benchmark](https://gist.github.com/okuramasafumi/4e375525bd3a28e4ca812d2a3b3e5829).
 
 ## Installation
 
@@ -24,6 +41,24 @@ Or install it yourself as:
 
 ## Usage
 
+### Configuration
+
+Alba's configuration is fairly simple.
+
+#### Backend
+
+Backend is the actual part serializing an object into JSON. Alba supports these backends.
+
+* Oj, the fastest. Gem installation required.
+* active_support, mostly for Rails. Gem installation required.
+* default or json, with no external dependencies.
+
+You can set a backend like this:
+
+```ruby
+Alba.backend = :oj
+```
+
 ### Simple serialization with key
 
 ```ruby
@@ -124,15 +159,65 @@ end
 
 Although this might be useful sometimes, it's generally recommended to define a class for both Resource and Serializer.
 
+### Inheritance and Ignorance
+
+You can `exclude` or `ignore` certain attributes using `ignoring`.
+
+```ruby
+class Foo
+  attr_accessor :id, :name, :body
+
+  def initialize(id, name, body)
+    @id = id
+    @name = name
+    @body = body
+  end
+end
+
+class GenericFooResource
+  include Alba::Resource
+
+  attributes :id, :name, :body
+end
+
+class RestrictedFooResouce < GenericFooResource
+  ignoring :id, :body
+end
+
+RestrictedFooResouce.new(foo).serialize
+# => '{"name":"my foo"}'
+end
+```
+
 ## Comparison
 
-Since Alba is intended to be stupid, there are many things Alba can't do while other gems can. However, from the same reason, it's extremely faster than alternatives.
+Alba is faster than alternatives.
 For a performance benchmark, see https://gist.github.com/okuramasafumi/4e375525bd3a28e4ca812d2a3b3e5829.
 
+## Rails
+
+When you use Alba in Rails, you can create an initializer file with the line below for compatibility with Rails JSON encoder.
+
+```ruby
+Alba.backend = :active_support
+```
+
 ## Why named "Alba"?
 
 The name "Alba" comes from "albatross", a kind of birds. In Japanese, this bird is called "Aho-dori", which means "stupid bird". I find it funny because in fact albatrosses fly really fast. I hope Alba looks stupid but in fact it does its job quick.
 
+## Alba internals
+
+Alba has three component, `Serializer`, `Resource` and `Value` (`Value` is conceptual and not implemented directly).
+
+`Serializer` is a component responsible for rendering JSON output with `Resource`. `Serializer` can add more data to `Resource` such as `metadata`. Users can define one single `Serializer` and reuse it for all `Resource`s. The main interface is `#serialize`.
+
+`Resource` is a component responsible for defining how an object (or a collection of objects) is converted into JSON. The difference between `Serializer` and `Resource` is that while `Serializer` can add arbitrary data into JSON, `Resource` can get data only from the object under it. The main interface is `#serializable_hash`.
+
+`One` and `Many` are the special object fetching other resources and converting them into Hash.
+
+The main `Alba` module holds config values and one convenience method, `.serialize`.
+
 ## 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/alba.gemspec

@@ -1,27 +1,27 @@
 require_relative 'lib/alba/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "alba"
+  spec.name          = 'alba'
   spec.version       = Alba::VERSION
-  spec.authors       = ["OKURA Masafumi"]
-  spec.email         = ["masafumi.o1988@gmail.com"]
+  spec.authors       = ['OKURA Masafumi']
+  spec.email         = ['masafumi.o1988@gmail.com']
 
-  spec.summary       = "Fast and flexible JSON serializer"
-  spec.description   = "Fast and flexible JSON serializer"
-  spec.homepage      = "https://github.com/okuramasafumi/alba"
-  spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.summary       = 'Alba is the fastest JSON serializer for Ruby.'
+  spec.description   = "Alba is designed to be a simple, easy to use and fast alternative to existing JSON serializers. Its performance is better than almost all gems which do similar things. The internal is so simple that it's easy to hack and maintain."
+  spec.homepage      = 'https://github.com/okuramasafumi/alba'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.8')
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/okuramasafumi/alba"
-  spec.metadata["changelog_uri"] = "https://github.com/okuramasafumi/alba/CHANGELOG.md"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/okuramasafumi/alba'
+  spec.metadata['changelog_uri'] = 'https://github.com/okuramasafumi/alba/CHANGELOG.md'
 
   # 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
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 end

data/lib/alba.rb

@@ -7,12 +7,15 @@ require 'alba/resources/default_resource'
 # Core module
 module Alba
   class Error < StandardError; end
+  class UnsupportedBackend < Error; end
 
   class << self
-    attr_reader :backend
+    attr_reader :backend, :encoder
+    attr_accessor :default_serializer
 
     def backend=(backend)
       @backend = backend&.to_sym
+      set_encoder
     end
 
     def serialize(object, with: nil, &block)
@@ -20,13 +23,50 @@ module Alba
 
       resource_class.class_eval(&block)
       resource = resource_class.new(object)
+      with ||= @default_serializer
       resource.serialize(with: with)
     end
 
     private
 
+    def set_encoder
+      @encoder = case @backend
+                 when :oj
+                   try_oj
+                 when :active_support
+                   try_active_support
+                 when nil, :default, :json
+                   default_encoder
+                 else
+                   raise Alba::UnsupportedBackend, "Unsupported backend, #{backend}"
+                 end
+    end
+
+    def try_oj
+      require 'oj'
+      ->(hash) { Oj.dump(hash, mode: :strict) }
+    rescue LoadError
+      default_encoder
+    end
+
+    def try_active_support
+      require 'active_support/json'
+      ->(hash) { ActiveSupport::JSON.encode(hash) }
+    rescue LoadError
+      default_encoder
+    end
+
+    def default_encoder
+      lambda do |hash|
+        require 'json'
+        JSON.dump(hash)
+      end
+    end
+
     def resource_class
       ::Alba::Resources::DefaultResource.clone
     end
   end
+
+  @encoder = default_encoder
 end

data/lib/alba/association.rb

@@ -0,0 +1,26 @@
+module Alba
+  # Base class for `One` and `Many`
+  # Child class should implement `to_hash` method
+  class Association
+    def initialize(name:, condition: nil, resource: nil, &block)
+      @name = name
+      @condition = condition
+      @block = block
+      @resource = resource || resource_class
+      raise ArgumentError, 'resource or block is required' if @resource.nil? && @block.nil?
+    end
+
+    def to_hash
+      :not_implemented
+    end
+
+    private
+
+    def resource_class
+      klass = ::Alba::Resources::DefaultResource.dup
+      klass.reset
+      klass.class_eval(&@block)
+      klass
+    end
+  end
+end

data/lib/alba/many.rb

@@ -1,26 +1,12 @@
+require 'alba/association'
+
 module Alba
   # Representing many association
-  class Many
-    def initialize(name:, resource: nil, &block)
-      @name = name
-      @resource = resource
-      @block = block
-      raise ArgumentError, 'resource or block is required' if @resource.nil? && @block.nil?
-    end
-
-    def to_hash(target)
+  class Many < Association
+    def to_hash(target, params: {})
       objects = target.public_send(@name)
-      @resource ||= resource_class
-      objects.map { |o| @resource.new(o).to_hash }
-    end
-
-    private
-
-    def resource_class
-      klass = Class.new
-      klass.include(::Alba::Resource)
-      klass.class_exec(&@block)
-      klass
+      objects = @condition.call(objects) if @condition
+      objects.map { |o| @resource.new(o, params: params).to_hash }
     end
   end
 end

data/lib/alba/one.rb

@@ -1,26 +1,12 @@
+require 'alba/association'
+
 module Alba
   # Representing one association
-  class One
-    def initialize(name:, resource: nil, &block)
-      @name = name
-      @resource = resource
-      @block = block
-      raise ArgumentError, 'resource or block is required' if @resource.nil? && @block.nil?
-    end
-
-    def to_hash(target)
+  class One < Association
+    def to_hash(target, params: {})
       object = target.public_send(@name)
-      @resource ||= resource_class
-      @resource.new(object).to_hash
-    end
-
-    private
-
-    def resource_class
-      klass = Class.new
-      klass.include(::Alba::Resource)
-      klass.class_exec(&@block)
-      klass
+      object = @condition.call(object) if @condition
+      @resource.new(object, params: params).to_hash
     end
   end
 end

data/lib/alba/resource.rb

@@ -1,5 +1,4 @@
 require 'alba/serializer'
-require 'alba/attribute'
 require 'alba/one'
 require 'alba/many'
 require 'alba/serializers/default_serializer'
@@ -7,13 +6,13 @@ require 'alba/serializers/default_serializer'
 module Alba
   # This module represents what should be serialized
   module Resource
-    DSLS = [:_attributes, :_serializer].freeze
+    DSLS = {_attributes: {}, _serializer: nil, _key: nil}.freeze
     def self.included(base)
+      super
       base.class_eval do
         # Initialize
-        DSLS.each do |name|
-          initial = name == :_serializer ? nil : {}
-          instance_variable_set("@#{name}", initial) unless instance_variable_defined?("@#{name}")
+        DSLS.each do |name, initial|
+          instance_variable_set("@#{name}", initial.dup) unless instance_variable_defined?("@#{name}")
         end
       end
       base.include InstanceMethods
@@ -22,9 +21,12 @@ module Alba
 
     # Instance methods
     module InstanceMethods
-      def initialize(resource)
-        @_resource = resource
-        DSLS.each { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
+      attr_reader :object, :_key, :params
+
+      def initialize(object, params: {})
+        @object = object
+        @params = params
+        DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
       end
 
       def serialize(with: nil)
@@ -38,54 +40,89 @@ module Alba
                      else
                        raise ArgumentError, 'Unexpected type for with, possible types are Class or Proc'
                      end
-        serializer.new(serializable_hash).serialize
+        serializer.new(self).serialize
       end
 
       def serializable_hash
-        @_attributes.transform_values do |attribute|
-          attribute.to_hash(@_resource)
-        end
+        collection? ? @object.map(&converter) : converter.call(@object)
       end
       alias to_hash serializable_hash
 
+      def key
+        @_key || self.class.name.delete_suffix('Resource').downcase.gsub(/:{2}/, '_').to_sym
+      end
+
       private
 
+      def converter
+        lambda do |resource|
+          @_attributes.transform_values do |attribute|
+            case attribute
+            when Symbol
+              resource.public_send attribute
+            when Proc
+              instance_exec(resource, &attribute)
+            when Alba::One, Alba::Many
+              attribute.to_hash(resource, params: params)
+            else
+              raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
+            end
+          end
+        end
+      end
+
       def inline_extended_serializer(with)
         klass = ::Alba::Serializers::DefaultSerializer.clone
         klass.class_eval(&with)
         klass
       end
+
+      def collection?
+        @object.is_a?(Enumerable)
+      end
     end
 
     # Class methods
     module ClassMethods
-      attr_accessor(*DSLS)
+      attr_reader(*DSLS.keys)
 
       def inherited(subclass)
-        DSLS.each { |name| subclass.public_send("#{name}=", instance_variable_get("@#{name}")) }
+        super
+        DSLS.each_key { |name| subclass.instance_variable_set("@#{name}", instance_variable_get("@#{name}").clone) }
       end
 
       def attributes(*attrs)
-        attrs.each { |attr_name| @_attributes[attr_name] = Attribute.new(name: attr_name, method: attr_name) }
+        attrs.each { |attr_name| @_attributes[attr_name.to_sym] = attr_name.to_sym }
       end
 
       def attribute(name, &block)
         raise ArgumentError, 'No block given in attribute method' unless block
 
-        @_attributes[name] = Attribute.new(name: name, method: block)
+        @_attributes[name.to_sym] = block
       end
 
-      def one(name, resource: nil, &block)
-        @_attributes[name.to_sym] = One.new(name: name, resource: resource, &block)
+      def one(name, condition = nil, resource: nil, key: nil, &block)
+        @_attributes[key&.to_sym || name.to_sym] = One.new(name: name, condition: condition, resource: resource, &block)
       end
 
-      def many(name, resource: nil, &block)
-        @_attributes[name.to_sym] = Many.new(name: name, resource: resource, &block)
+      def many(name, condition = nil, resource: nil, key: nil, &block)
+        @_attributes[key&.to_sym || name.to_sym] = Many.new(name: name, condition: condition, resource: resource, &block)
       end
 
       def serializer(name)
         @_serializer = name <= Alba::Serializer ? name : nil
       end
+
+      def key(key)
+        @_key = key.to_sym
+      end
+
+      # Use this DSL in child class to ignore certain attributes
+      def ignoring(*attributes)
+        attributes.each do |attr_name|
+          @_attributes.delete(attr_name.to_sym)
+        end
+      end
     end
   end
 end

data/lib/alba/resources/default_resource.rb

@@ -3,7 +3,11 @@ module Alba
     # Empty resource class, use this with `class_eval` for
     # inline associations and serializations.
     class DefaultResource
-      include ::Alba::Resource
+      include Alba::Resource
+
+      def self.reset
+        @_attributes = {}
+      end
     end
   end
 end

data/lib/alba/serializer.rb

@@ -1,8 +1,8 @@
 module Alba
   # This module represents how a resource should be serialized.
-  #
   module Serializer
     def self.included(base)
+      super
       base.include InstanceMethods
       base.extend ClassMethods
     end
@@ -10,39 +10,48 @@ module Alba
     # Instance methods
     module InstanceMethods
       def initialize(resource)
-        @_resource = resource
-        @_opts = self.class._opts || {}
-        key = @_opts[:key]
-        @_resource = {key.to_sym => @_resource} if key
+        @resource = resource
+        @hash = resource.serializable_hash
+        @hash = {key.to_sym => @hash} if key
+        # @hash is either Hash or Array
+        @hash.is_a?(Hash) ? @hash.merge!(metadata.to_h) : @hash << metadata
       end
 
       def serialize
-        fallback = lambda do
-          require 'json'
-          JSON.dump(@_resource)
-        end
-        case Alba.backend
-        when :oj
-          begin
-            require 'oj'
-            -> { Oj.dump(@_resource, mode: :strict) }
-          rescue LoadError
-            fallback
-          end
-        else
-          fallback
-        end.call
+        Alba.encoder.call(@hash)
+      end
+
+      private
+
+      def key
+        opts = self.class._opts || {}
+        opts[:key] == true ? @resource.key : opts[:key]
+      end
+
+      def metadata
+        metadata = self.class._metadata || {}
+        metadata.transform_values { |block| block.call(@resource.object) }
       end
     end
 
     # Class methods
     module ClassMethods
-      attr_reader :_opts
+      attr_reader :_opts, :_metadata
+
+      def inherited(subclass)
+        super
+        %w[_opts _metadata].each { |name| subclass.instance_variable_set("@#{name}", instance_variable_get("@#{name}")) }
+      end
 
       def set(key: false)
         @_opts ||= {}
         @_opts[:key] = key
       end
+
+      def metadata(name, &block)
+        @_metadata ||= {}
+        @_metadata[name] = block
+      end
     end
   end
 end

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

data/sider.yml

@@ -4,6 +4,7 @@ linter:
 #   # https://help.sider.review/tools/ruby/rubocop
   rubocop:
     gems:
+      - "rubocop-minitest"
       - "rubocop-performance"
       - "rubocop-sensible"
     safe: false

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.10.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-23 00:00:00.000000000 Z
 dependencies: []
-description: Fast and flexible JSON serializer
+description: Alba is designed to be a simple, easy to use and fast alternative to
+  existing JSON serializers. Its performance is better than almost all gems which
+  do similar things. The internal is so simple that it's easy to hack and maintain.
 email:
 - masafumi.o1988@gmail.com
 executables: []
@@ -30,7 +32,7 @@ files:
 - bin/console
 - bin/setup
 - lib/alba.rb
-- lib/alba/attribute.rb
+- lib/alba/association.rb
 - lib/alba/many.rb
 - lib/alba/one.rb
 - lib/alba/resource.rb
@@ -54,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -64,5 +66,5 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: Fast and flexible JSON serializer
+summary: Alba is the fastest JSON serializer for Ruby.
 test_files: []

data/lib/alba/attribute.rb

@@ -1,19 +0,0 @@
-module Alba
-  # This class represents an attribute, which is serialized
-  # by either sending message or calling a Proc.
-  class Attribute
-    def initialize(name:, method:)
-      @name = name
-      @method = method
-    end
-
-    def to_hash(target)
-      case @method
-      when Symbol, String
-        target.public_send(@method)
-      when Proc
-        @method.arity.zero? ? target.instance_exec(&@method) : @method.call(target)
-      end
-    end
-  end
-end