easy_talk 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da6e2b2c29860236280b654d18e4df4af908ab0246f01e1e5e376805f8359d37
-  data.tar.gz: 1a36d4e08f82069391386c3b2bd03becfeaea198657b8db05ff2ebda793d4ec8
+  metadata.gz: 1ebe87803e47220d1a3f6396a1735fd2aa04b3f2b1428bea43cd873cb32f3bca
+  data.tar.gz: ecdaaa2801742335160a89a38a92ef9b402be563d3ce0e54c52f3068d75c93ce
 SHA512:
-  metadata.gz: 9026006c5e296adf2f3a7c826757ffe4b17a1387c3621907442ac47293d2d7d89eb4779fe3863ef24f6a8fc34174a7b4e7e22d2aaf0a26a4534ddc65f08ab482
-  data.tar.gz: d3cd70fb2ac65241cf395606d0eae55e2282006578f4f78096f9e03256ae6fa91bd371b0874d20aa797667b4972be4ff91c5b38b4396ee1be89a3b4d057d4681
+  metadata.gz: 866e44d124957d2149bd67584c0e35129bd922c98da0bb9d4b37cead66636d84b508290be35b4ce79ad3940bd556585ee604aeb79c220f898450624765e3fd50
+  data.tar.gz: 551cd5c6f3de517efd56fadb407fd723de14764d3520b7be7ee73e12a7027d391816452ad13a00752e0fa690d5da2eef4aff2d0b12b585ed686eeb31635875ac

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.1.10] - 2024-04-29
+- Accept `:optional` key as constraint which excludes property from required node.
+- Spec fixes
+## [0.1.9] - 2024-04-29
+- Added the ability to describe an object schema withing the define_schema block. Example:
+```ruby
+...
+property :email, :object do
+    property :address, :string
+    property :verified, :boolean
+end
+```
+
 ## [0.1.8] - 2024-04-24
 - mostly refactoring without changes to the public API.
 

data/README.md

@@ -12,7 +12,10 @@ class User
     title "User"
     description "A user of the system"
     property :name, String, description: "The user's name", title: "Full Name"
-    property :email, String, description: "The user's email", format: "email", title: "Email Address"
+    property :email, :object do
+      property :address, String, format: "email", description: "The user's email", title: "Email Address"
+      property :verified, T::Boolean, description: "Whether the email is verified"
+    end
     property :group, String, enum: [1, 2, 3], default: 1, description: "The user's group"
     property :age, Integer, minimum: 18, maximum: 100, description: "The user's age"
     property :tags, T::Array[String], min_items: 1, unique_item: true, description: "The user's tags"
