cattri 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8689b6e0fa1e741fc271fece58183191d290875fe203af5622f069aaf3c4cf7
-  data.tar.gz: 2435ba9915a003f39d2d0275c725064c0c5c885940e7de109bb852a7258dfdd6
+  metadata.gz: 2495a8756d30c301267ad2db2dfbd4c9669e817119fa316b608408665988b747
+  data.tar.gz: 47d682eaf5465e4ab6cc4bdb7dcc74d053c93c6b8d1ee3a8cfda0925cf68662a
 SHA512:
-  metadata.gz: 847f1396957fa8567868273f61c1906e95001e0fd8c632de72ed3f520ec4a7edb1c91c7c1f6a02101913c392d119b24a32a4d835827dab864338ab0e6b668574
-  data.tar.gz: f7347d6cb14bb1b0501ff45799ba513388462ede2c95a47f84efb9d4a99ce7c9a6c6a8c726e605b4d475b26664c5f8861f8fc50922da4ebfbe4b139a257af131
+  metadata.gz: aae777877b7576a76b0be11a529aafaaac9c59066efd873fc9020689ba3ccefb78688411907b2246cb603dafa5e6868e1841e4724f296f634eac821a1bc27bc9
+  data.tar.gz: 8e919b6782d0cce71ed1a78bb46ebb92df995471238080a4e20604914d0fe958c041aec201eb598f9764598384fd776aaff03f5b131908082428c2d546c97cd9

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## [0.1.3] - 2025-04-22
+
+### Added
+
+- ✅ Support for `predicate: true` on both `iattr` and `cattr` — defines a `:name?` method returning `!!send(:name)`
+- ✅ `iattr_alias` and `cattr_alias` — define alias methods that delegate to existing attributes (e.g., `:foo?` for `:foo`)
+- Predicate methods inherit visibility from the original attribute and are excluded from introspection (`iattrs`, `cattrs`)
+- Raised error when attempting to define an attribute ending in `?`, with guidance to use `predicate: true` or `*_alias`
+
+## [0.1.2] - 2025-04-22
+
+### Added
+
+- Support for defining multiple attributes in a single call to `cattr` or `iattr`.
+  - Example: `cattr :foo, :bar, default: 1`
+  - Shared options apply to all attributes.
+- Adds `cattr_setter` and `iattr_setter` for defining setters on attributes, useful when defining multiple attributes since ambiguous blocks are not allow.
+  ```ruby
+  class Config
+    include Cattri
+  
+    cattr :a, :b               # new functionality, does not allow setter blocks.
+                               # creates writers as def a=(val); @a = val; end
+    
+    cattr_setter :a do |val|   # redefines a= as def a=(val); val.to_s.downcase.to_sym; end
+      val.to_s.downcase.to_sym
+    end
+  end
+  ```
+- Validation to prevent use of a block when defining multiple attributes.
+  - Raises `Cattri::AmbiguousBlockError` if `&block` is passed with more than one attribute.
+
 ## [0.1.1] - 2025-04-22
 
 ### Added

data/README.md

@@ -43,19 +43,24 @@ class Config
   include Cattri          # exposes `cattr` & `iattr`
 
   # -- class‑level ----------------------------------
-  cattr :enabled,  default: true
-  cattr :timeout,  default: -> { 5.0 }, instance_reader: false
+  cattr :flag_a, :flag_b, default: true
+  cattr :enabled,         default: true, predicate: true
+  cattr :timeout,         default: -> { 5.0 }, instance_reader: false
 
   # -- instance‑level -------------------------------
-  iattr :name,     default: "anonymous"
-  iattr :age,      default: 0 do |val|                 # coercion block
+  iattr :item_a, :item_b, default: true
+  iattr :name,            default: "anonymous"
+  iattr_alias :username, :name
+  iattr :age,             default: 0 do |val|                 # coercion block
     Integer(val)
   end
 end
 
 Config.enabled        # => true
 Config.enabled = false
+Config.enabled?       # => false (created with predicate: true flag)
 Config.new.age = "42" # => 42
+Config.new.username   # proxy to Config.new.name
 ```
 
 ---
@@ -65,12 +70,14 @@ Config.new.age = "42" # => 42
 ### Class attributes (`cattr`)
 
 ```ruby
