schematist 0.1.0 → 1.0.0

data/lib/schematist/helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Schematist
+  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/schematist/json_output.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Schematist
+  module JsonOutput
+    DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema"
+
+    # A Draft 2020-12 JSON Schema document, string-keyed and ready for any JSON Schema validator
+    def to_json_schema
+      validate! # Validate schema before generating JSON
+
+      document = schema_body
+      class_description = document.delete(:description)
+      header = {
+        "$schema" => DRAFT_2020_12,
+        title: document.delete(:title) || @name,
+        description: @description || class_description
+      }.compact
+
+      json_compatible(resolve_runtime_values(header.merge(document)))
+    end
+
+    def to_json(*_args)
+      validate! # Validate schema before generating JSON string
+      JSON.pretty_generate(to_json_schema)
+    end
+
+    private
+
+    def schema_body
+      schema_hash = {
+        type: "object",
+        properties: self.class.properties,
+        required: self.class.required_properties,
+        additionalProperties: self.class.additional_properties
+      }
+
+      # Only include $defs if there are definitions
+      schema_hash["$defs"] = self.class.definitions unless self.class.definitions.empty?
+
+      self.class.send(:merge_schema_keywords, schema_hash, self.class)
+
+      schema_hash
+    end
+
+    # JSON Schema documents are string-keyed. Symbols survive a Ruby comparison but not a JSON round trip.
+    def json_compatible(value)
+      case value
+      when Hash
+        value.to_h { |key, nested_value| [key.to_s, json_compatible(nested_value)] }
+      when Array
+        value.map { |nested_value| json_compatible(nested_value) }
+      when Symbol
+        value.to_s
+      else
+        value
+      end
+    end
+
+    # Values declared as procs are resolved here, so one schema class can render differently per instance
+    def resolve_runtime_values(value)
+      case value
+      when Proc
+        resolve_runtime_values(value.arity.zero? ? instance_exec(&value) : value.call(self))
+      when Hash
+        value.transform_values { |nested_value| resolve_runtime_values(nested_value) }
+      when Array
+        value.map { |nested_value| resolve_runtime_values(nested_value) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/schematist/schema.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Schematist
+  class Schema
+    extend DSL
+    include JsonOutput
+
+    class << self
+      def create(&block)
+        schema_class = Class.new(Schema)
+        schema_class.class_eval(&block)
+        schema_class
+      end
+
+      def properties
+        @properties ||= {}
+      end
+
+      def required_properties
+        @required_properties ||= []
+      end
+
+      def definitions
+        @definitions ||= {}
+      end
+
+      def name(name = nil)
+        @schema_name = name if name
+        return @schema_name if defined?(@schema_name)
+
+        super()
+      end
+
+      def annotations
+        @annotations ||= {}
+      end
+
+      def title(*args)
+        annotation(:title, *args)
+      end
+
+      def description(*args)
+        annotation(:description, *args)
+      end
+
+      def default(*args)
+        annotation(:default, *args)
+      end
+
+      def examples(*args)
+        annotation(:examples, *args)
+      end
+
+      def deprecated(*args)
+        annotation(:deprecated, *args)
+      end
+
+      def read_only(*args)
+        annotation(:read_only, *args)
+      end
+
+      def write_only(*args)
+        annotation(:write_only, *args)
+      end
+
+      def core_keywords
+        @core_keywords ||= {}
+      end
+
+      def id(*args)
+        core_keyword(:id, *args)
+      end
+
+      def anchor(*args)
+        core_keyword(:anchor, *args)
+      end
+
+      def comment(*args)
+        core_keyword(:comment, *args)
+      end
+
+      def dynamic_anchor(*args)
+        core_keyword(:dynamic_anchor, *args)
+      end
+
+      def dynamic_ref(*args)
+        core_keyword(:dynamic_ref, *args)
+      end
+
+      def vocabulary(*args)
+        core_keyword(:vocabulary, *args)
+      end
+
+      def additional_properties(value = nil)
+        return @additional_properties ||= false if value.nil?
+
+        @additional_properties = value
+      end
+
+      def validate!
+        validator = Validator.new(self)
+        validator.validate!
+      end
+
+      def valid?
+        validator = Validator.new(self)
+        validator.valid?
+      end
+
+      private
+
+      def annotation(name, *args)
+        read_or_write(annotations, ANNOTATIONS.fetch(name), *args)
+      end
+
+      def core_keyword(name, *args)
+        read_or_write(core_keywords, CORE_KEYWORDS.fetch(name), *args)
+      end
+
+      def read_or_write(store, keyword, *args)
+        return store[keyword] if args.empty?
+
+        store[keyword] = args.first
+      end
+    end
+
+    def initialize(name = nil, description: nil)
+      @name = name || self.class.name || "Schema"
+      @description = description
+    end
+
+    def validate!
+      self.class.validate!
+    end
+
+    def valid?
+      self.class.valid?
+    end
+
+    def method_missing(method_name, ...)
+      if respond_to_missing?(method_name)
+        self.class.send(method_name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      %i[string number integer boolean array tuple object any_of one_of all_of none_of raw null].include?(method_name) || super
+    end
+  end
+end

data/lib/schematist/validator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Schematist
+  class Validator
+    # Node states for DFS-based topological sort
+    WHITE = :white  # No mark (unvisited)
+    GRAY = :gray    # Temporary mark (currently being processed)
+    BLACK = :black  # Permanent mark (completely processed)
+
+    def initialize(schema_class)
+      @schema_class = schema_class
+    end
+
+    def validate!
+      validate_circular_references!
+      # Future validations can be added here
+    end
+
+    def valid?
+      validate!
+      true
+    rescue ValidationError
+      false
+    end
+
+    private
+
+    def validate_circular_references!
+      definitions = @schema_class.definitions
+      return if definitions.empty?
+
+      # Initialize all nodes as WHITE (no mark)
+      marks = Hash.new { WHITE }
+
+      # Visit each unmarked node
+      definitions.each_key do |node|
+        visit(node, definitions, marks) if marks[node] == WHITE
+      end
+    end
+
+    # DFS visit function
+    def visit(node, definitions, marks)
+      # If node has a permanent mark, return
+      return if marks[node] == BLACK
+
+      # If node has a temporary mark, we found a cycle
+      raise ValidationError, "Circular reference detected involving '#{node}'" if marks[node] == GRAY
+
+      # Mark node with temporary mark
+      marks[node] = GRAY
+
+      # Visit all adjacent nodes (dependencies)
+      definition = definitions[node]
+      if definition && definition[:properties]
+        definition[:properties].each_value do |property|
+          references = extract_references(property)
+          references.each do |adjacent_node|
+            visit(adjacent_node, definitions, marks)
+          end
+        end
+      end
+
+      # Mark node with permanent mark
+      marks[node] = BLACK
+    end
+
+    def extract_references(property)
+      references = []
+
+      case property
+      when Hash
+        if property["$ref"]
+          # Extract definition name from reference like "#/$defs/user"
+          ref_name = property["$ref"].split("/").last&.to_sym
+          references << ref_name if ref_name
+        else
+          # Recursively check nested properties
+          property.each_value do |value|
+            references.concat(extract_references(value))
+          end
+        end
+      when Array
+        property.each do |item|
+          references.concat(extract_references(item))
+        end
+      end
+
+      references
+    end
+  end
+end

data/lib/schematist/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Schematist
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/lib/schematist.rb

@@ -1,4 +1,46 @@
 # frozen_string_literal: true
 
-require_relative 'schematist/version'
-require 'ruby_llm/schema'
+require "json"
+
+require_relative "schematist/version"
+require_relative "schematist/errors"
+
+module Schematist
+  PRIMITIVE_TYPES = %i[string number integer boolean null].freeze
+
+  # Annotations describe a schema for humans and tools. They carry no validation weight.
+  ANNOTATIONS = {
+    title: :title,
+    description: :description,
+    default: :default,
+    examples: :examples,
+    deprecated: :deprecated,
+    read_only: :readOnly,
+    write_only: :writeOnly
+  }.freeze
+
+  # Core keywords identify a schema and point at other schemas.
+  CORE_KEYWORDS = {
+    id: "$id",
+    anchor: "$anchor",
+    comment: "$comment",
+    dynamic_anchor: "$dynamicAnchor",
+    dynamic_ref: "$dynamicRef",
+    vocabulary: "$vocabulary"
+  }.freeze
+end
+
+# Every file defines the constant its path implies. The DSL modules come before dsl.rb,
+# which includes them, and the DSL before schema.rb, which extends it.
+require_relative "schematist/dsl/schema_builders"
+require_relative "schematist/dsl/primitive_types"
+require_relative "schematist/dsl/complex_types"
+require_relative "schematist/dsl/conditional_builder"
+require_relative "schematist/dsl/conditional_context"
+require_relative "schematist/dsl/conditionals"
+require_relative "schematist/dsl/utilities"
+require_relative "schematist/dsl"
+require_relative "schematist/json_output"
+require_relative "schematist/validator"
+require_relative "schematist/helpers"
+require_relative "schematist/schema"

data/lib/tasks/release.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+namespace :release do
+  desc 'Prepare for release'
+  task :prepare do
+    sh 'overcommit --run'
+  end
+end

metadata

@@ -1,32 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: schematist
 version: !ruby/object:Gem::Version
-  version: 0.1.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:
-- !ruby/object:Gem::Dependency
-  name: ruby_llm-schema
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Schematist is the next home of ruby_llm-schema. Installing schematist
-  installs ruby_llm-schema and requiring schematist loads it. The expanded JSON Schema
-  (draft 2020-12) toolkit lands here in a future release.
+dependencies: []
+description: A compact Ruby DSL for building standards-oriented JSON Schema documents
+  from Ruby.
 email:
+- d@friis.me
 - carmine@paolino.me
 executables: []
 extensions: []
@@ -35,13 +22,29 @@ files:
 - LICENSE
 - README.md
 - lib/schematist.rb
+- lib/schematist/dsl.rb
+- lib/schematist/dsl/complex_types.rb
+- lib/schematist/dsl/conditional_builder.rb
+- lib/schematist/dsl/conditional_context.rb
+- lib/schematist/dsl/conditionals.rb
+- lib/schematist/dsl/primitive_types.rb
+- lib/schematist/dsl/schema_builders.rb
+- lib/schematist/dsl/utilities.rb
+- lib/schematist/errors.rb
+- lib/schematist/helpers.rb
+- lib/schematist/json_output.rb
+- lib/schematist/schema.rb
+- lib/schematist/validator.rb
 - lib/schematist/version.rb
-homepage: https://github.com/crmne/ruby_llm-schema
+- lib/tasks/release.rake
+homepage: https://github.com/crmne/schematist#readme
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/crmne/ruby_llm-schema
-  source_code_uri: https://github.com/crmne/ruby_llm-schema
+  homepage_uri: https://github.com/crmne/schematist#readme
+  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'
 rdoc_options: []
 require_paths:
@@ -59,5 +62,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: A Ruby DSL for building JSON Schema documents.
+summary: A simple Ruby DSL for creating JSON schemas.
 test_files: []