plutonium 0.54.0 → 0.56.0

data/lib/generators/pu/lite/maintenance/templates/app/jobs/sqlite_maintenance_job.rb.tt

@@ -0,0 +1,60 @@
+class SqliteMaintenanceJob < ApplicationJob
+  queue_as :default
+
+  # Isolated connection for maintenance. Establishing on this dedicated
+  # abstract class (instead of ActiveRecord::Base) means we never mutate
+  # the global primary connection — a sibling job on the other worker
+  # thread keeps talking to the right database.
+  class MaintenanceConnection < ActiveRecord::Base
+    self.abstract_class = true
+  end
+
+  # Names match the keys in config/database.yml. Add your own database
+  # names here if you run extra SQLite databases.
+  #
+  # PRAGMA optimize is cheap (just refreshes query-planner stats, brief
+  # shared lock) so it runs everywhere. Full VACUUM rewrites the file
+  # under a global *exclusive* lock for its whole duration, so it only
+  # runs on databases without live 24/7 writers.
+  OPTIMIZE_DBS = %w[primary queue cache cable errors rails_pulse].freeze
+
+  # queue/cable/cache are deliberately excluded: SolidQueue, Solid Cable
+  # and Solid Cache write to them constantly, and a VACUUM lock there
+  # stalls (and errors out) those processes — e.g. SolidQueue's process
+  # deregistration hitting "database is locked". They also barely benefit:
+  # in WAL mode deleted pages land on the freelist and get reused, so a
+  # churning DB sits at a steady-state size without nightly reclamation.
+  VACUUM_DBS = %w[primary errors rails_pulse].freeze
+
+  def perform
+    OPTIMIZE_DBS.each { |db_name| run_maintenance(db_name) }
+  end
+
+  private
+
+  def run_maintenance(db_name)
+    config = ActiveRecord::Base.configurations.configs_for(
+      env_name: Rails.env,
+      name: db_name,
+      include_hidden: true
+    )
+    return unless config
+
+    MaintenanceConnection.establish_connection(config)
+    MaintenanceConnection.connection_pool.with_connection do |conn|
+      Rails.logger.info { "[SqliteMaintenance] PRAGMA optimize on #{db_name}" }
+      conn.execute("PRAGMA optimize")
+
+      next unless VACUUM_DBS.include?(db_name)
+
+      Rails.logger.info { "[SqliteMaintenance] VACUUM on #{db_name}" }
+      started = Time.current
+      conn.execute("VACUUM")
+      Rails.logger.info { "[SqliteMaintenance] VACUUM on #{db_name} done in #{(Time.current - started).round(2)}s" }
+    end
+  rescue => e
+    Rails.error.report(e, context: {db: db_name, action: "sqlite_maintenance"})
+  ensure
+    MaintenanceConnection.remove_connection
+  end
+end

data/lib/generators/pu/lite/rails_pulse/rails_pulse_generator.rb

@@ -7,6 +7,7 @@ module Pu
     class RailsPulseGenerator < Rails::Generators::Base
       include PlutoniumGenerators::Generator
       include PlutoniumGenerators::Concerns::ConfiguresSqlite
+      include PlutoniumGenerators::Concerns::ConfiguresRecurring
       include PlutoniumGenerators::Concerns::MountsEngines
 
       source_root File.expand_path("templates", __dir__)
@@ -69,25 +70,11 @@ module Pu
       end
 
       def setup_recurring_tasks
