rhino-rails 4.8.1 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c77838e9b0818c083a66439097840287fdfadcd94fe17f7e403b9a1c00e08322
-  data.tar.gz: 698536e45e86aed2abd48ba646c0ebc4e821511838c79db07e6525413ace80c5
+  metadata.gz: 7940c1894a48b568ac853c65c73597adc6e56128b3a4d5958c003c6bc0ab03e9
+  data.tar.gz: 4214c47df8a3caaa7bb7ef81957a77935b795d67c057b1797bf4945e66c677cb
 SHA512:
-  metadata.gz: 52ec8339ccd944fcb4b3c071bc4829acaf37c1d401abfce18bec28648eac3005d7ca18c407ad3784bc541dcd16cf3238144c8ebd7bbc58ada65b8537f64e0515
-  data.tar.gz: '096db647db3f380fe23621e6fc31496321e857a80ce22911bc2133a7877a7e607a49be3e60cb08f88594030c784b9b3a6d3e8f9415969ed0188bfb11569e3ffc'
+  metadata.gz: 0f8235a208d9e2b23be8e6a33f2ad0623d56f43fa2443ed0727c19aa8888e888ea88778ea4885bb8d38abc2d3d3de030e500767f9e372b0986d0ebfb6037bd76
+  data.tar.gz: d373f8eed1679caef1d7f2f6a9f516161eb8eb6bfae9e6e536add126cf8a3f923ed849fe3713865810cd2d9e943905bf3befbc0201d599bbb0ab8455808fb4f2

data/lib/rhino/argument_binder.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Rhino
+  # Binds the arguments a client sent in the bracket query form
+  # (<tt>?scope[name][param]=value</tt>, <tt>?attributes[name][param]=value</tt>)
+  # to the parameters a model declared, in declared order.
+  #
+  # The algorithm is shared by named scopes and computed attributes so the two
+  # features cannot drift. Everything that differs between them is passed in:
+  #
+  # * +subject+ is the noun used in every error message ("Scope",
+  #   "Computed attribute"), so each feature keeps its own wording;
+  # * +error_class+ is the exception raised, so each feature keeps its own
+  #   controller +rescue_from+;
+  # * +underscore_keys+ reproduces the scope binder's wire-name translation.
+  #   Computed attributes match parameter names verbatim, exactly as Laravel and
+  #   NestJS do, so they leave it off.
+  #
+  # Nothing here decides whether a name may be used: callers MUST run the
+  # declared-check and the policy-check BEFORE binding, so an argument error can
+  # only ever be seen for a name the caller was already allowed to use.
+  module ArgumentBinder
+    module_function
+
+    # Clean a declared parameter list: stringify the names, and drop any
+    # +optional+ entry that is not actually a declared parameter.
+    def normalize_params(params, optional = [])
+      params = Array(params).map(&:to_s)
+
+      { params: params, optional: Array(optional).map(&:to_s) & params }
+    end
+
+    # Bind the raw value a client sent for one name to positional arguments,
+    # in the order the model declared them.
+    #
+    # +raw+ is whatever the query string produced for the bracket key: nil or ""
+    # (no arguments), a scalar (the single parameter), or a hash of parameter
+    # name => value.
+    def bind(subject:, name:, spec:, raw:, error_class:, underscore_keys: false)
+      params = Array(spec[:params]).map(&:to_s)
+      optional = Array(spec[:optional]).map(&:to_s)
+
+      given = normalize_raw_arguments(
+        subject: subject, name: name, params: params, raw: raw,
+        error_class: error_class, underscore_keys: underscore_keys
+      )
+
+      given.each_key do |key|
+        unless params.include?(key)
+          raise error_class, "#{subject} '#{name}' does not accept parameter '#{key}'"
+        end
+      end
+
+      args = params.map do |param|
+        if given.key?(param)
+          coerce(given[param])
+        elsif optional.include?(param)
+          nil
+        else
+          raise error_class, "#{subject} '#{name}' requires parameter '#{param}'"
+        end
+      end
+
+      # Drop trailing nils so an omitted optional parameter falls back to the
+      # default in the callable's own signature.
+      #
+      # NOTE: `args.empty?` rather than `args.any?` — Array#any? without a block
+      # is false for [nil], so the old form skipped the drop entirely when EVERY
+      # argument was nil (an all-optional declaration with nothing sent), passing
+      # [nil] where Laravel and NestJS pass []. Every other case is unchanged.
+      args.pop until args.empty? || !args.last.nil?
+      args
+    end
+
+    # Turn the raw query-string value into a parameter name => value hash.
+    def normalize_raw_arguments(subject:, name:, params:, raw:, error_class:, underscore_keys: false)
+      # ?scope[archived]= (or a bare ?scope[archived]): no arguments. A name
+      # with required parameters still fails, in bind, naming them.
+      return {} if raw.nil? || raw == ""
+
+      raw = raw.to_unsafe_h if raw.respond_to?(:to_unsafe_h)
+
+      if raw.is_a?(Array)
+        # A positional list (scope[between][]=a) names nothing.
+        raise error_class, "#{subject} '#{name}' requires named parameters"
+      end
+
+      unless raw.is_a?(Hash)
+        raise error_class, "#{subject} '#{name}' does not accept arguments" if params.empty?
+
+        # A bare value binds to the single declared parameter. Two parameters can
+        # never be guessed at from one value.
+        if params.length > 1
+          raise error_class, "#{subject} '#{name}' requires named parameters"
+        end
+
+        return { params.first => raw }
+      end
+
+      raise error_class, "#{subject} '#{name}' does not accept arguments" if params.empty?
+
+      raw.each_with_object({}) do |(key, value), out|
+        unless value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(TrueClass) ||
+               value.is_a?(FalseClass) || value.nil?
+          raise error_class, "#{subject} '#{name}' requires named parameters"
+        end
+
+        key = key.to_s
+        out[underscore_keys ? key.underscore : key] = value
+      end
+    end
+
+    # Query-string values always arrive as strings; hand callables real booleans
+    # so a check cannot be fooled by the string "false".
+    def coerce(value)
+      return value unless value.is_a?(String)
+
+      case value.downcase
+      when "true" then true
+      when "false" then false
+      else value
+      end
+    end
+  end
+end

