Class: Riffer::Param

Inherits:
Object
  • Object
show all
Defined in:
lib/riffer/param.rb

Overview

Riffer::Param represents a single parameter definition.

Handles type validation and JSON Schema generation for individual parameters.

Constant Summary collapse

TYPE_MAPPINGS =

Maps Ruby types to JSON Schema type strings

{
  String => "string",
  Integer => "integer",
  Float => "number",
  Riffer::Boolean => "boolean",
  TrueClass => "boolean",
  FalseClass => "boolean",
  Array => "array",
  Hash => "object"
}.freeze
PRIMITIVE_TYPES =

Primitive types allowed for the of: keyword on Array params

(TYPE_MAPPINGS.keys - [Array, Hash]).freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil) ⇒ Param

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



34
35
36
37
38
39
40
41
42
43
 
# File 'lib/riffer/param.rb', line 34

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

Instance Attribute Details

#default ⇒ Object (readonly)

: untyped



28
29
30
 
# File 'lib/riffer/param.rb', line 28

def default
  @default
end

#description ⇒ Object (readonly)

: String?



26
27
28
 
# File 'lib/riffer/param.rb', line 26

def description
  @description
end

#enum ⇒ Object (readonly)

: Array?



27
28
29
 
# File 'lib/riffer/param.rb', line 27

def enum
  @enum
end

#item_type ⇒ Object (readonly)

: Class?



29
30
31
 
# File 'lib/riffer/param.rb', line 29

def item_type
  @item_type
end

#name ⇒ Object (readonly)

: Symbol



23
24
25
 
# File 'lib/riffer/param.rb', line 23

def name
  @name
end

#nested_params ⇒ Object (readonly)

: Riffer::Params?



30
31
32
 
# File 'lib/riffer/param.rb', line 30

def nested_params
  @nested_params
end

#required ⇒ Object (readonly)

: bool



25
26
27
 
# File 'lib/riffer/param.rb', line 25

def required
  @required
end

#type ⇒ Object (readonly)

: Class



24
25
26
 
# File 'lib/riffer/param.rb', line 24

def type
  @type
end

Instance Method Details

#to_json_schema(strict: false) ⇒ Object

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]



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/riffer/param.rb', line 79

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

#type_name ⇒ Object

Returns the JSON Schema type name for this parameter.

– : () -> String



63
64
65
 
# File 'lib/riffer/param.rb', line 63

def type_name
  TYPE_MAPPINGS[type] || type.to_s.downcase
end

#valid_type?(value) ⇒ Boolean

Validates that a value matches the expected type.

– : (untyped) -> bool

Returns:



49
50
51
52
53
54
55
56
57
 
# File 'lib/riffer/param.rb', line 49

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