alba 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec3b28fdf4ed9303e346f6dca7771480d8b9bba19dea65374b41a526e895c10
-  data.tar.gz: 1ca8398f44a505fbdfc7bc5df7b743de07e4dc6bcd7580bdff3dec0732278474
+  metadata.gz: 5d12f771fcf00170b05fe313ce064b0215f134d75a14d1238d0766e3964d562f
+  data.tar.gz: b9c77e2574d7b502fc450140483eef2d66eeb3cb7e1a6c6497bb2b29d173d095
 SHA512:
-  metadata.gz: 0dd664193cc78874ac9e5e2630eaf201d172ce170137084041b65e8e683d95f435c4609df296b2f8b47b588219576e9e743473d83c0f7854a9e6ec6a25c0cce0
-  data.tar.gz: 3fc3dc98d059878f5f97e40c81999f0990ee96bb82848acc63cc5c0b49c4240bed2c1b17a077ac46d16754c1e603c6839617e1afa1e1185371885bdc9589955b
+  metadata.gz: 6ed47193f8bb3ff7395b51ca990fc438665f40fad85eefdc4cfbe7e53a7c783c9b34456d2c931f967e0767cae63a737f807f1a47abf14f2d5ef4e14d6b8f249a
+  data.tar.gz: d2231e2244a99fd960b778df059813ee99b64e8ff8d83e13dcebeb15da655e2c5b5127f28ee2f4efcb5e294816424bfc32f3021695c03b791e9d30caffc3e42d

data/CHANGELOG.md