-cattr :log_level, default: :info,
-                  access:  :protected,     # respects current visibility by default
-                  readonly: false,
-                  instance_reader: true do |value|
-                    value.to_sym
-                  end
+cattr :log_level,
+      default: :info,
+      access:  :protected,     # respects current visibility by default
+      readonly: false,
+      predicate: true,         # defines #{name}? predicate method that respects visibility
+      instance_reader: true do |value|
+  value.to_sym
+end
 ```
 
 ### Instance attributes (`iattr`)
@@ -78,7 +85,8 @@ cattr :log_level, default: :info,
 ```ruby
 iattr :token, default: -> { SecureRandom.hex(8) },
               reader:  true,
-              writer:  false                  # read‑only
+              writer:  false,                  # read‑only
+              predicate: true
 ```
 
 Both forms accept:
@@ -90,11 +98,54 @@ Both forms accept:
 | `reader:` / `writer:` | Disable reader or writer for instance attributes. |
 | `readonly:` | Shorthand for class attributes (`writer` is always present). |
 | `instance_reader:` | Expose class attribute as instance reader (default: **true**). |
+| `predicate` | Define a `:name?` method that calls `!!send(name)`
 
 If you pass a block, it’s treated as a **coercion setter** and receives the incoming value.
 
 ---
 
+## Post-definition coercion with `*_setter`
+
+If you define multiple attributes at once, you can't provide a coercion block inline:
+
+```ruby
+cattr :foo, :bar, default: nil      # ❌ cannot use block here
+```
+
+Instead, define them first, then apply a coercion later using:
+
+- `cattr_setter` for class attributes
+- `iattr_setter` for instance attributes
+
+These allow you to attach or override the setter logic after the fact:
+
+```ruby
+class Config
+  include Cattri
+
+  cattr :log_level
+  cattr_setter :log_level do |val|
+    val.to_s.downcase.to_sym
+  end
+
+  iattr_writer :token
+  iattr_setter :token do |val|
+    val.strip
+  end
+end
+```
+
+Coercion is only applied when the attribute is written (via `=` or callable form), not when read.
+
+Attempting to use `*_setter` on an undefined attribute or one without a writer will raise:
+
+- `Cattri::AttributeNotDefinedError` – the attribute doesn't exist or wasn't fully defined
+- `Cattri::AttributeDefinitionError` – the attribute is marked as readonly
+
+These APIs ensure your DSL stays consistent and extensible, even when bulk-declaring attributes up front.
+
+---
+
 ## Visibility tracking
 
 Cattri watches calls to `public`, `protected`, and `private` while you define methods:
@@ -180,7 +231,7 @@ end
 * **ActiveSupport** extends the API but still relies on mutable class variables and offers no visibility control.
 * **Dry‑configurable** is robust yet heavyweight when you only need a handful of attributes outside a full config object.
 
-Cattri sits in the sweet spot: **micro‑sized (~200 LOC)**, dependency‑free, and purpose‑built for attribute declaration.
+Cattri sits in the sweet spot: **micro‑sized (~300 LOC)**, dependency‑free, and purpose‑built for attribute declaration.
 
 ---
 

data/lib/cattri/attribute.rb

@@ -23,13 +23,15 @@ module Cattri
     # Default options for class-level attributes.
     DEFAULT_CLASS_ATTRIBUTE_OPTIONS = {
       readonly: false,
-      instance_reader: true
+      instance_reader: true,
+      predicate: false
     }.freeze
 
     # Default options for instance-level attributes.
     DEFAULT_INSTANCE_ATTRIBUTE_OPTIONS = {
       reader: true,
-      writer: true
+      writer: true,
+      predicate: false
     }.freeze
 
     # @return [Symbol] the attribute name

data/lib/cattri/attribute_definer.rb

@@ -47,13 +47,32 @@ module Cattri
       def define_instance_level_reader(attribute, context)
         return unless attribute.class_level?
 
-        context.target.define_method(attribute.name) do
+        define_instance_level_method(attribute, context) do
           self.class.__send__(attribute.name)
         end
 
         context.send(:apply_access, attribute.name, attribute)
       end
 
+      # Defines an instance-level method for a class-level attribute.
+      #
+      # This is a shared utility for defining instance methods that delegate to class attributes,
+      # including both regular readers and predicate-style readers (`predicate: true`).
+      #
+      # Visibility is inherited from the attribute and applied to the defined method.
+      #
+      # @param attribute [Cattri::Attribute] the associated attribute metadata
+      # @param context [Cattri::Context] the context in which to define the method
+      # @param name [Symbol, nil] optional override for the method name (defaults to `attribute.name`)
+      # @yield the method body to define
+      # @return [void]
+      def define_instance_level_method(attribute, context, name: nil, &block)
+        name = (name || attribute.name).to_sym
+        context.target.define_method(name, &block)
+
+        context.send(:apply_access, name, attribute)
+      end
+
       # Defines standard reader and writer methods for instance-level attributes.
       #
       # Skips definition if `reader: false` or `writer: false` is specified.
@@ -92,6 +111,18 @@ module Cattri
         end
       end
 
+      # Defines, or redefines, a writer method (`foo=`) that sets and coerces a value via the attribute setter.
+      #
+      # @param attribute [Cattri::Attribute]
+      # @param context [Cattri::Context]
+      # @return [void]
+      def define_writer!(attribute, context)
+        context.define_method!(attribute, name: :"#{attribute.name}=") do |value|
+          coerced_value = attribute.setter.call(value)
+          instance_variable_set(attribute.ivar, coerced_value)
+        end
+      end
+
       private
 
       # Returns the memoized value for an attribute or computes it from the default.

data/lib/cattri/class_attributes.rb

@@ -20,31 +20,43 @@ module Cattri
   # Class attributes are stored internally as `Cattri::Attribute` instances and
   # values are memoized using class-level instance variables.
   module ClassAttributes
-    # Defines a class-level attribute with optional default, coercion, and reader access.
+    # Defines one or more class-level attributes with optional default, coercion, and reader access.
     #
-    # @param name [Symbol] the attribute name
+    # This method supports defining multiple attributes at once, provided they share the same options.
+    # If a block is given, only one attribute may be defined to avoid ambiguity.
+    #
+    # @example Define multiple attributes with shared options
+    #   class_attribute :foo, :bar, default: 42
+    #
+    # @example Define a single attribute with a coercion block
+    #   class_attribute :path do |val|
+    #     Pathname(val)
+    #   end
+    #
+    # @param names [Array<Symbol | String>] the names of the attributes to define
     # @param options [Hash] additional attribute options
     # @option options [Object, Proc] :default the default value or lambda
     # @option options [Boolean] :readonly whether the attribute is read-only
     # @option options [Boolean] :instance_reader whether to define an instance-level reader (default: true)
     # @option options [Symbol] :access visibility level (:public, :protected, :private)
+    # @option options [Boolean] :predicate whether to define a predicate-style alias method
+    #   (e.g., `foo?`) for the attribute
     # @yieldparam value [Object] an optional custom setter block
     # @raise [Cattri::AttributeError] or its subclasses, including `Cattri::AttributeDefinedError` or
     #   `Cattri::AttributeDefinitionError` if defining the attribute fails (e.g., if the attribute is
     #    already defined or an error occurs while defining methods)
-    def class_attribute(name, **options, &block)
-      options[:access] ||= __cattri_visibility
-      attribute = Cattri::Attribute.new(name, :class, options, block)
+    # @return [void]
+    def class_attribute(*names, **options, &block)
+      raise Cattri::AmbiguousBlockError if names.size > 1 && block_given?
 
-      raise Cattri::AttributeDefinedError, attribute if class_attribute_defined?(attribute.name)
+      names.each do |name|
+        if name.end_with?("?")
+          raise Cattri::AttributeError,
+                "Attribute names ending in '?' are not allowed. Use `predicate: true` or `cattr_alias` instead."
 
-      begin
-        __cattri_class_attributes[name] = attribute
+        end
 
-        Cattri::AttributeDefiner.define_callable_accessor(attribute, context)
-        Cattri::AttributeDefiner.define_instance_level_reader(attribute, context) if attribute[:instance_reader]
-      rescue StandardError => e
-        raise Cattri::AttributeDefinitionError.new(self, attribute, e)
+        define_class_attribute(name, options, block)
       end
     end
 
@@ -52,18 +64,79 @@ module Cattri
     #
     # Equivalent to calling `class_attribute(name, readonly: true, ...)`
     #
-    # @param name [Symbol]
-    # @param options [Hash]
+    # @param names [Array<Symbol | String>] the names of the attributes to define
+    # @param options [Hash] additional attribute options
+    # @option options [Object, Proc] :default the default value or lambda
+    # @option options [Boolean] :readonly whether the attribute is read-only
+    # @option options [Boolean] :instance_reader whether to define an instance-level reader (default: true)
+    # @option options [Symbol] :access visibility level (:public, :protected, :private)
+    # @option options [Boolean] :predicate whether to define a predicate-style alias method
+    #   (e.g., `foo?`) for the attribute
+    # @raise [Cattri::AttributeError] or its subclasses, including `Cattri::AttributeDefinedError` or
+    #   `Cattri::AttributeDefinitionError` if defining the attribute fails (e.g., if the attribute is
+    #    already defined or an error occurs while defining methods)
+    # @return [void]
+    def class_attribute_reader(*names, **options)
+      class_attribute(*names, **options, readonly: true)
+    end
+
+    # Updates the setter behavior of an existing class-level attribute.
+    #
+    # This allows coercion logic to be defined or overridden after the attribute
+    # has been declared using `cattr`, as long as the writer method exists.
+    #
+    # @example Add coercion to an existing attribute
+    #   cattr :format
+    #   cattr_setter :format do |val|
+    #     val.to_s.downcase.to_sym
+    #   end
+    #
+    # @param name [Symbol, String] the name of the attribute
+    # @yieldparam value [Object] the value passed to the setter
+    # @yieldreturn [Object] the coerced value to be assigned
+    # @raise [Cattri::AttributeNotDefinedError] if the attribute is not defined or the writer method does not exist
+    # @raise [Cattri::AttributeDefinitionError] if method redefinition fails
+    # @return [void]
+    def class_attribute_setter(name, &block)
+      name = name.to_sym
+      attribute = __cattri_class_attributes[name]
+      puts "<<< #{attribute} = #{name}>"
+
+      if attribute.nil? || !context.method_defined?(:"#{name}=")
+        raise Cattri::AttributeNotDefinedError.new(:class, name)
+      end
+
+      attribute.instance_variable_set(:@setter, attribute.send(:normalize_setter, block))
+      Cattri::AttributeDefiner.define_writer!(attribute, context)
+    end
+
+    # Defines an alias method for an existing class-level attribute.
+    #
+    # This does **not** register a new attribute; it simply defines a method
+    # (e.g., a predicate-style alias like `foo?`) that delegates to an existing one.
+    #
+    # The alias method inherits the visibility of the original attribute.
+    #
+    # @param alias_name [Symbol, String] the new method name (e.g., `:foo?`)
+    # @param original [Symbol, String] the name of the existing attribute to delegate to (e.g., `:foo`)
+    # @raise [Cattri::AttributeNotDefinedError] if the original attribute is not defined
     # @return [void]
-    def class_attribute_reader(name, **options)
-      class_attribute(name, readonly: true, **options)
+    def class_attribute_alias(alias_name, original)
+      attribute = __cattri_class_attributes[original.to_sym]
+      raise Cattri::AttributeNotDefinedError.new(:class, original) if attribute.nil?
+
+      context.define_method(attribute, name: alias_name) { public_send(original) }
     end
 
     # Returns a list of defined class attribute names.
     #
     # @return [Array<Symbol>]
     def class_attributes
-      __cattri_class_attributes.keys
+      ([self] + ancestors + singleton_class.included_modules)
+        .uniq
+        .select { |mod| mod.respond_to?(:__cattri_class_attributes, true) }
+        .flat_map { |mod| mod.send(:__cattri_class_attributes).keys }
+        .uniq
     end
 
     # Checks whether a class attribute has been defined.
@@ -97,6 +170,16 @@ module Cattri
     #   @see #class_attribute_reader
     alias cattr_reader class_attribute_reader
 
+    # @!method cattr_setter(name, **options)
+    #   Alias for {.class_attribute_setter}
+    #   @see #class_attribute_setter
+    alias cattr_setter class_attribute_setter
+
+    # @!method cattr_alias(name, **options)
+    #   Alias for {.class_attribute_alias}
+    #   @see #class_attribute_alias
+    alias cattr_alias class_attribute_alias
+
     # @!method cattrs
     #   Alias for {.class_attributes}
     #   @return [Array<Symbol>]
@@ -116,6 +199,65 @@ module Cattri
 
     private
 
+    # Defines a single class-level attribute.
+    #
+    # This is the internal implementation used by {.class_attribute} and its aliases.
+    # It constructs a `Cattri::Attribute`, registers it, and defines the necessary
+    # class and instance methods.
+    #
+    # @param name [Symbol] the name of the attribute to define
+    # @param options [Hash] additional attribute options (e.g., :default, :readonly)
+    # @param block [Proc, nil] an optional setter block for coercion
+    #
+    # @raise [Cattri::AttributeDefinedError] if the attribute has already been defined
+    # @raise [Cattri::AttributeDefinitionError] if method definition fails
+    #
+    # @return [void]
+    def define_class_attribute(name, options, block) # rubocop:disable Metrics/AbcSize
+      options[:access] ||= __cattri_visibility
+      attribute = Cattri::Attribute.new(name, :class, options, block)
+
+      raise Cattri::AttributeDefinedError.new(:class, name) if class_attribute_defined?(attribute.name)
+
+      begin
+        __cattri_class_attributes[name] = attribute
+
+        Cattri::AttributeDefiner.define_callable_accessor(attribute, context)
+        Cattri::AttributeDefiner.define_instance_level_reader(attribute, context) if attribute[:instance_reader]
+      rescue StandardError => e
+        raise Cattri::AttributeDefinitionError.new(self, attribute, e)
+      end
+
+      define_predicate_methods(attribute) if attribute[:predicate]
+    end
+
+    # Defines predicate-style (`:name?`) methods for a class-level attribute.
+    #
+    # If `attribute[:predicate]` is true, this defines a method named `:name?` that returns
+    # a boolean based on the truthiness of the attribute's value (`!!value`).
+    #
+    # If `attribute[:instance_reader]` is also true, an instance-level predicate method
+    # is defined that delegates to the class-level value.
+    #
+    # Visibility is inherited from the original attribute.
+    #
+    # @param attribute [Cattri::Attribute] the attribute for which to define predicate methods
+    # @return [void]
+    def define_predicate_methods(attribute)
+      return unless attribute[:predicate]
+
+      predicate_name = :"#{attribute.name}?"
+
+      # rubocop:disable Style/DoubleNegation
+      context.define_method(attribute, name: predicate_name) { !!send(attribute.name) }
+      return unless attribute[:instance_reader]
+
+      Cattri::AttributeDefiner.define_instance_level_method(attribute, context, name: predicate_name) do
+        !!self.class.__send__(attribute.name)
+      end
+      # rubocop:enable Style/DoubleNegation
+    end
+
     # Internal registry of defined class-level attributes.
     #
     # @return [Hash{Symbol => Cattri::Attribute}]

data/lib/cattri/context.rb

@@ -63,11 +63,27 @@ module Cattri
       name = (name || attribute.name).to_sym
       return if method_defined?(name)
 
+      define_method!(attribute, name: name, &block)
+    end
+
+    # Defines a method on the target class or singleton class, regardless of whether it already exists.
+    #
+    # This bypasses any checks for prior definition and forcibly installs the method using `define_method`.
+    # The method will be assigned visibility based on the attribute's `:access` setting.
+    #
+    # Used internally by attribute definers to (re)define writers, readers, or callables.
+    #
+    # @param attribute [Cattri::Attribute] the attribute whose context and access rules apply
+    # @param name [Symbol, nil] the method name to define (defaults to attribute name)
+    # @yield the method body to define
+    # @raise [Cattri::AttributeDefinitionError] if method definition fails
+    # @return [void]
+    def define_method!(attribute, name: nil, &block)
       target = target_for(attribute)
 
       begin
         target.define_method(name, &block)
-        @defined_methods << name
+        @defined_methods << name unless method_defined?(name)
         apply_access(name, attribute)
       rescue StandardError => e
         raise Cattri::AttributeDefinitionError.new(target, attribute, e)

data/lib/cattri/error.rb

@@ -30,9 +30,31 @@ module Cattri
   #   rescue Cattri::AttributeDefinedError => e
   #     puts e.message
   class AttributeDefinedError < Cattri::AttributeError
-    # @param attribute [Cattri::Attribute] the conflicting attribute
-    def initialize(attribute)
-      super("#{attribute.type.capitalize} attribute :#{attribute.name} has already been defined")
+    # @param type [Symbol, String] either :class or :instance
+    # @param name [Symbol, String] the name of the missing attribute
+    def initialize(type, name)
+      super("#{type.capitalize} attribute :#{name} has already been defined")
+    end
+  end
+
+  # Raised when attempting to access or modify an attribute that has not been defined.
+  #
+  # This applies to both class-level and instance-level attributes.
+  # It is typically raised when calling `.class_attribute_setter` or `.instance_attribute_setter`
+  # on a name that does not exist or lacks the expected method (e.g., writer).
+  #
+  # @example
+  #   raise Cattri::AttributeNotDefinedError.new(:class, :foo)
+  #   # => Class attribute :foo has not been defined
+  #
+  # @example
+  #   rescue Cattri::AttributeNotDefinedError => e
+  #     puts e.message
+  class AttributeNotDefinedError < Cattri::AttributeError
+    # @param type [Symbol, String] either :class or :instance
+    # @param name [Symbol, String] the name of the missing attribute
+    def initialize(type, name)
+      super("#{type.capitalize} attribute :#{name} has not been defined")
     end
   end
 
@@ -63,10 +85,21 @@ module Cattri
   # @example
   #   raise Cattri::UnsupportedTypeError.new(:foo)
   #   # => Attribute type :foo is not supported
-  class UnsupportedTypeError < Error
+  class UnsupportedTypeError < Cattri::AttributeError
     # @param type [Symbol] the invalid type that triggered the error
     def initialize(type)
       super("Attribute type :#{type} is not supported")
     end
   end
+
+  # Raised when a block is provided when defining a group of attributes `cattr :attr_a, :attr_b do ... end`
+  #
+  # @example
+  #   raise Cattri::AmbiguousBlockError
+  #   # => Cannot define multiple attributes with a block
+  class AmbiguousBlockError < Cattri::AttributeError
+    def initialize
+      super("Cannot define multiple attributes with a block")
+    end
+  end
 end

data/lib/cattri/instance_attributes.rb

@@ -26,29 +26,43 @@ module Cattri
 
     # Defines instance-level attribute DSL methods.
     module ClassMethods
-      # Defines an instance-level attribute with optional default and coercion.
+      # Defines one or more instance-level attributes with optional default and coercion.
       #
-      # @param name [Symbol, String] the name of the attribute
+      # This method supports defining multiple attributes at once, provided they share the same options.
+      # If a block is given, only one attribute may be defined to avoid ambiguity.
+      #
+      # @example Define multiple attributes with shared defaults
+      #   iattr :foo, :bar, default: []
+      #
+      # @example Define a single attribute with coercion
+      #   iattr :level do |val|
+      #     Integer(val)
+      #   end
+      #
+      # @param names [Array<Symbol | String>] the names of the attributes to define
       # @param options [Hash] additional options like `:default`, `:reader`, `:writer`
       # @option options [Object, Proc] :default the default value or lambda
       # @option options [Boolean] :reader whether to define a reader method (default: true)
       # @option options [Boolean] :writer whether to define a writer method (default: true)
       # @option options [Symbol] :access method visibility (:public, :protected, :private)
+      # @option options [Boolean] :predicate whether to define a predicate-style alias method
+      #   (e.g., `foo?`) for the attribute
       # @yieldparam value [Object] optional custom coercion logic for the setter
       # @raise [Cattri::AttributeError] or its subclasses, including `Cattri::AttributeDefinedError` or
       #   `Cattri::AttributeDefinitionError` if defining the attribute fails (e.g., if the attribute is
       #    already defined or an error occurs while defining methods)
-      def instance_attribute(name, **options, &block)
-        options[:access] ||= __cattri_visibility
-        attribute = Cattri::Attribute.new(name, :instance, options, block)
+      # @return [void]
+      def instance_attribute(*names, **options, &block)
+        raise Cattri::AmbiguousBlockError if names.size > 1 && block_given?
 
-        raise Cattri::AttributeDefinedError, attribute if instance_attribute_defined?(attribute.name)
+        names.each do |name|
+          if name.end_with?("?")
+            raise Cattri::AttributeError,
+                  "Attribute names ending in '?' are not allowed. Use `predicate: true` or `iattr_alias` instead."
 
-        begin
-          __cattri_instance_attributes[name.to_sym] = attribute
-          Cattri::AttributeDefiner.define_accessor(attribute, context)
-        rescue StandardError => e
-          raise Cattri::AttributeDefinitionError.new(self, attribute, e)
+          end
+
+          define_instance_attribute(name, options, block)
         end
       end
 
@@ -56,30 +70,95 @@ module Cattri
       #
       # Equivalent to `instance_attribute(..., writer: false)`
       #
-      # @param name [Symbol, String]
-      # @param options [Hash]
+      # @param names [Array<Symbol | String>] the names of the attributes to define
+      # @param options [Hash] additional options like `:default`, `:reader`, `:writer`
+      # @option options [Object, Proc] :default the default value or lambda
+      # @option options [Boolean] :reader whether to define a reader method (default: true)
+      # @option options [Symbol] :access method visibility (:public, :protected, :private)
+      # @option options [Boolean] :predicate whether to define a predicate-style alias method
+      #   (e.g., `foo?`) for the attribute
+      # @yieldparam value [Object] optional custom coercion logic for the setter
+      # @raise [Cattri::AttributeError] or its subclasses, including `Cattri::AttributeDefinedError` or
+      #   `Cattri::AttributeDefinitionError` if defining the attribute fails (e.g., if the attribute is
+      #    already defined or an error occurs while defining methods)
       # @return [void]
-      def instance_attribute_reader(name, **options)
-        instance_attribute(name, writer: false, **options)
+      def instance_attribute_reader(*names, **options)
+        instance_attribute(*names, **options, writer: false)
       end
 
       # Defines a write-only instance-level attribute.
       #
-      # Equivalent to `instance_attribute(..., reader: false)`
+      # Equivalent to `instance_attribute(..., reader: false)`. The predicate: option is not allowed
+      # when defining writer methods.
       #
-      # @param name [Symbol, String]
-      # @param options [Hash]
-      # @yieldparam value [Object] optional coercion logic
+      # @param names [Array<Symbol | String>] the names of the attributes to define
+      # @param options [Hash] additional options like `:default`, `:reader`, `:writer`
+      # @option options [Object, Proc] :default the default value or lambda
+      # @option options [Boolean] :writer whether to define a writer method (default: true)
+      # @option options [Symbol] :access method visibility (:public, :protected, :private)
+      # @yieldparam value [Object] optional custom coercion logic for the setter
+      # @raise [Cattri::AttributeError] or its subclasses, including `Cattri::AttributeDefinedError` or
+      #   `Cattri::AttributeDefinitionError` if defining the attribute fails (e.g., if the attribute is
+      #    already defined or an error occurs while defining methods)
       # @return [void]
-      def instance_attribute_writer(name, **options, &block)
-        instance_attribute(name, reader: false, **options, &block)
+      def instance_attribute_writer(*names, **options, &block)
+        instance_attribute(*names, **options.merge(reader: false, predicate: false), &block)
+      end
+
+      # Updates the setter behavior of an existing instance-level attribute.
+      #
+      # This allows coercion logic to be defined or overridden after the attribute
+      # has been declared using `iattr`, as long as the writer method exists.
+      #
+      # @example Add coercion to an existing attribute
+      #   iattr :format
+      #   iattr_setter :format do |val|
+      #     val.to_s.downcase.to_sym
+      #   end
+      #
+      # @param name [Symbol, String] the name of the attribute
+      # @yieldparam value [Object] the value passed to the setter
+      # @yieldreturn [Object] the coerced value to be assigned
+      # @raise [Cattri::AttributeNotDefinedError] if the attribute is not defined or the writer method does not exist
+      # @raise [Cattri::AttributeDefinitionError] if method redefinition fails
+      # @return [void]
+      def instance_attribute_setter(name, &block)
+        attribute = __cattri_instance_attributes[name.to_sym]
+
+        raise Cattri::AttributeNotDefinedError.new(:instance, name) if attribute.nil?
+        raise Cattri::AttributeError, "Cannot define setter for readonly attribute :#{name}" unless attribute[:writer]
+
+        attribute.instance_variable_set(:@setter, attribute.send(:normalize_setter, block))
+        Cattri::AttributeDefiner.define_writer!(attribute, context)
+      end
+
+      # Defines an alias method for an existing instance-level attribute.
+      #
+      # This does **not** register a new attribute; it simply defines a method
+      # (e.g., a predicate-style alias like `foo?`) that delegates to an existing one.
+      #
+      # The alias method inherits the visibility of the original attribute.
+      #
+      # @param alias_name [Symbol, String] the new method name (e.g., `:foo?`)
+      # @param original [Symbol, String] the name of the existing attribute to delegate to (e.g., `:foo`)
+      # @raise [Cattri::AttributeNotDefinedError] if the original attribute is not defined
+      # @return [void]
+      def instance_attribute_alias(alias_name, original)
+        attribute = __cattri_instance_attributes[original.to_sym]
+        raise Cattri::AttributeNotDefinedError.new(:instance, original) if attribute.nil?
+
+        context.define_method(attribute, name: alias_name) { public_send(original) }
       end
 
       # Returns a list of defined instance-level attribute names.
       #
       # @return [Array<Symbol>]
       def instance_attributes
-        __cattri_instance_attributes.keys
+        ([self] + ancestors + singleton_class.included_modules)
+          .uniq
+          .select { |mod| mod.respond_to?(:__cattri_instance_attributes, true) }
+          .flat_map { |mod| mod.send(:__cattri_instance_attributes).keys }
+          .uniq
       end
 
       # Checks if an instance-level attribute has been defined.
@@ -100,34 +179,81 @@ module Cattri
 
       # @!method iattr(name, **options, &block)
       #   Alias for {#instance_attribute}
+      #   @see #instance_attribute
       alias iattr instance_attribute
 
       # @!method iattr_accessor(name, **options, &block)
       #   Alias for {#instance_attribute}
+      #   @see #instance_attribute
       alias iattr_accessor instance_attribute
 
       # @!method iattr_reader(name, **options)
       #   Alias for {#instance_attribute_reader}
+      #   @see #instance_attribute_reader
       alias iattr_reader instance_attribute_reader
 
       # @!method iattr_writer(name, **options, &block)
       #   Alias for {#instance_attribute_writer}
+      #   @see #instance_attribute_writer
       alias iattr_writer instance_attribute_writer
 
+      # @!method iattr_setter(name, &block)
+      #   Alias for {#instance_attribute_setter}
+      #   @see #instance_attribute_setter
+      alias iattr_setter instance_attribute_setter
+
+      # @!method iattr_alias(name, &block)
+      #   Alias for {#instance_attribute_alias}
+      #   @see #instance_attribute_alias
+      alias iattr_alias instance_attribute_alias
+
       # @!method iattrs
       #   Alias for {#instance_attributes}
+      #   @see #instance_attributes
       alias iattrs instance_attributes
 
       # @!method iattr_defined?(name)
       #   Alias for {#instance_attribute_defined?}
+      #   @see #instance_attribute_defined?
       alias iattr_defined? instance_attribute_defined?
 
       # @!method iattr_definition(name)
       #   Alias for {#instance_attribute_definition}
+      #   @see #instance_attribute_definition
       alias iattr_definition instance_attribute_definition
 
       private
 
+      # Defines a single instance-level attribute.
+      #
+      # This is the internal implementation used by {.instance_attribute} and its aliases.
+      # It creates a `Cattri::Attribute`, registers it, and defines the appropriate
+      # reader and/or writer methods on the class.
+      #
+      # @param name [Symbol, String] the attribute name
+      # @param options [Hash] additional options for the attribute
+      # @param block [Proc, nil] optional setter coercion logic
+      #
+      # @raise [Cattri::AttributeDefinedError] if the attribute has already been defined
+      # @raise [Cattri::AttributeDefinitionError] if method definition fails
+      #
+      # @return [void]
+      def define_instance_attribute(name, options, block) # rubocop:disable Metrics/AbcSize
+        options[:access] ||= __cattri_visibility
+        attribute = Cattri::Attribute.new(name, :instance, options, block)
+
+        raise Cattri::AttributeDefinedError.new(:instance, name) if instance_attribute_defined?(attribute.name)
+
+        begin
+          __cattri_instance_attributes[name.to_sym] = attribute
+          Cattri::AttributeDefiner.define_accessor(attribute, context)
+        rescue StandardError => e
+          raise Cattri::AttributeDefinitionError.new(self, attribute, e)
+        end
+
+        context.define_method(attribute, name: :"#{name}?") { !!send(attribute.name) } if options[:predicate]
+      end
+
       # Internal registry of instance attributes defined on the class.
       #
       # @return [Hash{Symbol => Cattri::Attribute}]

data/lib/cattri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cattri
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cattri
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Nathan Lucas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-22 00:00:00.000000000 Z
+date: 2025-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec