alba 0.8.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 592412974accb17b359ab871e293e2c839519f7cfffb31a04485bfe261b88202
-  data.tar.gz: d8fbb2ec751eac8e7dbe278e8993da6641eaa88f302b3438055b2062c08bd229
+  metadata.gz: 9aae01860e12e1e5fd71f066e8772fb3a80b4aec6e99cf9dd55ad8652896ea24
+  data.tar.gz: c9930853dcaaa5ea2ff28e954c3b0d7e2ba559efc64b82e7da6b0c28968f55ed
 SHA512:
-  metadata.gz: 97c3fc639d1d6b7fa588c78fa84f4be7318982ebf3154b9037e1b9c6ac38d1d9a0528bcf45618a5d1b1dc009df30441589eb27d1bdfbd8afaca1e61a0708e31e
-  data.tar.gz: 7abd201ba80bdfff652840e948e8aede24e90d0cfc26722f08044916f239387fd0bada0a1e9a0d71cf252ced9400d1549124349a1070ea7bd8c8e5a7be0ebc38
+  metadata.gz: 7882b0950c339f87fc75b19e79bcdc2481a296331e9be47a646db997fa4db5639af31c49d529063d099cd5df405357d245397af23b0038c568e32feb86bd5718
+  data.tar.gz: 2bc8c03f0ca5049a23b7dd5c2f6582051f98296a0ba9e0a436e08e9a426a53896e7ac94af276cc3a82e5a0a253f30d381db5384e483c77918ff3d5ef9165a1b7

data/.rubocop.yml

@@ -12,12 +12,40 @@ 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/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
+
+Style/ConstantVisibility:
+  Exclude:
+    - 'lib/alba/version.rb'
+
+Style/Copyright:
+  Enabled: false
 
 Style/FrozenStringLiteralComment:
   Enabled: false
+
+Style/InlineComment:
+  Enabled: false
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: false

data/.travis.yml

@@ -5,4 +5,6 @@ rvm:
   - 2.5.8
   - 2.6.6
   - 2.7.1
+  # - ruby-head # oj doesn't work with Ruby 2.8.0
+  - truffleruby
 before_install: gem install bundler -v 2.1.4

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--exclude lib/alba/version.rb

data/Gemfile

@@ -3,11 +3,13 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in alba.gemspec
 gemspec
 
-gem 'coveralls', require: false
-gem 'minitest', '~> 5.0'
-gem 'oj', '~> 3.10'
-gem 'rake', '~> 13.0'
-gem 'rubocop', '>= 0.79.0', require: false
-gem 'rubocop-minitest', '~> 0.10.1', 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.14' # For test
+gem 'oj', '~> 3.10', platform: :ruby, require: false # 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
+gem 'yard', require: false

data/Gemfile.lock

@@ -1,12 +1,19 @@
 PATH
   remote: .
   specs:
-    alba (0.8.0)
+    alba (0.11.1)
 
 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)
+    concurrent-ruby (1.1.6)
     coveralls (0.8.23)
       json (>= 1.8, < 3)
       simplecov (~> 0.16.1)
@@ -14,9 +21,11 @@ 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.8)
+    minitest (5.14.2)
+    oj (3.10.13)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
@@ -24,17 +33,17 @@ GEM
     rake (13.0.1)
     regexp_parser (1.7.1)
     rexml (3.2.4)
-    rubocop (0.88.0)
+    rubocop (0.90.0)
       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)
@@ -51,23 +60,30 @@ 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)
+    yard (0.9.25)
+    zeitwerk (2.4.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
   alba!
   coveralls
-  minitest (~> 5.0)
+  minitest (~> 5.14)
   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)
+  yard
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -2,11 +2,29 @@
 [![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)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/okuramasafumi/alba)