@@ -6,6 +6,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## 4.0.1 2026-10-17
+
+### Added
+
+- Ship the RBS signatures in the gem so applications can load them [#575](https://github.com/okuramasafumi/alba/pull/575)
+
+### Changed
+
+- Improve RBS signatures for resource classes, serialization results, callbacks, inflectors, and custom types [#576](https://github.com/okuramasafumi/alba/pull/576)
+- Correct RBS signatures to allow anonymous resource classes to have no name [#579](https://github.com/okuramasafumi/alba/pull/579)
+- Rename the `Alba::Association.new` keyword argument `condition:` to `modifier:` to clarify its purpose
+
+### Fixed
+
+- Raise `TypeError` instead of `NoMethodError` when automatic type conversion is enabled without a converter
+- Raise `Alba::Error` instead of `NoMethodError` when `root_key!` is used on an anonymous resource class [#580](https://github.com/okuramasafumi/alba/pull/580)
+
 ## 4.0.0 2026-08-28
 
 ### Changed

data/lib/alba/association.rb

@@ -13,7 +13,7 @@ module Alba
     attr_reader :name
 
     # @param name [Symbol, String] name of the method to fetch association
-    # @param condition [Proc, nil] a proc filtering data
+    # @param modifier [Proc, nil] a Proc to modify the association
     # @param resource [Class<Alba::Resource>, Proc, String, Symbol, nil]
     #   a resource class for the association, a proc returning a resource class or a name of the resource
     # @param source [Proc, nil] a proc to specify the source of the association
@@ -25,7 +25,7 @@ module Alba
     # @param block [Block] used to define resource when resource arg is absent
     def initialize(
       name:,
-      condition: nil,
+      modifier: nil,
       resource: nil,
       source: nil,
       with_traits: nil,
@@ -36,14 +36,11 @@ module Alba
       &block
     )
       @name = name
-      @condition = condition
-      @resource = resource
+      @modifier = modifier
+      @resource = resource || resource_from(nesting, key_transformation, block, helper)
       @source = source
       @with_traits = with_traits
       @params = params
-      return if @resource
-
-      assign_resource(nesting, key_transformation, block, helper)
     end
 
     # This is the same API in `NestedAttribute`
@@ -82,7 +79,7 @@ module Alba
           else
             target.is_a?(Hash) ? target.fetch(@name) : target.__send__(@name)
           end
-      o = @condition.call(o, params, target) if @condition
+      o = @modifier.call(o, params, target) if @modifier
       o
     end
 
@@ -99,14 +96,14 @@ module Alba
       end
     end
 
-    def assign_resource(nesting, key_transformation, block, helper)
-      @resource = if block
-                    Alba.resource_class(helper: helper, key_transformation: key_transformation, &block)
-                  elsif Alba.inflector
-                    Alba.infer_resource_class(@name, nesting: nesting)
-                  else
-                    raise ArgumentError, 'When Alba.inflector is nil, either resource or block is required'
-                  end
+    def resource_from(nesting, key_transformation, block, helper)
+      if block
+        Alba.resource_class(helper: helper, key_transformation: key_transformation, &block)
+      elsif Alba.inflector
+        Alba.infer_resource_class(@name, nesting: nesting)
+      else
+        raise ArgumentError, 'When Alba.inflector is nil, either resource or block is required'
+      end
     end
 
     def to_h_with_each_resource(object, within, params)

data/lib/alba/resource.rb

@@ -182,6 +182,8 @@ module Alba
         raise Alba::Error, 'You must set inflector when setting root key as true.' unless inflector
 
         class_name = self.class.name
+        raise Alba::Error, 'An anonymous resource class has no name to derive a root key from. Set the key explicitly.' unless class_name
+
         suffix = class_name.end_with?('Resource') ? 'Resource' : 'Serializer'
         name = inflector.demodulize(class_name).delete_suffix(suffix)
         underscore_name = inflector.underscore(name)
@@ -258,7 +260,7 @@ module Alba
                 else raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
                   # :nocov:
                 end
-        nil_handler && value.nil? ? instance_exec(obj, key, attribute, &nil_handler) : value
+        nil_handler && value.nil? ? instance_exec(obj, key, attribute, &nil_handler) : value # steep:ignore
       end
 
       def fetch_attribute_from_object_and_resource(obj, attribute)
@@ -388,7 +390,7 @@ module Alba
       # Set association
       #
       # @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 modifier [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 source [Proc, nil] a Proc to customize the association source
@@ -402,11 +404,11 @@ module Alba
       # @param block [Block]
       # @return [void]
       # @see Alba::Association#initialize
-      def association(name, condition = nil, resource: nil, serializer: nil, source: nil, key: nil, with_traits: nil, params: EMPTY_HASH, **options, &block)
+      def association(name, modifier = nil, resource: nil, serializer: nil, source: nil, key: nil, with_traits: nil, params: EMPTY_HASH, **options, &block)
         resource ||= serializer
         transformation = @_key_transformation_cascade ? @_transform_type : :none
         assoc = Association.new(
-          name: name, condition: condition, resource: resource, source: source, with_traits: with_traits,
+          name: name, modifier: modifier, resource: resource, source: source, with_traits: with_traits,
           params: params, nesting: nesting, key_transformation: transformation, helper: @_helper,
           &block
         )
@@ -418,11 +420,10 @@ module Alba
       alias has_many association
 
       def nesting
-        if name.nil?
-          nil
-        else
-          name.rpartition('::').first.then { |n| n.empty? ? nil : n }
-        end
+        class_name = name
+        return if class_name.nil?
+
+        class_name.rpartition('::').first.then { |n| n.empty? ? nil : n }
       end
       private :nesting
 
@@ -546,7 +547,7 @@ module Alba
       end
 
       # Set error handler
-      # If this is set it's used as a error handler overriding global one
+      # Defaults to raising errors when no handler is set.
       #
       # @param handler [Symbol] `:raise`, `:ignore` or `:nullify`
       # @param block [Block]

data/lib/alba/type.rb

@@ -32,7 +32,7 @@ module Alba
     #
     # @param obj [Object] object to convert
     def convert(obj)
-      @auto_convert ? @converter.call(obj) : raise(TypeError)
+      @auto_convert && @converter ? @converter.call(obj) : raise(TypeError) # steep:ignore
     end
 
     # Enable auto convert with given converter

data/lib/alba/version.rb

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

data/lib/alba.rb

@@ -112,7 +112,7 @@ module Alba
     # @param block [Block] resource body
     # @return [Class<Alba::Resource>] resource class
     def resource_class(helper: nil, key_transformation: :none, &block)
-      klass = Class.new(resolved_default_superclass)
+      klass = Class.new(resolved_default_superclass) # : Class & Alba::resource_class
       klass.include(Alba::Resource)
       klass.helper(helper) if helper
       klass.transform_keys(key_transformation)
@@ -120,11 +120,11 @@ module Alba
       klass
     end
 
-    # @param name [String] a String Alba infers resource name with
+    # @param name [String, Symbol] a name Alba infers resource name with
     # @param nesting [String, nil] namespace Alba tries to find resource class in
     # @return [Class<Alba::Resource>] resource class
     def infer_resource_class(name, nesting: nil)
-      raise Alba::Error, 'Inference is disabled so Alba cannot infer resource name. Set inflector before use.' unless Alba.inflector
+      raise Alba::Error, 'Inference is disabled so Alba cannot infer resource name. Set inflector before use.' unless inflector
 
       const_parent = nesting.nil? ? Object : Object.const_get(nesting)
       begin
@@ -203,8 +203,6 @@ module Alba
     def reset!
       @encoder = default_encoder
       @symbolize_keys = false
-      @_on_error = :raise
-      @_on_nil = nil
       @types = {}
       @non_collection_types = [Struct, Range, Hash]
       @default_superclass = ::Object
@@ -326,7 +324,7 @@ module Alba
 
     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))
+        register_type(t, check: ->(obj) { obj.is_a?(String) }, converter: lambda(&:to_s)) # steep:ignore
       end
       [Integer, :Integer].each do |t|
         register_type(t, check: ->(obj) { obj.is_a?(Integer) }, converter: ->(obj) { Integer(obj) })

data/sig/alba/association.rbs

@@ -0,0 +1,46 @@
+module Alba
+  # Representing association
+  class Association
+    # Class methods
+    self.@const_cache: Hash[Symbol | String, Class]
+
+    @modifier: untyped
+    @resource: untyped
+    @source: Proc?
+    @with_traits: Symbol | Array[Symbol] | nil
+    @params: generic_hash
+
+    def self.const_cache: () -> Hash[Symbol | String, Class]
+
+    # Instance variables and methods
+    attr_reader name: Symbol | String
+
+    def initialize: (
+      name: Symbol | String,
+      ?modifier: Proc?,
+      ?resource: (Class | Proc | String | Symbol)?,
+      ?source: Proc?,
+      ?with_traits: (Symbol | Array[Symbol])?,
+      ?params: generic_hash,
+      ?nesting: String?,
+      ?key_transformation: Alba::transform_type,
+      ?helper: Module?
+    ) ?{ () [self: singleton(Resource)] -> void } -> void
+
+    def key_transformation=: (Symbol | String type) -> void
+
+    def to_h: (
+      untyped target,
+      ?within: within,
+      ?params: generic_hash
+    ) -> (generic_hash | Array[generic_hash] | nil)
+
+    private
+
+    def object_from: (untyped target, generic_hash params) -> untyped
+    def constantize: (Class | Symbol | String resource) -> Class
+    def resource_from: (String? nesting, Alba::transform_type key_transformation, (^() [self: singleton(::Alba::Resource)] -> void)? block, Module? helper) -> Alba::resource_class
+    def to_h_with_each_resource: (Enumerable[untyped] object, within within, generic_hash params) -> Array[generic_hash]
+    def to_h_with_constantize_resource: (untyped object, within within, generic_hash params) -> generic_hash
+  end
+end

data/sig/alba/conditional_attribute.rbs

@@ -0,0 +1,24 @@
+module Alba
+  # Represents attribute with `if` option
+  class ConditionalAttribute
+    type condition = Symbol | Proc
+    @body: untyped
+    @condition: untyped
+
+    def initialize: (
+      body: Alba::Resource::attribute,
+      condition: condition
+    ) -> void
+
+    def with_passing_condition: (
+      resource: Alba::Resource::InstanceMethods,
+      ?object: untyped
+    ) { (Alba::Resource::attribute) -> untyped } -> untyped
+
+    private
+
+    def condition_passes?: (Alba::Resource::InstanceMethods resource, untyped object) -> bool
+    def with_two_arity_proc_condition?: () -> bool
+    def second_object: (untyped object, Alba::Resource::InstanceMethods resource) -> untyped
+  end
+end

data/sig/alba/constants.rbs

@@ -0,0 +1,4 @@
+module Alba
+  # A constant to remove key from serialized JSON
+  REMOVE_KEY: Object
+end

data/sig/alba/default_inflector.rbs

@@ -0,0 +1,13 @@
+module Alba
+  # Adapter module for ActiveSupport inflector
+  # Note: This is already defined in alba.rbs but moved here for consistency
+  module DefaultInflector
+    def self.camelize: (String key) -> String
+    def self.camelize_lower: (String key) -> String
+    def self.dasherize: (String key) -> String
+    def self.underscore: (String key) -> String
+    def self.classify: (String | Symbol key) -> String
+    def self.demodulize: (String key) -> String
+    def self.pluralize: (String key) -> String
+  end
+end

data/sig/alba/deprecation.rbs

@@ -0,0 +1,7 @@
+module Alba
+  # Module for printing deprecation warning
+  module Deprecation
+    def self?.warn: (_ToS message) -> nil
+    def caller_locations: (Range[Integer]) -> Array[Thread::Backtrace::Location]
+  end
+end

data/sig/alba/errors.rbs

@@ -0,0 +1,13 @@
+module Alba
+  # Base error class for Alba
+  class Error < StandardError
+  end
+
+  # Raised when an unsupported backend is specified
+  class UnsupportedBackend < Error
+  end
+
+  # Raised when an unknown type is specified
+  class UnsupportedType < Error
+  end
+end

data/sig/alba/layout.rbs

@@ -0,0 +1,35 @@
+module Alba
+  # Layout serialization
+  class Layout
+    @body: untyped
+    @resource: untyped
+    @serialized_json: String
+
+    def object: () -> untyped
+    def params: () -> generic_hash
+    def serializable_hash: () -> generic_hash
+    def to_h: () -> generic_hash
+
+    def self.def_delegators: (Symbol, *Symbol) -> void
+
+    def initialize: (
+      file: String?,
+      inline: Proc?
+    ) -> void
+
+    def serialize: (
+      resource: Alba::Resource::_InstanceMethods,
+      serialized_json: String,
+      binding: Binding
+    ) -> String
+
+    private
+
+    attr_reader serialized_json: String
+
+    def check_and_return: (Object obj, String message, Class klass) -> Object
+    def serialize_within_string_layout: (Binding bnd) -> String
+    def serialize_within_inline_layout: () -> String
+    def encode: (generic_hash hash) -> String
+  end
+end

data/sig/alba/nested_attribute.rbs

@@ -0,0 +1,21 @@
+module Alba
+  # Representing nested attribute
+  class NestedAttribute
+    attr_writer key_transformation: Symbol | String
+
+    @key_transformation: Symbol | String
+    @block: untyped
+    @klass: untyped
+
+    def initialize: (
+      klass: untyped,
+      ?key_transformation: Alba::transform_type
+    ) { () [self: singleton(Alba::Resource)] -> void } -> void
+
+    def value: (
+      object: untyped,
+      params: generic_hash,
+      within: within
+    ) -> generic_hash
+  end
+end

data/sig/alba/resource.rbs

@@ -0,0 +1,152 @@
+module Alba
+  module Resource
+    type attribute = String | Symbol | ^(untyped) [self: ::Alba::Resource::InstanceMethods] -> untyped | ConditionalAttribute | NestedAttribute | TypedAttribute | Association
+    type instance_proc = ^(*untyped) [self: InstanceMethods] -> untyped
+    type metadata_proc = ^() [self: InstanceMethods] -> generic_hash
+
+    INTERNAL_VARIABLES: Hash[Symbol, untyped]
+    WITHIN_DEFAULT: Object
+    EMPTY_HASH: generic_hash
+
+    def self.included: (Class) -> void
+
+    interface _InstanceMethods
+      def nil?: () -> bool
+      def object: () -> untyped
+      def params: () -> generic_hash
+      def serialize: (?root_key: root_key_type, ?meta: generic_hash) -> String
+      def to_json: (?generic_hash, ?root_key: root_key_type, ?meta: generic_hash) -> String
+      def as_json: (?generic_hash, ?root_key: root_key_type, ?meta: generic_hash) -> serializable_hash_type
+      def serializable_hash: () -> serializable_hash_type
+      alias to_h serializable_hash
+    end
+
+    interface _ClassMethods
+      def method_added: (Symbol) -> void
+      def inherited: (Class) -> void
+      def attributes: (*(Symbol | String), ?if: instance_proc | Symbol | nil, **untyped) -> void
+      def assign_attributes: (Array[Symbol | String], instance_proc | Symbol | nil) -> void
+      def assign_attributes_with_types: (Hash[Symbol | String, untyped], instance_proc | Symbol | nil) ?{ (untyped) [self: InstanceMethods] -> untyped } -> void
+      def attribute: (?Symbol | String | nil, ?if: instance_proc | Symbol | nil, **untyped) ?{ (untyped) [self: InstanceMethods] -> untyped } -> void
+      def association: (Symbol | String, ?instance_proc?, ?resource: (Class | Proc | String | Symbol)?, ?serializer: (Class | Proc | String | Symbol)?, ?source: Proc?, ?key: key_type, ?with_traits: Symbol | Array[Symbol] | nil, ?params: generic_hash, **untyped) ?{ () [self: singleton(Resource)] -> void } -> (Alba::Association | Alba::ConditionalAttribute)
+      alias one association
+      alias many association
+      alias has_one association
+      alias has_many association
+      def nesting: () -> String?
+      def nested_attribute: (Symbol | String, **untyped) ?{ () [self: singleton(Resource)] -> void } -> (Alba::ConditionalAttribute | Alba::NestedAttribute)
+      alias nested nested_attribute
+      def trait: (Symbol | String) ?{ () [self: singleton(Resource)] -> void } -> Proc
+      def root_key: (Symbol | String, ?Symbol | String | nil) -> Symbol?
+      def root_key_for_collection: (Symbol | String) -> Symbol
+      def root_key!: () -> class_key_type
+      def meta: (?Symbol?) ?{ () [self: InstanceMethods] -> generic_hash } -> [Symbol?, metadata_proc?]
+      def layout: (?file: String?, ?inline: Proc?) -> Alba::Layout
+      def transform_keys: (Symbol | String, ?root: bool, ?cascade: bool) -> bool
+      def transform_keys!: (Symbol | String) -> untyped
+      def collection_key: (Symbol | String) -> Symbol
+      def on_error: (?( :raise | :ignore | :nullify | nil) handler) ?{ (*untyped) [self: InstanceMethods] -> untyped } -> (Proc | :raise | :ignore | :nullify)?
+      def validated_error_handler: ((:raise | :ignore | :nullify | nil) handler) -> (:raise | :ignore | :nullify)?
+      def on_nil: () ?{ (*untyped) [self: InstanceMethods] -> untyped } -> instance_proc?
+      def helper: (?Module) ?{ (Module) [self: Module] -> untyped } -> Module
+      def prefer_resource_method!: () -> Symbol
+      def prefer_object_method!: () -> Symbol
+    end
+
+    module InstanceMethods
+      @object: untyped
+      @params: generic_hash
+      @within: untyped
+      @with_traits: Symbol | Array[Symbol] | nil
+
+      def initialize: (untyped, ?params: generic_hash, ?within: within, ?with_traits: Symbol | Array[Symbol] | nil) -> void
+      include _InstanceMethods
+
+      def hash_from_traits: (untyped) -> generic_hash
+      def serialize_with: (untyped) -> String
+      def hash_with_metadata: (generic_hash, generic_hash) -> generic_hash
+      def _metadata: (metadata_proc?, generic_hash) -> generic_hash
+      def serializable_hash_for_collection: () -> (Array[generic_hash] | Hash[root_key_type, generic_hash])
+      def fetch_key: () -> root_key_type
+      def _key_for_collection: () -> root_key_type
+      def _key: () -> root_key_type
+      def resource_name: (?pluralized: bool) -> String
+      def transforming_root_key?: () -> bool
+      def attributes_to_hash: (untyped, generic_hash) -> generic_hash
+      def select: (key_type, untyped, attribute) -> bool
+      def set_key_and_attribute_body_from: (untyped, untyped, attribute, generic_hash) -> void
+      def do_select: (key_type, untyped, attribute) -> bool
+      def handle_error: (StandardError, untyped, Symbol | String, attribute, generic_hash) -> void
+      def transform_key: (Symbol | String | nil) -> untyped
+      def fetch_attribute: (untyped, key_type, attribute) -> untyped
+      def fetch_attribute_from_object_and_resource: (untyped, Symbol) -> untyped
+      def _fetch_attribute_from_object_first: (untyped, Symbol) -> untyped
+      def _fetch_attribute_from_resource_first: (untyped, Symbol) -> untyped
+      def nil_handler: () -> instance_proc?
+      def yield_if_within: (Symbol) { (within) -> untyped } -> untyped
+      def check_within: (Symbol) -> within
+      def _setup: () -> void
+
+      # These methods are available on the eventual resource instance. Declaring
+      # them here models the module's inclusion context for Steep.
+      def class: () -> Class
+      def instance_eval: [A] () { () [self: self] -> A } -> A
+      def instance_exec: [A] (untyped) { (untyped) [self: self] -> A } -> A
+                       | [A] (*untyped) { (*untyped) [self: self] -> A } -> A
+      def __send__: (Symbol, *untyped) -> untyped
+      def binding: () -> Binding
+      def encode: (untyped) -> String
+    end
+
+    interface _ClassContext
+      def alias_method: (Symbol, Symbol) -> Symbol
+      def private: (*Symbol) -> void
+      def instance_method: (Symbol) -> UnboundMethod
+      def include: (*Module) -> self
+      def extend: (*Module) -> self
+      def class_eval: [A] () { () [self: untyped] -> A } -> A
+      def module_eval: [A] () { () [self: untyped] -> A } -> A
+      def name: () -> String?
+      def dup: () -> untyped
+      def new: (*untyped, **untyped) -> Resource::_InstanceMethods
+      def _resource_methods: () -> Array[Symbol]
+    end
+
+    module ClassMethods
+      @_attributes: Hash[Symbol | String, attribute]
+      @_key: class_key_type
+      @_key_for_collection: class_key_type
+      @_meta: [Symbol?, metadata_proc?]?
+      @_transform_type: transform_type
+      @_transforming_root_key: bool
+      @_key_transformation_cascade: bool
+      @_on_error: (Proc | :raise | :ignore | :nullify)?
+      @_on_nil: instance_proc?
+      @_layout: Layout?
+      @_collection_key: key_type
+      @_helper: Module?
+      @_resource_methods: Array[Symbol]
+      @_select_arity: Integer?
+      @_traits: Hash[Symbol, Proc]
+
+      def alias_method: (Symbol, Symbol) -> Symbol
+      def private: (*Symbol) -> void
+      def instance_method: (Symbol) -> UnboundMethod
+      def include: (*Module) -> self
+      def extend: (*Module) -> self
+      def class_eval: [A] () { () [self: untyped] -> A } -> A
+      def module_eval: [A] () { () [self: untyped] -> A } -> A
+      def name: () -> String?
+      def dup: () -> untyped
+      def new: (*untyped, **untyped) -> Resource::_InstanceMethods
+      def _resource_methods: () -> Array[Symbol]
+
+      include _ClassMethods
+    end
+
+    include InstanceMethods
+    extend ClassMethods
+  end
+
+  Serializer: singleton(Resource)
+end

data/sig/alba/type.rbs

@@ -0,0 +1,26 @@
+module Alba
+  # Representing type itself, combined with TypedAttribute
+  class Type
+    type converter = nil | ^(untyped) [self: Type] -> untyped
+    type check = bool | ^(untyped) [self: Type] -> bool
+
+    attr_reader name: Symbol | String | Class
+    attr_writer auto_convert: bool
+
+    @name: Symbol | String | Class
+    @check: untyped
+    @converter: converter
+    @auto_convert: bool
+
+    def initialize: (
+      Symbol | String | Class name,
+      check: check,
+      converter: converter,
+      ?auto_convert: bool
+    ) -> void
+
+    def check: (Object value) -> bool
+    def convert: (Object obj) -> untyped
+    def auto_convert_with: (converter converter) -> void
+  end
+end

data/sig/alba/typed_attribute.rbs

@@ -0,0 +1,22 @@
+module Alba
+  # Representing typed attributes to encapsulate logic about types
+  class TypedAttribute
+    attr_reader name: Symbol | String
+    
+    @name: Symbol | String
+    @type: Alba::Type
+    @block: untyped
+    
+    def initialize: (
+      name: Symbol | String,
+      type: Symbol | Class,
+      converter: untyped
+    ) ?{ (untyped) [self: Alba::Resource::InstanceMethods] -> untyped } -> void
+    
+    def value: (?object: untyped) { (Symbol | String) -> untyped } -> untyped
+    
+    private
+    
+    def display_value_for: (untyped value) -> String
+  end
+end

data/sig/alba/version.rbs

@@ -0,0 +1,4 @@
+module Alba
+  # Current version of Alba
+  VERSION: String
+end

data/sig/alba.rbs

@@ -0,0 +1,82 @@
+module Alba
+  type generic_hash = Hash[Symbol | String, untyped]
+  type key_type = Symbol | String | nil
+  type root_key_type = Symbol | String | nil
+  type class_key_type = root_key_type | true
+  type transform_type = Symbol
+  type backend_type = :oj | :oj_strict | :oj_rails | :oj_default | :active_support | :default | :json | :custom | nil
+  type encoder_type = ^(untyped) [self: top] -> String
+  type inflector_type = _Inflector?
+  type resource_class = _ResourceClass
+  type with_type = :inference | Class | ^(untyped) -> resource_class
+  type within = generic_hash | Array[Symbol | String] | Symbol | bool | nil | Object
+  type serializable_hash_type = generic_hash | Array[generic_hash] | Hash[root_key_type, generic_hash] | Hash[root_key_type, Array[generic_hash]]
+
+  interface _ResourceClass
+    include Resource::_ClassMethods
+
+    def new: (Object? object, ?params: generic_hash, ?within: within, ?with_traits: Symbol | Array[Symbol] | nil) -> Resource::_InstanceMethods
+    def class_eval: () { () [self: singleton(Resource)] -> void } -> void
+  end
+
+  interface _Inflector
+    def camelize: (String) -> String
+    def camelize_lower: (String) -> String
+    def dasherize: (String) -> String
+    def underscore: (String) -> String
+    def classify: (String | Symbol) -> String
+    def demodulize: (String) -> String
+    def pluralize: (String) -> String
+    def inspect: () -> String
+    def respond_to?: (Symbol) -> bool
+  end
+
+  self.@backend: backend_type
+  self.@encoder: encoder_type
+  self.@inflector: inflector_type
+  self.@symbolize_keys: bool
+  self.@types: Hash[Symbol | Class, Type]
+  self.@non_collection_types: Array[Class]
+  self.@default_superclass: Class | String | Symbol
+  self.@_transformed_keys: Hash[transform_type, Hash[String | Symbol, key_type]]
+
+  attr_reader self.backend: backend_type
+  attr_reader self.encoder: encoder_type
+  attr_reader self.inflector: inflector_type
+  attr_reader self.non_collection_types: Array[Class]
+  attr_writer self.default_superclass: Class | String | Symbol
+
+  def self.backend=: (backend_type) -> void
+  def self.encoder=: (encoder_type) -> void
+  def self.serialize: (?untyped object, ?with: with_type, ?root_key: root_key_type) ?{ () [self: singleton(Resource)] -> void } -> String
+  def self.hashify: (?untyped object, ?with: with_type, ?root_key: root_key_type) ?{ () [self: singleton(Resource)] -> void } -> (serializable_hash_type | Array[serializable_hash_type] | Hash[root_key_type, Array[serializable_hash_type]])
+  def self.collection?: (Object? object) -> bool
+  def self.inflector=: (:default | :active_support | :dry | inflector_type) -> void
+  def self.resource_class: (?helper: Module?, ?key_transformation: transform_type) ?{ () [self: singleton(Resource)] -> void } -> resource_class
+  def self.infer_resource_class: (String | Symbol, ?nesting: String?) -> resource_class
+  def self.symbolize_keys!: () -> bool
+  def self.stringify_keys!: () -> bool
+  def self.regularize_key: (root_key_type) -> key_type
+  def self.transform_key: (String | Symbol, transform_type: transform_type) -> key_type
+  def self.register_type: (Symbol | Class, ?check: Alba::Type::check, ?converter: Alba::Type::converter, ?auto_convert: bool) -> void
+  def self.find_type: (Symbol | Class) -> Type
+  def self.reset!: () -> void
+  def self.resource_for: (untyped, ?params: generic_hash, ?with: with_type) -> Resource::_InstanceMethods
+                       | (untyped, ?params: generic_hash, ?with: with_type) ?{ () [self: singleton(Resource)] -> void } -> untyped
+
+  def self._resource_for: (untyped, ?params: generic_hash, ?with: with_type) ?{ () [self: singleton(Resource)] -> void } -> Resource::_InstanceMethods
+  def self.inflector_from: (:default | :active_support | :dry | _Inflector | nil) -> inflector_type
+  def self.set_encoder_from_backend: () -> encoder_type
+  def self.try_oj: (mode: Symbol) -> encoder_type
+  def self.try_active_support: () -> encoder_type
+  def self.default_encoder: () -> encoder_type
+  def self.hashify_collection: (Enumerable[untyped], with_type, root_key_type) ?{ () [self: singleton(Resource)] -> void } -> (Array[serializable_hash_type] | Hash[root_key_type, Array[serializable_hash_type]])
+  def self.validate_inflector: (_Inflector) -> _Inflector
+  def self.reset_transform_keys: () -> Hash[transform_type, Hash[String | Symbol, key_type]]
+  def self.resolved_default_superclass: () -> untyped
+  def self.register_default_types: () -> void
+end
+
+module Oj
+  def self.dump: (untyped, **untyped) -> String
+end

data/sig/manifest.yaml

@@ -0,0 +1,6 @@
+dependencies:
+  - name: rbs
+  - name: logger
+  - name: json
+  - name: erb
+  - name: forwardable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - OKURA Masafumi
@@ -34,6 +34,20 @@ files:
 - lib/alba/type.rb
 - lib/alba/typed_attribute.rb
 - lib/alba/version.rb
+- sig/alba.rbs
+- sig/alba/association.rbs
+- sig/alba/conditional_attribute.rbs
+- sig/alba/constants.rbs
+- sig/alba/default_inflector.rbs
+- sig/alba/deprecation.rbs
+- sig/alba/errors.rbs
+- sig/alba/layout.rbs
+- sig/alba/nested_attribute.rbs
+- sig/alba/resource.rbs
+- sig/alba/type.rbs
+- sig/alba/typed_attribute.rbs
+- sig/alba/version.rbs
+- sig/manifest.yaml
 homepage: https://github.com/okuramasafumi/alba
 licenses:
 - MIT