class Riffer::Param

Riffer::Param represents a single parameter definition.

Handles type validation and JSON Schema generation for individual parameters.

Constants

PRIMITIVE_TYPES: Primitive types allowed for the +of:+ keyword on Array params
TYPE_MAPPINGS: Maps Ruby types to JSON Schema type strings

Attributes

default [R]

description [R]

enum [R]

item_type [R]

name [R]

nested_params [R]

required [R]

type [R]

Public Class Methods

new (name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)

Source

# File lib/riffer/param.rb, line 33
def initialize(name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)
  @name = name.to_sym
  @type = type
  @required = required
  @description = description
  @enum = enum
  @default = default
  @item_type = item_type
  @nested_params = nested_params
end

: (name: Symbol, type: Class, required: bool, ?description: String?, ?enum: Array?, ?default: untyped, ?item_type: Class?, ?nested_params: Riffer::Params?) -> void

Public Instance Methods

to_json_schema (strict: false)

Source

# File lib/riffer/param.rb, line 75
def to_json_schema(strict: false)
  nullable = strict && !required

  if nullable && enum
    schema = {anyOf: [{type: type_name, enum: enum}, {type: "null"}]}
    schema[:description] = description if description
    return schema
  end

  type = type_name
  type = [type, "null"] if nullable

  schema = {type: type}
  schema[:description] = description if description
  schema[:enum] = enum if enum

  if self.type == Array && nested_params
    schema[:items] = nested_params.to_json_schema(strict: strict)
  elsif self.type == Array && item_type
    schema[:items] = {type: TYPE_MAPPINGS[item_type]}
  elsif self.type == Hash && nested_params
    schema.merge!(nested_params.to_json_schema(strict: strict))
  end

  schema
end

Converts this parameter to JSON Schema format.

When +strict+ is true, optional parameters are made nullable (+[“type”, “null”]+) so that strict mode providers can distinguish “absent” from “present” without rejecting the schema.

Optional parameters with an +enum+ use +anyOf+ to separate the enum constraint from the null type, since providers like Anthropic reject +{“type”: [“string”, “null”], “enum”: […]}+.

: (?strict: bool) -> Hash[Symbol, untyped]

type_name ()

Source

# File lib/riffer/param.rb, line 60
def type_name
  TYPE_MAPPINGS[type] || type.to_s.downcase
end

Returns the JSON Schema type name for this parameter.

: () -> String

valid_type? (value)

Source

# File lib/riffer/param.rb, line 47
def valid_type?(value)
  return true if value.nil? && !required

  if type == Riffer::Boolean || type == TrueClass || type == FalseClass
    value == true || value == false
  else
    value.is_a?(type)
  end
end

Validates that a value matches the expected type.

: (untyped) -> bool