data/lib/rhino/commands/export_postman_command.rb

@@ -175,15 +175,42 @@ module Rhino
           allowed_fields: model_class.try(:allowed_fields) || [],
           allowed_includes: model_class.try(:allowed_includes) || [],
           allowed_search: model_class.try(:allowed_search) || [],
-          # Computed attributes: names only (the callables never leave the server).
-          collection_computed_attributes: computed_names(model_class.try(:rhino_collection_computed_attributes)),
-          record_computed_attributes: computed_names(record_computed_declaration(model_class)),
+          # Computed attributes: names and parameter specs only — the callables
+          # never leave the server. The spec is what lets the collection show a
+          # parameterised attribute the way a client must actually send it.
+          collection_computed_attributes: computed_specs(model_class.try(:rhino_collection_computed_attributes)),
+          record_computed_attributes: computed_specs(record_computed_declaration(model_class)),
           default_sort: model_class.try(:default_sort_field)
         }
       end
 
-      def computed_names(declared)
-        declared.is_a?(Hash) ? declared.keys.map(&:to_s) : []
+      # name => { params:, optional: } — the same shape as a scope's spec, for
+      # the same reason.
+      def computed_specs(declared)
+        Rhino::ComputedAttributeSpec.normalize(declared).transform_values do |spec|
+          { params: spec[:params], optional: spec[:optional] }
+        end
+      end
+
+      # The query parameters that select one computed attribute, in whichever
+      # form its declaration requires: the plain list when it takes no
+      # parameters, the bracket form when it does.
+      def computed_attribute_query(key, attribute, spec)
+        params = Array(spec[:params])
+
+        return { key.to_sym => attribute } if params.empty?
+        return { "#{key}[#{attribute}]" => "example" } if params.size == 1
+
+        params.each_with_object({}) do |param, out|
+          out["#{key}[#{attribute}][#{param}]"] = "example"
+        end
+      end
+
+      # The attribute names that can be requested without arguments — the only
+      # ones a combined "give me everything" request may name, since a required
+      # parameter left out is a guaranteed 403.
+      def argument_free_computed_attributes(specs)
+        specs.reject { |_, spec| Rhino::ComputedAttributeSpec.requires_arguments?(spec) }.keys
       end
 
       # Instantiating is safe (no DB round trip) and is the only way to read an
@@ -206,7 +233,7 @@ module Rhino
         folders << { name: "Update", item: build_update_requests(base) } unless except.include?("update")
         folders << { name: "Destroy", item: build_destroy_requests(base) } unless except.include?("destroy")
 
-        if Array(meta[:collection_computed_attributes]).any? && !except.include?("computed")
+        if (meta[:collection_computed_attributes] || {}).any? && !except.include?("computed")
           folders << { name: "Computed Attributes", item: build_computed_requests(base, meta) }
         end
 