+![GitHub](https://img.shields.io/github/license/okuramasafumi/alba)
 
 # Alba
 
 `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
 
 Add this line to your application's Gemfile:
@@ -23,8 +41,56 @@ Or install it yourself as:
 
     $ gem install alba
 
+## Supported Ruby versions
+
+Alba supports CRuby 2.5.7 and higher and latest TruffleRuby.
+
+## Documentation
+
+You can find the documentation on [RubyDoc](https://rubydoc.info/gems/alba).
+
+## Features
+
+* Resource-based serialization
+* Arbitrary attribute definition
+* One and many association with the ability to define them inline
+* Adding condition and filter to association
+* Parameters can be injected and used in attributes and associations
+* Setting root key separately in Serializer
+* Adding metadata
+* Selectable backend
+* No runtime dependencies
+
+## Anti features
+
+* Sorting keys
+* Class level support of parameters
+* Supporting all existing JSON encoder/decoder
+* Cache
+* [JSON:API](https://jsonapi.org) support
+* Association name inflection
+* And many others
+
 ## 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
@@ -91,7 +157,7 @@ class ArticleResource
   attributes :title
 end
 
-class UserResource1
+class UserResource
   include Alba::Resource
 
   attributes :id
@@ -105,7 +171,7 @@ user.articles << article1
 article2 = Article.new(2, 'Super nice', 'Really nice!')
 user.articles << article2
 
-UserResource1.new(user).serialize
+UserResource.new(user).serialize
 # => '{"id":1,"articles":[{"title":"Hello World!"},{"title":"Super nice"}]}'
 ```
 
@@ -125,11 +191,49 @@ 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
 
 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.
@@ -142,7 +246,7 @@ Alba has three component, `Serializer`, `Resource` and `Value` (`Value` is conce
 
 `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`.
 
-`Value` is either `Attribute`, `One` or `Many`. They are responsible for fetching data from the object for `Resource`. The main interface is `#to_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`.
 

data/alba.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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.required_ruby_version = Gem::Requirement.new('>= 2.5.7')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/okuramasafumi/alba'

data/lib/alba.rb

@@ -1,21 +1,36 @@
-require 'alba/version'
-require 'alba/serializers/default_serializer'
-require 'alba/serializer'
-require 'alba/resource'
-require 'alba/resources/default_resource'
+require_relative 'alba/version'
+require_relative 'alba/serializer'
+require_relative 'alba/resource'
 
 # Core module
 module Alba
+  # Base class for Errors
   class Error < StandardError; end
+  # Error class for backend which is not supported
+  class UnsupportedBackend < Error; end
 
   class << self
-    attr_reader :backend
+    attr_reader :backend, :encoder
     attr_accessor :default_serializer
 
+    # Set the backend, which actually serializes object into JSON
+    #
+    # @param backend [#to_sym, nil] the name of the backend
+    #   Possible values are `oj`, `active_support`, `default`, `json` and nil
+    # @return [Proc] the proc to encode object into JSON
+    # @raise [Alba::UnsupportedBackend] if backend is not supported
     def backend=(backend)
       @backend = backend&.to_sym
+      set_encoder
     end
 
+    # Serialize the object with inline definitions
+    #
+    # @param object [Object] the object to be serialized
+    # @param with [nil, Proc, Alba::Serializer] selializer
+    # @param block [Block] resource block
+    # @return [String] serialized JSON string
+    # @raise [ArgumentError] if block is absent or `with` argument's type is wrong
     def serialize(object, with: nil, &block)
       raise ArgumentError, 'Block required' unless block
 
@@ -27,8 +42,47 @@ module Alba
 
     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
+      @resource_class ||= begin
+                             klass = Class.new
+                             klass.include(Alba::Resource)
+                           end
     end
   end
+
+  @encoder = default_encoder
 end

data/lib/alba/association.rb

@@ -0,0 +1,31 @@
+module Alba
+  # Base class for `One` and `Many`
+  # Child class should implement `to_hash` method
+  class Association
+    # @param name [Symbol] name of the method to fetch association
+    # @param condition [Proc] a proc filtering data
+    # @param resource [Class<Alba::Resource>] a resource class for the association
+    # @param block [Block] used to define resource when resource arg is absent
+    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
+
+    # @abstract
+    def to_hash
+      :not_implemented
+    end
+
+    private
+
+    def resource_class
+      klass = Class.new
+      klass.include(Alba::Resource)
+      klass.class_eval(&@block)
+      klass
+    end
+  end
+end

data/lib/alba/many.rb

@@ -1,26 +1,17 @@
+require_relative '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
+    # Recursively converts objects into an Array of Hashes
+    #
+    # @param target [Object] the object having an association method
+    # @param params [Hash] user-given Hash for arbitrary data
+    # @return [Array<Hash>]
+    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, params) if @condition
+      objects.map { |o| @resource.new(o, params: params).to_hash }
     end
   end
 end

data/lib/alba/one.rb

@@ -1,26 +1,17 @@
+require_relative '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
+    # Recursively converts an object into a Hash
+    #
+    # @param target [Object] the object having an association method
+    # @param params [Hash] user-given Hash for arbitrary data
+    # @return [Hash]
+    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, params) if @condition
+      @resource.new(object, params: params).to_hash
     end
   end
 end

