alba 0.13.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 993f4b887c19f4e1149ddb850cd07a8cb8c2042cde0fb3974b1380537707a55d
-  data.tar.gz: acf77a0aa35f7fe23fc3f98843064d2800e0b4e0739e587dd29aab65f06269ad
+  metadata.gz: c3999a63b9564e6bf0a7b00dfeb64a19d6d076c94047f7ee869a4ac4a38c6646
+  data.tar.gz: dd7244bf63111e4795639a62dac91a744e51adb38f6a88d851c9cc6de3043dc0
 SHA512:
-  metadata.gz: 9b8e52dcaf4ca33cba0685c2a0a06c16df69cd04b6d399c092e920548f5baa6a21aeab8097f90e92ab35ac9c260d83858c19462a9ec2a689d97c6999daef5e3a
-  data.tar.gz: e525a66c30477cab6741436128398a6f0309a0f786040fe946a9f2783d08f619df00d85157d04c5876cc579e19cceabf22dcb3556addf6ad061d44d1f0cfa888
+  metadata.gz: f93aaadf9b8fae4b9ae334f87647c3b0f1645147fd237b62f12451f4306f5cb6699ed25c935b563b68ab45c965bb1cfb8f2c73e08b23899a477384c37124d325
+  data.tar.gz: adb456a4796782e725bffa5720d1b5e6f831c1e0ec215721a814b331890f4a1d0ebe592e7e906239138729dd81586ad6e1c850ece61c5495ce829551feada9a1

data/.gitignore

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

data/.rubocop.yml

@@ -15,6 +15,7 @@ AllCops:
     - 'benchmark/**/*.rb'
   NewCops: enable
   EnabledByDefault: true
+  TargetRubyVersion: 2.5
 
 # Oneline comment is not valid so until it gets valid, we disable it
 Bundler/GemComment:
@@ -36,6 +37,11 @@ Metrics/ClassLength:
 Metrics/MethodLength:
   Max: 15
 
