alba 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb5260b5a6f3697f2e9c42ba198e3e17a1b0dc2aa0ea1bd2feb9ed4b18364a2
-  data.tar.gz: 794c146a493068865d7284de00bedda11c3b2fabd2ce7dccaa781e72181d957e
+  metadata.gz: b2c2e8c84ddccf4db9f9f18dd155361567f2a1733c55f817f5b4d97d573675d5
+  data.tar.gz: 3f11dd120c8b57aef909d79f6570482b8af810cd19c57ddcaa0d7b2ee70c2d6b
 SHA512:
-  metadata.gz: 46d179154f3981879a4cda7f5ea0360d7eeb3481788d895acefcbb5df156fde10ee1b0eb78bd399ab247449ea85100aceaa2dcb757a54ba64cce9450d82d1825
-  data.tar.gz: a3ee5f28b7bbc626d4dcf92db32017eba85f60df42df02f07d464cdaa8c190f5c07914db5e9f7db21f73fd1356529add373ef2c79ac82038d22f2c5dd5ee273c
+  metadata.gz: 8948a681fb88b3d84e3751e6df0f5ca28314d6c9b5e183666780be95b14fd3c7728e6ad1eb13309d4b7114115b56edbb28fe929c2376bbcc5b762846a7d00404
+  data.tar.gz: 9a2430efc4cf3b7a24b27bb40228dad67e00bd0cb10c9e0fc3764eb49e9caafda5b6d9fa0cc0335c77edc42e0a60416b20343dee5cee23dcfbfe350bed90e9a6

data/.rubocop.yml

@@ -49,7 +49,8 @@ Metrics/MethodLength:
 
 # `Resource` module is a core module and its length tends to be long...
 Metrics/ModuleLength:
-  Max: 150
+  Exclude:
+    - 'lib/alba/resource.rb'
 
 # Resource class includes DSLs, which tend to accept long list of parameters
 Metrics/ParameterLists:

data/CHANGELOG.md

