alba 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68ec07a949642b11dfd36b3bf748249d0d725178ece9dd331e373fc2339cb8a
-  data.tar.gz: 7704431d69f96b88d9632c114dae90cfceae018c8372c8736c091efd2050b65a
+  metadata.gz: 3ba9736fa95cae41e16375e21770a7244b1ee5af9787090a1dadbe3f50839221
+  data.tar.gz: cb06fc313a5abb4914fceb3eb044911bd556d11cfa2239b3509147f5f992ab9e
 SHA512:
-  metadata.gz: 98ca1b6fa7c6851f3a69d6d1cb54cd782a3142fccfb33391eb08cbc093ad691496a8fdb9e93e5ce89543032a0003ab8b60022ca8bbbba81c73de249b571a3fa6
-  data.tar.gz: 3756fe21da92358031a722d83b7169ef81e8749ccf6430bef577dfaac7ab4a80e68c07c6e0205497e54692f74b16e66aabad390db6eda09e486a732387541630
+  metadata.gz: 4814af5d6e0a69d34ba6f3c9ef9292e7a83196ff3d231851d799857518888e9db4bc075a0cbc88ae8e7e39aa20e724085224e1944b843edc7b685ef372cefa71
+  data.tar.gz: 9cb559556d0e44ea4218328d645f4666e0dd5cf63a4b380b64e7e6bf1460724ecd3e04b8eb138ac1aac30176a5d0491db1451e3bdaf2130771ab06bdbb2e4d50

data/.codeclimate.yml

@@ -9,3 +9,4 @@ checks:
 exclude_patterns:
   - "benchmark/**/*"
   - "script/**/*"
+  - "test/**/*"

data/.rubocop.yml

@@ -3,7 +3,12 @@
 inherit_gem:
   rubocop-sensible: 'config/rubocop.yml'
 
+inherit_mode:
+  merge:
+    - Exclude
+
 require:
+  - rubocop-md
   - rubocop-minitest
   - rubocop-performance
   - rubocop-rake
@@ -22,6 +27,11 @@ AllCops:
 Bundler/GemVersion:
   Enabled: false
 
+# Test class is a class, but not really
+Layout/ClassStructure:
+  Exclude:
+    - 'test/**/*'
+
 # We'd like to write something like:
 #   assert_equal(
 #     expected,
@@ -80,14 +90,26 @@ Style/Copyright:
 Style/DisableCopsWithinSourceCodeDirective:
   Enabled: false
 
+Style/Documentation:
+  Exclude:
+    - 'test/**/*'
+
+Style/DocumentationMethod:
+  Exclude:
+    - 'README.md'
+
 Style/FrozenStringLiteralComment:
   Enabled: false
 
+Style/ImplicitRuntimeError:
+  Exclude:
+    - 'README.md'
+
 Style/InlineComment:
   Enabled: false
 
 Style/MethodCallWithArgsParentheses:
-  IgnoredMethods: ['require', 'require_relative', 'include', 'extend', 'puts', 'p', 'warn', 'raise', 'send', 'public_send']
+  AllowedMethods: ['require', 'require_relative', 'include', 'extend', 'puts', 'p', 'warn', 'raise', 'send', 'public_send']
   Exclude:
     # There are so many `attributes` call without parenthese and that's absolutely fine
     - 'test/**/*.rb'
@@ -95,3 +117,7 @@ Style/MethodCallWithArgsParentheses:
 # There are so many cases we just want `if` expression!
 Style/MissingElse:
   EnforcedStyle: case
+
+Style/OptionalBooleanParameter:
+  Exclude:
+    - 'README.md'

data/CHANGELOG.md

@@ -6,6 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.0] 2023-04-24
+
+### Added
+
+- Add compatibility option for key [#304](https://github.com/okuramasafumi/alba/pull/304)
+- It now infers resource name from Serializer [#309](https://github.com/okuramasafumi/alba/pull/309)
+- `Alba.serialize` is easier to use for multiple root keys [#311](https://github.com/okuramasafumi/alba/pull/311)
+- Gives access to params in nested_attribute [#312](https://github.com/okuramasafumi/alba/pull/312)
+  - Thank you, @GabrielErbetta
+
 ## [2.2.0] 2023-02-17
 
 ### Added

data/Gemfile

@@ -10,6 +10,7 @@ gem 'minitest', '~> 5.14' # For test
 gem 'railties', require: false # For Rails integration testing
 gem 'rake', '~> 13.0' # For test and automation
 gem 'rubocop', '>= 0.79.0', require: false # For lint
+gem 'rubocop-md', '~> 1.0', require: false # For lint
 gem 'rubocop-minitest', '>= 0.25.0', require: false # For lint
 gem 'rubocop-performance', '>= 1.15.0', require: false # For lint
 gem 'rubocop-rake', '>= 0.5.1', require: false # For lint

data/HACKING.md

@@ -17,6 +17,7 @@ Class methods (DSL):
 * `attribute` for block style attribute
 * `attributes` for symbol style attribute
 * `association` and its aliases such as `one` for association
+* `nested` for nested attribute
 
 Instance methods:
 
@@ -29,7 +30,7 @@ Other methods are rather trivial. They'll be added to this list when it turned o
 
 In `Alba::Resource` module there are some things to note.
 
-`@object` is an object for serialization. It's either singular object or collection.
+`@object` is an object for serialization. It's either a singular object or a collection.
 
 Attribute object can be either `Symbol`, `Proc`, `Alba::Association` or `Alba::TypedAttribute`.
 

data/README.md

@@ -43,7 +43,7 @@ Alba is faster than most of the alternatives. We have a [benchmark](https://gith
 
 ### Easy
 
-Alba is easy to use because there are only a few methods to remember. It's also easy to understand due to clean and short codebase. Finally it's easy to extend since it provides some methods for override to change default behavior of Alba.
+Alba is easy to use because there are only a few methods to remember. It's also easy to understand due to clean and small codebase. Finally it's easy to extend since it provides some methods for override to change default behavior of Alba.
 
 ### Feature rich
 
@@ -143,13 +143,27 @@ Alba.inflector = nil
 To check if inference is enabled etc, inspect the return value of `inflector`:
 
 ```ruby
-if Alba.inflector == nil
-  puts "inflector not set"
+if Alba.inflector.nil?
+  puts 'inflector not set'
 else
   puts "inflector is set to #{Alba.inflector}"
 end
 ```
 
+### Naming
+
+Alba tries to infer resource name from class name like the following.
+
+|Class name|Resource name|
+| --- | --- |
+| FooResource | Foo |
+| FooSerializer | Foo |
+| FooElse | FooElse |
+
+Resource name is used as the default name of the root key, so you might want to name it ending with "Resource" or "Serializer"
+
+When you use Alba with Rails, it's recommended to put your resource/serializer classes in corresponding directory such as `app/resources` or `app/serializers`.
+
 ### Simple serialization with root key
 
 You can define attributes with (yes) `attributes` macro with attribute names. If your attribute need some calculations, you can use `attribute` with block.
@@ -157,6 +171,7 @@ You can define attributes with (yes) `attributes` macro with attribute names. If
 ```ruby
 class User
   attr_accessor :id, :name, :email, :created_at, :updated_at
+
   def initialize(id, name, email)
     @id = id
     @name = name
@@ -356,11 +371,11 @@ class UserResource
 
   # Second proc works as a filter
   many :articles,
-    proc { |articles, params, user|
-      filter = params[:filter] || :odd?
-      articles.select {|a| a.id.send(filter) && !user.banned  }
-    },
-    resource: ArticleResource
+       proc { |articles, params, user|
+         filter = params[:filter] || :odd?
+         articles.select { |a| a.id.__send__(filter) && !user.banned }
+       },
+       resource: ArticleResource
 end
 
 user = User.new(1)
@@ -384,8 +399,8 @@ class UserResource
   attributes :id
 
   many :articles,
-    key: 'my_articles', # Set key here
-    resource: ArticleResource
+       key: 'my_articles', # Set key here
+       resource: ArticleResource
 end
 UserResource.new(user).serialize
 # => '{"id":1,"my_articles":[{"title":"Hello World!"}]}'
@@ -452,7 +467,7 @@ class FooResourceWithParamsOverride
 
   root_key :foo
 
-  one :bar, resource: BarResource, params: { expose_secret: false }
+  one :bar, resource: BarResource, params: {expose_secret: false}
 end
 
 Baz = Struct.new(:data, :secret)
@@ -544,6 +559,48 @@ Alba.serialize(something)
 
 Although this might be useful sometimes, it's generally recommended to define a class for Resource.
 
+#### Inline definition for multiple root keys
+
+While Alba doesn't directly support multiple root keys, you can simulate it with `Alba.serialize`.
+
+```ruby
+# Define foo and bar local variables here
+
+Alba.serialize do
+  attribute :key1 do
+    FooResource.new(foo).to_h
+  end
+
+  attribute :key2 do
+    BarResource.new(bar).to_h
+  end
+end
+# => JSON containing "key1" and "key2" as root keys
+```
+
+Note that we must use `to_h`, not `serialize`, with resources.
+
+We can also generate a JSON with multiple root keys without making any class by the combination of `Alba.serialize` and `Alba.hashify`.
+
+```ruby
+# Define foo and bar local variables here
+
+Alba.serialize do
+  attribute :foo do
+    Alba.hashify(foo) do
+      attributes :id, :name # For example
+    end
+  end
+
+  attribute :bar do
+    Alba.hashify(bar) do
+      attributes :id
+    end
+  end
+end
+# => JSON containing "foo" and "bar" as root keys
+```
+
 ### Serializable Hash
 
 Instead of serializing to JSON, you can also output a Hash by calling `serializable_hash` or the `to_h` alias. Note also that the `serialize` method is aliased as `to_json`.
@@ -796,20 +853,15 @@ A custom inflector can be plugged in as follows.
 module CustomInflector
   module_function
 
-  def camelize(string)
-  end
+  def camelize(string); end
 
-  def camelize_lower(string)
-  end
+  def camelize_lower(string); end
 
-  def dasherize(string)
-  end
+  def dasherize(string); end
 
-  def underscore(string)
-  end
+  def underscore(string); end
 
-  def classify(string)
-  end
+  def classify(string); end
 end
 
 Alba.inflector = CustomInflector
@@ -926,7 +978,7 @@ class User
   end
 
   def email
-    raise RuntimeError, 'Error!'
+    raise 'Error!'
   end
 end
 
@@ -1122,8 +1174,10 @@ Sometimes we want to serialize a collection into a Hash, not an Array. It's poss
 ```ruby
 class User
   attr_reader :id, :name
+
   def initialize(id, name)
-    @id, @name = id, name
+    @id = id
+    @name = name
   end
 end
 
@@ -1289,8 +1343,8 @@ module AlbaExtension
   # Here attrs are an Array of Symbol
   def formatted_time_attributes(*attrs)
     attrs.each do |attr|
-      attribute attr do |object|
-        time = object.send(attr)
+      attribute(attr) do |object|
+        time = object.__send__(attr)
         time.strftime('%m/%d/%Y')
       end
     end
@@ -1347,13 +1401,14 @@ Alba currently doesn't support logging directly, but you can add your own loggin
 
 ```ruby
 module Logging
-  def serialize(...) # `...` was added in Ruby 2.7
+  # `...` was added in Ruby 2.7
+  def serialize(...)
     puts serializable_hash
     super(...)
   end
 end
 
-FooResource.prepend Logging
+FooResource.prepend(Logging)
 FooResource.new(foo).serialize
 # => "{:id=>1}" is printed
 ```

data/benchmark/README.md

@@ -10,72 +10,76 @@ Machine spec:
 
 |Key|Value|
 |---|---|
-|OS|macOS 12.2.1|
+|OS|macOS 13.2.1|
 |CPU|Intel Corei7 Quad Core 2.3Ghz|
 |RAM|32GB|
-|Ruby|ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-darwin19]|
+|Ruby|ruby 3.2.1 (2023-02-08 revision 31819e82c8) [x86_64-darwin21]|
+
+Library versions:
+
+|Library|Version|
+|---|---|
+|alba|2.2.0|
+|blueprinter|0.25.3|
+|fast_serializer_ruby|0.6.9|
+|jserializer|0.2.1|
+|oj|3.14.2|
+|simple_ams|0.2.6|
+|representable|3.2.0|
+|turbostreamer|1.10.0|
+|jbuilder|2.11.5|
+|panko_serializer|0.7.9|
+|active_model_serializers|0.10.13|
 
 `benchmark-ips` with `Oj.optimize_rails`:
 
 ```
 Comparison:
-               panko:      267.6 i/s
-               rails:      111.2 i/s - 2.41x  (± 0.00) slower
-         jserializer:      106.2 i/s - 2.52x  (± 0.00) slower
-                alba:      102.8 i/s - 2.60x  (± 0.00) slower
-       turbostreamer:       99.9 i/s - 2.68x  (± 0.00) slower
-            jbuilder:       90.7 i/s - 2.95x  (± 0.00) slower
-         alba_inline:       90.0 i/s - 2.97x  (± 0.00) slower
-           primalize:       82.1 i/s - 3.26x  (± 0.00) slower
-     fast_serializer:       62.7 i/s - 4.27x  (± 0.00) slower
- jsonapi_same_format:       59.5 i/s - 4.50x  (± 0.00) slower
-             jsonapi:       55.3 i/s - 4.84x  (± 0.00) slower
-         blueprinter:       54.1 i/s - 4.95x  (± 0.00) slower
-       representable:       35.9 i/s - 7.46x  (± 0.00) slower
-          simple_ams:       25.4 i/s - 10.53x  (± 0.00) slower
-                 ams:        9.1 i/s - 29.39x  (± 0.00) slower
+               panko:      310.4 i/s
+         jserializer:      120.6 i/s - 2.57x  slower
+       turbostreamer:      117.3 i/s - 2.65x  slower
+               rails:      114.0 i/s - 2.72x  slower
+         alba_inline:       99.3 i/s - 3.13x  slower
+                alba:       94.1 i/s - 3.30x  slower
+     fast_serializer:       67.8 i/s - 4.58x  slower
+         blueprinter:       57.6 i/s - 5.39x  slower
+       representable:       36.3 i/s - 8.56x  slower
+          simple_ams:       23.3 i/s - 13.32x  slower
+                 ams:       10.9 i/s - 28.53x  slower
 ```
 
 `benchmark-ips` without `Oj.optimize_rails`:
 
 ```
 Comparison:
-               panko:      283.8 i/s
-       turbostreamer:      102.9 i/s - 2.76x  (± 0.00) slower
-                alba:      102.4 i/s - 2.77x  (± 0.00) slower
-         alba_inline:       98.7 i/s - 2.87x  (± 0.00) slower
-         jserializer:       93.3 i/s - 3.04x  (± 0.00) slower
-     fast_serializer:       60.1 i/s - 4.73x  (± 0.00) slower
-         blueprinter:       53.8 i/s - 5.28x  (± 0.00) slower
-               rails:       37.1 i/s - 7.65x  (± 0.00) slower
-            jbuilder:       37.1 i/s - 7.66x  (± 0.00) slower
-           primalize:       31.2 i/s - 9.08x  (± 0.00) slower
- jsonapi_same_format:       28.3 i/s - 10.03x  (± 0.00) slower
-       representable:       27.8 i/s - 10.23x  (± 0.00) slower
-             jsonapi:       27.5 i/s - 10.34x  (± 0.00) slower
-          simple_ams:       16.9 i/s - 16.75x  (± 0.00) slower
-                 ams:        8.3 i/s - 34.36x  (± 0.00) slower
+               panko:      326.1 i/s
+       turbostreamer:      120.6 i/s - 2.70x  slower
+         jserializer:      119.2 i/s - 2.74x  slower
+         alba_inline:      104.3 i/s - 3.13x  slower
+                alba:      102.2 i/s - 3.19x  slower
+     fast_serializer:       66.9 i/s - 4.88x  slower
+         blueprinter:       56.7 i/s - 5.75x  slower
+               rails:       33.9 i/s - 9.63x  slower
+       representable:       30.3 i/s - 10.77x  slower
+          simple_ams:       16.4 i/s - 19.84x  slower
+                 ams:        9.4 i/s - 34.56x  slower
 ```
 
 `benchmark-memory`:
 
 ```
 Comparison:
-               panko:     230418 allocated
-                alba:     733217 allocated - 3.18x more
-         alba_inline:     748297 allocated - 3.25x more
-       turbostreamer:     781008 allocated - 3.39x more
-         jserializer:     819705 allocated - 3.56x more
-           primalize:    1195163 allocated - 5.19x more
-     fast_serializer:    1232385 allocated - 5.35x more
-               rails:    1236761 allocated - 5.37x more
-         blueprinter:    1588937 allocated - 6.90x more
-            jbuilder:    1774157 allocated - 7.70x more
- jsonapi_same_format:    2132489 allocated - 9.25x more
-             jsonapi:    2279958 allocated - 9.89x more
-       representable:    2869166 allocated - 12.45x more
-                 ams:    4473161 allocated - 19.41x more
-          simple_ams:    7868345 allocated - 34.15x more
+               panko:     242426 allocated
+       turbostreamer:     817568 allocated - 3.37x more
+         jserializer:     831705 allocated - 3.43x more
+                alba:    1072217 allocated - 4.42x more
+         alba_inline:    1084889 allocated - 4.48x more
+     fast_serializer:    1244385 allocated - 5.13x more
+               rails:    1272761 allocated - 5.25x more
+         blueprinter:    1680137 allocated - 6.93x more
+       representable:    2892425 allocated - 11.93x more
+                 ams:    4479569 allocated - 18.48x more
+          simple_ams:    6957913 allocated - 28.70x more
 ```
 
-Conclusion: panko is extremely fast but it's a C extension gem. As pure Ruby gems, Alba, turbostreamer and jserializer are notably faster than others. With `Oj.optimize_rails` jbuilder and Rails standard serialization are also fast.
+Conclusion: panko is extremely fast but it's a C extension gem. As pure Ruby gems, Alba, `turbostreamer` and `jserializer` are notably faster than others, but Alba is slightly slower than other two. With `Oj.optimize_rails`, `jbuilder` and Rails standard serialization are also fast.

data/docs/rails.md

@@ -14,11 +14,13 @@ You might want to add some configurations to initializer file such as `alba.rb`
 ```ruby
 # alba.rb
 Alba.backend = :active_support
-Alba.enable_inference!(with: :active_support)
+Alba.inflector = :active_support
 ```
 
 You can also use `:oj_rails` for backend if you prefer using Oj.
 
+Alba 2.2 introduced new Rails integration so that you don't have to add initializer file for setting inflector. You still need to add initializer file if you want to set backend or configure inflector with something different from `active_support`.
+
 ## Rendering JSON
 
 You can render JSON with Rails in two ways. One way is to pass JSON String.

data/lib/alba/association.rb

@@ -32,7 +32,7 @@ module Alba
     # @param params [Hash] user-given Hash for arbitrary data
     # @return [Hash]
     def to_h(target, within: nil, params: {})
-      params = params.merge(@params) unless @params.empty?
+      params = params.merge(@params)
       @object = target.__send__(@name)
       @object = @condition.call(object, params, target) if @condition
       return if @object.nil?

data/lib/alba/conditional_attribute.rb

@@ -20,7 +20,7 @@ module Alba
       return Alba::REMOVE_KEY unless condition_passes?(resource, object)
 
       fetched_attribute = yield(@body)
-      return fetched_attribute if !with_two_arity_proc_condition
+      return fetched_attribute unless with_two_arity_proc_condition
 
       return Alba::REMOVE_KEY unless resource.instance_exec(object, attribute_from_association_body_or(fetched_attribute), &@condition)
 

data/lib/alba/nested_attribute.rb

@@ -8,12 +8,14 @@ module Alba
       @block = block
     end
 
-    # @return [Hash]
-    def value(object)
+    # @param object [Object] the object being serialized
+    # @param params [Hash] params Hash inherited from Resource
+    # @return [Hash] hash serialized from running the class body in the object
+    def value(object:, params:)
       resource_class = Alba.resource_class
       resource_class.transform_keys(@key_transformation)
       resource_class.class_eval(&@block)
-      resource_class.new(object).serializable_hash
+      resource_class.new(object, params: params).serializable_hash
     end
   end
 end

data/lib/alba/resource.rb

@@ -17,15 +17,21 @@ module Alba
     WITHIN_DEFAULT = Object.new.freeze
     private_constant :WITHIN_DEFAULT
 
+    # `setup` method is meta-programmatically defined here for performance.
     # @private
-    def self.included(base)
+    def self.included(base) # rubocop:disable Metrics/MethodLength
       super
+      setup_method_body = 'private def _setup;'
       base.class_eval do
         # Initialize
         DSLS.each do |name, initial|
           instance_variable_set("@#{name}", initial.dup) unless instance_variable_defined?("@#{name}")
+          setup_method_body << "@#{name} = self.class.#{name};"
         end
+        base.define_method(:encode, Alba.encoder)
       end
+      setup_method_body << 'end'
+      base.class_eval(setup_method_body, __FILE__, __LINE__ + 1)
       base.include InstanceMethods
       base.extend ClassMethods
     end
@@ -41,7 +47,7 @@ module Alba
         @object = object
         @params = params
         @within = within
-        DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.__send__(name)) }
+        _setup
       end
 
       # Serialize object into JSON string
@@ -80,7 +86,8 @@ module Alba
       # @param meta [Hash] metadata for this seialization
       # @return [Hash]
       def as_json(root_key: nil, meta: {})
-        key = root_key.nil? ? fetch_key : root_key.to_s
+        key = root_key.nil? ? fetch_key : root_key
+        key = Alba.regularize_key(key)
         if key && !key.empty?
           h = {key => serializable_hash}
           hash_with_metadata(h, meta)
@@ -99,15 +106,9 @@ module Alba
 
       private
 
-      def encode(hash)
-        Alba.encoder.call(hash)
-      end
-
       def _to_json(root_key, meta, options)
         options.reject! { |k, _| %i[layout prefixes template status].include?(k) } # Rails specific guard
-        # TODO: use `filter_map` after dropping support of Ruby 2.6
-        names = options.map { |k, v| k unless v.nil? }
-        names.compact!
+        names = options.filter_map { |k, v| k unless v.nil? }
         unless names.empty?
           names.sort!
           names.map! { |s| "\"#{s}\"" }
@@ -134,7 +135,11 @@ module Alba
 
       def serializable_hash_for_collection
         if @_collection_key
-          @object.to_h { |item| [item.public_send(@_collection_key).to_s, converter.call(item)] }
+          @object.to_h do |item|
+            k = item.public_send(@_collection_key)
+            key = Alba.regularize_key(k)
+            [key, converter.call(item)]
+          end
         else
           @object.each_with_object([], &collection_converter)
         end
@@ -147,34 +152,26 @@ module Alba
       end
 
       def _key_for_collection
-        if Alba.inflector
-          @_key_for_collection == true ? resource_name(pluralized: true) : @_key_for_collection.to_s
-        else
-          @_key_for_collection == true ? raise_root_key_inference_error : @_key_for_collection.to_s
-        end
+        k = @_key_for_collection == true ? resource_name(pluralized: true) : @_key_for_collection
+        Alba.regularize_key(k)
       end
 
-      # @return [String]
       def _key
-        if Alba.inflector
-          @_key == true ? resource_name(pluralized: false) : @_key.to_s
-        else
-          @_key == true ? raise_root_key_inference_error : @_key.to_s
-        end
+        k = @_key == true ? resource_name(pluralized: false) : @_key
+        Alba.regularize_key(k)
       end
 
       def resource_name(pluralized: false)
-        class_name = self.class.name
         inflector = Alba.inflector
-        name = inflector.demodulize(class_name).delete_suffix('Resource')
+        raise Alba::Error, 'You must set inflector when setting root key as true.' unless inflector
+
+        class_name = self.class.name
+        suffix = class_name.end_with?('Resource') ? 'Resource' : 'Serializer'
+        name = inflector.demodulize(class_name).delete_suffix(suffix)
         underscore_name = inflector.underscore(name)
         pluralized ? inflector.pluralize(underscore_name) : underscore_name
       end
 
-      def raise_root_key_inference_error
-        raise Alba::Error, 'You must set inflector when setting root key as true.'
-      end
-
       def transforming_root_key?
         @_transforming_root_key
       end
@@ -237,14 +234,16 @@ module Alba
         end
       end
 
-      # @return [Symbol]
-      def transform_key(key) # rubocop:disable Metrics/CyclomaticComplexity
-        key = key.to_s
-        return key if @_transform_type == :none || key.empty? # We can skip transformation
+      def transform_key(key)
+        return Alba.regularize_key(key) if @_transform_type == :none || key.nil? || key.empty? # We can skip transformation
 
         inflector = Alba.inflector
         raise Alba::Error, 'Inflector is nil. You must set inflector before transforming keys.' unless inflector
 
+        Alba.regularize_key(_transform_key(inflector, key.to_s))
+      end
+
+      def _transform_key(inflector, key)
         case @_transform_type # rubocop:disable Style/MissingElse
         when :camel then inflector.camelize(key)
         when :lower_camel then inflector.camelize_lower(key)
@@ -258,7 +257,8 @@ module Alba
                 when Symbol then fetch_attribute_from_object_and_resource(obj, attribute)
                 when Proc then instance_exec(obj, &attribute)
                 when Alba::Association then yield_if_within(attribute.name.to_sym) { |within| attribute.to_h(obj, params: params, within: within) }
-                when TypedAttribute, NestedAttribute then attribute.value(obj)
+                when TypedAttribute then attribute.value(obj)
+                when NestedAttribute then attribute.value(object: obj, params: params)
                 when ConditionalAttribute then attribute.with_passing_condition(resource: self, object: obj) { |attr| fetch_attribute(obj, key, attr) }
                 else
                   raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
@@ -327,8 +327,9 @@ module Alba
 
       def assign_attributes(attrs, if_value)
         attrs.each do |attr_name|
-          attr = if_value ? ConditionalAttribute.new(body: attr_name.to_sym, condition: if_value) : attr_name.to_sym
-          @_attributes[attr_name.to_sym] = attr
+          attr_name = attr_name.to_sym
+          attr = if_value ? ConditionalAttribute.new(body: attr_name, condition: if_value) : attr_name
+          @_attributes[attr_name] = attr
         end
       end
       private :assign_attributes

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '2.2.0'.freeze
+  VERSION = '2.3.0'.freeze
 end

data/lib/alba.rb

@@ -44,13 +44,23 @@ module Alba
     # @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, root_key: nil, &block)
-      klass = block ? resource_class(&block) : infer_resource_class(object.class.name)
-
-      resource = klass.new(object)
+    def serialize(object = nil, root_key: nil, &block)
+      resource = resource_with(object, &block)
       resource.serialize(root_key: root_key)
     end
 
+    # Hashify the object with inline definitions
+    #
+    # @param object [Object] the object to be serialized
+    # @param root_key [Symbol, nil, true]
+    # @param block [Block] resource block
+    # @return [String] serialized JSON string
+    # @raise [ArgumentError] if block is absent or `with` argument's type is wrong
+    def hashify(object = nil, root_key: nil, &block)
+      resource = resource_with(object, &block)
+      resource.as_json(root_key: root_key)
+    end
+
     # Enable inference for key and resource name
     #
     # @param with [Symbol, Class, Module] inflector
@@ -107,16 +117,45 @@ module Alba
       const_parent.const_get("#{inflector.classify(name)}Resource")
     end
 
+    # Configure Alba to symbolize keys
+    def symbolize_keys!
+      @symbolize_keys = true
+    end
+
+    # Configure Alba to stringify (not symbolize) keys
+    def stringify_keys!
+      @symbolize_keys = false
+    end
+
+    # Regularize key to be either Symbol or String depending on @symbolize_keys
+    # Returns nil if key is nil
+    #
+    # @param key [String, Symbol, nil]
+    # @return [Symbol, String, nil]
+    def regularize_key(key)
+      return if key.nil?
+
+      @symbolize_keys ? key.to_sym : key.to_s
+    end
+
     # Reset config variables
     # Useful for test cleanup
     def reset!
       @encoder = default_encoder
+      @symbolize_keys = false
       @_on_error = :raise
       @_on_nil = nil
     end
 
     private
 
+    # This method could be part of public API, but for now it's private
+    def resource_with(object, &block)
+      klass = block ? resource_class(&block) : infer_resource_class(object.class.name)
+
+      klass.new(object)
+    end
+
     def inflector_from(name_or_module)
       case name_or_module
       when nil then nil
@@ -126,8 +165,7 @@ module Alba
       when :dry
         require 'dry/inflector'
         Dry::Inflector.new
-      else
-        validate_inflector(name_or_module)
+      else validate_inflector(name_or_module)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-17 00:00:00.000000000 Z
+date: 2023-04-24 00:00:00.000000000 Z
 dependencies: []
 description: Alba is the fastest JSON serializer for Ruby. It focuses on performance,
   flexibility and usability.
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Alba is the fastest JSON serializer for Ruby.