@@ -251,9 +278,9 @@ module Rhino
                                    { "fields[#{slug}]" => meta[:allowed_fields].first(5).join(",") }, headers)
         end
 
-        Array(meta[:record_computed_attributes]).each do |attribute|
+        (meta[:record_computed_attributes] || {}).each do |attribute, spec|
           requests << request_item("With computed attribute #{attribute}", "GET", base,
-                                   { computed_attributes: attribute }, headers)
+                                   computed_attribute_query("computed_attributes", attribute, spec), headers)
         end
 
         unless meta[:allowed_search].empty?
@@ -274,9 +301,9 @@ module Rhino
           requests << request_item("Show with include", "GET", path, { include: meta[:allowed_includes].first.to_s }, headers)
         end
 
-        Array(meta[:record_computed_attributes]).each do |attribute|
+        (meta[:record_computed_attributes] || {}).each do |attribute, spec|
           requests << request_item("Show with computed attribute #{attribute}", "GET", path,
-                                   { computed_attributes: attribute }, headers)
+                                   computed_attribute_query("computed_attributes", attribute, spec), headers)
         end
 
         requests
@@ -302,17 +329,22 @@ module Rhino
       def build_computed_requests(base, meta)
         headers = default_headers
         path = "#{base}/computed"
-        attributes = Array(meta[:collection_computed_attributes])
+        attributes = meta[:collection_computed_attributes] || {}
 
+        # A bare /computed skips required-parameter attributes server-side, so
+        # this stays a valid request.
         requests = [request_item("All computed attributes", "GET", path, {}, headers)]
 
-        attributes.each do |attribute|
-          requests << request_item("Computed: #{attribute}", "GET", path, { attributes: attribute }, headers)
+        attributes.each do |attribute, spec|
+          requests << request_item("Computed: #{attribute}", "GET", path,
+                                   computed_attribute_query("attributes", attribute, spec), headers)
         end
 
-        if attributes.size > 1
+        combinable = argument_free_computed_attributes(attributes)
+
+        if combinable.size > 1
           requests << request_item("Computed: multiple attributes", "GET", path,
-                                   { attributes: attributes.join(",") }, headers)
+                                   { attributes: combinable.join(",") }, headers)
         end
 
         requests

data/lib/rhino/commands/generate_command.rb

@@ -15,6 +15,7 @@ module Rhino
           menu.choice "Model (with migration and factory)", "model"
           menu.choice "Policy (extends ResourcePolicy)", "policy"
           menu.choice "Scope (for ScopedDB)", "scope"
+          menu.choice "Request (validation for store/update)", "request"
         end
 
         name = ask("What is the resource name? (PascalCase singular, e.g., Post):")
@@ -32,6 +33,8 @@ module Rhino
           generate_policy(name)
         when "scope"
           generate_scope(name)
+        when "request"
+          generate_request(name)
         end
       end
 
@@ -198,6 +201,50 @@ module Rhino
         say ""
       end
 
+      # ----------------------------------------------------------------
+      # Request generation
+      # ----------------------------------------------------------------
+
+      # Generates {Model}StoreRequest / {Model}UpdateRequest into app/requests/,
+      # which Zeitwerk autoloads like every other app/* directory — no
+      # initializer and no eager_load_paths entry is needed for the naming
+      # convention to find them.
+      def generate_request(name)
+        model_name = name.sub(/(Store|Update)?Request\z/, "")
+        model_name = name if model_name.blank?
+
+        which = select("Which request classes should be generated?") do |menu|
+          menu.choice "Store (POST /{resource})", "store"
+          menu.choice "Update (PUT /{resource}/:id)", "update"
+          menu.choice "Both", "both"
+        end
+
+        actions = which == "both" ? %w[store update] : [which]
+        created = []
+
+        actions.each do |request_action|
+          class_name = request_class_name(model_name, request_action)
+          task("Generating #{class_name}") do
+            created << write_request_file(model_name, request_action)
+          end
+        end
+
+        say ""
+        say "#{created.length == 1 ? 'Request' : 'Requests'} generated successfully!", :green
+        say ""
+        created.each { |path| say "  Created: #{path}" }
+        say ""
+        say "  Next steps:", :yellow
+        say "    1. Declare an `attribute` for EVERY field the action may write —"
+        say "       an undeclared field is dropped, not persisted."
+        say "    2. Add validations, and override authorize?/prepare if needed."
+        say ""
+      end
+
+      def request_class_name(model_name, request_action)
+        "#{model_name}#{request_action == 'update' ? 'Update' : 'Store'}Request"
+      end
+
       # ----------------------------------------------------------------
       # Column collection
       # ----------------------------------------------------------------
