alba 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1a7b2fac43a1ae40bc0598d6f989fb7b81108d00ca929d31327113590880b2f
-  data.tar.gz: d6bc3c22c9178eeaf8b3b7f3d3d92bc526edd18904fa736c0c25488250f89d02
+  metadata.gz: 9013289126b33b20a7460d7c5092a3df8a39c7d79c7114d6f33e7111a2703a20
+  data.tar.gz: ae73ef30b48cdc1dfee93cd5c7cb55576ec0bd818d899c0fc2a041fbe09a90f7
 SHA512:
-  metadata.gz: da62c8a7d30ab7c4c39032950c9e02cef238b8662f403843351116fb86e3a3010e2780a3b5efe958697fd698e7e703a130a292129f3efad4da253cc9e84570bd
-  data.tar.gz: 94a580ab65397d4f61a8534bfd22999d86bdd9e6cca0ec83b15d03bd2fdbdedc220bbbaf091b20c34e58c7dfe5c7b21c9f046a78b25639dcecf59b71b95199c0
+  metadata.gz: ed86e0c309632cb9fe70752f5c7d5ddacbd529ea5c8b06ec802736e2fd745604470cf3163b43d287a6409529babf0d6c4d713c0d7b6035d4248ea33eec8e3a49
+  data.tar.gz: 93fc142fabd4a9358f279dccd0a85c8d0a22cabb8ff452d76ef221bb7ca929aa28bbd58a20bb29bc4a0bbe955e64a2616adf2f882728540e349eef3f82418906

data/CHANGELOG.md

@@ -6,6 +6,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.0] 2025-03-11
+
+### Added
+
+- Add serializer keyword argument as an alias for resource [#408](https://github.com/okuramasafumi/alba/pull/408)
+- `Alba.resource_for` as a replacement to `resource_with`
+- Hash serialization [#427](https://github.com/okuramasafumi/alba/pull/427)
+
+### Changed
+
+- Performance improvements [#421](https://github.com/okuramasafumi/alba/pull/421) and [#423](https://github.com/okuramasafumi/alba/pull/423)
+
+### Fixed
+
+- Range is not a collection [#417](https://github.com/okuramasafumi/alba/issues/417)
+
+### Deprecated
+
+- `Alba.resource_with` is deprecated in favor of `Alba.resource_for`
+- Overriding `Alba::Resource#attributes` is now deprecated in favor of `Alba::Resource#select`
+
+## [3.5.0] 2025-01-01
+
+### Added
+
+-  `render_serialized_json` now works with `root_key` and `meta` [#398](https://github.com/okuramasafumi/alba/pull/398)
+
+### Improved
+
+- Add transform_keys caching [#402](https://github.com/okuramasafumi/alba/pull/402)
+
 ## [3.4.0] 2024-12-01
 
 ### Added

data/README.md

@@ -686,7 +686,7 @@ Alba.serialize(something)
 # => Same as `FooResource.new(something).serialize` when `something` is an instance of `Foo`.
 ```
 
-Although this might be useful sometimes, it's generally recommended to define a class for Resource.
+Although this might be useful sometimes, it's generally recommended to define a class for Resource. Defining a class is often more readable and more maintainable, and inline definitions cannot levarage the benefit of YJIT (it's the slowest with the benchmark YJIT enabled).
 
 #### Inline definition for multiple root keys
 
@@ -836,48 +836,11 @@ In this example we add `baz` attribute and change `root_key`. This way, you can
 
 ### Filtering attributes
 
-Filtering attributes can be done in two ways - with `attributes` and `select`. They have different semantics and usage.
-
-`select` is a new and more intuitive API, so generally it's recommended to use `select`.
-
-#### Filtering attributes with `attributes`
-
-You can filter out certain attributes by overriding `attributes` instance method. This is useful when you want to customize existing resource with inheritance.
-
-You can access raw attributes via `super` call. It returns a Hash whose keys are the name of the attribute and whose values are the body. Usually you need only keys to filter out, like below.
-
-```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 RestrictedFooResource < GenericFooResource
-  def attributes
-    super.select { |key, _| key.to_sym == :name }
-  end
-end
-
-foo = Foo.new(1, 'my foo', 'body')
-
-RestrictedFooResource.new(foo).serialize
-# => '{"name":"my foo"}'
-```
+To filter attributes, you can use `select` instance method. Using `attributes` instance method is deprecated and will be removed in the future.
 
 #### Filtering attributes with `select`
 
-When you want to filter attributes based on more complex logic, you can use `select` instance method. `select` takes two parameters, the name of an attribute and the value of an attribute. If it returns false that attribute is rejected.
+`select` takes two or three parameters, the name of an attribute, the value of an attribute and the attribute object (`Alba::Association`, for example). If it returns false that attribute is rejected.
 
 ```ruby
 class Foo
@@ -900,6 +863,9 @@ class RestrictedFooResource < GenericFooResource
   def select(_key, value)
     !value.nil?
   end
+
+  # This is also possible
+  # def select(_key, _value, _attribute)
 end
 
 foo = Foo.new(1, nil, 'body')
@@ -1156,7 +1122,7 @@ end
 class UserResource
   include Alba::Resource
 
-  root_key!
+  root_key! # This is required to add inferred root key, otherwise it has no root key
 
   attributes :id
 

data/lib/alba/association.rb

@@ -32,6 +32,9 @@ module Alba
     end
 
     # This is the same API in `NestedAttribute`
+    #
+    # @param type [String, Symbol] one of `snake`, `:camel`, `:lower_camel`, `:dash` and `none`
+    # @return [void]
     def key_transformation=(type)
       @resource.transform_keys(type) unless @resource.is_a?(Proc)
     end
@@ -44,7 +47,7 @@ module Alba
     # @return [Hash]
     def to_h(target, within: nil, params: {})
       params = params.merge(@params)
-      object = target.__send__(@name)
+      object = target.is_a?(Hash) ? target.fetch(@name) : target.__send__(@name)
       object = @condition.call(object, params, target) if @condition
       return if object.nil?
 

data/lib/alba/conditional_attribute.rb

@@ -2,13 +2,12 @@
 
 require_relative 'association'
 require_relative 'constants'
-require 'ostruct'
 
 module Alba
   # Represents attribute with `if` option
   # @api private
   class ConditionalAttribute
-    # @param body [Symbol, Proc, Alba::Association, Alba::TypedAttribute] real attribute wrapped with condition
+    # @param body [Symbol, Proc, Alba::Association, Alba::TypedAttribute, Alba::NestedAttribute] real attribute wrapped with condition
     # @param condition [Symbol, Proc] condition to check
     def initialize(body:, condition:)
       @body = body
@@ -26,7 +25,7 @@ module Alba
       fetched_attribute = yield(@body)
       return fetched_attribute unless with_two_arity_proc_condition
 
-      return Alba::REMOVE_KEY unless resource.instance_exec(object, objectize(fetched_attribute), &@condition)
+      return Alba::REMOVE_KEY unless resource.instance_exec(object, second_object(object), &@condition)
 
       fetched_attribute
     end
@@ -51,17 +50,15 @@ module Alba
       @condition.is_a?(Proc) && @condition.arity >= 2
     end
 
-    # OpenStruct is used as a simple solution for converting Hash or Array of Hash into an object
-    # Using OpenStruct is not good in general, but in this case there's no other solution
-    def objectize(fetched_attribute)
-      return fetched_attribute unless @body.is_a?(Alba::Association)
-
-      if fetched_attribute.is_a?(Array)
-        fetched_attribute.map do |hash|
-          OpenStruct.new(hash)
-        end
-      else
-        OpenStruct.new(fetched_attribute)
+    def second_object(object)
+      case @body
+      when Symbol, Alba::Association, Alba::TypedAttribute
+        object.__send__(@body.name)
+      when Alba::NestedAttribute
+        nil
+      when Proc
+        @body.call(object)
+      else raise Alba::Error, "Unreachable code, @body is: #{@body.inspect}"
       end
     end
   end

data/lib/alba/layout.rb

@@ -15,13 +15,9 @@ module Alba
     # @param inline [Proc] a proc returning JSON string or a Hash representing JSON
     def initialize(file:, inline:)
       @body = if file
-                raise ArgumentError, 'File layout must be a String representing filename' unless file.is_a?(String)
-
-                file
+                check_and_return(file, 'File layout must be a String representing filename', String)
               elsif inline
-                raise ArgumentError, 'Inline layout must be a Proc returning a Hash or a String' unless inline.is_a?(Proc)
-
-                inline
+                check_and_return(inline, 'Inline layout must be a Proc returning a Hash or a String', Proc)
               else
                 raise ArgumentError, 'Layout must be either String or Proc'
               end
@@ -47,6 +43,12 @@ module Alba
 
     attr_reader :serialized_json
 
+    def check_and_return(obj, message, klass)
+      raise ArgumentError, message unless obj.is_a?(klass)
+
+      obj
+    end
+
     def serialize_within_string_layout(bnd)
       ERB.new(File.read(@body)).result(bnd)
     end

data/lib/alba/railtie.rb

@@ -7,13 +7,14 @@ module Alba
       Alba.inflector = :active_support
 
       ActiveSupport.on_load(:action_controller) do
-        define_method(:serialize) do |obj, with: nil, &block|
-          with.nil? ? Alba.resource_with(obj, &block) : with.new(obj)
+        define_method(:serialize) do |obj, with: nil, root_key: nil, meta: {}, &block|
+          resource = with.nil? ? Alba.resource_for(obj, &block) : with.new(obj)
+          resource.to_json(root_key: root_key, meta: meta)
         end
 
-        define_method(:render_serialized_json) do |obj, with: nil, &block|
-          json = with.nil? ? Alba.resource_with(obj, &block) : with.new(obj)
-          render json: json
+        define_method(:render_serialized_json) do |obj, with: nil, root_key: nil, meta: {}, &block|
+          json = with.nil? ? Alba.resource_for(obj, &block) : with.new(obj)
+          render json: json.to_json(root_key: root_key, meta: meta)
         end
       end
     end

data/lib/alba/resource.rb

@@ -14,14 +14,14 @@ module Alba
   module Resource
     # @!parse include InstanceMethods
     # @!parse extend ClassMethods
-    INTERNAL_VARIABLES = {_attributes: {}, _key: nil, _key_for_collection: nil, _meta: nil, _transform_type: :none, _transforming_root_key: false, _key_transformation_cascade: true, _on_error: nil, _on_nil: nil, _layout: nil, _collection_key: nil, _helper: nil, _resource_methods: []}.freeze # rubocop:disable Layout/LineLength
+    INTERNAL_VARIABLES = {_attributes: {}, _key: nil, _key_for_collection: nil, _meta: nil, _transform_type: :none, _transforming_root_key: false, _key_transformation_cascade: true, _on_error: nil, _on_nil: nil, _layout: nil, _collection_key: nil, _helper: nil, _resource_methods: [], _select_arity: nil}.freeze # rubocop:disable Layout/LineLength
     private_constant :INTERNAL_VARIABLES
 
     WITHIN_DEFAULT = Object.new.freeze
     private_constant :WITHIN_DEFAULT
 
     # `setup` method is meta-programmatically defined here for performance.
-    # @private
+    # @api private
     def self.included(base) # rubocop:disable Metrics/MethodLength
       super
       base.class_eval do
@@ -68,7 +68,8 @@ module Alba
       # @see #serialize
       # @see https://github.com/rails/rails/blob/7-0-stable/actionpack/lib/action_controller/metal/renderers.rb#L156
       def to_json(options = {}, root_key: nil, meta: {})
-        confusing_options = options.keys.select { |k| k.to_sym == :only || k.to_sym == :except }
+        confusing_keys = [:only, :except]
+        confusing_options = options.keys.select { |k| confusing_keys.include?(k.to_sym) }
         unless confusing_options.empty?
           confusing_options.sort!
           confusing_options.map! { |s| "\"#{s}\"" }
@@ -99,12 +100,16 @@ module Alba
       #
       # @return [Hash]
       def serializable_hash
-        Alba.collection?(@object) ? serializable_hash_for_collection : converter.call(@object)
+        Alba.collection?(@object) ? serializable_hash_for_collection : attributes_to_hash(@object, {})
       end
       alias to_h serializable_hash
 
       private
 
+      def deprecated_serializable_hash
+        Alba.collection?(@object) ? serializable_hash_for_collection : converter.call(@object)
+      end
+
       def serialize_with(hash)
         serialized_json = encode(hash)
         return serialized_json unless @_layout
@@ -130,6 +135,18 @@ module Alba
       end
 
       def serializable_hash_for_collection
+        if @_collection_key
+          @object.to_h do |item|
+            k = item.public_send(@_collection_key)
+            key = Alba.regularize_key(k)
+            [key, attributes_to_hash(item, {})]
+          end
+        else
+          @object.map { |obj| attributes_to_hash(obj, {}) }
+        end
+      end
+
+      def deprecated_serializable_hash_for_collection
         if @_collection_key
           @object.to_h do |item|
             k = item.public_send(@_collection_key)
@@ -200,22 +217,30 @@ module Alba
 
       # This is default behavior for getting attributes for serialization
       # Override this method to filter certain attributes
+      #
+      # @deprecated in favor of `select`
       def attributes
         @_attributes
       end
 
       # Default implementation for selecting attributes
       # Override this method to filter attributes based on key and value
-      def select(_key, _value)
+      def select(_key, _value, _attribute)
         true
       end
 
       def set_key_and_attribute_body_from(obj, key, attribute, hash)
         key = transform_key(key)
         value = fetch_attribute(obj, key, attribute)
-        return unless select(key, value)
+        # When `select` is not overridden, skip calling it for better performance
+        unless @_select_arity.nil?
+          # `select` can be overridden with both 2 and 3 parameters
+          # Here we check the arity and build arguments accordingly
+          args = @_select_arity == 3 ? [key, value, attribute] : [key, value]
+          return unless select(*args)
+        end
 
-        hash[key] = value unless value == Alba::REMOVE_KEY
+        hash[key] = value unless Alba::REMOVE_KEY == value # rubocop:disable Style/YodaCondition
       end
 
       def handle_error(error, obj, key, attribute, hash)
@@ -259,12 +284,16 @@ module Alba
       end
 
       def _fetch_attribute_from_object_first(obj, attribute)
+        return obj.fetch(attribute) if obj.is_a?(Hash)
+
         obj.__send__(attribute)
       rescue NoMethodError
         __send__(attribute, obj)
       end
 
       def _fetch_attribute_from_resource_first(obj, attribute)
+        return obj.fetch(attribute) if obj.is_a?(Hash)
+
         if @_resource_methods.include?(attribute)
           __send__(attribute, obj)
         else
@@ -299,12 +328,27 @@ module Alba
       attr_reader(*INTERNAL_VARIABLES.keys)
 
       # This `method_added` is used for defining "resource methods"
-      def method_added(method_name)
-        _resource_methods << method_name.to_sym unless method_name.to_sym == :_setup
+      def method_added(method_name) # rubocop:disable Metrics/MethodLength
+        case method_name
+        when :collection_converter, :converter
+          warn "Defining ##{method_name} methods is deprecated", category: :deprecated, uplevel: 1
+          alias_method :serializable_hash_for_collection, :deprecated_serializable_hash_for_collection
+          private(:serializable_hash_for_collection)
+          alias_method :serializable_hash, :deprecated_serializable_hash
+          alias_method :to_h, :deprecated_serializable_hash
+        when :attributes
+          warn 'Overriding `attributes` is deprecated, use `select` instead.', category: :deprecated, uplevel: 1
+        when :select
+          @_select_arity = instance_method(:select).arity
+        when :_setup # noop
+        else
+          _resource_methods << method_name.to_sym
+        end
+
         super
       end
 
-      # @private
+      # @api private
       def inherited(subclass)
         super
         INTERNAL_VARIABLES.each_key { |name| subclass.instance_variable_set(:"@#{name}", instance_variable_get(:"@#{name}").clone) }
@@ -316,7 +360,7 @@ module Alba
       #
       # @param attrs [Array<String, Symbol>]
       # @param if [Proc] condition to decide if it should serialize these attributes
-      # @param attrs_with_types [Hash<[Symbol, String], [Array<Symbol, Proc>, Symbol]>]
+      # @param attrs_with_types [Hash{Symbol, String => Array<Symbol, Proc>, Symbol}]
       #   attributes with name in its key and type and optional type converter in its value
       # @return [void]
       def attributes(*attrs, if: nil, **attrs_with_types)
@@ -364,6 +408,7 @@ module Alba
       # @param name [String, Symbol] name of the association, used as key when `key` param doesn't exist
       # @param condition [Proc, nil] a Proc to modify the association
       # @param resource [Class<Alba::Resource>, String, Proc, nil] representing resource for this association
+      # @param serializer [Class<Alba::Resource>, String, Proc, nil] alias for `resource`
       # @param key [String, Symbol, nil] used as key when given
       # @param params [Hash] params override for the association
       # @param options [Hash<Symbol, Proc>]
@@ -371,7 +416,8 @@ module Alba
       # @param block [Block]
       # @return [void]
       # @see Alba::Association#initialize
-      def association(name, condition = nil, resource: nil, key: nil, params: {}, **options, &block)
+      def association(name, condition = nil, resource: nil, serializer: nil, key: nil, params: {}, **options, &block)
+        resource ||= serializer
         transformation = @_key_transformation_cascade ? @_transform_type : :none
         assoc = Association.new(
           name: name, condition: condition, resource: resource, params: params, nesting: nesting, key_transformation: transformation, helper: @_helper, &block
@@ -477,9 +523,7 @@ module Alba
           if @_key_transformation_cascade
             # We need to update key transformation of associations and nested attributes
             @_attributes.each_value do |attr|
-              next unless attr.is_a?(Association) || attr.is_a?(NestedAttribute)
-
-              attr.key_transformation = type
+              attr.key_transformation = type if attr.is_a?(Association) || attr.is_a?(NestedAttribute)
             end
           end
           self # Return the new class

data/lib/alba/typed_attribute.rb

@@ -4,6 +4,8 @@ module Alba
   # Representing typed attributes to encapsulate logic about types
   # @api private
   class TypedAttribute
+    attr_reader :name
+
     # @param name [Symbol, String]
     # @param type [Symbol, Class]
     # @param converter [Proc]

data/lib/alba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Alba
-  VERSION = '3.4.0'
+  VERSION = '3.6.0'
 end

data/lib/alba.rb

@@ -46,13 +46,15 @@ module Alba
     # @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
+    # @raise [ArgumentError] if both object and block are not given
     def serialize(object = nil, with: :inference, root_key: nil, &block)
+      raise ArgumentError, 'Either object or block must be given' if object.nil? && block.nil?
+
       if collection?(object)
-        h = hashify_collection(object, with, &block)
+        h = hashify_collection(object, with, root_key, &block)
         Alba.encoder.call(h)
       else
-        resource = resource_with(object, &block)
+        resource = resource_for(object, &block)
         resource.serialize(root_key: root_key)
       end
     end
@@ -64,22 +66,24 @@ module Alba
     # @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
+    # @raise [ArgumentError] if both object and block are not given
     def hashify(object = nil, with: :inference, root_key: nil, &block)
+      raise ArgumentError, 'Either object or block must be given' if object.nil? && block.nil?
+
       if collection?(object)
-        hashify_collection(object, with, &block)
+        hashify_collection(object, with, root_key, &block)
       else
-        resource = resource_with(object, &block)
+        resource = resource_for(object, &block)
         resource.as_json(root_key: root_key)
       end
     end
 
     # Detect if object is a collection or not.
-    # When object is a Struct, it's Enumerable but not a collection
+    # When object is a Struct or a Range, it's Enumerable but not a collection
     #
     # @api private
     def collection?(object)
-      object.is_a?(Enumerable) && !object.is_a?(Struct)
+      object.is_a?(Enumerable) && !object.is_a?(Struct) && !object.is_a?(Range) && !object.is_a?(Hash)
     end
 
     # Enable inference for key and resource name
@@ -117,6 +121,7 @@ module Alba
     #   When it's a Class or a Module, it should have some methods, see {Alba::DefaultInflector}
     def inflector=(inflector)
       @inflector = inflector_from(inflector)
+      reset_transform_keys
     end
 
     # @param block [Block] resource body
@@ -144,11 +149,13 @@ module Alba
 
     # Configure Alba to symbolize keys
     def symbolize_keys!
+      reset_transform_keys unless @symbolize_keys
       @symbolize_keys = true
     end
 
     # Configure Alba to stringify (not symbolize) keys
     def stringify_keys!
+      reset_transform_keys if @symbolize_keys
       @symbolize_keys = false
     end
 
@@ -159,8 +166,9 @@ module Alba
     # @return [Symbol, String, nil]
     def regularize_key(key)
       return if key.nil?
+      return key.to_sym if @symbolize_keys
 
-      @symbolize_keys ? key.to_sym : key.to_s
+      key.is_a?(Symbol) ? key.name : key.to_s
     end
 
     # Transform a key with given transform_type
@@ -168,19 +176,22 @@ module Alba
     # @param key [String] a target key
     # @param transform_type [Symbol] a transform type, either one of `camel`, `lower_camel`, `dash` or `snake`
     # @return [String]
-    def transform_key(key, transform_type:)
+    def transform_key(key, transform_type:) # rubocop:disable Metrics/MethodLength
       raise Alba::Error, 'Inflector is nil. You must set inflector before transforming keys.' unless inflector
 
-      key = key.to_s
+      @_transformed_keys[transform_type][key] ||= begin
+        key = key.to_s
 
-      k = case transform_type
-          when :camel then inflector.camelize(key)
-          when :lower_camel then inflector.camelize_lower(key)
-          when :dash then inflector.dasherize(key)
-          when :snake then inflector.underscore(key)
-          else raise Alba::Error, "Unknown transform type: #{transform_type}"
-          end
-      regularize_key(k)
+        k = case transform_type
+            when :camel then inflector.camelize(key)
+            when :lower_camel then inflector.camelize_lower(key)
+            when :dash then inflector.dasherize(key)
+            when :snake then inflector.underscore(key)
+            else raise Alba::Error, "Unknown transform type: #{transform_type}"
+            end
+
+        regularize_key(k)
+      end
     end
 
     # Register types, used for both builtin and custom types
@@ -208,22 +219,49 @@ module Alba
       @_on_error = :raise
       @_on_nil = nil
       @types = {}
+      reset_transform_keys
       register_default_types
     end
 
+    # @deprecated Use resource_for instead
+    def resource_with(object, with: :inference, &block)
+      Kernel.warn('Alba.resource_with is deprecated. Use `Alba.resource_for` instead.')
+      _resource_for(object, with: with, &block)
+    end
+
     # Get a resource object from arguments
     # If block is given, it creates a resource class with the block
-    # Otherwise, it infers resource class from the object's class name
+    # Otherwise, it behaves depending on `with` argument
     #
-    # @ param object [Object] the object whose class name is used for inferring resource class
-    def resource_with(object, &block)
-      klass = block ? resource_class(&block) : infer_resource_class(object.class.name)
-
-      klass.new(object)
+    # @param object [Object] the object whose class name is used for inferring resource class
+    # @param with [:inference, Proc, Class<Alba::Resource>] determines how to get resource class for `object`
+    #   When it's `:inference`, it infers resource class from `object`'s class name
+    #   When it's a Proc, it calls the Proc with `object` as an argument
+    #   When it's a Class, it uses the Class as a resource class
+    #   Otherwise, it raises an ArgumentError
+    # @return [Alba::Resource] resource class with `object` as its target object
+    # @raise [ArgumentError] if `with` argument is not one of `:inference`, Proc or Class
+    def resource_for(object, with: :inference, &block)
+      _resource_for(object, with: with, &block)
     end
 
     private
 
+    def _resource_for(object, with: :inference, &block) # rubocop:disable Metrics/MethodLength
+      klass = if block
+                resource_class(&block)
+              else
+                case with
+                when :inference then infer_resource_class(object.class.name)
+                when Class then with
+                when Proc then with.call(object)
+                else raise ArgumentError, '`with` argument must be either :inference, Proc or Class'
+                end
+              end
+
+      klass.new(object)
+    end
+
     def inflector_from(name_or_module)
       case name_or_module
       when nil then nil
@@ -276,22 +314,14 @@ module Alba
       end
     end
 
-    def hashify_collection(collection, with, &block) # rubocop:disable Metrics/MethodLength
-      collection.map do |obj|
-        resource = if block
-                     resource_class(&block)
-                   else
-                     case with
-                     when Class then with
-                     when :inference then infer_resource_class(obj.class.name)
-                     when Proc then with.call(obj)
-                     else raise ArgumentError, '`with` argument must be either :inference, Proc or Class'
-                     end
-                   end
+    def hashify_collection(collection, with, root_key, &block)
+      array = collection.map do |obj|
+        resource = resource_for(obj, with: with, &block)
         raise Alba::Error if resource.nil?
 
-        resource.new(obj).to_h
+        resource.to_h
       end
+      root_key ? {root_key => array} : array
     end
 
     def validate_inflector(inflector)
@@ -302,6 +332,10 @@ module Alba
       inflector
     end
 
+    def reset_transform_keys
+      @_transformed_keys = Hash.new { |h, k| h[k] = {} }
+    end
+
     def register_default_types # rubocop:disable Metrics/AbcSize
       [String, :String].each do |t|
         register_type(t, check: ->(obj) { obj.is_a?(String) }, converter: lambda(&:to_s))