alba 0.4.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 115b71c658fcda000dd3e4d4ccc0306c3cf94033f42fd96eb8e26223cba1ed3a
-  data.tar.gz: 8c9f023c9d60c905c35b6f285120f6de536b4a21258fdf42b867a5601c2162d6
+  metadata.gz: 3a92c56eee7615f823efc93ed7edb87ba6c47a4bcf8e8b11e48edfc62c380545
+  data.tar.gz: 310eca11a4a5a83287d3d87c1346c2436900bf1283e5642baa3878c69087812d
 SHA512:
-  metadata.gz: 66bc3c85b71f412c761629a6eae760c038115edd826e1d2cc34d204e2cdb4164ababdc31fc3f9569eb89ea51d364176cfd2a53b9ffbfb995fb3daeada1c110e3
-  data.tar.gz: 6f8b53f011829b941ea6ebb6237f96f52dbc7cd36042db6cab996c7e4a4a3ead931f3801243c64be6f7c60f8d144cb85d5beea62f020f95e6d1bc3585bbadd1b
+  metadata.gz: 2fed0c44e90d2d876b2db635867741b3520a21c470acfb07a0218b7e0b627ce718edb1da964dfafdf0c79b3fe16bf7502a4fd873e998778c5307bd0c37d0c7c0
+  data.tar.gz: 334edc5389f1fceba2ee880a322f894ccb145533793a885777ac29c08c273b5dda9a31cf9885b493b6ec3fabcf859a1d1643ce37b848c225db66b658b36e3e34

data/.rubocop.yml

@@ -4,6 +4,7 @@ inherit_gem:
   rubocop-sensible: 'config/rubocop.yml'
 
 require:
+  - rubocop-minitest
   - rubocop-performance
 
 AllCops:
@@ -15,13 +16,12 @@ AllCops:
 Layout/SpaceInsideHashLiteralBraces:
   EnforcedStyle: no_space
 
+Metrics/ClassLength:
+  Exclude:
+    - 'test/alba_test.rb'
+
 Metrics/MethodLength:
   Max: 20
 
-Naming/PredicateName:
-  AllowedMethods:
-    - 'has_one'
-    - 'has_many'
-
 Style/FrozenStringLiteralComment:
   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 'activesupport', require: false
 gem 'coveralls', require: false
 gem 'minitest', '~> 5.0'
+gem 'oj', '~> 3.10', platforms: :ruby
 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

data/Gemfile.lock

@@ -1,12 +1,19 @@
 PATH
   remote: .
   specs:
-    alba (0.4.0)
+    alba (0.9.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)
+    concurrent-ruby (1.1.6)
     coveralls (0.8.23)
       json (>= 1.8, < 3)
       simplecov (~> 0.16.1)
@@ -14,8 +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)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
@@ -23,17 +33,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 +60,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,11 @@
+[![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.
 
 ## Installation
 
@@ -24,6 +25,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
@@ -108,15 +127,81 @@ UserResource1.new(user).serialize
 # => '{"id":1,"articles":[{"title":"Hello World!"},{"title":"Super nice"}]}'
 ```
 
+### Inline definition with `Alba.serialize`
+
+`Alba.serialize` method is a shortcut to define everything inline.
+
+```ruby
+Alba.serialize(user, with: proc { set key: :foo }) do
+  attributes :id
+  many :articles do
+    attributes :title, :body
+  end
+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.
+
+### 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

@@ -2,20 +2,66 @@ require 'alba/version'
 require 'alba/serializers/default_serializer'
 require 'alba/serializer'
 require 'alba/resource'
+require 'alba/resources/default_resource'
 
 # Core module
 module Alba
   class Error < StandardError; end
 
   class << self
-    attr_reader :backend
-  end
+    attr_reader :backend, :encoder
+    attr_accessor :default_serializer
 
-  def self.backend=(backend)
-    @backend = backend&.to_sym
-  end
+    def backend=(backend)
+      @backend = backend&.to_sym
+      set_encoder
+    end
+
+    def serialize(object, with: 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)
+    end
 
-  def self.serialize(object)
-    Serializers::DefaultSerializer.new(object).serialize
+    private
+
+    def set_encoder
+      @encoder = case @backend
+                 when :oj
+                   begin
+                     require 'oj'
+                     ->(hash) { Oj.dump(hash, mode: :strict) }
+                   rescue LoadError
+                     default_encoder
+                   end
+                 when :active_support
+                   begin
+                     require 'active_support/json'
+                     ->(hash) { ActiveSupport::JSON.encode(hash) }
+                   rescue LoadError
+                     default_encoder
+                   end
+                 when nil, :default, :json
+                   default_encoder
+                 else
+                   raise Alba::Error, "Unsupported backend, #{backend}"
+                 end
+    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,25 @@
+module Alba
+  # Base class for `One` and `Many`
+  # Child class should implement `to_hash` method
+  class Association
+    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
+      :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
-
+  class Many < Association
     def to_hash(target)
       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
-    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
-
+  class One < Association
     def to_hash(target)
       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
-    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)
@@ -33,38 +35,68 @@ module Alba
                        @_serializer || Alba::Serializers::DefaultSerializer
                      when ->(obj) { obj.is_a?(Class) && obj <= Alba::Serializer }
                        with
-                     when Symbol
-                       const_get(with.to_s.capitalize)
-                     when String
-                       const_get(with)
+                     when Proc
+                       inline_extended_serializer(with)
+                     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)
+            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] = attr_name }
       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] = block
       end
 
       def one(name, resource: nil, &block)
@@ -78,6 +110,17 @@ module Alba
       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)
+        end
+      end
     end
   end
 end

data/lib/alba/resources/default_resource.rb

@@ -0,0 +1,13 @@
+module Alba
+  module Resources
+    # Empty resource class, use this with `class_eval` for
+    # inline associations and serializations.
+    class DefaultResource
+      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,53 @@ 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
+        Alba.encoder.call(@hash)
+      end
+
+      private
+
+      def key
+        opts = self.class._opts || {}
+        case opts[:key]
+        when true
+          @resource.key
         else
-          fallback
-        end.call
+          opts[:key]
+        end
+      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.4.0'.freeze
+  VERSION = '0.9.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.4.0
+  version: 0.9.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2020-08-11 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,10 +32,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
@@ -53,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:
   - - ">="
@@ -63,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