@@ -389,6 +436,23 @@ module Rhino
         File.write(dest, content)
       end
 
+      def write_request_file(name, request_action)
+        template = File.expand_path("../../templates/generate/request.rb.erb", __FILE__)
+        class_name = request_class_name(name, request_action)
+        relative = "app/requests/#{class_name.underscore}.rb"
+        dest = Rails.root.join(relative)
+        FileUtils.mkdir_p(File.dirname(dest))
+
+        content = ERB.new(File.read(template), trim_mode: "-").result_with_hash(
+          name: name,
+          class_name: class_name,
+          action: request_action
+        )
+
+        File.write(dest, content)
+        relative
+      end
+
       def register_model_in_config(name)
         config_path = Rails.root.join("config/initializers/rhino.rb")
         return unless File.exist?(config_path)

data/lib/rhino/computed_attribute_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Rhino
+  # Parses a model's computed-attribute declarations
+  # (+rhino_record_computed_attributes+ / +rhino_collection_computed_attributes+)
+  # and binds the arguments a client sent for <tt>?attributes[name][param]=value</tt>
+  # (and <tt>?computed_attributes[name][param]=value</tt>) to the declared
+  # parameters.
+  #
+  # Declaration forms (both may be mixed in one hash):
+  #
+  #   {
+  #     # Legacy: anything that is not an extended spec is used as-is — a
+  #     # callable is called, any other value is serialized literally.
+  #     'active_users_count' => ->(scope, _user) { scope.count },
+  #     'schema_version'     => 3,
+  #
+  #     # Extended: a hash carrying at least one of params/optional/with.
+  #     'revenue' => {
+  #       params: %i[from to], optional: [:to],
+  #       with: ->(scope, _user, from, to = nil) { ... }
+  #     }
+  #   }
+  #
+  # Unlike named scopes, there is deliberately NO symbol or bare-list shorthand:
+  # <tt>'version' => 'v3'</tt> and <tt>'tags' => %w[a b]</tt> are valid *literal*
+  # value declarations today, and reinterpreting them as parameter lists would
+  # silently change what a shipped model returns. A declaration is an extended
+  # spec if and only if it is a hash carrying +params+, +optional+ or +with+ —
+  # those three keys are reserved inside a computed-attribute declaration.
+  module ComputedAttributeSpec
+    # The noun every computed-attribute argument error message starts with.
+    SUBJECT = "Computed attribute"
+
+    # The keys whose presence marks a declaration hash as an extended spec.
+    SPEC_KEYS = %i[params optional with].freeze
+
+    module_function
+
+    # Normalize a raw declaration hash into
+    # <tt>name => { params:, optional:, target: }</tt>.
+    #
+    # +target+ is the callable (or the literal value) that produces the
+    # attribute; for a legacy declaration it is the declared value itself.
+    def normalize(declared)
+      return {} unless declared.is_a?(Hash)
+
+      declared.each_with_object({}) do |(name, value), out|
+        out[name.to_s] = normalize_entry(value)
+      end
+    end
+
+    def normalize_entry(value)
+      return { params: [], optional: [], target: value } unless spec?(value)
+
+      spec = value.symbolize_keys
+
+      Rhino::ArgumentBinder
+        .normalize_params(spec[:params], spec[:optional])
+        .merge(target: spec[:with])
+    end
+
+    # Whether a declared value is an extended spec rather than a legacy
+    # callable/literal declaration.
+    def spec?(value)
+      return false unless value.is_a?(Hash)
+
+      SPEC_KEYS.any? { |key| value.key?(key) || value.key?(key.to_s) }
+    end
+
+    # The declared attribute names only.
+    def names(declared)
+      normalize(declared).keys
+    end
+
+    # Whether the attribute declares at least one parameter that the client MUST
+    # supply. Such attributes are skipped — never 403'd — when no selection was
+    # made (a bare <tt>GET /computed</tt>) and when a direct serialization call
+    # passes no arguments for them.
+    def requires_arguments?(spec)
+      (Array(spec[:params]).map(&:to_s) - Array(spec[:optional]).map(&:to_s)).any?
+    end
+
+    # Whether an entry is parameterised, and therefore must be called strictly
+    # with the bound arguments rather than through the tolerant arity branch a
+    # parameterless declaration keeps.
+    def parameterised?(spec)
+      Array(spec[:params]).any?
+    end
+
+    # Bind the raw value a client sent for one attribute to positional
+    # arguments, in the order the model declared them.
+    #
+    # Callers MUST have already checked that the attribute is declared and
+    # policy-visible: the messages raised here name the attribute.
+    def bind(name, spec, raw)
+      Rhino::ArgumentBinder.bind(
+        subject: SUBJECT,
+        name: name,
+        spec: spec,
+        raw: raw,
+        error_class: Rhino::InvalidComputedAttributeArgumentsError
+      )
+    end
+  end
+end