data/lib/alba/resource.rb

@@ -1,24 +1,22 @@
-require 'alba/serializer'
-require 'alba/attribute'
-require 'alba/one'
-require 'alba/many'
-require 'alba/serializers/default_serializer'
+require_relative 'serializer'
+require_relative 'one'
+require_relative 'many'
 
 module Alba
   # This module represents what should be serialized
   module Resource
-    DSLS = [:_attributes, :_serializer, :_key].freeze
+    # @!parse include InstanceMethods
+    # @!parse extend ClassMethods
+    DSLS = {_attributes: {}, _serializer: nil, _key: nil}.freeze
+    private_constant :DSLS
+
+    # @private
     def self.included(base)
+      super
       base.class_eval do
         # Initialize
-        DSLS.each do |name|
-          initial = case name
-                    when :_attributes
-                      {}
-                    when :_serializer, :_name
-                      nil
-                    end
-          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
@@ -27,17 +25,24 @@ module Alba
 
     # Instance methods
     module InstanceMethods
-      attr_reader :_object
-
-      def initialize(object)
-        @_object = object
-        DSLS.each { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
+      attr_reader :object, :_key, :params
+
+      # @param object [Object] the object to be serialized
+      # @param params [Hash] user-given Hash for arbitrary data
+      def initialize(object, params: {})
+        @object = object
+        @params = params.freeze
+        DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
       end
 
+      # Get serializer with `with` argument and serialize self with it
+      #
+      # @param with [nil, Proc, Alba::Serializer] selializer
+      # @return [String] serialized JSON string
       def serialize(with: nil)
         serializer = case with
                      when nil
-                       @_serializer || Alba::Serializers::DefaultSerializer
+                       @_serializer || empty_serializer
                      when ->(obj) { obj.is_a?(Class) && obj <= Alba::Serializer }
                        with
                      when Proc
@@ -48,71 +53,130 @@ module Alba
         serializer.new(self).serialize
       end
 
-      def serializable_hash(with_key: true)
-        get_attribute = lambda do |resource|
-          @_attributes.transform_values do |attribute|
-            attribute.to_hash(resource)
-          end
-        end
-        serializable_hash = if collection?
-                              @_object.map(&get_attribute)
-                            else
-                              get_attribute.call(@_object)
-                            end
-        with_key && @_key ? {@_key => serializable_hash} : serializable_hash
+      # A Hash for serialization
+      #
+      # @return [Hash]
+      def serializable_hash
+        collection? ? @object.map(&converter) : converter.call(@object)
       end
       alias to_hash serializable_hash
 
+      # @return [Symbol]
       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 empty_serializer
+        klass = Class.new
+        klass.include Alba::Serializer
+        klass
+      end
+
       def inline_extended_serializer(with)
-        klass = ::Alba::Serializers::DefaultSerializer.clone
+        klass = empty_serializer
         klass.class_eval(&with)
         klass
       end
 
       def collection?
-        @_object.is_a?(Enumerable)
+        @object.is_a?(Enumerable)
       end
     end
 
     # Class methods
     module ClassMethods
-      attr_reader(*DSLS)
+      attr_reader(*DSLS.keys)
 
+      # @private
       def inherited(subclass)
-        DSLS.each { |name| subclass.instance_variable_set("@#{name}", instance_variable_get("@#{name}")) }
+        super
+        DSLS.each_key { |name| subclass.instance_variable_set("@#{name}", instance_variable_get("@#{name}").clone) }
       end
 
+      # Set multiple attributes at once
+      #
+      # @param attrs [Array<String, Symbol>]
       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
 
+      # Set an attribute with the given block
+      #
+      # @param name [String, Symbol] key name
+      # @param block [Block] the block called during serialization
+      # @raise [ArgumentError] if block is absent
       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)
+      # Set One association
+      #
+      # @param name [String, Symbol]
+      # @param condition [Proc]
+      # @param resource [Class<Alba::Resource>]
+      # @param key [String, Symbol] used as key when given
+      # @param block [Block]
+      # @see Alba::One#initialize
+      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)
+      # Set Many association
+      #
+      # @param name [String, Symbol]
+      # @param condition [Proc]
+      # @param resource [Class<Alba::Resource>]
+      # @param key [String, Symbol] used as key when given
+      # @param block [Block]
+      # @see Alba::Many#initialize
+      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
 