+# Resource class includes DSLs, which tend to accept long list of parameters
+Metrics/ParameterLists:
+  Exclude:
+    - 'lib/alba/resource.rb'
+
 Style/ConstantVisibility:
   Exclude:
     - 'lib/alba/version.rb'

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2021-04-07
+
+This is the first major release of Alba and it includes so many features. To see all the features you can have a look at [README](https://github.com/okuramasafumi/alba/blob/master/README.md#features).

data/Gemfile

@@ -9,8 +9,9 @@ gem 'minitest', '~> 5.14' # For test
 gem 'oj', '~> 3.11', 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.3', require: false # For lint
+gem 'rubocop-minitest', '~> 0.11.0', require: false # For lint
 gem 'rubocop-performance', '~> 1.10.1', require: false # For lint
 gem 'rubocop-rake', '>= 0.5.1', require: false # For lint
 gem 'rubocop-sensible', '~> 0.3.0', require: false # For lint
+gem 'ruby-prof', require: false # For performance profiling
 gem 'yard', require: false

data/README.md

@@ -19,8 +19,6 @@ Alba has some advantages over other JSON serializers which we've wanted to have.
 
 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 about 330 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://github.com/okuramasafumi/alba/tree/master/benchmark).
@@ -56,10 +54,12 @@ You can find the documentation on [RubyDoc](https://rubydoc.info/github/okuramas
 * 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
+* Conditional attributes and associations
 * Selectable backend
 * Key transformation
+* Root key inference
+* Error handling
+* Resource name inflection based on association name
 * No runtime dependencies
 
 ## Anti features
@@ -69,7 +69,6 @@ You can find the documentation on [RubyDoc](https://rubydoc.info/github/okuramas
 * Supporting all existing JSON encoder/decoder
 * Cache
 * [JSON:API](https://jsonapi.org) support
-* Association name inflection
 * And many others
 
 ## Usage
@@ -78,7 +77,7 @@ You can find the documentation on [RubyDoc](https://rubydoc.info/github/okuramas
 
 Alba's configuration is fairly simple.
 
-#### Backend
+#### Backend configuration
 
 Backend is the actual part serializing an object into JSON. Alba supports these backends.
 
@@ -92,6 +91,26 @@ You can set a backend like this:
 Alba.backend = :oj
 ```
 
+#### Inference configuration
+
+You can enable inference feature using `enable_inference!` method.
+
+```ruby
+Alba.enable_inference!
+```
+
+You must install `ActiveSupport` to enable inference.
+
+#### Error handling configuration
+
+You can configure error handling with `on_error` method.
+
+```ruby
+Alba.on_error :ignore
+```
+
+For the details, see [Error handling section](#error-handling)
+
 ### Simple serialization with key
 
 ```ruby
@@ -109,6 +128,8 @@ end
 class UserResource
   include Alba::Resource
 
+  key :user
+
   attributes :id, :name
 
   attribute :name_with_email do |resource|
@@ -116,12 +137,6 @@ class UserResource
   end
 end
 
-class SerializerWithKey
-  include Alba::Serializer
-
-  set key: :user
-end
-
 user = User.new(1, 'Masafumi OKURA', 'masafumi@example.com')
 UserResource.new(user).serialize
 # => "{\"id\":1,\"name\":\"Masafumi OKURA\",\"name_with_email\":\"Masafumi OKURA: masafumi@example.com\"}"
@@ -181,7 +196,7 @@ UserResource.new(user).serialize
 `Alba.serialize` method is a shortcut to define everything inline.
 
 ```ruby
-Alba.serialize(user, with: proc { set key: :foo }) do
+Alba.serialize(user, key: :foo) do
   attributes :id
   many :articles do
     attributes :title, :body
@@ -190,7 +205,7 @@ end
 # => '{"foo":{"id":1,"articles":[{"title":"Hello World!","body":"Hello World!!!"},{"title":"Super nice","body":"Really nice!"}]}}'
 ```
 
-Although this might be useful sometimes, it's generally recommended to define a class for both Resource and Serializer.
+Although this might be useful sometimes, it's generally recommended to define a class for Resource.
 
 ### Inheritance and Ignorance
 
@@ -284,14 +299,147 @@ end
 
 user = User.new(1, nil, nil)
 UserResource.new(user).serialize # => '{"id":1}'
-
-
 ```
 
 The key part is the use of `Proc#>>` since `Alba::Resource#converter` returns a `Proc` which contains the basic logic and it's impossible to change its behavior by just overriding the method.
 
 It's not recommended to swap the whole conversion logic. It's recommended to always call `super` when you override `converter`.
 
+### Conditional attributes
+
+Filtering attributes with overriding `convert` works well for simple cases. However, It's cumbersome when we want to filter various attributes based on different conditions for keys.
+
+In these cases, conditional attributes works well. We can pass `if` option to `attributes`, `attribute`, `one` and `many`. Below is an example for the same effect as [filtering attributes section](#filtering-attributes).
+
+```ruby
+class User
+  attr_accessor :id, :name, :email, :created_at, :updated_at
+
+  def initialize(id, name, email)
+    @id = id
+    @name = name
+    @email = email
+  end
+end
+
+class UserResource
+  include Alba::Resource
+
+  attributes :id, :name, :email, if: proc { |user, attribute| !attribute.nil? }
+end
+
+user = User.new(1, nil, nil)
+UserResource.new(user).serialize # => '{"id":1}'
+```
+
+### Inference
+
+After `Alba.enable_inference!` called, Alba tries to infer root key and association resource name.
+
+```ruby
+Alba.enable_inference!
+
+class User
+  attr_reader :id
+  attr_accessor :articles
+
+  def initialize(id)
+    @id = id
+    @articles = []
+  end
+end
+
+class Article
+  attr_accessor :id, :title
+
+  def initialize(id, title)
+    @id = id
+    @title = title
+  end
+end
+
+class ArticleResource
+  include Alba::Resource
+
+  attributes :title
+end
+
+class UserResource
+  include Alba::Resource
+
+  key!
+
+  attributes :id
+
+  many :articles
+end
+
+user = User.new(1)
+user.articles << Article.new(1, 'The title')
+
+UserResource.new(user).serialize # => '{"user":{"id":1,"articles":[{"title":"The title"}]}}'
+UserResource.new([user]).serialize # => '{"users":[{"id":1,"articles":[{"title":"The title"}]}]}'
+```
+
+This resource automatically sets its root key to either "users" or "user", depending on the given object is collection or not.
+
+Also, you don't have to specify which resource class to use with `many`. Alba infers it from association name.
+
+Note that to enable this feature you must install `ActiveSupport` gem.
+
+### Error handling
+
+You can set error handler globally or per resource using `on_error`.
+
+```ruby
+class User
+  attr_accessor :id, :name
+
+  def initialize(id, name, email)
+    @id = id
+    @name = name
+    @email = email
+  end
+
+  def email
+    raise RuntimeError, 'Error!'
+  end
+end
+
+class UserResource
+  include Alba::Resource
+
+  attributes :id, :name, :email
+
+  on_error :ignore
+end
+
+user = User.new(1, 'Test', 'email@example.com')
+UserResource.new(user).serialize # => '{"id":1,"name":"Test"}'
+```
+
+This way you can exclude an entry when fetching an attribute gives an exception.
+
+There are four possible arguments `on_error` method accepts.
+
+* `:raise` re-raises an error. This is the default behavior.
+* `:ignore` ignores the entry with the error.
+* `:nullify` sets the attribute with the error to `nil`.
+* Block gives you more control over what to be returned.
+
+The block receives five arguments, `error`, `object`, `key`, `attribute` and `resource class` and must return a two-element array. Below is an example.
+
+```ruby
+# Global error handling
+Alba.on_error do |error, object, key, attribute, resource_class|
+  if resource_class == MyResource
+    ['error_fallback', object.error_fallback]
+  else
+    [key, error.message]
+  end
+end
+```
+
 ## Comparison
 
 Alba is faster than alternatives.
@@ -309,18 +457,6 @@ Alba.backend = :active_support
 
 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/lib/alba.rb

@@ -1,5 +1,4 @@
 require_relative 'alba/version'
-require_relative 'alba/serializer'
 require_relative 'alba/resource'
 
 # Core module
@@ -11,8 +10,7 @@ module Alba
   class UnsupportedBackend < Error; end
 
   class << self
-    attr_reader :backend, :encoder
-    attr_accessor :default_serializer
+    attr_reader :backend, :encoder, :inferring, :_on_error
 
     # Set the backend, which actually serializes object into JSON
     #
@@ -28,17 +26,43 @@ module Alba
     # Serialize the object with inline definitions
     #
     # @param object [Object] the object to be serialized
-    # @param with [nil, Proc, Alba::Serializer] selializer
+    # @param key [Symbol]
     # @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)
+    def serialize(object, key: nil, &block)
       raise ArgumentError, 'Block required' unless block
 
       resource_class.class_eval(&block)
       resource = resource_class.new(object)
-      with ||= @default_serializer
-      resource.serialize(with: with)
+      resource.serialize(key: key)
+    end
+
+    # Enable inference for key and resource name
+    def enable_inference!
+      begin
+        require 'active_support/inflector'
+      rescue LoadError
+        raise ::Alba::Error, 'To enable inference, please install `ActiveSupport` gem.'
+      end
+      @inferring = true
+    end
+
+    # Disable inference for key and resource name
+    def disable_inference!
+      @inferring = false
+    end
+
+    # Set error handler
+    #
+    # @param [Symbol] handler
+    # @param [Block]
+    def on_error(handler = nil, &block)
+      raise ArgumentError, 'You cannot specify error handler with both Symbol and block' if handler && block
+      raise ArgumentError, 'You must specify error handler with either Symbol or block' unless handler || block
+
+      p block if block
+      @_on_error = handler || block
     end
 
     private
@@ -86,4 +110,5 @@ module Alba
   end
 
   @encoder = default_encoder
+  @_on_error = :raise
 end

data/lib/alba/association.rb

@@ -2,16 +2,27 @@ module Alba
   # Base class for `One` and `Many`
   # Child class should implement `to_hash` method
   class Association
+    attr_reader :object
+
     # @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)
+    def initialize(name:, condition: nil, resource: nil, nesting: nil, &block)
       @name = name
       @condition = condition
       @block = block
-      @resource = resource || resource_class
-      raise ArgumentError, 'resource or block is required' if @resource.nil? && @block.nil?
+      @resource = resource
+      return if @resource
+
+      if @block
+        @resource = resource_class
+      elsif Alba.inferring
+        const_parent = nesting.nil? ? Object : Object.const_get(nesting)
+        @resource = const_parent.const_get("#{ActiveSupport::Inflector.classify(@name)}Resource")
+      else
+        raise ArgumentError, 'When Alba.inferring is false, either resource or block is required'
+      end
     end
 
     # @abstract
@@ -21,6 +32,15 @@ module Alba
 
     private
 
+    def constantize(resource)
+      case resource # rubocop:disable Style/MissingElse
+      when Class
+        resource
+      when Symbol, String
+        Object.const_get(resource)
+      end
+    end
+
     def resource_class
       klass = Class.new
       klass.include(Alba::Resource)

data/lib/alba/many.rb

@@ -9,11 +9,12 @@ module Alba
     # @param params [Hash] user-given Hash for arbitrary data
     # @return [Array<Hash>]
     def to_hash(target, params: {})
-      objects = target.public_send(@name)
-      objects = @condition.call(objects, params) if @condition
-      return if objects.nil?
+      @object = target.public_send(@name)
+      @object = @condition.call(@object, params) if @condition
+      return if @object.nil?
 
-      objects.map { |o| @resource.new(o, params: params).to_hash }
+      @resource = constantize(@resource)
+      @object.map { |o| @resource.new(o, params: params).to_hash }
     end
   end
 end

data/lib/alba/one.rb

@@ -9,10 +9,11 @@ module Alba
     # @param params [Hash] user-given Hash for arbitrary data
     # @return [Hash]
     def to_hash(target, params: {})
-      object = target.public_send(@name)
-      object = @condition.call(object, params) if @condition
-      return if object.nil?
+      @object = target.public_send(@name)
+      @object = @condition.call(object, params) if @condition
+      return if @object.nil?
 
+      @resource = constantize(@resource)
       @resource.new(object, params: params).to_hash
     end
   end

data/lib/alba/resource.rb

@@ -1,4 +1,3 @@
-require_relative 'serializer'
 require_relative 'one'
 require_relative 'many'
 
@@ -7,7 +6,7 @@ module Alba
   module Resource
     # @!parse include InstanceMethods
     # @!parse extend ClassMethods
-    DSLS = {_attributes: {}, _serializer: nil, _key: nil, _transform_keys: nil}.freeze
+    DSLS = {_attributes: {}, _key: nil, _transform_keys: nil, _on_error: nil}.freeze
     private_constant :DSLS
 
     # @private
@@ -25,7 +24,7 @@ module Alba
 
     # Instance methods
     module InstanceMethods
-      attr_reader :object, :_key, :params
+      attr_reader :object, :params
 
       # @param object [Object] the object to be serialized
       # @param params [Hash] user-given Hash for arbitrary data
@@ -35,22 +34,14 @@ module Alba
         DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
       end
 
-      # Get serializer with `with` argument and serialize self with it
+      # Serialize object into JSON string
       #
-      # @param with [nil, Proc, Alba::Serializer] selializer
+      # @param key [Symbol]
       # @return [String] serialized JSON string
-      def serialize(with: nil)
-        serializer = case with
-                     when nil
-                       @_serializer || empty_serializer
-                     when ->(obj) { obj.is_a?(Class) && obj <= Alba::Serializer }
-                       with
-                     when Proc
-                       inline_extended_serializer(with)
-                     else
-                       raise ArgumentError, 'Unexpected type for with, possible types are Class or Proc'
-                     end
-        serializer.new(self).serialize
+      def serialize(key: nil)
+        key = key.nil? ? _key : key
+        hash = key && key != '' ? {key.to_s => serializable_hash} : serializable_hash
+        Alba.encoder.call(hash)
       end
 
       # A Hash for serialization
@@ -61,22 +52,68 @@ module Alba
       end
       alias to_hash serializable_hash
 
-      # @return [Symbol]
-      def key
-        @_key || self.class.name.delete_suffix('Resource').downcase.gsub(/:{2}/, '_').to_sym
-      end
-
       private
 
-      # rubocop:disable Style/MethodCalledOnDoEndBlock
+      # @return [String]
+      def _key
+        if @_key == true && Alba.inferring
+          demodulized = ActiveSupport::Inflector.demodulize(self.class.name)
+          meth = collection? ? :tableize : :singularize
+          ActiveSupport::Inflector.public_send(meth, demodulized.delete_suffix('Resource').downcase)
+        else
+          @_key.to_s
+        end
+      end
+
       def converter
-        lambda do |resource|
-          @_attributes.map do |key, attribute|
-            [transform_key(key), fetch_attribute(resource, attribute)]
-          end.to_h
+        lambda do |object|
+          arrays = @_attributes.map do |key, attribute|
+            key = transform_key(key)
+            if attribute.is_a?(Array) # Conditional
+              conditional_attribute(object, key, attribute)
+            else
+              [key, fetch_attribute(object, attribute)]
+            end
+          rescue ::Alba::Error, FrozenError
+            raise
+          rescue StandardError => e
+            handle_error(e, object, key, attribute)
+          end
+          arrays.reject(&:empty?).to_h
+        end
+      end
+
+      def conditional_attribute(object, key, attribute)
+        condition = attribute.last
+        arity = condition.arity
+        return [] if arity <= 1 && !condition.call(object)
+
+        fetched_attribute = fetch_attribute(object, attribute.first)
+        attr = if attribute.first.is_a?(Alba::Association)
+                 attribute.first.object
+               else
+                 fetched_attribute
+               end
+        return [] if arity >= 2 && !condition.call(object, attr)
+
+        [key, fetched_attribute]
+      end
+
+      def handle_error(error, object, key, attribute)
+        on_error = @_on_error || Alba._on_error
+        case on_error
+        when :raise, nil
+          raise
+        when :nullify
+          [key, nil]
+        when :ignore
+          []
+        when Proc
+          on_error.call(error, object, key, attribute, self.class)
+        else
+          raise ::Alba::Error, "Unknown on_error: #{on_error.inspect}"
         end
       end
-      # rubocop:enable Style/MethodCalledOnDoEndBlock
 
       # Override this method to supply custom key transform method
       def transform_key(key)
@@ -86,31 +123,19 @@ module Alba
         KeyTransformer.transform(key, @_transform_keys)
       end
 
-      def fetch_attribute(resource, attribute)
+      def fetch_attribute(object, attribute)
         case attribute
         when Symbol
-          resource.public_send attribute
+          object.public_send attribute
         when Proc
-          instance_exec(resource, &attribute)
+          instance_exec(object, &attribute)
         when Alba::One, Alba::Many
-          attribute.to_hash(resource, params: params)
+          attribute.to_hash(object, params: params)
         else
           raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
         end
       end
 
-      def empty_serializer
-        klass = Class.new
-        klass.include Alba::Serializer
-        klass
-      end
-
-      def inline_extended_serializer(with)
-        klass = empty_serializer
-        klass.class_eval(&with)
-        klass
-      end
-
       def collection?
         @object.is_a?(Enumerable)
       end
@@ -129,19 +154,24 @@ module Alba
       # Set multiple attributes at once
       #
       # @param attrs [Array<String, Symbol>]
-      def attributes(*attrs)
-        attrs.each { |attr_name| @_attributes[attr_name.to_sym] = attr_name.to_sym }
+      # @param options [Hash] option hash including `if` that is a  condition to render these attributes
+      def attributes(*attrs, **options)
+        attrs.each do |attr_name|
+          attr = options[:if] ? [attr_name.to_sym, options[:if]] : attr_name.to_sym
+          @_attributes[attr_name.to_sym] = attr
+        end
       end
 
       # Set an attribute with the given block
       #
       # @param name [String, Symbol] key name
+      # @param options [Hash] option hash including `if` that is a  condition to render
       # @param block [Block] the block called during serialization
       # @raise [ArgumentError] if block is absent
-      def attribute(name, &block)
+      def attribute(name, **options, &block)
         raise ArgumentError, 'No block given in attribute method' unless block
 
-        @_attributes[name.to_sym] = block
+        @_attributes[name.to_sym] = options[:if] ? [block, options[:if]] : block
       end
 
       # Set One association
@@ -150,10 +180,13 @@ module Alba
       # @param condition [Proc]
       # @param resource [Class<Alba::Resource>]
       # @param key [String, Symbol] used as key when given
+      # @param options [Hash] option hash including `if` that is a  condition to render
       # @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)
+      def one(name, condition = nil, resource: nil, key: nil, **options, &block)
+        nesting = self.name&.rpartition('::')&.first
+        one = One.new(name: name, condition: condition, resource: resource, nesting: nesting, &block)
+        @_attributes[key&.to_sym || name.to_sym] = options[:if] ? [one, options[:if]] : one
       end
       alias has_one one
 
@@ -163,25 +196,27 @@ module Alba
       # @param condition [Proc]
       # @param resource [Class<Alba::Resource>]
       # @param key [String, Symbol] used as key when given
+      # @param options [Hash] option hash including `if` that is a  condition to render
       # @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)
+      def many(name, condition = nil, resource: nil, key: nil, **options, &block)
+        nesting = self.name&.rpartition('::')&.first
+        many = Many.new(name: name, condition: condition, resource: resource, nesting: nesting, &block)
+        @_attributes[key&.to_sym || name.to_sym] = options[:if] ? [many, options[:if]] : many
       end
       alias has_many many
 
-      # 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
+        @_key = key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+
+      # Set key to true
+      #
+      def key!
+        @_key = true
       end
 
       # Delete attributes
@@ -200,6 +235,17 @@ module Alba
       def transform_keys(type)
         @_transform_keys = type.to_sym
       end
+
+      # Set error handler
+      #
+      # @param [Symbol] handler
+      # @param [Block]
+      def on_error(handler = nil, &block)
+        raise ArgumentError, 'You cannot specify error handler with both Symbol and block' if handler && block
+        raise ArgumentError, 'You must specify error handler with either Symbol or block' unless handler || block
+
+        @_on_error = handler || block
+      end
     end
   end
 end

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '0.13.1'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 1.0.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-04-07 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
@@ -23,9 +23,9 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".yardopts"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -39,7 +39,6 @@ files:
 - lib/alba/many.rb
 - lib/alba/one.rb
 - lib/alba/resource.rb
-- lib/alba/serializer.rb
 - lib/alba/version.rb
 - sider.yml
 homepage: https://github.com/okuramasafumi/alba
@@ -64,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.11
+rubygems_version: 3.2.14
 signing_key:
 specification_version: 4
 summary: Alba is the fastest JSON serializer for Ruby.

data/Gemfile.lock

@@ -1,92 +0,0 @@
-PATH
-  remote: .
-  specs:
-    alba (0.13.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (6.1.3)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
-    ast (2.4.2)
-    concurrent-ruby (1.1.8)
-    coveralls (0.8.23)
-      json (>= 1.8, < 3)
-      simplecov (~> 0.16.1)
-      term-ansicolor (~> 1.3)
-      thor (>= 0.19.4, < 2.0)
-      tins (~> 1.6)
-    docile (1.3.2)
-    i18n (1.8.9)
-      concurrent-ruby (~> 1.0)
-    json (2.3.1)
-    minitest (5.14.3)
-    oj (3.11.2)
-    parallel (1.20.1)
-    parser (3.0.0.0)
-      ast (~> 2.4.1)
-    rainbow (3.0.0)
-    rake (13.0.3)
-    regexp_parser (2.1.1)
-    rexml (3.2.4)
-    rubocop (1.11.0)
-      parallel (~> 1.10)
-      parser (>= 3.0.0.0)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.2.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.4.1)
-      parser (>= 2.7.1.5)
-    rubocop-minitest (0.10.3)
-      rubocop (>= 0.87, < 2.0)
-    rubocop-performance (1.10.1)
-      rubocop (>= 0.90.0, < 2.0)
-      rubocop-ast (>= 0.4.0)
-    rubocop-rake (0.5.1)
-      rubocop
-    rubocop-sensible (0.3.0)
-      rubocop (>= 0.60.0)
-    ruby-progressbar (1.11.0)
-    simplecov (0.16.1)
-      docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    sync (0.5.0)
-    term-ansicolor (1.7.1)
-      tins (~> 1.0)
-    thor (1.0.1)
-    tins (1.25.0)
-      sync
-    tzinfo (2.0.4)
-      concurrent-ruby (~> 1.0)
-    unicode-display_width (2.0.0)
-    yard (0.9.26)
-    zeitwerk (2.4.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport
-  alba!
-  coveralls
-  minitest (~> 5.14)
-  oj (~> 3.11)
-  rake (~> 13.0)
-  rubocop (>= 0.79.0)
-  rubocop-minitest (~> 0.10.3)
-  rubocop-performance (~> 1.10.1)
-  rubocop-rake (>= 0.5.1)
-  rubocop-sensible (~> 0.3.0)
-  yard
-
-BUNDLED WITH
-   2.2.6

data/lib/alba/serializer.rb

@@ -1,75 +0,0 @@
-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.instance_variable_set('@_opts', {}) unless base.instance_variable_defined?('@_opts')
-      base.instance_variable_set('@_metadata', {}) unless base.instance_variable_defined?('@_metadata')
-      base.include InstanceMethods
-      base.extend ClassMethods
-    end
-
-    # Instance methods
-    module InstanceMethods
-      # @param resource [Alba::Resource]
-      def initialize(resource)
-        @resource = resource
-        @hash = resource.serializable_hash
-        @hash = {key.to_sym => @hash} if key
-        return if metadata.empty?
-
-        # @hash is either Hash or Array
-        @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
-        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, :_metadata
-
-      # @private
-      def inherited(subclass)
-        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[: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[name.to_sym] = block
-      end
-    end
-  end
-end