@@ -6,6 +6,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] 2021-05-31
+
+- [Perf] Improve performance for `many` [641d8f9]
+  - https://github.com/okuramasafumi/alba/pull/125
+- [Feat] Add custom inflector feature (#126) [ad73291]
+  - https://github.com/okuramasafumi/alba/pull/126
+  - Thank you @wuarmin !
+- [Feat] Support params in if condition [6e9915e]
+  - https://github.com/okuramasafumi/alba/pull/128
+- [Fix] fundamentally broken "circular association control" [fbbc9a1]
+  - https://github.com/okuramasafumi/alba/pull/130
+
 ## [1.2.0] 2021-05-09
 
 - [Fix] multiple word key inference [6c18e73]

data/README.md

@@ -66,7 +66,7 @@ You can find the documentation on [RubyDoc](https://rubydoc.info/github/okuramas
 * Error handling
 * Resource name inflection based on association name
 * Circular associations control
-* Types for validation and conversion
+* [Experimental] Types for validation and conversion
 * No runtime dependencies
 
 ## Anti features
@@ -246,9 +246,11 @@ end
 
 ### Key transformation
 
-** Note: You need to install `active_support` gem to use `transform_keys` DSL.
+If you want to use `transform_keys` DSL and you already have `active_support` installed, key transformation will work out of the box, using `ActiveSupport::Inflector`. If `active_support` is not around, you have 2 possibilities:
+* install it
+* use a [custom inflector](#custom-inflector)
 
-With `active_support` installed, you can transform attribute keys.
+With `transform_keys` DSL, you can transform attribute keys.
 
 ```ruby
 class User
@@ -309,6 +311,34 @@ This behavior to transform root key will become default at version 2.
 
 Supported transformation types are :camel, :lower_camel and :dash.
 
+#### Custom inflector
+
+A custom inflector can be plugged in as follows...
+```ruby
+Alba.inflector = MyCustomInflector
+```
+...and has to implement following interface (the parameter `key` is of type `String`):
+```ruby
+module InflectorInterface
+  def camelize(key)
+    raise "Not implemented"
+  end
+
+  def camelize_lower(key)
+    raise "Not implemented"
+  end
+
+  def dasherize(key)
+    raise "Not implemented"
+  end
+end
+
+```
+For example you could use `Dry::Inflector`, which implements exactly the above interface. If you are developing a `Hanami`-Application `Dry::Inflector` is around. In this case the following would be sufficient:
+```ruby
+Alba.inflector = Dry::Inflector.new
+```
+
 ### Filtering attributes
 
 You can filter attributes by overriding `Alba::Resource#converter` method, but it's a bit tricky.
@@ -482,11 +512,13 @@ end
 
 ### Circular associations control
 
+**Note that this feature works correctly since version 1.3. In previous versions it doesn't work as expected.**
+
 You can control circular associations with `within` option. `within` option is a nested Hash such as `{book: {authors: books}}`. In this example, Alba serializes a book's authors' books. This means you can reference `BookResource` from `AuthorResource` and vice versa. This is really powerful when you have a complex data structure and serialize certain parts of it.
 
 For more details, please refer to [test code](https://github.com/okuramasafumi/alba/blob/master/test/usecases/circular_association_test.rb)
 
-### Types
+### Experimental support of types
 
 You can validate and convert input with types.
 
@@ -525,6 +557,8 @@ UserResource.new(user).serialize
 # => TypeError, 'Attribute bio is expected to be String but actually nil.'
 ```
 
+Note that this feature is experimental and interfaces are subject to change.
+
 ### Caching
 
 Currently, Alba doesn't support caching, primarily due to the behavior of `ActiveRecord::Relation`'s cache. See [the issue](https://github.com/rails/rails/issues/41784).

data/alba.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['masafumi.o1988@gmail.com']
 
   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.description   = "Alba is the fastest JSON serializer for Ruby. It focuses on performance, flexibility and usability."
   spec.homepage      = 'https://github.com/okuramasafumi/alba'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')

data/benchmark/collection.rb

@@ -0,0 +1,392 @@
+# Benchmark script to run varieties of JSON serializers
+# Fetch Alba from local, otherwise fetch latest from RubyGems
+
+# --- Bundle dependencies ---
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+  git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+  gem "active_model_serializers"
+  gem "activerecord", "6.1.3"
+  gem "alba", path: '../'
+  gem "benchmark-ips"
+  gem "benchmark-memory"
+  gem "blueprinter"
+  gem "jbuilder"
+  gem "jsonapi-serializer" # successor of fast_jsonapi
+  gem "multi_json"
+  gem "primalize"
+  gem "oj"
+  gem "representable"
+  gem "simple_ams"
+  gem "sqlite3"
+end
+
+# --- Test data model setup ---
+
+require "active_record"
+require "logger"
+require "oj"
+require "sqlite3"
+Oj.optimize_rails
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+# ActiveRecord::Base.logger = Logger.new($stdout)
+
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+    t.string :body
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :post_id
+    t.string :body
+    t.integer :commenter_id
+  end
+
+  create_table :users, force: true do |t|
+    t.string :name
+  end
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  has_many :commenters, through: :comments, class_name: 'User', source: :commenter
+
+  def attributes
+    {id: nil, body: nil, commenter_names: commenter_names}
+  end
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :commenter, class_name: 'User'
+
+  def attributes
+    {id: nil, body: nil}
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :comments
+end
+
+# --- Alba serializers ---
+
+require "alba"
+
+class AlbaCommentResource
+  include ::Alba::Resource
+  attributes :id, :body
+end
+
+class AlbaPostResource
+  include ::Alba::Resource
+  attributes :id, :body
+  attribute :commenter_names do |post|
+    post.commenters.pluck(:name)
+  end
+  many :comments, resource: AlbaCommentResource
+end
+
+# --- ActiveModelSerializer serializers ---
+
+require "active_model_serializers"
+
+ActiveModelSerializers.logger = Logger.new(nil)
+
+class AMSCommentSerializer < ActiveModel::Serializer
+  attributes :id, :body
+end
+
+class AMSPostSerializer < ActiveModel::Serializer
+  attributes :id, :body
+  attribute :commenter_names
+  has_many :comments, serializer: AMSCommentSerializer
+
+  def commenter_names
+    object.commenters.pluck(:name)
+  end
+end
+
+# --- Blueprint serializers ---
+
+require "blueprinter"
+
+class CommentBlueprint < Blueprinter::Base
+  fields :id, :body
+end
+
+class PostBlueprint < Blueprinter::Base
+  fields :id, :body, :commenter_names
+  association :comments, blueprint: CommentBlueprint
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+# --- JBuilder serializers ---
+
+require "jbuilder"
+
+class Post
+  def to_builder
+    Jbuilder.new do |post|
+      post.call(self, :id, :body, :commenter_names, :comments)
+    end
+  end
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+class Comment
+  def to_builder
+    Jbuilder.new do |comment|
+      comment.call(self, :id, :body)
+    end
+  end
+end
+
+# --- JSONAPI:Serializer serializers / (successor of fast_jsonapi) ---
+
+class JsonApiStandardCommentSerializer
+  include JSONAPI::Serializer
+
+  attribute :id
+  attribute :body
+end
+
+class JsonApiStandardPostSerializer
+  include JSONAPI::Serializer
+
+  # set_type :post  # optional
+  attribute :id
+  attribute :body
+  attribute :commenter_names
+
+  attribute :comments do |post|
+    post.comments.map { |comment| JsonApiSameFormatCommentSerializer.new(comment) }
+  end
+end
+
+# --- JSONAPI:Serializer serializers that format the code the same flat way as the other gems here ---
+
+# code to convert from JSON:API output to "flat" JSON, like the other serializers build
+class JsonApiSameFormatSerializer
+  include JSONAPI::Serializer
+
+  def as_json(*_options)
+    hash = serializable_hash
+
+    if hash[:data].is_a? Hash
+      hash[:data][:attributes]
+
+    elsif hash[:data].is_a? Array
+      hash[:data].pluck(:attributes)
+
+    elsif hash[:data].nil?
+      { }
+
+    else
+      raise "unexpected data type #{hash[:data].class}"
+    end
+  end
+end
+
+class JsonApiSameFormatCommentSerializer < JsonApiSameFormatSerializer
+  attribute :id
+  attribute :body
+end
+
+class JsonApiSameFormatPostSerializer < JsonApiSameFormatSerializer
+  attribute :id
+  attribute :body
+  attribute :commenter_names
+
+  attribute :comments do |post|
+    post.comments.map { |comment| JsonApiSameFormatCommentSerializer.new(comment) }
+  end
+end
+
+# --- Primalize serializers ---
+#
+class PrimalizeCommentResource < Primalize::Single
+  attributes id: integer, body: string
+end
+
+class PrimalizePostResource < Primalize::Single
+  alias post object
+
+  attributes(
+    id: integer,
+    body: string,
+    comments: array(primalize(PrimalizeCommentResource)),
+    commenter_names: array(string),
+  )
+
+  def commenter_names
+    post.commenters.pluck(:name)
+  end
+end
+
+class PrimalizePostsResource < Primalize::Many
+  attributes posts: enumerable(PrimalizePostResource)
+end
+
+# --- Representable serializers ---
+
+require "representable"
+
+class CommentRepresenter < Representable::Decorator
+  include Representable::JSON
+
+  property :id
+  property :body
+end
+
+class PostsRepresenter < Representable::Decorator
+  include Representable::JSON::Collection
+
+  items class: Post do
+    property :id
+    property :body
+    property :commenter_names
+    collection :comments
+  end
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+# --- SimpleAMS serializers ---
+
+require "simple_ams"
+
+class SimpleAMSCommentSerializer
+  include SimpleAMS::DSL
+
+  attributes :id, :body
+end
+
+class SimpleAMSPostSerializer
+  include SimpleAMS::DSL
+
+  attributes :id, :body
+  attribute :commenter_names
+  has_many :comments, serializer: SimpleAMSCommentSerializer
+
+  def commenter_names
+    object.commenters.pluck(:name)
+  end
+end
+
+# --- Test data creation ---
+
+100.times do |i|
+  post = Post.create!(body: "post#{i}")
+  user1 = User.create!(name: "John#{i}")
+  user2 = User.create!(name: "Jane#{i}")
+  10.times do |n|
+    post.comments.create!(commenter: user1, body: "Comment1_#{i}_#{n}")
+    post.comments.create!(commenter: user2, body: "Comment2_#{i}_#{n}")
+  end
+end
+
+posts = Post.all.to_a
+
+# --- Store the serializers in procs ---
+
+alba = Proc.new { AlbaPostResource.new(posts).serialize }
+alba_inline = Proc.new do
+  Alba.serialize(posts) do
+    attributes :id, :body
+    attribute :commenter_names do |post|
+      post.commenters.pluck(:name)
+    end
+    many :comments do
+      attributes :id, :body
+    end
+  end
+end
+ams = Proc.new { ActiveModelSerializers::SerializableResource.new(posts, {}).as_json }
+blueprinter = Proc.new { PostBlueprint.render(posts) }
+jbuilder = Proc.new do
+  Jbuilder.new do |json|
+    json.array!(posts) do |post|
+      json.post post.to_builder
+    end
+  end.target!
+end
+jsonapi = proc { JsonApiStandardPostSerializer.new(posts).to_json }
+jsonapi_same_format = proc { JsonApiSameFormatPostSerializer.new(posts).to_json }
+primalize = proc { PrimalizePostsResource.new(posts: posts).to_json }
+rails = Proc.new do
+  ActiveSupport::JSON.encode(posts.map{ |post| post.serializable_hash(include: :comments) })
+end
+representable = Proc.new { PostsRepresenter.new(posts).to_json }
+simple_ams = Proc.new { SimpleAMS::Renderer::Collection.new(posts, serializer: SimpleAMSPostSerializer).to_json }
+
+# --- Execute the serializers to check their output ---
+
+puts "Serializer outputs ----------------------------------"
+{
+  alba: alba,
+  alba_inline: alba_inline,
+  ams: ams,
+  blueprinter: blueprinter,
+  jbuilder: jbuilder, # different order
+  jsonapi: jsonapi, # nested JSON:API format
+  jsonapi_same_format: jsonapi_same_format,
+  primalize: primalize,
+  rails: rails,
+  representable: representable,
+  simple_ams: simple_ams,
+}.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
+
+# --- Run the benchmarks ---
+
+require 'benchmark/ips'
+Benchmark.ips do |x|
+  x.report(:alba, &alba)
+  x.report(:alba_inline, &alba_inline)
+  x.report(:ams, &ams)
+  x.report(:blueprinter, &blueprinter)
+  x.report(:jbuilder, &jbuilder)
+  x.report(:jsonapi, &jsonapi)
+  x.report(:jsonapi_same_format, &jsonapi_same_format)
+  x.report(:primalize, &primalize)
+  x.report(:rails, &rails)
+  x.report(:representable, &representable)
+  x.report(:simple_ams, &simple_ams)
+
+  x.compare!
+end
+
+
+require 'benchmark/memory'
+Benchmark.memory do |x|
+  x.report(:alba, &alba)
+  x.report(:alba_inline, &alba_inline)
+  x.report(:ams, &ams)
+  x.report(:blueprinter, &blueprinter)
+  x.report(:jbuilder, &jbuilder)
+  x.report(:jsonapi, &jsonapi)
+  x.report(:jsonapi_same_format, &jsonapi_same_format)
+  x.report(:primalize, &primalize)
+  x.report(:rails, &rails)
+  x.report(:representable, &representable)
+  x.report(:simple_ams, &simple_ams)
+
+  x.compare!
+end

data/benchmark/{local.rb → single_resource.rb}

@@ -20,6 +20,7 @@ gemfile(true) do
   gem "primalize"
   gem "oj"
   gem "representable"
+  gem "simple_ams"
   gem "sqlite3"
 end
 
@@ -259,6 +260,28 @@ class PostRepresenter < Representable::Decorator
   end
 end
 
+# --- SimpleAMS serializers ---
+
+require "simple_ams"
+
+class SimpleAMSCommentSerializer
+  include SimpleAMS::DSL
+
+  attributes :id, :body
+end
+
+class SimpleAMSPostSerializer
+  include SimpleAMS::DSL
+
+  attributes :id, :body
+  attribute :commenter_names
+  has_many :comments, serializer: SimpleAMSCommentSerializer
+
+  def commenter_names
+    object.commenters.pluck(:name)
+  end
+end
+
 # --- Test data creation ---
 
 post = Post.create!(body: 'post')
@@ -290,6 +313,7 @@ jsonapi_same_format = proc { JsonApiSameFormatPostSerializer.new(post).to_json }
 primalize = proc { PrimalizePostResource.new(post).to_json }
 rails = Proc.new { ActiveSupport::JSON.encode(post.serializable_hash(include: :comments)) }
 representable = Proc.new { PostRepresenter.new(post).to_json }
+simple_ams = Proc.new { SimpleAMS::Renderer.new(post, serializer: SimpleAMSPostSerializer).to_json }
 
 # --- Execute the serializers to check their output ---
 
@@ -304,26 +328,12 @@ puts "Serializer outputs ----------------------------------"
   jsonapi_same_format: jsonapi_same_format,
   primalize: primalize,
   rails: rails,
-  representable: representable
+  representable: representable,
+  simple_ams: simple_ams,
 }.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
 
 # --- Run the benchmarks ---
 
-require 'benchmark'
-time = 1000
-Benchmark.bmbm do |x|
-  x.report(:alba) { time.times(&alba) }
-  x.report(:alba_inline) { time.times(&alba_inline) }
-  x.report(:ams) { time.times(&ams) }
-  x.report(:blueprinter) { time.times(&blueprinter) }
-  x.report(:jbuilder) { time.times(&jbuilder) }
-  x.report(:jsonapi) { time.times(&jsonapi) }
-  x.report(:jsonapi_same_format) { time.times(&jsonapi_same_format) }
-  x.report(:primalize) { time.times(&primalize) }
-  x.report(:rails) { time.times(&rails) }
-  x.report(:representable) { time.times(&representable) }
-end
-
 require 'benchmark/ips'
 Benchmark.ips do |x|
   x.report(:alba, &alba)
@@ -336,6 +346,25 @@ Benchmark.ips do |x|
   x.report(:primalize, &primalize)
   x.report(:rails, &rails)
   x.report(:representable, &representable)
+  x.report(:simple_ams, &simple_ams)
+
+  x.compare!
+end
+
+
+require 'benchmark/memory'
+Benchmark.memory do |x|
+  x.report(:alba, &alba)
+  x.report(:alba_inline, &alba_inline)
+  x.report(:ams, &ams)
+  x.report(:blueprinter, &blueprinter)
+  x.report(:jbuilder, &jbuilder)
+  x.report(:jsonapi, &jsonapi)
+  x.report(:jsonapi_same_format, &jsonapi_same_format)
+  x.report(:primalize, &primalize)
+  x.report(:rails, &rails)
+  x.report(:representable, &representable)
+  x.report(:simple_ams, &simple_ams)
 
   x.compare!
 end

data/lib/alba.rb

@@ -14,6 +14,7 @@ module Alba
 
   class << self
     attr_reader :backend, :encoder, :inferring, :_on_error, :transforming_root_key
+    attr_accessor :inflector
 
     # Set the backend, which actually serializes object into JSON
     #

data/lib/alba/association.rb

@@ -2,7 +2,7 @@ module Alba
   # Base class for `One` and `Many`
   # Child class should implement `to_hash` method
   class Association
-    attr_reader :object
+    attr_reader :object, :name
 
     # @param name [Symbol] name of the method to fetch association
     # @param condition [Proc] a proc filtering data
@@ -15,14 +15,7 @@ module Alba
       @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
+      assign_resource(nesting)
     end
 
     private
@@ -36,11 +29,26 @@ module Alba
       end
     end
 
+    def assign_resource(nesting)
+      @resource = if @block
+                    resource_class
+                  elsif Alba.inferring
+                    resource_class_with_nesting(nesting)
+                  else
+                    raise ArgumentError, 'When Alba.inferring is false, either resource or block is required'
+                  end
+    end
+
     def resource_class
       klass = Class.new
       klass.include(Alba::Resource)
       klass.class_eval(&@block)
       klass
     end
+
+    def resource_class_with_nesting(nesting)
+      const_parent = nesting.nil? ? Object : Object.const_get(nesting)
+      const_parent.const_get("#{ActiveSupport::Inflector.classify(@name)}Resource")
+    end
   end
 end

data/lib/alba/default_inflector.rb

@@ -0,0 +1,36 @@
+module Alba
+  # This module represents the inflector, which is used by default
+  module DefaultInflector
+    begin
+      require 'active_support/inflector'
+    rescue LoadError
+      raise ::Alba::Error, 'To use transform_keys, please install `ActiveSupport` gem.'
+    end
+
+    module_function
+
+    # Camelizes a key
+    #
+    # @params key [String] key to be camelized
+    # @return [String] camelized key
+    def camelize(key)
+      ActiveSupport::Inflector.camelize(key)
+    end
+
+    # Camelizes a key, 1st letter lowercase
+    #
+    # @params key [String] key to be camelized
+    # @return [String] camelized key
+    def camelize_lower(key)
+      ActiveSupport::Inflector.camelize(key, false)
+    end
+
+    # Dasherizes a key
+    #
+    # @params key [String] key to be dasherized
+    # @return [String] dasherized key
+    def dasherize(key)
+      ActiveSupport::Inflector.dasherize(key)
+    end
+  end
+end

data/lib/alba/key_transform_factory.rb

@@ -0,0 +1,33 @@
+module Alba
+  # This module creates key transform functions
+  module KeyTransformFactory
+    class << self
+      # Create key transform function for given transform_type
+      #
+      # @params transform_type [Symbol] transform type
+      # @return [Proc] transform function
+      # @raise [Alba::Error] when transform_type is not supported
+      def create(transform_type)
+        case transform_type
+        when :camel
+          ->(key) { _inflector.camelize(key) }
+        when :lower_camel
+          ->(key) { _inflector.camelize_lower(key) }
+        when :dash
+          ->(key) { _inflector.dasherize(key) }
+        else
+          raise ::Alba::Error, "Unknown transform_type: #{transform_type}. Supported transform_type are :camel, :lower_camel and :dash."
+        end
+      end
+
+      private
+
+      def _inflector
+        Alba.inflector || begin
+          require_relative './default_inflector'
+          Alba::DefaultInflector
+        end
+      end
+    end
+  end
+end

data/lib/alba/many.rb

@@ -15,7 +15,7 @@ module Alba
       return if @object.nil?
 
       @resource = constantize(@resource)
-      @object.map { |o| @resource.new(o, params: params, within: within).to_hash }
+      @resource.new(@object, params: params, within: within).to_hash
     end
   end
 end

data/lib/alba/resource.rb

@@ -1,14 +1,19 @@
 require_relative 'one'
 require_relative 'many'
+require_relative 'key_transform_factory'
+require_relative 'typed_attribute'
 
 module Alba
   # This module represents what should be serialized
   module Resource
     # @!parse include InstanceMethods
     # @!parse extend ClassMethods
-    DSLS = {_attributes: {}, _key: nil, _transform_keys: nil, _transforming_root_key: false, _on_error: nil}.freeze
+    DSLS = {_attributes: {}, _key: nil, _transform_key_function: nil, _transforming_root_key: false, _on_error: nil}.freeze
     private_constant :DSLS
 
+    WITHIN_DEFAULT = Object.new.freeze
+    private_constant :WITHIN_DEFAULT
+
     # @private
     def self.included(base)
       super
@@ -29,7 +34,7 @@ module Alba
       # @param object [Object] the object to be serialized
       # @param params [Hash] user-given Hash for arbitrary data
       # @param within [Hash] determines what associations to be serialized. If not set, it serializes all associations.
-      def initialize(object, params: {}, within: true)
+      def initialize(object, params: {}, within: WITHIN_DEFAULT)
         @object = object
         @params = params.freeze
         @within = within
@@ -60,21 +65,25 @@ module Alba
       def _key
         return @_key.to_s unless @_key == true && Alba.inferring
 
-        resource_name = self.class.name.demodulize.delete_suffix('Resource').underscore
-        key = collection? ? resource_name.pluralize : resource_name
-        transforming_root_key = @_transforming_root_key.nil? ? Alba.transforming_root_key : @_transforming_root_key
-        transforming_root_key ? transform_key(key) : key
+        transforming_root_key? ? transform_key(key_from_resource_name) : key_from_resource_name
+      end
+
+      def key_from_resource_name
+        collection? ? resource_name.pluralize : resource_name
+      end
+
+      def resource_name
+        self.class.name.demodulize.delete_suffix('Resource').underscore
+      end
+
+      def transforming_root_key?
+        @_transforming_root_key.nil? ? Alba.transforming_root_key : @_transforming_root_key
       end
 
       def converter
         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
+            key_and_attribute_body_from(object, key, attribute)
           rescue ::Alba::Error, FrozenError, TypeError
             raise
           rescue StandardError => e
@@ -84,10 +93,19 @@ module Alba
         end
       end
 
+      def key_and_attribute_body_from(object, key, attribute)
+        key = transform_key(key)
+        if attribute.is_a?(Array) # Conditional
+          conditional_attribute(object, key, attribute)
+        else
+          [key, fetch_attribute(object, attribute)]
+        end
+      end
+
       def conditional_attribute(object, key, attribute)
         condition = attribute.last
         arity = condition.arity
-        return [] if arity <= 1 && !condition.call(object)
+        return [] if arity <= 1 && !instance_exec(object, &condition)
 
         fetched_attribute = fetch_attribute(object, attribute.first)
         attr = if attribute.first.is_a?(Alba::Association)
@@ -95,7 +113,7 @@ module Alba
                else
                  fetched_attribute
                end
-        return [] if arity >= 2 && !condition.call(object, attr)
+        return [] if arity >= 2 && !instance_exec(object, attr, &condition)
 
         [key, fetched_attribute]
       end
@@ -118,10 +136,9 @@ module Alba
 
       # Override this method to supply custom key transform method
       def transform_key(key)
-        return key unless @_transform_keys
+        return key if @_transform_key_function.nil?
 
-        require_relative 'key_transformer'
-        KeyTransformer.transform(key, @_transform_keys)
+        @_transform_key_function.call(key.to_s)
       end
 
       def fetch_attribute(object, attribute)
@@ -131,70 +148,28 @@ module Alba
         when Proc
           instance_exec(object, &attribute)
         when Alba::One, Alba::Many
-          within = check_within
+          within = check_within(attribute.name.to_sym)
           return unless within
 
           attribute.to_hash(object, params: params, within: within)
-        when Hash # Typed Attribute
-          typed_attribute(object, attribute)
+        when TypedAttribute
+          attribute.value(object)
         else
           raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
         end
       end
 
-      def typed_attribute(object, hash)
-        attr_name = hash[:attr_name]
-        type = hash[:type]
-        type_converter = hash[:type_converter]
-        value, result = type_check(object, attr_name, type)
-        return value if result
-        raise TypeError if !result && !type_converter
-
-        type_converter = type_converter_for(type) if type_converter == true
-        type_converter.call(value)
-      rescue TypeError
-        raise TypeError, "Attribute #{attr_name} is expected to be #{type} but actually #{value.nil? ? 'nil' : value.class.name}."
-      end
-
-      def type_check(object, attr_name, type)
-        value = object.public_send(attr_name)
-        type_correct = case type
-                       when :String, ->(klass) { klass == String }
-                         value.is_a?(String)
-                       when :Integer, ->(klass) { klass == Integer }
-                         value.is_a?(Integer)
-                       when :Boolean
-                         [true, false].include?(attr_name)
-                       else
-                         raise Alba::UnsupportedType, "Unknown type: #{type}"
-                       end
-        [value, type_correct]
-      end
-
-      def type_converter_for(type)
-        case type
-        when :String, ->(klass) { klass == String }
-          ->(object) { object.to_s }
-        when :Integer, ->(klass) { klass == Integer }
-          ->(object) { Integer(object) }
-        when :Boolean
-          ->(object) { !!object }
-        else
-          raise Alba::UnsupportedType, "Unknown type: #{type}"
-        end
-      end
-
-      def check_within
+      def check_within(association_name)
         case @within
+        when WITHIN_DEFAULT # Default value, doesn't check within tree
+          WITHIN_DEFAULT
         when Hash # Traverse within tree
-          @within.fetch(_key.to_sym, nil)
+          @within.fetch(association_name, nil)
         when Array # within tree ends with Array
-          @within.find { |item| item.to_sym == _key.to_sym } # Check if at least one item in the array matches current resource
+          @within.find { |item| item.to_sym == association_name }
         when Symbol # within tree could end with Symbol
-          @within == _key.to_sym # Check if the symbol matches current resource
-        when true # In this case, Alba serializes all associations.
-          true
-        when nil, false # In these cases, Alba stops serialization here.
+          @within == association_name
+        when nil, true, false # In these cases, Alba stops serialization here.
           false
         else
           raise Alba::Error, "Unknown type for within option: #{@within.class}"
@@ -219,21 +194,32 @@ module Alba
       # Set multiple attributes at once
       #
       # @param attrs [Array<String, Symbol>]
-      # @param options [Hash] option hash including `if` that is a  condition to render these attributes
+      # @param if [Boolean] condition to decide if it should render these attributes
+      # @param attrs_with_types [Hash] attributes with name in its key and type and optional type converter in its value
       def attributes(*attrs, if: nil, **attrs_with_types) # rubocop:disable Naming/MethodParameterName
         if_value = binding.local_variable_get(:if)
+        assign_attributes(attrs, if_value)
+        assign_attributes_with_types(attrs_with_types, if_value)
+      end
+
+      def assign_attributes(attrs, if_value)
         attrs.each do |attr_name|
           attr = if_value ? [attr_name.to_sym, if_value] : attr_name.to_sym
           @_attributes[attr_name.to_sym] = attr
         end
+      end
+      private :assign_attributes
+
+      def assign_attributes_with_types(attrs_with_types, if_value)
         attrs_with_types.each do |attr_name, type_and_converter|
           attr_name = attr_name.to_sym
           type, type_converter = type_and_converter
-          typed_attr = {attr_name: attr_name, type: type, type_converter: type_converter}
+          typed_attr = TypedAttribute.new(name: attr_name, type: type, converter: type_converter)
           attr = if_value ? [typed_attr, if_value] : typed_attr
           @_attributes[attr_name] = attr
         end
       end
+      private :assign_attributes_with_types
 
       # Set an attribute with the given block
       #
@@ -307,7 +293,7 @@ module Alba
       # @param type [String, Symbol]
       # @param root [Boolean] decides if root key also should be transformed
       def transform_keys(type, root: nil)
-        @_transform_keys = type.to_sym
+        @_transform_key_function = KeyTransformFactory.create(type.to_sym)
         @_transforming_root_key = root
       end
 

data/lib/alba/typed_attribute.rb

@@ -0,0 +1,64 @@
+module Alba
+  # Representing typed attributes to encapsulate logic about types
+  class TypedAttribute
+    # @param name [Symbol, String]
+    # @param type [Symbol, Class]
+    # @param converter [Proc]
+    def initialize(name:, type:, converter:)
+      @name = name
+      @type = type
+      @converter = case converter
+                   when true then default_converter
+                   when false, nil then null_converter
+                   else converter
+                   end
+    end
+
+    # @param object [Object] target to check and convert type with
+    # @return [String, Integer, Boolean] type-checked or type-converted object
+    def value(object)
+      value, result = check(object)
+      result ? value : @converter.call(value)
+    rescue TypeError
+      raise TypeError, "Attribute #{@name} is expected to be #{@type} but actually #{display_value_for(value)}."
+    end
+
+    private
+
+    def check(object)
+      value = object.public_send(@name)
+      type_correct = case @type
+                     when :String, ->(klass) { klass == String }
+                       value.is_a?(String)
+                     when :Integer, ->(klass) { klass == Integer }
+                       value.is_a?(Integer)
+                     when :Boolean
+                       [true, false].include?(value)
+                     else
+                       raise Alba::UnsupportedType, "Unknown type: #{@type}"
+                     end
+      [value, type_correct]
+    end
+
+    def default_converter
+      case @type
+      when :String, ->(klass) { klass == String }
+        ->(object) { object.to_s }
+      when :Integer, ->(klass) { klass == Integer }
+        ->(object) { Integer(object) }
+      when :Boolean
+        ->(object) { !!object }
+      else
+        raise Alba::UnsupportedType, "Unknown type: #{@type}"
+      end
+    end
+
+    def null_converter
+      ->(_) { raise TypeError }
+    end
+
+    def display_value_for(value)
+      value.nil? ? 'nil' : value.class.name
+    end
+  end
+end

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.3.0'.freeze
 end

metadata

@@ -1,18 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-09 00:00:00.000000000 Z
+date: 2021-05-31 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
-  do similar things. The internal is so simple that it's easy to hack and maintain.
+description: Alba is the fastest JSON serializer for Ruby. It focuses on performance,
+  flexibility and usability.
 email:
 - masafumi.o1988@gmail.com
 executables: []
@@ -34,7 +33,8 @@ files:
 - Rakefile
 - SECURITY.md
 - alba.gemspec
-- benchmark/local.rb
+- benchmark/collection.rb
+- benchmark/single_resource.rb
 - bin/console
 - bin/setup
 - codecov.yml
@@ -43,10 +43,12 @@ files:
 - gemfiles/without_oj.gemfile
 - lib/alba.rb
 - lib/alba/association.rb
-- lib/alba/key_transformer.rb
+- lib/alba/default_inflector.rb
+- lib/alba/key_transform_factory.rb
 - lib/alba/many.rb
 - lib/alba/one.rb
 - lib/alba/resource.rb
+- lib/alba/typed_attribute.rb
 - lib/alba/version.rb
 - sider.yml
 homepage: https://github.com/okuramasafumi/alba

data/lib/alba/key_transformer.rb

@@ -1,32 +0,0 @@
-module Alba
-  # Transform keys using `ActiveSupport::Inflector`
-  module KeyTransformer
-    begin
-      require 'active_support/inflector'
-    rescue LoadError
-      raise ::Alba::Error, 'To use transform_keys, please install `ActiveSupport` gem.'
-    end
-
-    module_function
-
-    # Transform key as given transform_type
-    #
-    # @params key [String] key to be transformed
-    # @params transform_type [Symbol] transform type
-    # @return [String] transformed key
-    # @raise [Alba::Error] when transform_type is not supported
-    def transform(key, transform_type)
-      key = key.to_s
-      case transform_type
-      when :camel
-        ActiveSupport::Inflector.camelize(key)
-      when :lower_camel
-        ActiveSupport::Inflector.camelize(key, false)
-      when :dash
-        ActiveSupport::Inflector.dasherize(key)
-      else
-        raise ::Alba::Error, "Unknown transform_type: #{transform_type}. Supported transform_type are :camel, :lower_camel and :dash."
-      end
-    end
-  end
-end