-        recurring_file = "config/recurring.yml"
-        full_path = File.expand_path(recurring_file, destination_root)
-        return unless File.exist?(full_path)
-        return if file_includes?(recurring_file, "rails_pulse")
-
-        content = File.read(full_path)
-        env_keys = %w[production development staging test]
-        env_scoped = content.lines.any? { |l| l.match?(/^(#{env_keys.join("|")}):\s*$/) }
-
-        if env_scoped
-          create_file recurring_file, inject_rails_pulse_under_envs(content, env_keys), force: true
-        else
-          append_to_file recurring_file, "\n" + rails_pulse_tasks_yaml(0)
-        end
+        add_recurring_tasks(rails_pulse_tasks_yaml, marker: "rails_pulse")
       end
 
-      def rails_pulse_tasks_yaml(indent)
-        pad = " " * indent
-        <<~YAML.gsub(/^(?=.)/, pad)
+      def rails_pulse_tasks_yaml
+        <<~YAML
           rails_pulse_summary:
             class: RailsPulse::SummaryJob
             queue: default
@@ -101,40 +88,6 @@ module Pu
             description: "Archive/purge old Rails Pulse data"
         YAML
       end
-
-      def inject_rails_pulse_under_envs(content, env_keys)
-        lines = content.lines
-        env_re = /^(#{env_keys.join("|")}):\s*$/
-
-        env_starts = lines.each_with_index.select { |l, _| env_re.match?(l) }.map(&:last)
-
-        env_starts.reverse_each do |start|
-          end_idx = lines.length
-          ((start + 1)...lines.length).each do |i|
-            if lines[i].match?(/^[^\s#]/)
-              end_idx = i
-              break
-            end
-          end
-
-          indent = 2
-          ((start + 1)...end_idx).each do |i|
-            if (m = lines[i].match(/^(\s+)\S/))
-              indent = m[1].length
-              break
-            end
-          end
-
-          insert_at = end_idx
-          while insert_at > start + 1 && lines[insert_at - 1].strip.empty?
-            insert_at -= 1
-          end
-
-          lines.insert(insert_at, "\n", rails_pulse_tasks_yaml(indent))
-        end
-
-        lines.join
-      end
     end
   end
 end

data/lib/generators/pu/lite/rails_pulse/templates/config/initializers/rails_pulse.rb.tt

@@ -27,6 +27,6 @@ RailsPulse.configure do |config|
 <%- if options[:database] -%>
 
   # Use separate database for performance data
-  config.connects_to = {database: {writing: :<%= options[:database] %>}}
+  config.connects_to = {database: {writing: :<%= options[:database] %>, reading: :<%= options[:database] %>}}
 <%- end -%>
 end

data/lib/generators/pu/lite/tune/tune_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Lite
+    class TuneGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+
+      desc "Tune config/database.yml with performance pragmas for SQLite"
+
+      RAILS_8_1 = ::Gem::Version.new("8.1.0")
+      DATABASE_YML = "config/database.yml"
+
+      def start
+        path = File.expand_path(DATABASE_YML, destination_root)
+        unless File.exist?(path)
+          log :skip, "#{DATABASE_YML} not found"
+          return
+        end
+
+        content = File.read(path)
+        if content.include?("wal_autocheckpoint")
+          log :skip, "pragmas already tuned in #{DATABASE_YML}"
+          return
+        end
+
+        new_content = apply_pragmas(content, rails_version)
+        if new_content == content
+          log :skip, "no `default: &default` block in #{DATABASE_YML}"
+          return
+        end
+
+        create_file DATABASE_YML, new_content, force: true
+        say_status :tune, "added SQLite pragmas to #{DATABASE_YML}"
+      rescue => e
+        exception "#{self.class} failed:", e
+      end
+
+      private
+
+      # Pure: returns content with pragmas inserted into the `default: &default`
+      # block. Merges into an existing default-level `pragmas:` mapping (2-space
+      # indent) if present, otherwise inserts a fresh pragmas block. Returns the
+      # content unchanged when there is no default anchor. Scoped to the default
+      # block so a `pragmas:` nested under another env (e.g. production.primary)
+      # is never touched.
+      def apply_pragmas(content, version)
+        anchor = content.match(/^default: &default\n/)
+        return content unless anchor
+
+        body_start = anchor.end(0)
+        rest = content[body_start..]
+        # the default block runs until the next top-level (column-0) line
+        next_top = rest =~ /^\S/
+        default_body = next_top ? rest[0...next_top] : rest
+        tail = next_top ? rest[next_top..] : ""
+
+        if default_body.match?(/^  pragmas:\s*$/)
+          new_body = default_body.sub(/^(  pragmas:[ \t]*\n)/) { $1 + pragma_keys(version) }
+          content[0...body_start] + new_body + tail
+        else
+          content.sub(/^default: &default\n/, "default: &default\n" + pragma_block(version))
+        end
+      end
+
+      def pragma_block(version)
+        comment = <<~COMMENT.gsub(/^/, "  ")
+          # Plutonium-tuned SQLite pragmas (pu:lite:tune).
+          # Rails 8.1+ already sets WAL, synchronous=NORMAL, foreign_keys,
+          # mmap=128MB and journal_size_limit by default; only deltas are added
+          # there. We intentionally do NOT set SQLite's internal busy pragma —
+          # Rails routes the `timeout:` key to the sqlite3 gem's constant-poll
+          # busy_handler_timeout, which has better tail-latency than SQLite's
+          # backoff.
+          pragmas:
+        COMMENT
+        comment + pragma_keys(version)
+      end
+
+      def pragma_keys(version)
+        keys = +""
+        if version < RAILS_8_1
+          keys << <<~YAML.gsub(/^/, "    ")
+            journal_mode: WAL
+            synchronous: NORMAL
+            foreign_keys: true
+            journal_size_limit: 67108864 # 64 MB
+          YAML
+        end
+        keys << <<~YAML.gsub(/^/, "    ")
+          cache_size: -64000           # 64 MB page cache (default ~2 MB is too small)
+          temp_store: 2                # MEMORY — sorts/temp indexes stay off disk
+          mmap_size: 536870912         # 512 MB (override the 128 MB default)
+          wal_autocheckpoint: 10000    # checkpoint every ~40 MB of WAL, fewer pauses
+        YAML
+        keys
+      end
+
+      def rails_version
+        @rails_version ||= ::Gem::Version.new(Rails::VERSION::STRING).release
+      end
+    end
+  end
+end

data/lib/plutonium/definition/base.rb

@@ -33,6 +33,7 @@ module Plutonium
       include Scoping
       include Search
       include NestedInputs
+      include StructuredInputs
       include IndexViews
       include Metadata
 

data/lib/plutonium/definition/structured_inputs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Definition
+    # Classless structured inputs: a group of fields collected into a hash
+    # (single) or an array of hashes (when `repeat:` is given). Mixed into both
+    # resource definitions and interactions.
+    #
+    # @example
+    #   structured_input :address do |f|
+    #     f.input :street
+    #     f.input :city
+    #   end
+    #
+    #   structured_input :contacts, repeat: 10 do |f|
+    #     f.input :label
+    #     f.input :phone_number
+    #   end
+    module StructuredInputs
+      extend ActiveSupport::Concern
+
+      # Holder built per render from a structured_input block. Reuses the same
+      # field/input DSL as the rest of Plutonium definitions.
+      class FieldsDefinition
+        include Plutonium::Definition::DefineableProps
+
+        defineable_props :field, :input
+      end
+
+      class_methods do
+        # @option options [Integer, true] :repeat  presence => array; Integer => max rows
+        # @option options [Class] :using  a FieldsDefinition-like class instead of a block
+        # @option options [Array<Symbol>] :fields  restrict rendered fields
+        def structured_input(name, **options, &block)
+          unless block || options[:using]
+            raise ArgumentError,
+              "`structured_input :#{name}` needs a block or `using:` — e.g. " \
+              "`structured_input :#{name} do |f| f.input :field end` or " \
+              "`structured_input :#{name}, using: #{name.to_s.classify}Fields`"
+          end
+
+          defined_structured_inputs[name] = {options:, block:}.compact
+        end
+
+        def defined_structured_inputs
+          @defined_structured_inputs ||= {}
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(
+            :@defined_structured_inputs,
+            defined_structured_inputs.deep_dup
+          )
+        end
+      end
+
+      # Instance access mirrors the defineable_prop convention (where
+      # `defined_<plural>` is available on instances). The form's render path and
+      # the param cleaner both hold a definition instance, so they read the
+      # registry through here.
+      def defined_structured_inputs
+        self.class.defined_structured_inputs
+      end
+    end
+  end
+end

data/lib/plutonium/interaction/README.md

@@ -262,71 +262,21 @@ class MyInteraction < Plutonium::Interaction::Base
 end
 ```
 
-### Interactions with Nested Attributes
+### Interactions with Structured Input
 
-This example demonstrates how to handle nested attributes—specifically,
-a `User` with multiple `Contact` and `UserAddress` records using
-a Plutonium `Interaction`.
+> **Note:** `nested_input` and `accepts_nested_attributes_for` are **not**
+> available on interactions. They are resource-only features that work with
+> model-backed `has_many`/`has_one` associations. For collecting structured or
+> repeating input inside an interaction, use `structured_input` instead.
 
-#### Key Highlights
+`structured_input` declares an attribute on the interaction and renders an
+inline fieldset in the auto-generated form. It comes in two forms:
 
-The model definitions are included here for completeness, but the primary focus
-remains on demonstrating how to build interactions that handle nested
-attributes.
-
-- Core user attributes (`first_name`, `last_name`, `email`) are declared and
-  validated at the top level of the interaction.
-
-- Nested associations (`contacts`, `addresses`) are managed via
-  `accepts_nested_attributes_for`. The optional `reject_if` condition is used
-  to discard entries that lack required fields—helping ensure data integrity at
-  the input level.
-
-- The `nested_input` DSL provides a declarative way to structure nested inputs,
-  specifying accepted fields and mapping them to their respective definition
-  classes (`ContactDefinition` and `UserAddressDefinition`).
-
-- During execution, a `User` instance is initialized with both top-level and
-  nested attributes, then persisted with all applicable validations.
-
-**Note:** The `class_name` option is explicitly defined in the interaction's
-`accepts_nested_attributes_for` macro because the `addresses` association does
-not directly map to its underlying model name. Simply provide the class name,
-for example, `class_name: "UserAddress"`, to ensure the correct model is used.
-
-**This is essential only when the association name differs from the actual
-class name.**
-
-This approach enables seamless handling of complex nested input from forms or
-API requests, while keeping validation logic clean, maintainable, and modular.
+- **Single** — the attribute arrives in `execute` as a plain `Hash`.
+- **Repeat** — the attribute arrives as an `Array` of hashes (capped at the
+  given number of rows; `repeat: true` defaults to 10).
 
 ```ruby
-# app/models/user.rb
-class User < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  has_many :contacts
-  has_many :addresses, class_name: "UserAddress"
-
-  accepts_nested_attributes_for :contacts, :addresses
-end
-
-# app/models/contact.rb
-class Contact < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  belongs_to :user
-  validates :label, :phone_number, presence: true
-end
-
-# app/models/user_address.rb
-class UserAddress < ApplicationRecord
-  include Plutonium::Resource::Record
-
-  belongs_to :user
-  validates :label, :map_url, presence: true
-end
-
 # app/interactions/users/interactions/create_user_interaction.rb
 module Users
   module Interactions
@@ -338,37 +288,33 @@ module Users
       attribute :first_name, :string
       attribute :last_name, :string
       attribute :email, :string
-      attribute :contacts
-      attribute :addresses
 
       validates :first_name, :last_name, presence: true
       validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
 
-      accepts_nested_attributes_for :contacts,
-        reject_if: proc { |attributes| attributes[:label].blank? }
-
-      accepts_nested_attributes_for :addresses, class_name: "UserAddress",
-        reject_if: proc { |attributes| attributes[:label].blank? }
-
-      nested_input :contacts,
-        using: ContactDefinition,
-        fields: %i[label phone_number],
-        description: "Add one or more contacts for this user."
+      # single → a hash
+      structured_input :address do |f|
+        f.input :street
+        f.input :city
+      end
 
-      nested_input :addresses,
-        using: UserAddressDefinition,
-        fields: %i[label map_url],
-        description: "Add one or more addresses for this user."
+      # repeater → an array of hashes (max 5 rows)
+      structured_input :contacts, repeat: 5 do |f|
+        f.input :label
+        f.input :phone_number
+      end
 
       private
 
       def execute
-        user = User.new(self.attributes)
+        # address  => { "street" => "...", "city" => "..." }
+        # contacts => [ { "label" => "...", "phone_number" => "..." }, ... ]
+        user = User.new(first_name: first_name, last_name: last_name, email: email)
 
         if user.save
           success(user).with_message("User created successfully")
         else
-          failed(user.errors)
+          failure(user.errors)
         end
       end
     end

data/lib/plutonium/interaction/base.rb

@@ -25,8 +25,16 @@ module Plutonium
       include Plutonium::Definition::DefineableProps
       include Plutonium::Definition::ConfigAttr
       include Plutonium::Definition::Presentable
-      include Plutonium::Definition::NestedInputs
-      include Plutonium::Interaction::NestedAttributes
+      include Plutonium::Definition::StructuredInputs
+
+      # On interactions, declaring a structured input also declares the backing
+      # ActiveModel attribute so the value survives `attributes=` and appears in
+      # `attribute_names` (which drives the interaction form's field list).
+      def self.structured_input(name, **options, &block)
+        super
+        default = options[:repeat] ? -> { [] } : -> { {} }
+        attribute name, default: default
+      end
 
       # include Plutonium::Interaction::Concerns::WorkflowDSL
 

data/lib/plutonium/models/has_cents.rb

@@ -166,6 +166,16 @@ module Plutonium
         def has_cents_attribute?(attribute)
           has_cents_attributes.key?(attribute.to_sym)
         end
+
+        # Checks if a given attribute is the decimal accessor of a has_cents pair
+        # (e.g. :amount for `has_cents :amount_cents`).
+        #
+        # @param attribute [Symbol] The attribute to check
+        # @return [Boolean]
+        def has_cents_decimal_attribute?(attribute)
+          attribute = attribute.to_sym
+          has_cents_attributes.any? { |_, opts| opts[:name] == attribute }
+        end
       end
     end
   end

data/lib/plutonium/resource/controller.rb

@@ -16,6 +16,7 @@ module Plutonium
       include Plutonium::Resource::Controllers::CrudActions
       include Plutonium::Resource::Controllers::InteractiveActions
       include Plutonium::Resource::Controllers::Typeahead
+      include Plutonium::StructuredInputs::ParamsConcern
 
       included do
         after_action { response.headers.merge!(@pagy.headers_hash) if @pagy }
@@ -144,7 +145,11 @@ module Plutonium
         # Use existing record (cloned) for context during param extraction, or new instance for create
         # Pass form_action: false to prevent form from trying to generate URL (cloned record has id: nil)
         extraction_record = resource_record?&.dup || resource_class.new
-        @submitted_resource_params ||= build_form(extraction_record, form_action: false).extract_input(params, view_context:)[resource_param_key.to_sym].compact
+        @submitted_resource_params ||= begin
+          extracted = build_form(extraction_record, form_action: false)
+            .extract_input(params, view_context:)[resource_param_key.to_sym].compact
+          clean_structured_inputs(current_definition, extracted)
+        end
       end
 
       # Returns the resource parameters, including scoped and parent parameters

data/lib/plutonium/resource/controllers/interactive_actions.rb

@@ -3,6 +3,7 @@ module Plutonium
     module Controllers
       module InteractiveActions
         extend ActiveSupport::Concern
+        include Plutonium::StructuredInputs::ParamsConcern
 
         included do
           helper_method :current_interactive_action
@@ -239,13 +240,33 @@ module Plutonium
           @interaction
         end
 
-        # Returns the submitted resource parameters
-        # @return [Hash] The submitted resource parameters
+        # Returns the submitted interaction parameters
+        # @return [Hash] The submitted interaction parameters
         def submitted_interaction_params
-          @submitted_interaction_params ||= current_interactive_action
-            .interaction
-            .build_form(current_interactive_action.interaction.new(view_context:))
-            .extract_input(params, view_context:)[:interaction]
+          @submitted_interaction_params ||= begin
+            action = current_interactive_action
+            interaction = action.interaction
+            instance = interaction.new(view_context:)
+            # Bind the action's subject before the form is rendered for param
+            # extraction. extract_input renders the form when it hasn't been
+            # rendered yet, which eagerly materializes input choices — any
+            # `choices:` proc (or other render-time config) that reads the
+            # subject would otherwise run against a nil resource/resources and
+            # raise a deep-stack NoMethodError before the interaction ever runs.
+            # This mirrors the subject the real instance is given in
+            # build_interactive_*_action_interaction. interaction_params still
+            # strips :resource/:resources from the extracted params, so
+            # mass-assignment safety is unaffected.
+            if action.record_action? || action.collection_record_action?
+              instance.resource = resource_record!
+            elsif action.bulk_action?
+              instance.resources = interactive_bulk
+            end
+            extracted = interaction
+              .build_form(instance)
+              .extract_input(params, view_context:)[:interaction]
+            clean_structured_inputs(interaction, extracted)
+          end
         end
 
         def redirect_url_after_action_on(resource_record_or_resource_class)

data/lib/plutonium/routing/mapper_extensions.rb

@@ -99,8 +99,13 @@ module Plutonium
           next unless base_config
 
           # Register with association-based key: "parent_plural/association_name"
+          # Force route_type: :resources — has_many associations always nest as a
+          # plural (member-with-id) route, even when the child resource is registered
+          # `singular: true` at the top level (which would otherwise leak :resource
+          # into base_config and make member URL helpers resolve to the wrong name).
           nested_key = "#{resource.model_name.plural}/#{assoc_info[:name]}"
           nested_config = base_config.merge(
+            route_type: :resources,
             association_name: assoc_info[:name],
             resource_class: assoc_info[:klass]
           )

data/lib/plutonium/structured_inputs/param_cleaner.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module StructuredInputs
+    # Normalises an extracted structured-input value before it is stored.
+    #
+    # The form's `extract_input` already yields a `Hash` (single) or an
+    # `Array<Hash>` (repeater), so the only work left is to symbolise keys and,
+    # for repeaters, drop rows the user left entirely blank.
+    module ParamCleaner
+      module_function
+
+      # @param value [Hash, Array, nil] the extracted param for this input
+      # @param repeat [Boolean, Integer] truthy => array (repeater), else hash
+      # @return [Hash, Array<Hash>]
+      def call(value, repeat:)
+        repeat ? clean_collection(value) : clean_one(value)
+      end
+
+      def clean_one(value)
+        value.is_a?(Hash) ? symbolize(value) : {}
+      end
+
+      def clean_collection(value)
+        Array(value)
+          .select { |row| row.is_a?(Hash) }
+          .map { |row| symbolize(row) }
+          .reject { |row| row.values.all? { |v| v.to_s.strip.empty? } }
+      end
+
+      def symbolize(row)
+        row.to_h.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/plutonium/structured_inputs/params_concern.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module StructuredInputs
+    # Rewrites structured-input params in place through ParamCleaner. Shared by
+    # the resource controller and the interactive-actions controller.
+    module ParamsConcern
+      # @param definition a definition instance (resource) or class (interaction)
+      #   exposing `defined_structured_inputs`
+      # @param params [Hash] extracted form params (mutable copy)
+      # @return [Hash]
+      def clean_structured_inputs(definition, params)
+        registry = structured_inputs_registry(definition)
+        return params unless registry
+
+        registry.each do |name, entry|
+          next unless params.key?(name)
+
+          repeat = entry[:options]&.fetch(:repeat, false)
+          params[name] = Plutonium::StructuredInputs::ParamCleaner.call(params[name], repeat:)
+        end
+        params
+      end
+
+      private
+
+      def structured_inputs_registry(definition)
+        if definition.respond_to?(:defined_structured_inputs)
+          definition.defined_structured_inputs
+        elsif definition.class.respond_to?(:defined_structured_inputs)
+          definition.class.defined_structured_inputs
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/display/base.rb

@@ -34,6 +34,15 @@ module Plutonium
             create_component(Plutonium::UI::Display::Components::Color, :color, **, &)
           end
 
+          def badge_tag(**, &)
+            create_component(Plutonium::UI::Display::Components::Badge, :badge, **, &)
+          end
+          alias_method :enum_tag, :badge_tag
+
+          def currency_tag(**, &)
+            create_component(Plutonium::UI::Display::Components::Currency, :currency, **, &)
+          end
+
           # Type aliases for common column types
           alias_method :float_tag, :number_tag
           alias_method :decimal_tag, :number_tag