verse-schema 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63618ff4cf11b43ec35e8bb88adaffdf8d15ac3a49a461427fbdc3cd8908299a
-  data.tar.gz: 2ab22e1cd477e2b4f0e4cd070f50e2fd56e89b1c323795f4ca3cbfa1944e271d
+  metadata.gz: ac21990f8abf487af0be8d14959c40595c2327cdbbda87a4bc15d53cfcf87a36
+  data.tar.gz: 102efefd85e3181bda88e337672a810c54bfafe4c623ae825972b7e82e6bc689
 SHA512:
-  metadata.gz: d7c5cb3e34919f47de38726ea146aa1d3d3ffe77b26d999c18da1d5e441ca06fcba4d8827c42d3b515ea7c7abd73177e7627352e1c2714ef82c0e2e196b9d01a
-  data.tar.gz: 4b60874afb6bcf4b7721396b9fe799b38b1b21fe4fb31c9b8fd467b835ded25ff72f8df8a2ff7bb4cddd1dca322937aa8ad1f879bcc13e7d9e012cf027cc4f63
+  metadata.gz: 1e464f3fcbaa0d77b69d81f7001c80ecb7efba9298476aab84f16390bbda8481c1f37c3c7a5d80e11d9de31f7064c67e9db1448b545d4b927079d331ea939b3d
+  data.tar.gz: 89cfcaa93e6813a5ffab8834e49002ebf3791a42a64a5457444a0fa4ba941412583ea1925e5ba7c607e7bfcd3bd16628437f9c954b6710f6296f400b9b0d3be7

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.4.3

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.2
+
+- Add `Verse::Schema::Json.from` method to convert a Verse schema
+to JSON Schema format (note: doesn't work the other way around yet)
+
 ## 1.1
 
 - Add `strict` mode to `validate` which will raise an error if the input has

data/Gemfile

@@ -7,7 +7,7 @@ gemspec
 
 # Development dependencies
 group :development do
-  gem "prism", "~> 0.19.0", require: false
+  gem "prism", "~> 1.5.2", require: false
 end
 
 gem "rake", "~> 13.0"
@@ -18,6 +18,6 @@ gem "relaxed-rubocop"
 gem "rubocop", "~> 1.21"
 gem "simplecov"
 
-gem "ruby-prof"
+gem "ruby-prof", "~> 1.7.2"
 
 gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    verse-schema (1.1.0)
+    verse-schema (1.2.0)
       attr_chainable (~> 1.0)
 
 GEM
@@ -9,6 +9,7 @@ GEM
   specs:
     ast (2.4.2)
     attr_chainable (1.0.0)
+    base64 (0.3.0)
     bootsnap (1.18.3)
       msgpack (~> 1.2)
     coderay (1.1.3)
@@ -22,7 +23,7 @@ GEM
     parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
-    prism (0.19.0)
+    prism (1.5.2)
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -58,7 +59,8 @@ GEM
       unicode-display_width (>= 2.4.0, < 3.0)
     rubocop-ast (1.31.2)
       parser (>= 3.3.0.4)
-    ruby-prof (1.7.1)
+    ruby-prof (1.7.2)
+      base64
     ruby-progressbar (1.13.0)
     simplecov (0.22.0)
       docile (~> 1.1)
@@ -73,13 +75,13 @@ PLATFORMS
 
 DEPENDENCIES
   bootsnap (~> 1.16)
-  prism (~> 0.19.0)
+  prism (~> 1.5.2)
   pry
   rake (~> 13.0)
   relaxed-rubocop
   rspec (~> 3.0)
   rubocop (~> 1.21)
-  ruby-prof
+  ruby-prof (~> 1.7.2)
   simplecov
   verse-schema!
 

data/README.md

@@ -123,6 +123,11 @@ These examples are extracted directly from the gem's specs, ensuring they are ac
   - [Polymorphic Schema](#polymorphic-schema)
   
 
+- [JSON Schema Generation](#json-schema-generation)
+  
+  - [Generating JSON Schema](#generating-json-schema)
+  
+
 
 
 ## 1. Basic Usage
@@ -952,7 +957,7 @@ it "demonstrates reusable rules defined with Verse::Schema.rule" do
   is_positive = Verse::Schema.rule("must be positive") { |value| value > 0 }
 
   # Define another reusable rule
-  is_even = Verse::Schema.rule("must be even") { |value| value.even? }
+  is_even = Verse::Schema.rule("must be even", &:even?)
 
   # Create a schema that uses the reusable rules
   schema = Verse::Schema.define do
@@ -1666,7 +1671,6 @@ it "demonstrates a polymorphic schema" do
   # 3. Define a builder schema. The best way to do this is to use the
   # scalar type:
   builder_schema = Verse::Schema.scalar(Hash).transform do |input, error_builder|
-
     type = input[:type]
 
     if type.respond_to?(:to_sym)
@@ -1677,14 +1681,14 @@ it "demonstrates a polymorphic schema" do
     end
 
     schema = case type
-              when :facebook
-                facebook_schema
-              when :google
-                google_schema
-              else
-                error_builder.add(:type, "invalid type")
-                stop
-              end
+             when :facebook
+               facebook_schema
+             when :google
+               google_schema
+             else
+               error_builder.add(:type, "invalid type")
+               stop
+             end
 
     # Validate the input against the selected schema
     result = schema.validate(input, error_builder:)
@@ -1753,9 +1757,9 @@ it "demonstrates a polymorphic schema" do
   expect(invalid_result.success?).to be false
   # The errors are collected
   expect(invalid_result.errors).to eq({
-    :"events.0.url" => ["is required"],
-    :"events.1.location" => ["is required"],
-    :"events.2.type" => ["invalid type"]
+    "events.0.url": ["is required"],
+    "events.1.location": ["is required"],
+    "events.2.type": ["invalid type"]
   })
 end
 
@@ -1763,6 +1767,47 @@ end
 
 
 
+## JSON Schema Generation
+
+
+### Generating JSON Schema
+
+
+```ruby
+it "converts a simple schema to a valid JSON schema" do
+  schema = Verse::Schema.define do
+    field(:name, String).meta(description: "The name of the user")
+    field(:age, Integer)
+  end
+
+  json_schema = Verse::Schema::Json.from(schema)
+  puts JSON.pretty_generate(json_schema)
+
+  # The output of the `to_json` method will be a valid JSON schema hash:
+  #
+  # {
+  #   "type": "object",
+  #   "properties": {
+  #     "name": {
+  #       "type": "string",
+  #       "description": "The name of the user"
+  #     },
+  #     "age": {
+  #       "type": "integer"
+  #     }
+  #   },
+  #   "required": [
+  #     "name",
+  #     "age"
+  #   ],
+  #   "additionalProperties": false
+  # }
+end
+
+```
+
+
+
 
 ## License
 

data/lib/tasks/readme_doc_extractor.rb

@@ -109,7 +109,7 @@ class ReadmeDocExtractor
     end
   end
 
-   # Extract code from an example
+  # Extract code from an example
   def extract_code_from_example(example)
     # Get the example block directly using instance_variable_get
     example_block = example.instance_variable_get(:@example_block)

data/lib/verse/schema/base.rb

@@ -14,7 +14,7 @@ module Verse
 
       # Initialize a new schema.
       def initialize(post_processors: nil)
-        @post_processors   = post_processors
+        @post_processors = post_processors
       end
 
       def rule(fields = nil, message = "rule failed", &block)

data/lib/verse/schema/coalescer.rb

@@ -10,7 +10,7 @@ module Verse
       DEFAULT_MAPPER = lambda do |type|
         if type.is_a?(Base)
           proc do |value, _opts, locals:, strict:|
-            type.validate(value, locals:,  strict:)
+            type.validate(value, locals:, strict:)
           end
         elsif type.is_a?(Class)
           proc do |value|

data/lib/verse/schema/collection.rb

@@ -57,10 +57,28 @@ module Verse
         @values.all? do |child_type|
           # ...is a subtype (`<=`) of *at least one* type allowed by the parent collection.
           parent_schema.values.any? do |parent_type|
-            # Use the existing `<=` operator defined on schema types (Scalar, Struct, etc.)
-            # This assumes the `<=` operator correctly handles class inheritance (e.g., Integer <= Object)
-            # and schema type compatibility.
-            child_type <= parent_type
+            # Special handling for when child_type is a primitive class (like Integer)
+            # and parent_type is a Scalar
+            if !child_type.is_a?(Base) && parent_type.is_a?(Scalar)
+              # Check if the primitive class is compatible with any of the Scalar's values
+              parent_type.values.any? do |scalar_value|
+                # Use standard Ruby `<=` for comparison
+                child_type <= scalar_value
+              rescue TypeError
+                # Handle cases where <= is not defined between types
+                false
+              end
+            else
+              # Use the existing `<=` operator defined on schema types (Scalar, Struct, etc.)
+              # This assumes the `<=` operator correctly handles class inheritance (e.g., Integer <= Object)
+              # and schema type compatibility.
+              begin
+                child_type <= parent_type
+              rescue TypeError
+                # Handle cases where <= is not defined between types
+                false
+              end
+            end
           end
         end
       end
@@ -170,7 +188,6 @@ module Verse
 
         Result.new(output, error_builder.errors)
       end
-
     end
   end
 end

data/lib/verse/schema/dictionary.rb

@@ -14,7 +14,7 @@ module Verse
       def initialize(values:, post_processors: nil)
         super(post_processors:)
 
-        @values    = values
+        @values = values
       end
 
       def validate(input, error_builder: nil, locals: {}, strict: false)
@@ -155,7 +155,6 @@ module Verse
 
         Result.new(output, error_builder.errors)
       end
-
     end
   end
 end

data/lib/verse/schema/field.rb

@@ -8,7 +8,7 @@ module Verse
   module Schema
     # A field in a schema
     class Field
-      attr_reader :opts, :post_processors, :name, :type
+      attr_reader :opts, :post_processors, :name
 
       def initialize(name, type, opts, post_processors: nil, &block)
         @name = name
@@ -53,7 +53,7 @@ module Verse
         of_arg = @opts[:of] # For array and dictionary
         of_arg = [of_arg] unless of_arg.nil? || of_arg.is_a?(Array)
 
-        if type == Hash || type == Object
+        if [Hash, Object].include?(type)
           type = Schema.dictionary(*of_arg) if of_arg # dictionary
         elsif type == Array
           type = Schema.array(*of_arg) if of_arg
@@ -269,7 +269,7 @@ module Verse
           elsif c.is_a?(Class) && p.is_a?(Verse::Schema::Scalar)
             p.values.any? { |p_val| c <= p_val }
           elsif c.is_a?(Verse::Schema::Base) && p.is_a?(Verse::Schema::Base)
-             c <= p
+            c <= p
           elsif c.is_a?(Class) && p.is_a?(Class)
             c <= p
           else

data/lib/verse/schema/json.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Verse
+  module Schema
+    module Json
+      # rubocop:disable Lint/HashCompareByIdentity
+      # @param schema [Verse::Schema::Base] The schema to convert to JSON schema
+      # @return [Hash] The JSON schema
+      def self.from(schema)
+        definitions = {}
+        # directly build the root schema, don't use a ref.
+        output = _build_schema(schema, registry: {}, definitions: definitions)
+
+        if definitions.any?
+          output[:"$defs"] = definitions
+        end
+
+        output
+      end
+
+      def self._from_schema(schema, registry:, definitions:)
+        return { "$ref": registry[schema.object_id] } if registry.key?(schema.object_id)
+
+        if schema.is_a?(Verse::Schema::Struct)
+          # Register the schema to handle recursion
+          # and give it a name.
+          # The name is based on the class name, or the object_id if the class is anonymous.
+          name = :"Schema#{schema.object_id}"
+          ref = "#/$defs/#{name}"
+
+          registry[schema.object_id] = ref
+
+          # if it's the root schema, don't create a definition, just build it.
+          built_schema = _build_schema(schema, registry:, definitions:)
+
+          definitions[name] = built_schema
+
+          return { "$ref": ref }
+        end
+
+        _build_schema(schema, registry:, definitions:)
+      end
+
+      def self._build_schema(schema, registry:, definitions:)
+        case schema
+        when Verse::Schema::Struct
+          properties = schema.fields.each_with_object({}) do |field_obj, obj|
+            next if field_obj.type.is_a?(Verse::Schema::Selector)
+
+            obj[field_obj.name] = begin
+              output = _from_schema(field_obj.type, registry:, definitions:)
+              desc = field_obj.opts.dig(:meta, :description)
+
+              output[:description] = desc if desc
+
+              default = field_obj.opts[:default]
+
+              if default && !default.is_a?(Proc)
+                output[:default] = default
+              end
+
+              output
+            end
+          end
+
+          required_fields = schema.fields.select(&:required?).map(&:name)
+
+          json = {
+            type: "object",
+            properties: properties
+          }
+          json[:required] = required_fields if required_fields.any?
+          json[:additionalProperties] = schema.extra_fields?
+
+          # Handle selectors
+          schema.fields.each do |field_obj|
+            next unless field_obj.type.is_a?(Verse::Schema::Selector)
+
+            discriminator = field_obj.opts[:over]
+            json[:properties][field_obj.name] = { type: "object" }
+
+            selector_keys = field_obj.type.values.keys
+            if !selector_keys.include?(:__else__)
+              json[:properties][discriminator][:enum] = selector_keys.map(&:to_s)
+            end
+
+            json[:allOf] = field_obj.type.values.map do |key, sub_schema|
+              next if key == :__else__
+
+              {
+                if: {
+                  properties: { discriminator.to_sym => { const: key.to_s } }
+                },
+                then: {
+                  properties: {
+                    field_obj.name => _from_schema(sub_schema, registry:, definitions:)
+                  }
+                }
+              }
+            end.compact
+          end
+
+          json
+        when Verse::Schema::Collection
+          items = if schema.values.length > 1
+                    { anyOf: schema.values.map { |v| _from_schema(v, registry:, definitions:) } }
+                  else
+                    _from_schema(schema.values.first, registry:, definitions:)
+                  end
+
+          {
+            type: "array",
+            items: items
+          }
+        when Verse::Schema::Dictionary
+          additional_properties = if schema.values.length > 1
+                                    { anyOf: schema.values.map { |v| _from_schema(v, registry:, definitions:) } }
+                                  else
+                                    _from_schema(schema.values.first, registry:, definitions:)
+                                  end
+          {
+            type: "object",
+            additionalProperties: additional_properties
+          }
+        when Verse::Schema::Scalar
+          {
+            anyOf: schema.values.map { |v| _from_schema(v, registry:, definitions:) }
+          }
+        when Verse::Schema::Selector
+          # This should not be reached directly for a valid schema with `over`
+          raise "Selector schema must be used within a Struct with `over` option."
+        when String.singleton_class, Symbol.singleton_class
+          { type: "string" }
+        when Integer.singleton_class
+          { type: "integer" }
+        when Float.singleton_class, Numeric.singleton_class
+          { type: "number" }
+        when TrueClass.singleton_class, FalseClass.singleton_class
+          { type: "boolean" }
+        when Time.singleton_class
+          { type: "string", format: "date-time" }
+        when NilClass.singleton_class, nil
+          { type: "null" }
+        when Array
+          case schema.length
+          when 0
+            { type: "null" }
+          when 1
+            _from_schema(schema.first, registry:, definitions:)
+          else
+            { anyOf: schema.map { |v| _from_schema(v, registry:, definitions:) } }
+          end
+        else
+          raise "Unknown type #{schema.inspect}"
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Lint/HashCompareByIdentity
+    end
+  end
+end

data/lib/verse/schema/scalar.rb

@@ -65,16 +65,40 @@ module Verse
       end
 
       def <=(other)
-        other == self || inherit?(other)
+        # 1. Identical check: Is it the exact same object?
+        return true if other == self
+
+        # 2. Check if inheriting from another Scalar:
+        #    Use the existing inherit? method which correctly handles Scalar-to-Scalar inheritance.
+        #    (inherit? implicitly checks `other.is_a?(Scalar)`)
+        return true if inherit?(other)
+
+        # 3. NEW: Check compatibility with non-Scalar types:
+        #    If 'other' is not a Scalar, check if any type *wrapped* by this Scalar
+        #    is a subtype of 'other'. This handles `Scalar<Integer> <= Integer`.
+        #    We rely on the `<=` operator of the wrapped types themselves.
+        @values.any? do |wrapped_type|
+          # Use standard Ruby `<=` for comparison.
+          # This works for Class <= Class (e.g., Integer <= Integer, Integer <= Numeric)
+          # and potentially for SchemaType <= SchemaType if defined.
+          wrapped_type <= other
+        rescue TypeError
+          # Handle cases where <= is not defined between wrapped_type and other
+          false
+        end
       end
 
       def <(other)
-        other != self && inherit?(other)
+        other != self && self <= other
       end
 
       # rubocop:disable Style/InverseMethods
       def >(other)
-        !self.<=(other)
+        !(self <= other)
+      end
+
+      def >=(other)
+        other <= self
       end
       # rubocop:enable Style/InverseMethods
 
@@ -149,7 +173,6 @@ module Verse
 
         Result.new(coalesced_value, error_builder.errors)
       end
-
     end
   end
 end

data/lib/verse/schema/struct.rb

@@ -221,49 +221,49 @@ module Verse
         fields << :extra_fields if extra_fields?
 
         # Special case for empty schema (yeah, I know, it happens in my production code...)
-        if fields.empty?
-          @dataclass = Class.new do
-            def self.from_raw(*)=new
-            def self.schema = dataclass_schema
-
-            class_eval(&block) if block
-          end
-        else
-          @dataclass = ::Struct.new(*fields, keyword_init: true) do
-            # Redefine new method
-            define_singleton_method(:from_raw, &method(:new))
-
-            define_singleton_method(:new) do |*args, **kwargs|
-              # Use the schema to generate the hash for our record
-              if args.size > 1
-                raise ArgumentError, "You cannot pass more than one argument"
-              end
-
-              if args.size == 1
-                if kwargs.any?
-                  raise ArgumentError, "You cannot pass both a hash and keyword arguments"
-                end
-
-                kwargs = args.first
-              end
-
-              dataclass_schema.new(kwargs)
-            end
-
-            define_singleton_method(:schema){ dataclass_schema }
-
-            class_eval(&block) if block
-          end
-        end
+        @dataclass = if fields.empty?
+                       Class.new do
+                         def self.from_raw(*)=new
+                         def self.schema = dataclass_schema
+
+                         class_eval(&block) if block
+                       end
+                     else
+                       ::Struct.new(*fields, keyword_init: true) do
+                         # Redefine new method
+                         define_singleton_method(:from_raw, &method(:new))
+
+                         define_singleton_method(:new) do |*args, **kwargs|
+                           # Use the schema to generate the hash for our record
+                           if args.size > 1
+                             raise ArgumentError, "You cannot pass more than one argument"
+                           end
+
+                           if args.size == 1
+                             if kwargs.any?
+                               raise ArgumentError, "You cannot pass both a hash and keyword arguments"
+                             end
+
+                             kwargs = args.first
+                           end
+
+                           dataclass_schema.new(kwargs)
+                         end
+
+                         define_singleton_method(:schema){ dataclass_schema }
+
+                         class_eval(&block) if block
+                       end
+                     end
       end
 
       def inspect
         fields_string = @fields.map do |field|
-          if field.type.is_a?(Array)
-            type_str = field.type.map(&:inspect).join("|")
-          else
-            type_str = field.type.inspect
-          end
+          type_str = if field.type.is_a?(Array)
+                       field.type.map(&:inspect).join("|")
+                     else
+                       field.type.inspect
+                     end
 
           optional_marker = field.optional? ? "?" : ""
           "#{field.name}#{optional_marker}: #{type_str}"
@@ -320,7 +320,6 @@ module Verse
 
         Result.new(output, error_builder.errors)
       end
-
     end
   end
 end

data/lib/verse/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Verse
   module Schema
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/verse/schema.rb

@@ -9,6 +9,7 @@ module Verse
     require_relative "schema/base"
     require_relative "schema/coalescer"
     require_relative "schema/post_processor"
+    require_relative "schema/json"
 
     def define(from = nil, &block)
       if from

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: verse-schema
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Yacine Petitprez
 bindir: exe
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: attr_chainable
@@ -33,6 +33,7 @@ files:
 - ".rspec"
 - ".rubocop-https---relaxed-ruby-style-rubocop-yml"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -51,6 +52,7 @@ files:
 - lib/verse/schema/field.rb
 - lib/verse/schema/field/ext.rb
 - lib/verse/schema/invalid_schema_error.rb
+- lib/verse/schema/json.rb
 - lib/verse/schema/optionable.rb
 - lib/verse/schema/post_processor.rb
 - lib/verse/schema/result.rb
@@ -78,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Consume input schema and output coalesced version of them
 test_files: []