+      # Set serializer for the resource
+      #
+      # @param name [Alba::Serializer]
       def serializer(name)
         @_serializer = name <= Alba::Serializer ? name : nil
       end
 
+      # Set key
+      #
+      # @param key [String, Symbol]
       def key(key)
         @_key = key.to_sym
       end
+
+      # Delete attributes
+      # Use this DSL in child class to ignore certain attributes
+      #
+      # @param attributes [Array<String, Symbol>]
+      def ignoring(*attributes)
+        attributes.each do |attr_name|
+          @_attributes.delete(attr_name.to_sym)
+        end
+      end
     end
   end
 end

data/lib/alba/serializer.rb

@@ -1,45 +1,48 @@
 module Alba
   # This module represents how a resource should be serialized.
   module Serializer
+    # @!parse include InstanceMethods
+    # @!parse extend ClassMethods
+
+    # @private
     def self.included(base)
+      super
+      base.class_eval do
+        @_opts = {} unless instance_variable_defined?('@_opts')
+        @_metadata = {} unless instance_variable_defined?('@_metadata')
+      end
       base.include InstanceMethods
       base.extend ClassMethods
     end
 
     # Instance methods
     module InstanceMethods
+      # @param resource [Alba::Resource]
       def initialize(resource)
-        @_opts = self.class._opts || {}
-        @_metadata = self.class._metadata || {}
-        @_metadata = @_metadata.transform_values { |block| block.call(resource._object) }
-        key = case @_opts[:key]
-              when true
-                resource.key
-              else
-                @_opts[:key]
-              end
-        @hash = resource.serializable_hash(with_key: false)
+        @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
+        @hash.is_a?(Hash) ? @hash.merge!(metadata.to_h) : @hash << metadata
       end
 
+      # Use real encoder to actually serialize to JSON
+      #
+      # @return [String] JSON string
       def serialize
-        fallback = lambda do
-          require 'json'
-          JSON.dump(@hash)
-        end
-        case Alba.backend
-        when :oj
-          begin
-            require 'oj'
-            -> { Oj.dump(@hash, 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
 
@@ -47,18 +50,25 @@ module Alba
     module ClassMethods
       attr_reader :_opts, :_metadata
 
+      # @private
       def inherited(subclass)
-        %w[_opts _metadata].each { |name| subclass.instance_variable_set("@#{name}", instance_variable_get("@#{name}")) }
+        super
+        %w[_opts _metadata].each { |name| subclass.instance_variable_set("@#{name}", public_send(name).clone) }
       end
 
+      # Set options, currently key only
+      #
+      # @param key [Boolean, Symbol]
       def set(key: false)
-        @_opts ||= {}
         @_opts[:key] = key
       end
 
+      # Set metadata
+      #
+      # @param name [String, Symbol] key for the metadata
+      # @param block [Block] the content of the metadata
       def metadata(name, &block)
-        @_metadata ||= {}
-        @_metadata[name] = block
+        @_metadata[name.to_sym] = block
       end
     end
   end

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.11.1'.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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.11.1
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-06 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies: []
 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
@@ -22,6 +22,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"
+- ".yardopts"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -32,13 +33,11 @@ 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
-- lib/alba/resources/default_resource.rb
 - lib/alba/serializer.rb
-- lib/alba/serializers/default_serializer.rb
 - lib/alba/version.rb
 - sider.yml
 homepage: https://github.com/okuramasafumi/alba
@@ -56,7 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.8
+      version: 2.5.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

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

data/lib/alba/resources/default_resource.rb

@@ -1,9 +0,0 @@
-module Alba
-  module Resources
-    # Empty resource class, use this with `class_eval` for
-    # inline associations and serializations.
-    class DefaultResource
-      include ::Alba::Resource
-    end
-  end
-end

data/lib/alba/serializers/default_serializer.rb

@@ -1,11 +0,0 @@
-require 'alba/serializer'
-
-module Alba
-  module Serializers
-    # DefaultSerializer class is used when a user doesn't specify serializer opt.
-    # It's basically an alias of Alba::Serializer, but since it's a module this class simply include it.
-    class DefaultSerializer
-      include Alba::Serializer
-    end
-  end
-end