ruby_llm-schema 0.4.0 → 1.0.0

metadata

@@ -1,46 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-schema
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel Friis
+- Carmine Paolino
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
-description: A compact Ruby DSL for building standards-oriented JSON Schema documents
-  from Ruby.
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: schematist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Forwards RubyLLM::Schema to Schematist::Schema. Depend on schematist
+  instead.
 email:
 - d@friis.me
+- carmine@paolino.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - README.md
 - lib/ruby_llm/schema.rb
-- lib/ruby_llm/schema/dsl.rb
-- lib/ruby_llm/schema/dsl/complex_types.rb
-- lib/ruby_llm/schema/dsl/conditionals.rb
-- lib/ruby_llm/schema/dsl/primitive_types.rb
-- lib/ruby_llm/schema/dsl/schema_builders.rb
-- lib/ruby_llm/schema/dsl/utilities.rb
-- lib/ruby_llm/schema/errors.rb
-- lib/ruby_llm/schema/helpers.rb
-- lib/ruby_llm/schema/json_output.rb
-- lib/ruby_llm/schema/validator.rb
-- lib/ruby_llm/schema/version.rb
-- lib/tasks/release.rake
-homepage: https://github.com/crmne/ruby_llm-schema#readme
+homepage: https://github.com/crmne/schematist#migrating-from-ruby_llm-schema
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/crmne/ruby_llm-schema#readme
-  source_code_uri: https://github.com/crmne/ruby_llm-schema
-  changelog_uri: https://github.com/crmne/ruby_llm-schema/releases
-  bug_tracker_uri: https://github.com/crmne/ruby_llm-schema/issues
+  homepage_uri: https://github.com/crmne/schematist#migrating-from-ruby_llm-schema
+  source_code_uri: https://github.com/crmne/schematist
+  changelog_uri: https://github.com/crmne/schematist/releases
+  bug_tracker_uri: https://github.com/crmne/schematist/issues
   rubygems_mfa_required: 'true'
+post_install_message: |
+  ruby_llm-schema is now schematist. This release only forwards to it.
+  Switch your Gemfile to `gem 'schematist'` and RubyLLM::Schema to Schematist::Schema.
 rdoc_options: []
 require_paths:
 - lib
@@ -55,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
-summary: A simple Ruby DSL for creating JSON schemas.
+summary: Deprecated. ruby_llm-schema is now schematist.
 test_files: []