data/lib/rhino/concerns/has_validation.rb

@@ -33,6 +33,11 @@ module Rhino
     # Filters to only permitted fields, then runs ActiveModel validations
     # and cross-tenant FK validation.
     #
+    # @deprecated Model-level validation is superseded by request classes
+    #   ({Model}StoreRequest / {Model}UpdateRequest, see Rhino::ResourceRequest).
+    #   It still works unchanged for every model that has no request class for
+    #   the action and will be removed in 5.0.
+    #
     # @param params [Hash] The request data
     # @param permitted_fields [Array<String>] Fields the user is allowed to set (['*'] for all)
     # @param organization [Object, nil] Current organization for FK scoping (optional)
@@ -80,6 +85,25 @@ module Rhino
       end
     end
 
+    # Public entry point for cross-tenant FK validation.
+    #
+    # The request-class path (Rhino::ResourceRequest) runs its own validations
+    # and therefore never calls validate_for_action, but it still needs the
+    # cross-tenant FK check — including the indirect case, where the referenced
+    # table reaches the organization through a FK chain rather than an
+    # organization_id column. This wraps the existing private implementation so
+    # the chain walk and its class-level caches stay in one place.
+    #
+    # @param data [Hash] the write payload (string-keyed)
+    # @param organization [Object, nil]
+    # @return [Hash<String, Array<String>>] {} when there is no organization
+    def rhino_validate_foreign_keys(data, organization)
+      return {} unless organization
+      return {} unless data.is_a?(Hash)
+
+      validate_foreign_keys_for_organization(data, organization)
+    end
+
     private
 
     # Cache for FK chain lookups (class-level)

data/lib/rhino/concerns/hidable_columns.rb

@@ -72,15 +72,27 @@ module Rhino
       # Declaring at least one attribute here is what registers the
       # <tt>/computed</tt> route for the model.
       #
+      # An attribute may also declare PARAMETERS the client supplies as
+      # <tt>?attributes[name][param]=value</tt>. Use the extended form — a hash
+      # carrying +params+ (and optionally +optional+ and +with+) — and the bound
+      # arguments are appended after +user+, in declared order. An attribute
+      # with a REQUIRED parameter is skipped by a bare <tt>GET /computed</tt>
+      # rather than 403'd, so adding one never breaks a client that asks for
+      # everything.
+      #
       # @example
       #   def self.rhino_collection_computed_attributes
       #     {
       #       'active_users_count' => ->(scope, _user) { scope.where(status: 'active').count },
-      #       'blocked_users_count' => ->(scope, _user) { scope.where(status: 'blocked').count }
+      #       'blocked_users_count' => ->(scope, _user) { scope.where(status: 'blocked').count },
+      #       'revenue' => {
+      #         params: %i[from to],
+      #         with: ->(scope, _user, from, to) { scope.where(created_at: from..to).sum(:total) }
+      #       }
       #     }
       #   end
       #
-      # @return [Hash{String => #call}]
+      # @return [Hash{String => Object}]
       def rhino_collection_computed_attributes
         {}
       end
@@ -108,8 +120,14 @@ module Rhino
     # Do NOT override this method. Override +rhino_computed_attributes+ instead
     # to add computed/virtual attributes to the JSON response.
     #
+    # @param computed_attributes [Array<String>] opt-in record-level computed
+    #   attributes to evaluate, selected via <tt>?computed_attributes=</tt>.
+    # @param computed_arguments [Hash{String => Array}] positional arguments per
+    #   attribute name. An attribute with required parameters and no entry here
+    #   is skipped rather than called with too few arguments, so an existing
+    #   direct caller that passes only names keeps working.
     # @return [Hash]
-    def as_rhino_json(computed_attributes: [])
+    def as_rhino_json(computed_attributes: [], computed_arguments: {})
       user = rhino_current_user
       hidden = hidden_columns_for(user)
       result = as_json(except: hidden)
