money_attribute 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a26cda78a2361b592ca6f90c1afb5f8637792b432038d45b543aa562624d6349
-  data.tar.gz: 0e9d78eaf7c8118942676f81f4dbebe55614663469d0d8f3095622fc0def3dca
+  metadata.gz: 4101988f3c8acc6d5a4810519fa74d1fd27feaba2114ee047ecd755da3229c91
+  data.tar.gz: 2a7071882d41791e33c3d189bd5db42ea39b434c597f64a3c5b6ae88facd7e82
 SHA512:
-  metadata.gz: 4ba8368b5c3c11be2375368399113b1526b1e2d9f347b2e5d16499a64577dffb5b846a876ba4d04967e8ac8a76fccc717aafb8caaefd25c83bb7dc61ce22839e
-  data.tar.gz: 52dd36ef69c80695f8e22802e5486332d94d5afcc4e48cf671847705b3120de5ecfb636b191fe629077d8f6ebb35a2dcbd5b6a716f031bdb918a35abe32d23fa
+  metadata.gz: eac6fb9ca6ef50c717fc51b8c4aac7977e425787ea98032ae02e66091f74a66158b1f19f401b5b15df3cf8dc7a402aba942e9c7b55f1dc054ec2c617114d2c87
+  data.tar.gz: 2216348ddfa7df7d97ddacfe12d15a895d2e1c9ac28392719c14add69741a177ab5064b5a8da5befde3ec9b28a028e37924b4f3db433a2a70af626af5e619ddc

data/README.md

@@ -5,7 +5,7 @@
 
 Store and read Active Record attributes as `Money` objects with no manual serialization.
 