data/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2025 Daniel Friis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/lib/ruby_llm/schema/dsl/complex_types.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module ComplexTypes
-        def object(name, description: nil, required: true, requires: nil, **options, &block)
-          add_property(name, object_schema(description: description, **options, &block), required: required, requires: requires)
-        end
-
-        def array(name, description: nil, required: true, requires: nil, **options, &block)
-          add_property(name, array_schema(description: description, **options, &block), required: required, requires: requires)
-        end
-
-        def any_of(name, description: nil, required: true, requires: nil, **options, &block)
-          add_property(name, any_of_schema(description: description, **options, &block), required: required, requires: requires)
-        end
-
-        def one_of(name, description: nil, required: true, requires: nil, **options, &block)
-          add_property(name, one_of_schema(description: description, **options, &block), required: required, requires: requires)
-        end
-
-        def optional(name, description: nil, &block)
-          any_of(name, description: description) do
-            instance_eval(&block)
-            null
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/conditionals.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module Conditionals
-        def conditions
-          @conditions ||= []
-        end
-
-        def dependencies
-          @dependencies ||= {}
-        end
-
-        def dependent(property, &block)
-          builder = ConditionalBuilder.new
-          builder.instance_eval(&block)
-
-          dependencies[property.to_s] = builder
-        end
-
-        def given(**properties, &block)
-          raise ArgumentError, "given requires at least one property condition" if properties.empty?
-
-          if_schema = {
-            properties: properties.transform_keys(&:to_s).transform_values { |v| coerce_condition(v) },
-            required: properties.keys.map(&:to_s)
-          }
-
-          then_builder = ConditionalBuilder.new
-          else_builder = ConditionalBuilder.new
-
-          context = ConditionalContext.new(then_builder, else_builder)
-          context.instance_eval(&block)
-
-          condition = {if: if_schema, then: then_builder.to_schema}
-          condition[:else] = else_builder.to_schema unless else_builder.empty?
-
-          conditions << condition
-        end
-
-        private
-
-        def merge_conditions(schema, schema_class)
-          if schema_class.respond_to?(:conditions) && schema_class.conditions.any?
-            if schema_class.conditions.length == 1
-              schema.merge!(schema_class.conditions.first)
-            else
-              schema[:allOf] = schema_class.conditions
-            end
-          end
-
-          if schema_class.respond_to?(:dependencies) && schema_class.dependencies.any?
-            dependent_required = {}
-            dependent_schemas = {}
-
-            schema_class.dependencies.each do |property, builder|
-              if builder.validations_empty?
-                dependent_required[property] = builder.required_fields
-              else
-                dependent_schemas[property] = builder.to_schema
-              end
-            end
-
-            schema[:dependentRequired] = dependent_required if dependent_required.any?
-            schema[:dependentSchemas] = dependent_schemas if dependent_schemas.any?
-          end
-
-          schema
-        end
-
-        def coerce_condition(value)
-          case value
-          when Array then {enum: value}
-          when Regexp then {pattern: value.source}
-          when Hash then value
-          else {const: value}
-          end
-        end
-      end
-
-      class ConditionalContext
-        def initialize(then_builder, else_builder)
-          @then_builder = then_builder
-          @else_builder = else_builder
-        end
-
-        def requires(*fields)
-          @then_builder.requires(*fields)
-        end
-
-        def validates(field, **options)
-          @then_builder.validates(field, **options)
-        end
-
-        def otherwise(&block)
-          @else_builder.instance_eval(&block)
-        end
-      end
-
-      class ConditionalBuilder
-        def requires(*fields)
-          required.concat(fields.map(&:to_s))
-        end
-
-        VALIDATES_KEY_MAP = {
-          type: :type,
-          const: :const,
-          enum: :enum,
-          not_value: :not,
-          min_length: :minLength,
-          max_length: :maxLength,
-          pattern: :pattern,
-          minimum: :minimum,
-          maximum: :maximum
-        }.freeze
-
-        def validates(field, **options)
-          constraints = {}
-
-          options.each do |key, value|
-            schema_key = VALIDATES_KEY_MAP[key]
-            raise ArgumentError, "unknown validates option: #{key.inspect}" unless schema_key
-
-            case key
-            when :type then constraints[:type] = value.to_s
-            when :not_value then constraints[:not] = {const: value}
-            when :pattern then constraints[:pattern] = value.is_a?(Regexp) ? value.source : value
-            else constraints[schema_key] = value
-            end
-          end
-
-          validations[field.to_s] = constraints
-        end
-
-        def to_schema
-          schema = {}
-
-          schema[:required] = required if required.any?
-          schema[:properties] = validations if validations.any?
-
-          schema
-        end
-
-        def empty?
-          required.empty? && validations.empty?
-        end
-
-        def required_fields
-          required.dup
-        end
-
-        def validations_empty?
-          validations.empty?
-        end
-
-        private
-
-        def required
-          @required ||= []
-        end
-
-        def validations
-          @validations ||= {}
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/primitive_types.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module PrimitiveTypes
-        def string(name, description: nil, required: true, requires: nil, **options)
-          add_property(name, string_schema(description: description, **options), required: required, requires: requires)
-        end
-
-        def number(name, description: nil, required: true, requires: nil, **options)
-          add_property(name, number_schema(description: description, **options), required: required, requires: requires)
-        end
-
-        def integer(name, description: nil, required: true, requires: nil, **options)
-          add_property(name, integer_schema(description: description, **options), required: required, requires: requires)
-        end
-
-        def boolean(name, description: nil, required: true, requires: nil, **options)
-          add_property(name, boolean_schema(description: description, **options), required: required, requires: requires)
-        end
-
-        def null(name, description: nil, required: true, requires: nil, **options)
-          add_property(name, null_schema(description: description, **options), required: required, requires: requires)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/schema_builders.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module SchemaBuilders
-        def string_schema(description: nil, enum: nil, min_length: nil, max_length: nil, pattern: nil, format: nil)
-          {
-            type: "string",
-            enum: enum,
-            description: description,
-            minLength: min_length,
-            maxLength: max_length,
-            pattern: pattern,
-            format: format
-          }.compact
-        end
-
-        def number_schema(description: nil, minimum: nil, maximum: nil, multiple_of: nil)
-          {
-            type: "number",
-            description: description,
-            minimum: minimum,
-            maximum: maximum,
-            multipleOf: multiple_of
-          }.compact
-        end
-
-        def integer_schema(description: nil, minimum: nil, maximum: nil, multiple_of: nil)
-          {
-            type: "integer",
-            description: description,
-            minimum: minimum,
-            maximum: maximum,
-            multipleOf: multiple_of
-          }.compact
-        end
-
-        def boolean_schema(description: nil)
-          {type: "boolean", description: description}.compact
-        end
-
-        def null_schema(description: nil)
-          {type: "null", description: description}.compact
-        end
-
-        def object_schema(description: nil, of: nil, reference: nil, &block)
-          if reference
-            warn "[DEPRECATION] The `reference` option will be deprecated. Please use `of` instead."
-            of = reference
-          end
-
-          if of
-            determine_object_reference(of, description)
-          else
-            sub_schema = Class.new(Schema)
-            result = sub_schema.class_eval(&block)
-
-            # If the block returned a reference and no properties were added, use the reference
-            if result.is_a?(Hash) && result["$ref"] && sub_schema.properties.empty?
-              result.merge(description ? {description: description} : {})
-            # If the block returned a Schema class or instance, convert it to inline schema
-            elsif schema_class?(result) && sub_schema.properties.empty?
-              schema_class_to_inline_schema(result).merge(description ? {description: description} : {})
-            # Block didn't return reference or schema, so we build an inline object schema
-            else
-              schema = {
-                type: "object",
-                properties: sub_schema.properties,
-                required: sub_schema.required_properties,
-                additionalProperties: sub_schema.additional_properties,
-                description: description
-              }.compact
-
-              merge_conditions(schema, sub_schema)
-            end
-          end
-        end
-
-        def array_schema(description: nil, of: nil, min_items: nil, max_items: nil, &block)
-          items = determine_array_items(of, &block)
-
-          {
-            type: "array",
-            description: description,
-            items: items,
-            minItems: min_items,
-            maxItems: max_items
-          }.compact
-        end
-
-        def any_of_schema(description: nil, &block)
-          schemas = collect_schemas_from_block(&block)
-
-          {
-            description: description,
-            anyOf: schemas
-          }.compact
-        end
-
-        def one_of_schema(description: nil, &block)
-          schemas = collect_schemas_from_block(&block)
-
-          {
-            description: description,
-            oneOf: schemas
-          }.compact
-        end
-
-        private
-
-        def determine_array_items(of, &)
-          return collect_schemas_from_block(&).first if block_given?
-          return send("#{of}_schema") if primitive_type?(of)
-          return reference(of) if of.is_a?(Symbol)
-          return schema_class_to_inline_schema(of) if schema_class?(of)
-
-          raise InvalidArrayTypeError, "Invalid array type: #{of.inspect}. Must be a primitive type (:string, :number, etc.), a symbol reference, a Schema class, or a Schema instance."
-        end
-
-        def determine_object_reference(of, description = nil)
-          result = case of
-                   when Symbol
-                     reference(of)
-                   when Class
-                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Class must inherit from RubyLLM::Schema." unless schema_class?(of)
-
-                     schema_class_to_inline_schema(of)
-
-                   else
-                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Must be a symbol reference, a Schema class, or a Schema instance." unless schema_class?(of)
-
-                     schema_class_to_inline_schema(of)
-
-                   end
-
-          description ? result.merge(description: description) : result
-        end
-
-        def collect_schemas_from_block(&block)
-          schemas = []
-          schema_builder = self
-
-          context = Object.new
-
-          # Dynamically create methods for all schema builders
-          schema_builder.methods.grep(/_schema$/).each do |schema_method|
-            type_name = schema_method.to_s.sub(/_schema$/, "")
-
-            context.define_singleton_method(type_name) do |_name = nil, **options, &blk|
-              schemas << schema_builder.send(schema_method, **options, &blk)
-            end
-          end
-
-          # Allow Schema classes to be accessed in the context
-          context.define_singleton_method(:const_missing) do |name|
-            const_get(name) if const_defined?(name)
-          end
-
-          context.instance_eval(&block)
-          schemas
-        end
-
-        def schema_class_to_inline_schema(schema_class_or_instance)
-          # Handle both Schema classes and Schema instances
-          schema_class = if schema_class_or_instance.is_a?(Class)
-                           schema_class_or_instance
-                         else
-                           schema_class_or_instance.class
-                         end
-
-          # Directly convert schema class to inline object schema
-          {
-            type: "object",
-            properties: schema_class.properties,
-            required: schema_class.required_properties,
-            additionalProperties: schema_class.additional_properties
-          }.tap do |schema|
-            # For instances, prefer instance description over class description
-            description = if schema_class_or_instance.is_a?(Class)
-                            schema_class.description
-                          else
-                            schema_class_or_instance.instance_variable_get(:@description) || schema_class.description
-                          end
-
-            schema[:description] = description if description
-
-            merge_conditions(schema, schema_class)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/utilities.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module Utilities
-        # Schema definition and reference methods
-        def define(name, &)
-          sub_schema = Class.new(Schema)
-          sub_schema.class_eval(&)
-
-          schema = {
-            type: "object",
-            properties: sub_schema.properties,
-            required: sub_schema.required_properties,
-            additionalProperties: sub_schema.additional_properties
-          }
-
-          merge_conditions(schema, sub_schema)
-
-          definitions[name] = schema
-        end
-
-        def reference(schema_name)
-          if schema_name == :root
-            {"$ref" => "#"}
-          else
-            {"$ref" => "#/$defs/#{schema_name}"}
-          end
-        end
-
-        private
-
-        def add_property(name, definition, required:, requires: nil)
-          property_name = name.to_sym
-
-          properties[property_name] = definition
-          if required
-            required_properties << property_name unless required_properties.include?(property_name)
-          else
-            required_properties.delete(property_name)
-          end
-
-          if requires
-            builder = ConditionalBuilder.new
-            builder.requires(*Array(requires))
-            dependencies[name.to_s] = builder
-          end
-
-          nil
-        end
-
-        def primitive_type?(type)
-          type.is_a?(Symbol) && PRIMITIVE_TYPES.include?(type)
-        end
-
-        def schema_class?(type)
-          (type.is_a?(Class) && type < Schema) || type.is_a?(Schema)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "dsl/schema_builders"
-require_relative "dsl/primitive_types"
-require_relative "dsl/complex_types"
-require_relative "dsl/conditionals"
-require_relative "dsl/utilities"
-
-module RubyLLM
-  class Schema
-    module DSL
-      include SchemaBuilders
-      include PrimitiveTypes
-      include ComplexTypes
-      include Conditionals
-      include Utilities
-    end
-  end
-end