@@ -123,7 +141,9 @@ module Rhino
       # by name, so declaring an expensive attribute costs nothing on requests
       # that don't want it. Merged before policy filtering, so the blacklist and
       # whitelist below still govern them.
-      result.merge!(rhino_resolve_record_computed_attributes(computed_attributes, user))
+      result.merge!(
+        rhino_resolve_record_computed_attributes(computed_attributes, user, computed_arguments)
+      )
 
       # Apply blacklist to the final hash (covers DB columns from as_json
       # overrides AND computed attributes from rhino_computed_attributes)
@@ -173,15 +193,27 @@ module Rhino
     # Return a hash of attribute name => callable. The callable may accept
     # zero, one (record) or two (record, user) arguments.
     #
+    # An attribute may also declare PARAMETERS the client supplies as
+    # <tt>?computed_attributes[name][param]=value</tt>. Use the extended form —
+    # a hash carrying +params+ (and optionally +optional+ and +with+) — and the
+    # bound arguments are appended after +user+, in declared order. A
+    # parameterised entry is always called as <tt>call(record, user, *args)</tt>.
+    # Any other declared value (a callable, a scalar, a plain array) keeps its
+    # current meaning.
+    #
     # @example
     #   def rhino_record_computed_attributes
     #     {
     #       'open_tickets_count' => ->(record, _user) { record.tickets.where(closed_at: nil).count },
-    #       'full_name' => ->(record, _user) { "#{record.first_name} #{record.last_name}" }
+    #       'full_name' => ->(record, _user) { "#{record.first_name} #{record.last_name}" },
+    #       'tickets_since' => {
+    #         params: [:since],
+    #         with: ->(record, _user, since) { record.tickets.where("created_at >= ?", since).count }
+    #       }
     #     }
     #   end
     #
-    # @return [Hash{String => #call}]
+    # @return [Hash{String => Object}]
     def rhino_record_computed_attributes
       {}
     end
@@ -193,26 +225,49 @@ module Rhino
     # Names that are not declared are silently skipped — the controller has
     # already rejected unknown/forbidden names with a 403, and a direct
     # +as_rhino_json+ caller must not be able to force an arbitrary call.
-    def rhino_resolve_record_computed_attributes(names, user)
+    #
+    # An attribute that declares a required parameter is likewise skipped when
+    # +arguments+ carries no entry for it, so a custom controller calling
+    # <tt>as_rhino_json(computed_attributes: ['tickets_since'])</tt> gets a
+    # missing key rather than an ArgumentError.
+    def rhino_resolve_record_computed_attributes(names, user, arguments = {})
       return {} if names.blank?
 
-      declared = rhino_record_computed_attributes
-      return {} unless declared.is_a?(Hash) && declared.any?
+      specs = Rhino::ComputedAttributeSpec.normalize(rhino_record_computed_attributes)
+      return {} if specs.empty?
+
+      arguments = (arguments || {}).transform_keys(&:to_s)
 
       Array(names).each_with_object({}) do |name, memo|
         key = name.to_s
-        next unless declared.key?(key)
+        spec = specs[key]
+        next if spec.nil?
 
-        memo[key] = rhino_call_computed(declared[key], self, user)
+        if arguments.key?(key)
+          args = Array(arguments[key])
+        elsif Rhino::ComputedAttributeSpec.requires_arguments?(spec)
+          next
+        else
+          args = []
+        end
+
+        memo[key] = rhino_call_computed(spec, self, user, args)
       end
     end
 
-    # Invoke a declared callable, tolerating lambdas of arity 0, 1 or 2.
-    # Ruby lambdas are strict about arity, so the arity is honoured rather than
-    # forcing every declaration to accept both arguments.
-    def rhino_call_computed(entry, record, user)
+    # Invoke a declared entry.
+    #
+    # A PARAMETERISED entry is always called as `call(record, user, *args)` —
+    # the declaration is the contract. A parameterless entry keeps today's
+    # tolerant arity 0/1/2 branch: Ruby lambdas are strict about arity, so the
+    # arity is honoured rather than forcing every declaration to accept both
+    # arguments.
+    def rhino_call_computed(spec, record, user, args = [])
+      entry = spec[:target]
       return entry unless entry.respond_to?(:call)
 
+      return entry.call(record, user, *args) if Rhino::ComputedAttributeSpec.parameterised?(spec)
+
       case entry.try(:arity)
       when 0 then entry.call
       when 1 then entry.call(record)