minitwin 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0d2a4f4cc32ed09cb11728a1f8b81edf576da9cfe341a3cf287a42d37d1adf5
+  data.tar.gz: 23ea54c1c77af14a3782a70e617e4bc4fbbf206cc5f72df45de5ca67c7e0939c
+SHA512:
+  metadata.gz: a6f55c0a7e9b703b6451174d71f9835d3436728cad385a592133f385699a57fb26389255c073a5d4d043e970439d98f69126cc87b989a392a9586eb8689efcf6
+  data.tar.gz: 72b755ef287bccb6eff9e7f3d9d8e3b32457cedf24f02bd1f93bab5679a7f1358d7dbdf1577011c41dd567bb820f7e67fba78e7b4f0d3ff460e8481ce8120bec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 webit!
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Minitwin
+
+![Minitwin Logo](logo.png){width=20%}
+
+## What is Minitwin?
+
+It is a tiny presentation layer with a small DSL to define properties, collections, light type coercion via dry-types, and optional ActiveModel validations. It's designed to be framework-friendly but not framework-bound.
+
+
+## Dependencies
+
+- **Ruby** `>= 3.3`
+- **[dry-types](https://dry-rb.org/gems/dry-types)** _(optional)_ — enables the `type:` coercion option on properties
+- **[activesupport](https://github.com/rails/rails/tree/main/activesupport)** _(optional)_ — `to_hash` returns `HashWithIndifferentAccess` when available, otherwise a plain Hash
+- **[activemodel](https://github.com/rails/rails/tree/main/activemodel)** _(optional)_ — enables the `validates:` DSL and `valid?`; without it, twins are always considered valid
+
+
+## Getting Started
+
+Add to your Gemfile:
+
+`gem "minitwin"`
+
+Or build and install locally:
+
+`gem build minitwin.gemspec && gem install minitwin-*.gem`
+
+Then define your first Twin:
+
+```ruby
+class UserTwin < Minitwin
+  property :id, type: Types::Params::Integer.lax
+  property :name, validates: { presence: true }
+  property :active, type: Types::Params::Bool.lax
+end
+
+user = UserTwin.from_hash(
+  id: "42",
+  name: "Alex",
+  active: "1"
+)
+user.id     #=> 42 (coerced)
+user.name   #=> "Alex"
+user.active #=> true (coerced)
+
+user.to_json
+#=> '{"id":42,"name":"Alex","active":true}'
+```
+
+See [USAGE](./USAGE.md) for further examples.
+
+
+## RBS
+
+Minitwin comes with basic RBS signature files for its public interface. If you want to use them in
+your project, you have to declare the dependency explicitly in your `rbs_collection.yaml` like so:
+
+```yaml
+  gems:
+    - name: minitwin
+```
+
+Furthermore, Minitwin ships with a rake task, which generates the RBS signature files for all your
+classes inheriting from `Minitwin`.
+
+If you use Rails, the task is automatically loaded. Just run:
+```bash
+rails minitwin:generate_rbs
+```
+
+If you work with plain Ruby, you have to load the task in your `Rakefile`:
+
+```ruby
+load Gem.find_files("tasks/minitwin.rake").first
+```
+
+Then run the task:
+```bash
+rake minitwin:generate_rbs
+```
+
+By default, the task will output the rbs files in `sig/generated/`. You can adjust this by setting
+a task argument or an ENV var `MINITWIN_RBS_DIR`. If both is set, the argument will be used.
+
+```bash
+rake minitwin:generate_rbs[sig/custom_path]
+
+MINITWIN_RBS_DIR=sig/custom_path rake minitwin:generate_rbs
+```
+
+
+## Inspiration
+
+Minitwin was inspired by [Disposable](https://github.com/apotonick/disposable), a gem for building twin objects as a decorator layer on top of your domain models.
+
+
+## License
+
+Minitwin is licensed under the MIT License. See [LICENSE](./LICENSE) for more details.

data/USAGE.md

@@ -0,0 +1,390 @@
+# Usage
+
+- [Basic](#basic)
+- [Block properties](#block-properties)
+- [Collection properties](#collection-properties)
+- [Nested properties](#nested-properties)
+- [Aliases](#aliases)
+- [Coercion](#coercion)
+- [Validations](#validations)
+- [Working with objects](#working-with-objects)
+- [Composition](#composition)
+- [DSL Reference](#dsl-reference)
+- [Public Interface](#public-interface)
+
+## Basic
+
+Define properties and instantiate a twin from a hash:
+
+```ruby
+class ArticleTwin < Minitwin
+  property :title
+  property :published
+end
+
+article = ArticleTwin.from_hash(title: "Hello", published: true)
+article.title      #=> "Hello"
+article.published  #=> true
+
+article.to_hash    #=> { title: "Hello", published: true }
+article.to_json    #=> '{"title":"Hello","published":true}'
+```
+
+## Block properties
+
+A block creates an anonymous nested twin class for the property:
+
+```ruby
+class PostTwin < Minitwin
+  property :title
+  property :author do
+    property :name
+    property :email
+  end
+end
+
+post = PostTwin.from_hash(title: "Hi", author: { name: "Ana", email: "ana@example.com" })
+post.author.name   #=> "Ana"
+post.to_hash       #=> { title: "Hi", author: { name: "Ana", email: "ana@example.com" } }
+```
+
+Use `twin:` to reference an existing twin class instead of defining an inline block:
+
+```ruby
+class AddressTwin < Minitwin
+  property :city
+end
+
+class UserTwin < Minitwin
+  property :name
+  property :address, twin: AddressTwin
+end
+
+user = UserTwin.from_hash(name: "Bob", address: { city: "Berlin" })
+user.address.city  #=> "Berlin"
+```
+
+## Collection properties
+
+`collection` defines an array property. Each element can be a plain value or a nested twin:
+
+```ruby
+class InvoiceTwin < Minitwin
+  collection :tags
+end
+
+inv = InvoiceTwin.from_hash(tags: %w[urgent vip])
+inv.tags  #=> ["urgent", "vip"]
+```
+
+With a block, each element becomes a twin instance:
+
+```ruby
+class OrderTwin < Minitwin
+  collection :lines do
+    property :product
+    property :qty
+  end
+end
+
+order = OrderTwin.from_hash(lines: [
+  { product: "Mug", qty: 2 },
+  { product: "Shirt", qty: 1 }
+])
+order.lines.first.product  #=> "Mug"
+order.to_hash
+#=> { lines: [{ product: "Mug", qty: 2 }, { product: "Shirt", qty: 1 }] }
+```
+
+## Nested properties
+
+`nested` groups properties under a container key in serialization while keeping a flat write API on the parent:
+
+```ruby
+class ProfileTwin < Minitwin
+  property :username
+  nested :settings do
+    property :theme
+    property :locale
+  end
+end
+
+t = ProfileTwin.from_hash(username: "dana", theme: "dark", locale: "en")
+t.theme     #=> "dark"
+t.to_hash   #=> { username: "dana", settings: { theme: "dark", locale: "en" } }
+```
+
+`nested` also accepts `as:` to rename the container key in serialization, the same
+way `property` does. Because the block uses the plain `name` internally, the alias
+may be any symbol — even one that is not a valid method or instance variable name:
+
+```ruby
+nested :settings, as: :"app:settings" do
+  property :theme
+end
+#=> { :"app:settings" => { theme: "dark" } }
+```
+
+## Aliases
+
+A static alias (symbol) renames the public getter and protects the original name. The serialized key follows the alias:
+
+```ruby
+class TokenTwin < Minitwin
+  property :internal_token, as: :token
+end
+
+t = TokenTwin.from_hash(internal_token: "abc")
+t.token    #=> "abc"
+t.to_hash  #=> { token: "abc" }
+```
+
+A dynamic alias (lambda) is evaluated per instance, so the public name can depend on other attributes:
+
+```ruby
+class FieldTwin < Minitwin
+  property :key
+  property :value, as: -> { key }
+end
+
+t = FieldTwin.from_hash(key: "score", value: 42)
+t.score    #=> 42
+t.to_hash  #=> { key: "score", score: 42 }
+
+t.key   = "total"
+t.value = 99
+t.total    #=> 99
+t.to_hash  #=> { key: "total", total: 99 }
+```
+
+The lambda runs in instance context, so any reader on the twin is available. `as:` works the same way on `collection`.
+
+## Coercion
+
+Use `type:` with dry-types to coerce values on assignment. Coercion errors fall back to the raw value instead of raising:
+
+```ruby
+class EventTwin < Minitwin
+  property :visitor_count, type: Types::Params::Integer.lax
+  property :active,        type: Types::Params::Bool.lax
+end
+
+ev = EventTwin.from_hash(visitor_count: "42", active: "1")
+ev.visitor_count  #=> 42
+ev.active         #=> true
+```
+
+## Validations
+
+When ActiveModel is available, pass `validates:` to apply validations. Errors from nested twins and collections are aggregated on the parent:
+
+```ruby
+class ContactTwin < Minitwin
+  property :email, validates: { presence: true, format: { with: URI::MailTo::EMAIL_REGEXP } }
+  property :name,  validates: { presence: true }
+end
+
+c = ContactTwin.from_hash(email: "", name: "")
+c.valid?           #=> false
+c.errors.full_messages
+#=> ["Email can't be blank", "Email is invalid", "Name can't be blank"]
+```
+
+Validations propagate from nested twins:
+
+```ruby
+class RegistrationTwin < Minitwin
+  property :contact do
+    property :email, validates: { presence: true }
+  end
+end
+
+r = RegistrationTwin.from_hash(contact: { email: "" })
+r.valid?  #=> false
+r.errors.full_messages  #=> ["contact.email can't be blank"]
+```
+
+## Working with objects
+
+`from_object` reads attributes from any object with `attributes`, `to_h`, or readers:
+
+```ruby
+class UserTwin < Minitwin
+  property :name
+  property :email
+end
+
+User = Data.define(:name, :email)
+user = UserTwin.from_object(User.new(name: "Alex", email: "alex@example.com"))
+user.name  #=> "Alex"
+```
+
+`assign_hash` updates an existing twin in place (only known attributes):
+
+```ruby
+twin = UserTwin.from_hash(name: "Alex", email: "old@example.com")
+twin.assign_hash(email: "new@example.com")
+twin.email  #=> "new@example.com"
+```
+
+`sync` writes values back to the original model. It uses the stored reference from `from_object`, so no argument is needed:
+
+```ruby
+class ItemTwin < Minitwin
+  property :name
+  property :price
+end
+
+class Item
+  attr_accessor :name, :price
+
+  def initialize(name:, price:)
+    @name  = name
+    @price = price
+  end
+end
+
+item = Item.new(name: "Book", price: 10)
+twin = ItemTwin.from_object(item)
+
+twin.price = 20
+twin.sync    #=> true
+
+item.price   #=> 20
+```
+
+## Composition
+
+Use `on:` to read a property from a specific source object instead of storing the value on the twin itself:
+
+```ruby
+class SummaryTwin < Minitwin
+  property :id,    on: :order
+  property :total, on: :order
+  property :name,  on: :customer
+end
+
+Order    = Data.define(:id, :total)
+Customer = Data.define(:name)
+
+summary = SummaryTwin.from_objects(
+  order:    Order.new(id: 7, total: 99.0),
+  customer: Customer.new(name: "Dana")
+)
+summary.id     #=> 7
+summary.name   #=> "Dana"
+```
+
+---
+
+## DSL Reference
+
+### `property`
+
+| Option | Description |
+|---|---|
+| `as:` | Public getter name. Protects the original name. Accepts a symbol or a lambda `-> { ... }` for dynamic aliases computed per instance. |
+| `default:` | Default value when the property is `nil`. Accepts a callable (`-> { ... }`) for computed defaults. |
+| `type:` | A dry-types type for coercion on assignment (e.g. `Types::Params::Integer.lax`). Errors fall back to the raw value. |
+| `twin:` | Wraps the value in another twin class. Accepts a hash, a twin instance, or an object with `to_h`/`attributes`. |
+| `expose:` | `false` omits the property from `to_hash`/`to_json`. |
+| `readonly:` | `true` prevents assignment via `assign_hash` and `assign_params`. |
+| `getter:` | A lambda `-> { ... }` or a symbol `:method_name` that fully replaces the generated getter. The lambda runs in instance context; the symbol calls the named method on the instance. If the lambda or method accepts a parameter, the current raw property value is passed as the argument. |
+| `setter:` | A lambda `->(value) { ... }` that fully replaces the generated setter. Not allowed together with a block. |
+| `on:` | Reads the value from a named composition source (see `from_objects`). |
+| `validates:` | ActiveModel validation options, e.g. `{ presence: true }`. Ignored when ActiveModel is not available. |
+| block | Defines an inline nested twin class. Mutually exclusive with `setter:`. |
+
+### `collection`
+
+| Option | Description |
+|---|---|
+| `as:` | Public getter name. Accepts a symbol or a lambda `-> { ... }` for dynamic aliases. |
+| `default:` | Default value. Defaults to `[]`. |
+| `twin:` | Wraps each element in the given twin class. |
+| `getter:` | A lambda `-> { ... }` or a symbol `:method_name` that fully replaces the generated getter. The lambda runs in instance context; the symbol calls the named method on the instance. If the lambda or method accepts a parameter, the current raw property value is passed as the argument. |
+| `on:` | Reads the collection from a named composition source. Each element is wrapped in the element twin when one is configured. |
+| `validates:` | ActiveModel validation options applied to the collection property itself. |
+| block | Defines an inline nested twin class used for each element. |
+
+### `nested`
+
+Groups properties under a container key in serialization while keeping a flat read/write API on the parent twin. Requires a block.
+
+```ruby
+nested :address do
+  property :city
+  property :zip
+end
+```
+
+The leaf properties (`city`, `zip`) are accessible directly on the parent instance. `to_hash` places them under the `address` key.
+
+| Option | Description |
+|---|---|
+| block | Required. Defines the nested twin class. |
+| `as:` | Renames the container key in serialization. Accepts any symbol, including one that is not a valid identifier. |
+
+---
+
+## Public Interface
+
+### Class methods
+
+**Constructors**
+
+| Method | Description |
+|---|---|
+| `from_hash(hash)` | Instantiates a twin from a plain Ruby Hash. |
+| `from_json(string)` | Parses a JSON string and delegates to `from_hash`. |
+| `from_params(params)` | Accepts `ActionController::Parameters` or a plain Hash. Unwraps `to_unsafe_h` automatically. |
+| `from_object(model)` | Reads attributes from a single object via `attributes`, `to_h`, or readers. Stores the object for later `sync`. |
+| `from_objects(**models)` | Merges attributes from multiple named objects. Last value wins on key conflicts. Stored objects are available as composition sources via `on:`. |
+| `from_collection(array)` | Applies `from_objects` semantics to each element and returns an array of twins. |
+
+**Other**
+
+| Method | Description |
+|---|---|
+| `to_rbs` | Returns an RBS signature string for the twin class. |
+
+---
+
+### Instance methods
+
+**Serialization**
+
+| Method | Description |
+|---|---|
+| `to_hash(render_nil: false)` | Returns the twin as a Hash (or `HashWithIndifferentAccess` when ActiveSupport is available). Nested twins are serialized recursively. Unexposed properties are omitted. |
+| `to_h` | Alias for `to_hash`. |
+| `to_json` | Delegates to `to_hash.to_json`. |
+| `attributes` | Returns a Hash keyed by the original setter names (before any `as:` aliasing). Includes protected readers. |
+| `pretty_print(q)` | Integrates with Ruby's `pp` library. Outputs the twin with class name, properties in definition order, and nested twins recursively formatted with their own class names. |
+
+**Validation**
+
+| Method | Description |
+|---|---|
+| `valid?` | Returns `true` when all validations pass. Without ActiveModel, always returns `true`. Errors from nested twins and collections are aggregated with dot/bracket paths (e.g. `contact.email`, `lines[0].qty`). |
+
+**Assignment**
+
+| Method | Description |
+|---|---|
+| `assign_hash(hash)` | Updates known attributes in place from a Hash. Recurses into nested twins and collection elements. |
+| `assign_params(params)` | Like `assign_hash`, but also accepts `ActionController::Parameters`. |
+| `assign_object(model)` | Copies matching attributes from an object via its readers and stores the object for later `sync`. |
+| `to_object(model)` | Mirrors the twin's values into an existing model via its writers. Does not store the model. |
+
+**Sync**
+
+| Method | Description |
+|---|---|
+| `sync(model = nil, validate: true)` | Writes the twin's values back to the model. When `model` is omitted, uses the object stored by `from_object`/`assign_object`. Returns `false` when validation fails or no model is available. Recurses into nested twins and collection elements. |
+
+**Introspection**
+
+| Method | Description |
+|---|---|
+| `dynamic_aliases` | Returns a Hash of `alias_name => target_method` for all dynamic aliases active on the current instance. |

data/lib/minitwin/assignment.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Minitwin
+  # Assign/update helpers to merge incoming data into an existing twin.
+  # - assign_object: copy readable attributes from an object and remember it
+  # - assign_hash / assign_params: update only known attributes, recursing into
+  #   nested twins and collection items when possible
+  module Assignment
+
+    # Mirror values from a model's getters into this twin's setters
+    #: (untyped) -> instance
+    def to_object(model)
+      assignable_attribute_methods.each do |method|
+        next unless model.respond_to?(method)
+
+        value = model.public_send(method)
+
+        ivar_name = Minitwin::Utils.ivar_name(method)
+        current_value = instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+
+        if current_value.is_a?(Minitwin) && !value.nil? && !value.is_a?(Hash)
+          current_value.to_object(value)
+        elsif respond_to?("#{method}=", true)
+          send("#{method}=", value)
+        end
+      end
+      self
+    end
+
+    #: (untyped) -> instance
+    def assign_object(model)
+      to_object(model)
+      instance_variable_set(self.class.internal_model_name("model"), model)
+      self
+    end
+
+    #: (Hash[ String | Symbol, untyped ] hash) -> instance
+    def assign_hash(hash = {})
+      hash = hash.to_h.transform_keys(&:to_sym)
+      allowed = assignable_attribute_methods
+
+      was_skipping = @__skip_alias_recompute__
+      @__skip_alias_recompute__ = true
+      begin
+        hash.each do |method, value|
+          next unless allowed.include?(method)
+
+          ivar_name = Minitwin::Utils.ivar_name(method)
+          current_value = instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+
+          if current_value.respond_to?(:assign_hash) && value.is_a?(Hash)
+            current_value.assign_hash(value)
+          elsif value.is_a?(Array) && current_value.is_a?(Array)
+            value.each_with_index do |item, idx|
+              if item.is_a?(Hash) && current_value.size > idx && current_value[idx].respond_to?(:assign_hash)
+                current_value[idx].assign_hash(item)
+              else
+                current_value[idx] = item
+              end
+            end
+          elsif respond_to?("#{method}=", true)
+            send("#{method}=", value)
+          end
+        end
+      ensure
+        @__skip_alias_recompute__ = was_skipping
+      end
+
+      if !@__skip_alias_recompute__ && self.class.dynamic_aliases?
+        __recompute_dynamic_aliases__
+      end
+
+      self
+    end
+
+    # Actually, this is expected to be an `ActionController::Parameters`
+    # object. The type will be unknown when used without rails. So for RBS
+    # the argument is typed `untyped`.
+    #: (untyped params) -> instance
+    def assign_params(params = {})
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+      assign_hash(params)
+    end
+
+    # Gets the non-readonly methods, which can be assigned with new values.
+    #: () -> Array[Symbol]
+    def assignable_attribute_methods
+      attribute_methods.reject do |method|
+        prop_meta = self.class.properties[method]
+        prop_meta && prop_meta[:readonly]
+      end
+    end
+  end
+end

data/lib/minitwin/class_methods/caches.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Minitwin
+  module ClassMethods
+    module Caches
+
+      #: () -> bool
+      def dynamic_aliases?
+        return @has_dynamic_aliases_cache unless @has_dynamic_aliases_cache.nil?
+
+        @has_dynamic_aliases_cache = begin
+          procs = properties.any? { |_, m| m[:as].is_a?(Proc) } ||
+            collections.any? { |_, m| m[:as].is_a?(Proc) }
+          nested = respond_to?(:dynamic_nested_aliases) && dynamic_nested_aliases.any?
+          procs || nested
+        end
+      end
+
+      private
+
+      def invalidate_caches
+        @serializable_getters = nil
+        @allowed_attribute_keys = nil
+        @allowed_attribute_keys_array = nil
+        @setter_methods = nil
+        @has_dynamic_aliases_cache = nil
+      end
+
+      def serializable_getters
+        @serializable_getters ||= begin
+          unexposed = unexposed_properties.to_set(&:to_sym)
+          prot = (protected_instance_methods - Minitwin.protected_instance_methods).to_set
+          declared = declared_property_keys
+          own_and_inherited = serializable_method_candidates
+          own_and_inherited.reject do |m|
+            s = m.to_s
+            s.end_with?("=", "?", "_attributes") || unexposed.include?(m) || prot.include?(m) ||
+              !declared.include?(instance_method(m).original_name)
+          end
+        end
+      end
+
+      # Methods defined directly on the twin class hierarchy: this class and any
+      # intermediate Minitwin subclasses, but not Minitwin itself. Methods mixed
+      # in via modules (e.g. ActionView helpers, which include arg-taking methods
+      # like #link_to) are excluded because instance_methods(false) reports only
+      # methods owned by the class, not by included modules.
+      def serializable_method_candidates
+        twin_class_hierarchy.flat_map { |klass| klass.instance_methods(false) }.uniq
+      end
+
+      # Base names of every declared property and collection across the twin
+      # class hierarchy. Only methods whose declaration name is one of these
+      # serialize, so plain getters hand-defined on a twin are excluded. `as:`
+      # aliases pass because #original_name maps them back to the original
+      # property (the aliased reader is made protected and rejected separately).
+      def declared_property_keys
+        twin_class_hierarchy.each_with_object(Set.new) do |klass, keys|
+          keys.merge(klass.properties.keys)
+          keys.merge(klass.collections.keys)
+        end
+      end
+
+      # This class and any intermediate Minitwin subclasses, but not Minitwin
+      # itself or mixed-in modules.
+      def twin_class_hierarchy
+        ancestors.take_while { |a| a != Minitwin }.select { |a| a.instance_of?(Class) }
+      end
+
+      def allowed_attribute_keys
+        # Setters defined directly on the twin class hierarchy. Uses the same
+        # candidate set as serializable_getters so mixed-in module setters
+        # (e.g. ActionView's #output_buffer=) are not treated as assignable
+        # attributes.
+        @allowed_attribute_keys ||= serializable_method_candidates.
+                                      grep(/=\z/).to_set { |m| m.to_s.delete_suffix("=").to_sym }
+      end
+
+      def allowed_attribute_keys_array
+        @allowed_attribute_keys_array ||= begin
+          allowed = allowed_attribute_keys
+          ordered = property_order.select { |k| allowed.include?(k) }
+          remaining = allowed.to_a - ordered
+          (ordered + remaining).freeze
+        end
+      end
+
+      def setter_methods
+        @setter_methods ||= public_instance_methods(false).select { |m| m.to_s.end_with?("=") }
+      end
+    end
+  end
+end