data/lib/ruby_llm/schema/errors.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    # Base error class for all schema-related errors
-    class Error < StandardError; end
-
-    # Raised when an invalid schema type is specified
-    class InvalidSchemaTypeError < Error
-      def initialize(type)
-        super("Unknown schema type: #{type}")
-      end
-    end
-
-    # Raised when an invalid array type is specified
-    class InvalidArrayTypeError < Error; end
-
-    # Raised when an invalid object type is specified
-    class InvalidObjectTypeError < Error; end
-
-    # Raised when schema definition is invalid
-    class InvalidSchemaError < Error; end
-
-    # Raised when schema validation fails
-    class ValidationError < Error; end
-
-    # Raised when maximum limits are exceeded
-    class LimitExceededError < Error; end
-  end
-end

data/lib/ruby_llm/schema/helpers.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Helpers
-    def schema(name = nil, description: nil, &block)
-      schema_class = Schema.create(&block)
-      schema_class.new(name, description: description)
-    end
-  end
-end

data/lib/ruby_llm/schema/json_output.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module JsonOutput
-      def to_json_schema
-        validate! # Validate schema before generating JSON
-
-        schema_hash = {
-          type: "object",
-          properties: self.class.properties,
-          required: self.class.required_properties,
-          additionalProperties: self.class.additional_properties
-        }
-
-        schema_hash[:strict] = self.class.strict unless self.class.strict.nil?
-
-        # Only include $defs if there are definitions
-        schema_hash["$defs"] = self.class.definitions unless self.class.definitions.empty?
-
-        self.class.send(:merge_conditions, schema_hash, self.class)
-
-        {
-          name: @name,
-          description: @description || self.class.description,
-          schema: schema_hash
-        }
-      end
-
-      def to_json(*_args)
-        validate! # Validate schema before generating JSON string
-        JSON.pretty_generate(to_json_schema)
-      end
-    end
-  end
-end