alba 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad9473eff6bbd8fb5f282d2ad7c9d84ad3f104b0a5e190999bd7788fcec2d8be
-  data.tar.gz: f778882ced7677d043694ba257df58bea4fb09fd108804fd4c0a28b7c722cc20
+  metadata.gz: 9013289126b33b20a7460d7c5092a3df8a39c7d79c7114d6f33e7111a2703a20
+  data.tar.gz: ae73ef30b48cdc1dfee93cd5c7cb55576ec0bd818d899c0fc2a041fbe09a90f7
 SHA512:
-  metadata.gz: 484f8725e3a71a7d7714f2d19e0c005c11fd995c33e59431bef48f1dac8336360fef3fdd7657f47984bded1753e366a85b4e8bd7101bd0e418c658a508788ccf
-  data.tar.gz: 0e7c53e58d3e9146b775b06d929b37e9860dba366114db7aca21e53628e78f946dd0ac13c7dc2788b0cc7fb10eb7211b9afc0c7ecf7c4bedd892786a07c04ea2
+  metadata.gz: ed86e0c309632cb9fe70752f5c7d5ddacbd529ea5c8b06ec802736e2fd745604470cf3163b43d287a6409529babf0d6c4d713c0d7b6035d4248ea33eec8e3a49
+  data.tar.gz: 93fc142fabd4a9358f279dccd0a85c8d0a22cabb8ff452d76ef221bb7ca929aa28bbd58a20bb29bc4a0bbe955e64a2616adf2f882728540e349eef3f82418906

data/CHANGELOG.md

@@ -6,6 +6,27 @@ 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

data/README.md

@@ -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')

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

@@ -8,12 +8,12 @@ module Alba
 
       ActiveSupport.on_load(:action_controller) do
         define_method(:serialize) do |obj, with: nil, root_key: nil, meta: {}, &block|
-          resource = with.nil? ? Alba.resource_with(obj, &block) : with.new(obj)
+          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, root_key: nil, meta: {}, &block|
-          json = with.nil? ? Alba.resource_with(obj, &block) : with.new(obj)
+          json = with.nil? ? Alba.resource_for(obj, &block) : with.new(obj)
           render json: json.to_json(root_key: root_key, meta: meta)
         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.5.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
@@ -162,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
@@ -218,19 +223,45 @@ module Alba
       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
@@ -283,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)
@@ -329,7 +352,3 @@ module Alba
 
   reset!
 end
-
-# Monkey patch for TruffleRuby
-# Delete this after 24.1.2 is released
-File::SHARE_DELETE = 0 if defined?(Truffle)

metadata

@@ -1,28 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - OKURA Masafumi
 bindir: exe
 cert_chain: []
-date: 2025-01-01 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
+date: 2025-04-01 00:00:00.000000000 Z
+dependencies: []
 description: Alba is the fastest JSON serializer for Ruby. It focuses on performance,
   flexibility and usability.
 email:
@@ -31,40 +17,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".codeclimate.yml"
-- ".editorconfig"
-- ".github/ISSUE_TEMPLATE/bug_report.md"
-- ".github/ISSUE_TEMPLATE/feature_request.md"
-- ".github/dependabot.yml"
-- ".github/workflows/codeql-analysis.yml"
-- ".github/workflows/lint.yml"
-- ".github/workflows/main.yml"
-- ".gitignore"
-- ".rubocop.yml"
-- ".yardopts"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- CONTRIBUTING.md
-- Gemfile
-- HACKING.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- SECURITY.md
-- alba.gemspec
-- benchmark/Gemfile
-- benchmark/README.md
-- benchmark/collection.rb
-- benchmark/prep.rb
-- benchmark/single_resource.rb
-- bin/console
-- bin/setup
-- codecov.yml
-- docs/migrate_from_active_model_serializers.md
-- docs/migrate_from_jbuilder.md
-- docs/rails.md
-- gemfiles/without_active_support.gemfile
-- gemfiles/without_oj.gemfile
 - lib/alba.rb
 - lib/alba/association.rb
 - lib/alba/conditional_attribute.rb
@@ -79,9 +34,6 @@ files:
 - lib/alba/type.rb
 - lib/alba/typed_attribute.rb
 - lib/alba/version.rb
-- logo/alba-card.png
-- logo/alba-sign.png
-- logo/alba-typography.png
 homepage: https://github.com/okuramasafumi/alba
 licenses:
 - MIT
@@ -105,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Alba is the fastest JSON serializer for Ruby.
 test_files: []

data/.codeclimate.yml

@@ -1,12 +0,0 @@
-version: "2"         # required to adjust maintainability checks
-
-checks:
-  method-complexity:
-    enabled: true
-    config:
-      threshold: 7
-
-exclude_patterns:
-  - "benchmark/**/*"
-  - "script/**/*"
-  - "test/**/*"