verse-schema 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6608dcff00a7bef2d8313866053ac7d37d82933d9b597052a222f0bcad693f91
-  data.tar.gz: dfcecf7d576b599b3c39d552cfbbf082ceda4707f0ec532d94d4a0db3dbfa620
+  metadata.gz: ac21990f8abf487af0be8d14959c40595c2327cdbbda87a4bc15d53cfcf87a36
+  data.tar.gz: 102efefd85e3181bda88e337672a810c54bfafe4c623ae825972b7e82e6bc689
 SHA512:
-  metadata.gz: d3bc6f97bf7b683d4e45ee578af5a1cd57375d56f54161a93ed3b725c2f783cbfedb2583fa9dc6470e68243bdaa3cda93f703dc82df4a63bd912d386695933bc
-  data.tar.gz: 49c7ae54ea24d5a4e7a8304e1361f70feb81f68a4993beddc153fabd1c88fa1d63e5eb5bd5bbcb41eea83bd863f7188bcfc73cdf31d98c9a0b08b32d749c0ecc
+  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.1)
+    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/verse/schema/collection.rb

@@ -62,13 +62,11 @@ module Verse
             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|
-                begin
-                  # Use standard Ruby `<=` for comparison
-                  child_type <= scalar_value
-                rescue TypeError
-                  # Handle cases where <= is not defined between types
-                  false
-                end
+                # 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.)

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

@@ -64,45 +64,43 @@ module Verse
         end
       end
 
-  def <=(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|
-      begin
-        # 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
+      def <=(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
-    end
-  end
 
-  def <(other)
-    other != self && self <= other
-  end
+      def <(other)
+        other != self && self <= other
+      end
 
-  # rubocop:disable Style/InverseMethods
-  def >(other)
-    !(self <= other)
-  end
+      # rubocop:disable Style/InverseMethods
+      def >(other)
+        !(self <= other)
+      end
 
-  def >=(other)
-    other <= self
-  end
-  # rubocop:enable Style/InverseMethods
+      def >=(other)
+        other <= self
+      end
+      # rubocop:enable Style/InverseMethods
 
       # Aggregation of two schemas.
       def +(other)

data/lib/verse/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Verse
   module Schema
-    VERSION = "1.1.1"
+    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.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Yacine Petitprez
 bindir: exe
 cert_chain: []
-date: 2025-04-25 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: []