-`money_attribute` uses two DB columns (amount + currency) for per-row multi-currency data. A simpler `money_amount` variant is also available for fixed-currency models (see [note](#single-column-mode-money_amount-fixed-currency)).
+`money_attribute` uses two DB columns (amount + currency) for per-row multi-currency data.
 
 ```ruby
 class Product < ApplicationRecord
@@ -68,16 +68,16 @@ That's it. `Product.new(price: 12.dollars).price` is a `Money`.
 - **No serialization boilerplate** — declare once, read/write `Money` everywhere.
 - **Integer or decimal columns** — auto-detects the column type and adjusts serialization (e.g. integer stores cents, decimal stores unit value).
 - **Normalizes everything** — pass a number, string, or `Money`; always get a `Money` back.
-- **Currency enforcement** — fixed-currency attributes reject wrong currencies at assignment time.
+- **Currency handling** — each record stores its own currency and accepts registered currencies at assignment time.
 - **Built on Rails primitives** — uses `ActiveRecord::Type`, `composed_of`, and `normalizes` under the hood. No monkey-patching of core classes.
 
 ### At a glance — vs money-rails
 
 | Feature | MoneyAttribute | money-rails |
 |---|---|---|
-| **Declare** | `t.money_attribute :price` / `money_attribute :price` or `t.money_amount :price` / `money_amount :price` | `monetize :price_cents` |
+| **Declare** | `t.money_attribute :price` / `money_attribute :price` | `monetize :price_cents` |
 | **Column types** | `integer`, `decimal`, `bigint` — auto-detected | `integer` cents only |
-| **Storage modes** | Composite (amount+currency), single column | Single cents column, composite (cents+currency) |
+| **Storage mode** | Composite (amount+currency) | Single cents column, composite (cents+currency) |
 | **Decimal columns** | Native — `t.decimal :price` | Not supported — must convert to cents manually |
 | **Multi-currency** | `money_attribute :price` (convention: `<name>_amount` + `<name>_currency`) | `monetize :price_cents, with_currency: :price_currency` |
 | **Rails integration** | `ActiveRecord::Type` + `composed_of` — no monkey-patches | `monetize` overrides reader/writer methods |
@@ -149,7 +149,33 @@ class AddPriceToProducts < ActiveRecord::Migration[8.1]
 end
 ```
 
-### Naming
+### Default column names
+
+For `money_attribute :price`, the default columns are `price` for the amount
+and `price_currency` for the currency. The migration helper and model macro use
+the same mapping:
+
+```ruby
+create_table :products do |t|
+  t.money_attribute :price
+end
+
+class Product < ApplicationRecord
+  money_attribute :price
+end
+```
+
+This creates and maps to:
+
+```text
+price
+price_currency
+```
+
+The amount column defaults to `decimal(20,4)` and the currency column defaults
+to `string(16)`.
+
+### Naming options
 
 **`money_attribute` (composite):**
 
@@ -158,7 +184,7 @@ end
 | `t.money_attribute :price` | `price` decimal(20,4) + `price_currency` string(16) | `money_attribute :price` |
 | `t.money_attribute :price_amount` | `price_amount` decimal(20,4) + `price_currency` string(16) | `money_attribute :price` |
 | `t.money_attribute :price, amount: { type: :fiat_integer }` | `price` bigint + `price_currency` string(16) | `money_attribute :price` |
-| `t.money_attribute :price, amount: { column: :a }, currency: { column: :c }` | `a` + `c` | `money_attribute :price, mapping: { amount: :a, currency: :c }` |
+| `t.money_attribute :price, amount: { column: :a }, currency: { column: :c }` | `a` + `c` | `money_attribute :price, amount: { column: :a }, currency: { column: :c }` |
 | `t.money_attribute :price, currency: { limit: 5 }` | `price` decimal(20,4) + `price_currency` string(5) | `money_attribute :price` |
 | `t.remove_money_attribute :price` | Removes `price` + `price_currency` | `money_attribute :price` |
 
@@ -281,26 +307,30 @@ Order.new(total: 19.99.to_money('USD')).total_amount # => 1999
 
 ## Custom column names
 
-If your columns don't follow the `<name>_amount` / `<name>_currency` convention:
+If your columns do not follow the default mapping, use the same nested column
+options as the migration helper:
 
 ```ruby
 class Invoice < ApplicationRecord
-  money_attribute :total, mapping: {
-    amount:   :total_amount,
-    currency: :currency_code
-  }
+  money_attribute :total,
+    amount: { column: :total_amount },
+    currency: { column: :currency_code }
 end
 ```
 
-The mapping keys are `:amount` and `:currency`; values are your database column names. You can provide only one key — the other falls back to the `<name>_amount` / `<name>_currency` convention:
+You can provide only one nested option; the other falls back to the default
+mapping. The older `mapping:` syntax remains supported (but it will eventually be deprecated):
 
 ```ruby
 class Invoice < ApplicationRecord
-  money_attribute :total, mapping: { amount: :total_amount }
-  # currency column inferred as `total_currency`
+  money_attribute :total, amount: { column: :total_amount }
+  money_attribute :subtotal, mapping: { amount: :subtotal }
 end
 ```
 
+Model declarations accept only the nested `:column` option. Migration-only
+options such as `:type`, `:null`, and `:default` belong in the migration.
+
 ## Column resolution
 
 `money_attribute :name` is always composite. Columns are resolved in two phases:
@@ -313,6 +343,11 @@ end
 | `name == 'amount'` AND `currency` exists | `amount` + `currency` |
 | Otherwise | `<name>_amount` + `<name>_currency` |
 
+The first row is the canonical mapping used by the migration helpers. The
+final row supports existing schemas that use the `<name>_amount` /
+`<name>_currency` convention. For example, `money_attribute :price` also maps
+to `price_amount` + `price_currency` when those are the available columns.
+
 **Phase 2 — Override** via `mapping:` is merged on top of the default. Missing keys inherit from the default mapping:
 
 ```ruby
@@ -320,7 +355,7 @@ money_attribute :total, mapping: { amount: :total_amount }
 # currency falls back to default => :total_currency
 ```
 
-Raises `ArgumentError` if the resolved columns don't exist. For single-column fixed-currency attributes, see [`money_amount`](#single-column-mode-money_amount-fixed-currency).
+Raises `ArgumentError` if the resolved columns don't exist. For single-column fixed-currency attributes, see the [advanced `money_amount` section](#advanced-money_amount-single-column-fixed-currency).
 
 **Example**
 
@@ -332,7 +367,6 @@ create_table :financial_transactions do |t|
   t.string  :discount_currency, limit: 3
   t.decimal :price_amount
   t.string  :price_currency, limit: 3
-  t.bigint  :tax
   t.decimal :total_amount
   t.string  :currency_code, limit: 3
 end
@@ -344,7 +378,6 @@ class FinancialTransaction < ApplicationRecord
   money_attribute :discount                 # step 2: discount(int) + discount_currency
   money_attribute :price                    # step 4: price_amount + price_currency
   money_attribute :total, mapping: { amount: :total_amount, currency: :currency_code }  # step 1: explicit
-  money_amount  :tax                        # single-column, fixed-currency (uses default currency)
 end
 ```
 
@@ -355,7 +388,7 @@ end
 Multi-currency (`money_attribute`) attributes support equality queries via `composed_of`:
 
 ```ruby
-Offer.where(price: 10.to_money('EUR'))
+Offer.where(price: 10.euros)
 ```
 
 For comparisons, use the backing columns directly:
@@ -365,15 +398,25 @@ Offer.where(price_amount: 10..20, price_currency: 'EUR')
 Offer.where('price_amount > ? AND price_currency = ?', 10, 'EUR')
 ```
 
-Fixed-currency (`money_amount`) attributes support full Rails-native querying through the custom type — equality, IN, BETWEEN, ordering, and aggregation all work:
+### Composite query matrix
 
-```ruby
-Product.where(price: 10.to_money('USD'))                        # equality
-Product.where(price: [10.to_money('USD'), 20.to_money('USD')]) # IN
-Product.where(price: 10.to_money('USD')..20.to_money('USD'))   # BETWEEN
-Product.order(price: :desc)                                     # ordering
-Product.where(price: 10.to_money('USD')).sum(:price)            # aggregation
-```
+For `money_attribute`, use native Rails queries for simple equality. Use the
+money-aware helpers when working with `Money` objects or when you need an
+explicit currency filter alongside an amount query:
+
+| Operation | Native Rails | Money-aware helper |
+|---|---|---|
+| Equality | `where(price: 10.euros)` | `where_amount(price: 10.euros)` |
+| `IN` | Query backing columns directly | `where_amount(price: [10.euros, 20.euros])` |
+| Range/comparison | Query backing columns directly | `where_currency(price: 'EUR').where_amount(price: 10.euros..20.euros)` |
+| Currency filter | `where(price_currency: 'EUR')` | `where_currency(price: 'EUR')` |
+| Ordering | Query backing columns directly | `order_by_amount(price: :desc)` |
+| Pluck | Returns backing column values | `pluck_amount(:price)` returns `Money` |
+| Pick | Returns backing column values | `pick_amount(:price)` returns `Money` |
+| Sum | Group and sum backing columns directly | `sum_amount(:price)` groups by currency |
+
+`where_amount` accepts `Money` values and converts them to the backing amount
+unit. Pair it with `where_currency` when the currency must be constrained.
 
 ### Money-aware query helpers
 
@@ -384,35 +427,28 @@ For multi-currency attributes, manually decomposing columns is tedious. The quer
 Filters by amount value. Accepts a scalar, Range, or Array.
 
 ```ruby
-Offer.where_amount(price: 10)               # equality (any currency)
-Offer.where_amount(price: [10, 30])         # IN — matches EUR 10, USD 30
-Offer.where_amount(price: 10..100)          # BETWEEN (inclusive)
-Offer.where_amount(price: 10...100)         # BETWEEN (exclusive upper bound)
+Offer.where_amount(price: 10.euros)                    # equality
+Offer.where_amount(price: [10.euros, 30.euros])        # IN
+Offer.where_amount(price: 10.euros..100.euros)         # BETWEEN (inclusive)
+Offer.where_amount(price: 10.euros...100.euros)        # BETWEEN (exclusive upper bound)
 ```
 
-Ranges work across currencies — `10..50` matches EUR 10 and USD 50:
+For a currency-specific range, constrain the currency explicitly:
 
 ```ruby
 Offer.create!(price: 10.euros)
-Offer.create!(price: 50.dollars)
+Offer.create!(price: 50.euros)
 
-Offer.where_amount(price: 10..50)           # => both records
+Offer.where_currency(price: 'EUR').where_amount(price: 10.euros..50.euros) # => both records
 ```
 
 For integer (subunit) columns, pass `Money` objects directly — subunit conversion is handled automatically:
 
 ```ruby
-FinancialTransaction.where_amount(amount: [10.dollars, 10.yens])
+FinancialTransaction.where_amount(amount: [10.dollars, 20.dollars])
 FinancialTransaction.where_amount(amount: 10.dollars..100.dollars)
 ```
 
-For decimal columns, raw numbers work:
-
-```ruby
-SimpleOffer.where_amount(price: 50)
-SimpleOffer.where_amount(price: 10..100)
-```
-
 #### `where_currency`
 
 Filters by currency code. Composite attributes only — raises `ArgumentError` for single-column attributes.
@@ -470,6 +506,20 @@ Offer.none.sum_amount(:price)
 
 All query helpers raise `ArgumentError` for non-money attributes. Internally, money attribute metadata is registered per model class. The same attribute name can be used safely in different models, but subclasses do not automatically inherit a parent model's registered money attributes.
 
+### Introspection
+
+Use `money_attribute?` and `money_attribute_kind` when building generic model
+or form code:
+
+```ruby
+Product.money_attribute?(:price)       # => true
+Product.money_attribute_kind(:price)   # => :composite or :single
+Product.money_attribute?(:unknown)     # => false
+```
+
+`money_attribute_kind` returns `:composite` for `money_attribute`, `:single`
+for `money_amount`, and `nil` for undeclared attributes.
+
 ## Convenience methods
 
 MoneyAttribute adds small helpers on `Numeric` and `String`:
@@ -484,24 +534,53 @@ MoneyAttribute adds small helpers on `Numeric` and `String`:
 
 ## Form helpers
 
-MoneyAttribute adds `money_field` and `money_amount_field` to Rails form builders. `money_field` renders a text input with the locale-formatted money string; `money_amount_field` renders a number input with the raw decimal value.
+MoneyAttribute adds `money_field` to Rails form builders for composite money attributes. It renders a text input with the locale-formatted money string.
 
 ```erb
 <%= form_with model: @product do |form| %>
   <%= form.label :price %>
   <%= form.money_field :price %>       <!-- text input, e.g. "$1,234.56" -->
-
-  <%= form.label :tax %>
-  <%= form.money_amount_field :tax %>  <!-- number input, e.g. "1234.56" -->
 <% end %>
 ```
 
-### Single-column mode — `money_amount` (fixed-currency)
+The field submits a locale-formatted string under the normal model parameter:
+
+```ruby
+# app/controllers/products_controller.rb
+def create
+  @product = Product.new(product_params)
+
+  if @product.save
+    redirect_to @product
+  else
+    render :new, status: :unprocessable_entity
+  end
+end
+
+private
+
+def product_params
+  params.require(:product).permit(:name, :price)
+end
+```
+
+The model normalizes the submitted string through `MoneyAttribute::Converter`.
+For a composite attribute, provide a separate currency input or set the
+currency explicitly when the form must accept a currency different from the
+configured default.
+
+### Advanced: `money_amount` (single-column, fixed-currency)
 
-`money_amount` wraps a numeric column as `Money` using the application's default currency. No per-row currency. A lighter alternative when you don't need multi-currency support.
+`money_amount` is an advanced compatibility utility for schemas where one
+numeric column stores amounts in one fixed currency. It is not suitable for
+per-row or multi-currency data. New applications should normally use
+`money_attribute`.
 
 The accessor name must match the column name. `money_amount` does not support custom column mapping.
 
+Use `money_amount_field` when rendering a form for this mode; it renders a
+number input with the raw decimal value.
+
 #### Migration helpers
 
 | Method | Action |
@@ -552,7 +631,19 @@ money_amount :price
 
 #### Querying
 
-Fixed-currency attributes support full Rails-native querying — see [Querying](#querying) for examples.
+Fixed-currency attributes support full Rails-native querying. The helper methods
+are also available when a consistent query interface is useful:
+
+| Operation | Native Rails | Money-aware helper |
+|---|---|---|
+| Equality | `where(price: 10.reais)` | `where_amount(price: 10.reais)` |
+| `IN` | `where(price: [10.reais, 20.reais])` | `where_amount(price: [10.reais, 20.reais])` |
+| Range/comparison | `where(price: 10.reais..20.reais)` | `where_amount(price: 10.reais..20.reais)` |
+| Currency filter | Not applicable | Raises `ArgumentError` |
+| Ordering | `order(price: :desc)` | `order_by_amount(price: :desc)` |
+| Pluck | `pluck(:price)` | `pluck_amount(:price)` |
+| Pick | `pick(:price)` | `pick_amount(:price)` |
+| Sum | `sum(:price)` | `sum_amount(:price)` |
 
 ## Roadmap
 

data/Rakefile

@@ -85,3 +85,15 @@ task 'bench:profile' do
   mode = ENV['MODE'] || 'all'
   sh({ 'RAILS_ENV' => 'test' }, 'bundle', 'exec', 'ruby', 'benchmark/profile.rb', mode)
 end
+
+desc 'Run focused performance roadmap benchmarks'
+task 'bench:performance' do
+  sh({ 'RAILS_ENV' => 'test' }, 'bundle', 'exec', 'ruby', 'benchmark/performance.rb')
+end
+
+desc 'Compare two focused performance benchmark result files'
+task 'bench:performance:compare' do
+  baseline = ENV.fetch('BASELINE')
+  current = ENV.fetch('CURRENT')
+  sh 'bundle', 'exec', 'ruby', 'benchmark/compare_performance.rb', baseline, current
+end

data/lib/money_attribute/attribute_spec_registry.rb

@@ -14,6 +14,7 @@ module MoneyAttribute
 
     REGISTRY = Concurrent::Map.new
     PATTERNS = Concurrent::Map.new
+    QUERY_PLANS = Concurrent::Map.new
 
     class_methods do
       # Registers a money attribute spec for the current model class.
@@ -35,6 +36,9 @@ module MoneyAttribute
         )
 
         money_attribute_specs[spec.name] = spec
+        PATTERNS.delete(:"#{self}_name_set")
+        PATTERNS.delete(:"#{self}_name_pattern")
+        QUERY_PLANS.delete(self)
         spec
       end
 
@@ -74,5 +78,31 @@ module MoneyAttribute
         end
       end
     end
+
+    class_methods do
+      # Returns whether the model has a registered money attribute.
+      #
+      # @param name [Symbol, String] the attribute name
+      # @return [Boolean]
+      def money_attribute?(name)
+        !money_attribute_spec(name).nil?
+      end
+
+      # Returns the storage mode for a registered money attribute.
+      #
+      # @param name [Symbol, String] the attribute name
+      # @return [Symbol, nil] +:composite+, +:single+, or +nil+
+      def money_attribute_kind(name)
+        money_attribute_spec(name)&.kind
+      end
+
+      # Returns the compiled string-query cache for the current model class.
+      #
+      # @return [Concurrent::Map]
+      # @api private
+      def money_attribute_query_plan_cache
+        QUERY_PLANS.fetch_or_store(self) { Concurrent::Map.new }
+      end
+    end
   end
 end

data/lib/money_attribute/converter.rb

@@ -36,7 +36,7 @@ module MoneyAttribute
       case amount
       when Money, NilClass      then amount
       when Numeric              then Money.from(amount, currency)
-      when String               then Money.parse(amount, currency)
+      when String               then Money.parse(amount, default_currency: currency)
       else raise ArgumentError, "Cannot convert #{amount.inspect} (#{amount.class}) to Money"
       end
     end

data/lib/money_attribute/core_ext/string.rb

@@ -14,5 +14,5 @@ class String
   # @raise [ArgumentError] if the string cannot be parsed
   # @example
   #   '12.34'.to_money('USD') # => Mint::Money(12.34, 'USD')
-  def to_money(currency = MoneyAttribute.default_currency) = Money.parse(self, currency)
+  def to_money(currency = MoneyAttribute.default_currency) = Money.parse(self, default_currency: currency)
 end

data/lib/money_attribute/macro.rb

@@ -98,6 +98,35 @@ module MoneyAttribute
               "Expected: #{mapping.values.join(', ')}, " \
               "Found: #{attribute_names.join(', ')}"
       end
+
+      # Normalizes migration-style column options to the legacy mapping format.
+      #
+      # @param mapping [Hash] the user-supplied +mapping:+ option
+      # @param amount [Hash, nil] migration-style amount options
+      # @param currency [Hash, nil] migration-style currency options
+      # @return [Hash] normalized column mapping
+      # @raise [ArgumentError] if options are ambiguous or unsupported
+      # @api private
+      def normalize_mapping(mapping, amount, currency)
+        mapping = mapping.compact
+        nested = { amount:, currency: }.compact
+        conflicts = mapping.keys & nested.keys
+        unless conflicts.empty?
+          raise ArgumentError, "Specify #{conflicts.join(', ')} using either mapping: or nested options, not both"
+        end
+
+        nested.each do |key, options|
+          mapping[key] = normalize_nested_column(key, options)
+        end
+
+        mapping
+      end
+
+      def normalize_nested_column(key, options)
+        return options[:column] if options.is_a?(Hash) && options.keys == [:column] && options[:column]
+
+        raise ArgumentError, "#{key}: must be a hash containing only a non-empty :column option"
+      end
     end
 
     class_methods do
@@ -109,6 +138,8 @@ module MoneyAttribute
       #
       # @param name [Symbol, String] the money attribute accessor name
       # @param mapping [Hash] custom column mapping (+:amount+, +:currency+)
+      # @param amount [Hash, nil] migration-style amount options (+:column+ only)
+      # @param currency [Hash, nil] migration-style currency options (+:column+ only)
       # @return [void]
       #
       # @example
@@ -116,7 +147,8 @@ module MoneyAttribute
       #     money_attribute :price
       #     money_attribute :price, mapping: { amount: :base_price, currency: :base_currency }
       #   end
-      def money_attribute(name, mapping: {})
+      def money_attribute(name, mapping: {}, amount: nil, currency: nil)
+        mapping = normalize_mapping(mapping, amount, currency)
         mapping = resolve_mapping(name, mapping)
         spec = register_composite_spec(name, mapping)
 

data/lib/money_attribute/query/amount_condition.rb

@@ -10,6 +10,7 @@ module MoneyAttribute
   # @api private
   module AmountCondition
     ALLOWED_KEYWORDS = %w[and or not is null].to_set.freeze
+    QueryPlan = Struct.new(:sql, :value_specs, keyword_init: true)
 
     # Builds an amount filter for the registered money attribute.
     #
@@ -37,19 +38,31 @@ module MoneyAttribute
     # @raise [ArgumentError] on unknown identifiers or placeholder mismatch
     # @api private
     def resolve_amount_condition_from_sql(sql, *values)
-      specs = klass.money_attribute_specs
-      attr_names = klass.money_attribute_names_set
-
-      validate_sql_identifiers!(sql, attr_names)
-      value_specs = map_placeholders_to_specs(sql, specs)
-      decomposed = decompose_values(values, value_specs)
-      substituted = substitute_attribute_names(sql, specs)
+      plan = klass.money_attribute_query_plan_cache.fetch_or_store(sql) do
+        compile_query_plan(sql)
+      end
+      decomposed = decompose_values(values, plan.value_specs)
 
-      where(substituted, *decomposed)
+      where(plan.sql, *decomposed)
     end
 
     private
 
+    # Compiles a string query into substituted SQL and bind metadata.
+    #
+    # @param sql [String] the SQL fragment
+    # @return [QueryPlan] the compiled query plan
+    # @api private
+    def compile_query_plan(sql)
+      specs = klass.money_attribute_specs
+      value_specs = parse_sql_value_specs(sql, specs)
+
+      QueryPlan.new(
+        sql: substitute_attribute_names(sql, specs),
+        value_specs: value_specs.freeze
+      ).freeze
+    end
+
     # Builds an Arel predicate for the given amount value.
     #
     # @param col [Arel::Attributes::Attribute] the amount column node
@@ -88,69 +101,34 @@ module MoneyAttribute
       spec.normalize_query_value(value)
     end
 
-    # Validates that every word in the SQL is a registered attribute name or an
-    # allowed keyword.
-    #
-    # @param sql [String] the SQL fragment
-    # @param attr_names [Set<String>] registered money attribute names
-    # @return [void]
-    # @raise [ArgumentError] on the first unknown identifier
-    # @api private
-    def validate_sql_identifiers!(sql, attr_names)
-      sql.scan(/\b[a-z_]\w*\b/i).each do |word|
-        next if attr_names.include?(word.downcase) || ALLOWED_KEYWORDS.include?(word.downcase)
-
-        raise ArgumentError, "'#{word}' is not a money attribute on #{klass.name}"
-      end
-    end
-
-    # Matches each +?+ placeholder to the nearest preceding money attribute name
-    # and returns the corresponding spec.
+    # Validates identifiers and associates placeholders with the nearest
+    # preceding money attribute in one left-to-right pass.
     #
     # @param sql [String] the SQL fragment
     # @param specs [Hash{String => AttributeSpec}] the money attribute specs
-    # @return [Array<AttributeSpec>] one spec per +?+ placeholder
-    # @raise [ArgumentError] if a placeholder has no preceding attribute name
-    # @api private
-    def map_placeholders_to_specs(sql, specs)
-      ref_pattern = klass.money_attribute_name_pattern
-
-      placeholder_positions(sql).map { |pos| spec_at_position(sql, pos, ref_pattern, specs) }
-    end
-
-    # Returns character positions of each +?+ in the SQL.
-    #
-    # @param sql [String] the SQL fragment
-    # @return [Array<Integer>] the positions of each +?+
+    # @return [Array<AttributeSpec>] one spec per bind value
+    # @raise [ArgumentError] on an unknown identifier or unassociated placeholder
     # @api private
-    def placeholder_positions(sql)
-      positions = []
-      offset = 0
+    def parse_sql_value_specs(sql, specs)
+      current_spec = nil
+      value_specs = []
 
-      while (idx = sql.index('?', offset))
-        positions << idx
-        offset = idx + 1
-      end
+      sql.scan(/[a-z_]\w*|\?/i) do |token|
+        if token == '?'
+          raise ArgumentError, "No money attribute found before '?' in: #{sql.inspect}" unless current_spec
 
-      positions
-    end
+          value_specs << current_spec
+          next
+        end
 
-    # Returns the spec for the +?+ at the given position.
-    #
-    # @param sql [String] the SQL fragment
-    # @param pos [Integer] position of the +?+
-    # @param ref_pattern [Regexp] pre-compiled attribute name pattern
-    # @param specs [Hash{String => AttributeSpec}] the money attribute specs
-    # @return [AttributeSpec] the spec for the nearest preceding attribute name
-    # @raise [ArgumentError] if no attribute name precedes the placeholder
-    # @api private
-    def spec_at_position(sql, pos, ref_pattern, specs)
-      preceding = sql[0...pos]
-      matched = preceding.scan(ref_pattern).flatten.compact
+        word = token.downcase
+        next if ALLOWED_KEYWORDS.include?(word)
 
-      raise ArgumentError, "No money attribute found before '?' in: #{sql.inspect}" if matched.empty?
+        current_spec = specs[word]
+        raise ArgumentError, "'#{token}' is not a money attribute on #{klass.name}" unless current_spec
+      end
 
-      specs[matched.last.downcase]
+      value_specs
     end
 
     # Decomposes +Mint::Money+ bind values to raw storage values using their

data/lib/money_attribute/type.rb

@@ -7,7 +7,11 @@ module MoneyAttribute
     #
     # @param value [String, Numeric, Mint::Money, nil] the input value
     # @return [Mint::Money, Numeric, nil] a Money value for strings, otherwise delegates to super
-    def cast(value) = value.is_a?(String) ? Money.parse(value, MoneyAttribute.default_currency) : super
+    def cast(value)
+      return Money.parse(value, default_currency: MoneyAttribute.default_currency) if value.is_a?(String)
+
+      super
+    end
 
     # Validates that the value is compatible with the fixed currency type.
     #

data/lib/money_attribute/version.rb

@@ -2,5 +2,5 @@
 
 module MoneyAttribute
   # The current gem version, following semantic versioning.
-  VERSION = '1.2.1'
+  VERSION = '1.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: money_attribute
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Gilson Ferraz
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.18
 specification_version: 4
 summary: Money attributes for ActiveRecord
 test_files: []