@@ -34,10 +37,23 @@ Calling `User.json_schema` will return the JSON Schema for the User class:
             "type": "string"
         },
         "email": {
-            "title": "Email Address",
-            "description": "The user's email",
-            "type": "string",
-            "format": "email"
+            "type": "object",
+            "properties": {
+                "address": {
+                    "title": "Email Address",
+                    "description": "The user's email",
+                    "type": "string",
+                    "format": "email"
+                },
+                "verified": {
+                    "type": "boolean",
+                    "description": "Whether the email is verified"
+                }
+            },
+            "required": [
+                "address",
+                "verified"
+            ]
         },
         "group": {
             "type": "number",

data/lib/easy_talk/builders/base_builder.rb

@@ -11,7 +11,8 @@ module EasyTalk
       # representing schema properties.
       COMMON_OPTIONS = {
         title: { type: T.nilable(String), key: :title },
-        description: { type: T.nilable(String), key: :description }
+        description: { type: T.nilable(String), key: :description },
+        optional: { type: T.nilable(T::Boolean), key: :optional }
       }.freeze
 
       attr_reader :name, :schema, :options

data/lib/easy_talk/builders/object_builder.rb

@@ -11,10 +11,10 @@ module EasyTalk
       attr_reader :schema
 
       VALID_OPTIONS = {
-        properties: { type: T::Hash[Symbol, T.untyped], key: :properties },
+        properties: { type: T::Hash[T.any(Symbol, String), T.untyped], key: :properties },
         additional_properties: { type: T::Boolean, key: :additionalProperties },
         subschemas: { type: T::Array[T.untyped], key: :subschemas },
-        required: { type: T::Array[Symbol], key: :required },
+        required: { type: T::Array[T.any(Symbol, String)], key: :required },
         defs: { type: T.untyped, key: :$defs },
         allOf: { type: T.untyped, key: :allOf },
         anyOf: { type: T.untyped, key: :anyOf },
@@ -33,42 +33,60 @@ module EasyTalk
 
       private
 
-      def properties_from_schema_definition(properties)
+      def properties_from_schema_definition
+        properties = schema.delete(:properties) || {}
         properties.each_with_object({}) do |(property_name, options), context|
-          @required_properties << property_name unless options[:type].respond_to?(:nilable?) && options[:type].nilable?
-          context[property_name] = Property.new(property_name, options[:type], options[:constraints])
+          add_required_property(property_name, options)
+          context[property_name] = build_property(property_name, options)
         end
       end
 
-      def subschemas_from_schema_definition(subschemas)
+      def add_required_property(property_name, options)
+        return if options.is_a?(Hash) && !!(options[:type].respond_to?(:nilable?) && options[:type].nilable?)
+
+        return if options.respond_to?(:optional?) && options.optional?
+
+        @required_properties << property_name
+      end
+
+      def build_property(property_name, options)
+        if options.is_a?(EasyTalk::SchemaDefinition)
+          ObjectBuilder.new(options).build
+        else
+          Property.new(property_name, options[:type], options[:constraints])
+        end
+      end
+
+      def subschemas_from_schema_definition
+        subschemas = schema.delete(:subschemas) || []
         subschemas.each do |subschema|
-          definitions = subschema.items.each_with_object({}) do |item, hash|
-            hash[item.name] = item.schema
-          end
-          schema[:defs] = definitions
-          references = subschema.items.map do |item|
-            { '$ref': item.ref_template }
-          end
-          schema[subschema.name] = references
+          add_definitions(subschema)
+          add_references(subschema)
         end
       end
 
+      def add_definitions(subschema)
+        definitions = subschema.items.each_with_object({}) do |item, hash|
+          hash[item.name] = item.schema
+        end
+        schema[:defs] = definitions
+      end
+
+      def add_references(subschema)
+        references = subschema.items.map do |item|
+          { '$ref': item.ref_template }
+        end
+        schema[subschema.name] = references
+      end
+
       def options
-        subschemas_from_schema_definition(subschemas)
         @options = schema
-        @options[:properties] = properties_from_schema_definition(properties)
+        subschemas_from_schema_definition
+        @options[:properties] = properties_from_schema_definition
         @options[:required] = @required_properties
         @options.reject! { |_key, value| [nil, [], {}].include?(value) }
         @options
       end
-
-      def properties
-        schema.delete(:properties) || {}
-      end
-
-      def subschemas
-        schema.delete(:subschemas) || []
-      end
     end
   end
 end

data/lib/easy_talk/builders/string_builder.rb

@@ -15,7 +15,8 @@ module EasyTalk
         max_length: { type: Integer, key: :maxLength },
         enum: { type: T::Array[String], key: :enum },
         const: { type: String, key: :const },
-        default: { type: String, key: :default }
+        default: { type: String, key: :default },
+        optional: { type: T::Boolean, key: :optional }
       }.freeze
 
       sig { params(name: Symbol, constraints: Hash).void }

data/lib/easy_talk/schema_definition.rb

@@ -16,8 +16,8 @@ module EasyTalk
 
     attr_reader :name, :schema
 
-    def initialize(name)
-      @schema = {}
+    def initialize(name, schema = {})
+      @schema = schema
       @name = name
     end
 
@@ -32,10 +32,23 @@ module EasyTalk
       @schema[:subschemas] += subschemas
     end
 
-    sig { params(name: Symbol, type: T.untyped, constraints: T.untyped).void }
-    def property(name, type, **constraints)
+    sig do
+      params(name: T.any(Symbol, String), type: T.untyped, constraints: T.untyped, blk: T.nilable(T.proc.void)).void
+    end
+    def property(name, type, **constraints, &blk)
       @schema[:properties] ||= {}
-      @schema[:properties][name] = { type:, constraints: }
+
+      if block_given?
+        property_schema = SchemaDefinition.new(name, constraints)
+        property_schema.instance_eval(&blk)
+        @schema[:properties][name] = property_schema
+      else
+        @schema[:properties][name] = { type:, constraints: }
+      end
+    end
+
+    def optional?
+      @schema[:optional]
     end
   end
 end

data/lib/easy_talk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EasyTalk
-  VERSION = '0.1.8'
+  VERSION = '0.1.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Sergio Bayona
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport