validrb 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb818549e6bca37a89242aee2e72b9f74c32cbafa3db4bb6cbaad060b93fc426
-  data.tar.gz: 0d7debd6603cbf1afb0bf664e1a3252de6c270bd2844ea8f2cd1406b198e4008
+  metadata.gz: 501a47fc614649d04bede576eba6ee6d235906c47a41968b8f2458fee449a1f5
+  data.tar.gz: 3f2ae0e43d9508efd7e88ee5a08a84c52d1bc6af13ff2406eb2826e63789287f
 SHA512:
-  metadata.gz: 33da9e6eefcc7c7b4ab78d8785c7b12b0216f8f0677b4d7120ebec5056ba1b6a42030afa3c13618c03d4e22e47538da085bc0783db7973698dcec6d2b44fea20
-  data.tar.gz: 2845fbd1a754e91509692d671d5ff050e738cc8799625d34028acc77cf47a041861f80556b23cefb05206c58b56350c62643d540b2ad6e51d5cc2644fea1ce16
+  metadata.gz: edc2ba6b67124989d7266c71fed51589042fdaae23d486972b98c1dce86c013843a60472d383ace2f096a37b10ad1daa6a1666fbde9d6891cc192832074c54a4
+  data.tar.gz: 90cd6baccf04eef4775416c96ce38fcc705ff8e43a3812bd218a6c85afdc03c0c53565bbba92098ef36e515eb2d9cccb151d3c251272a065f213cd1c1d93560a

data/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2024-01-31
+
+### Added
+- **Inline nested schemas** - Define nested schemas directly in field blocks
+  ```ruby
+  field :address, :object do
+    field :street, :string
+    field :city, :string
+  end
+  ```
+- **Array of schemas shorthand** - Pass Schema instances directly to `of:` option
+  ```ruby
+  field :items, :array, of: ItemSchema  # No wrapper needed
+  ```
+- **OpenAPI convenience methods** on Generator:
+  - `request_body(schema)` - Generate request body structure
+  - `query_params(schema)` - Convert schema to query parameters
+  - `path_params(*names)` - Generate path parameters
+  - `response_schema(schema)` - Generate response with schema
+  - `response(description)` - Generate simple response
+  - `error_response` - Generate standard error response structure
+
+### Changed
+- `parse` and `safe_parse` now accept both hash and kwargs syntax:
+  ```ruby
+  schema.safe_parse({ name: "John" })  # Hash syntax
+  schema.safe_parse(name: "John")      # Kwargs syntax (new)
+  ```
+
 ## [0.5.0] - 2024-01-15
 
 ### Added
@@ -92,6 +121,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Requires Ruby >= 3.0
 - Inspired by Pydantic (Python) and Zod (TypeScript)
 
+[0.6.0]: https://github.com/validrb/validrb/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/validrb/validrb/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/validrb/validrb/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/validrb/validrb/compare/v0.2.0...v0.3.0

data/README.md

@@ -128,6 +128,45 @@ schema = Validrb.schema do
 end
 ```
 
+### Inline Nested Schemas (v0.6.0+)
+
+Define nested schemas directly without creating separate schema objects:
+
+```ruby
+schema = Validrb.schema do
+  field :name, :string
+
+  # Inline object schema
+  field :address, :object do
+    field :street, :string
+    field :city, :string
+    field :zip, :string, format: /\A\d{5}\z/
+  end
+
+  # Inline array item schema
+  field :items, :array do
+    field :product_id, :integer
+    field :quantity, :integer, min: 1
+  end
+end
+```
+
+### Array of Schemas Shorthand (v0.6.0+)
+
+Pass schema instances directly to `of:`:
+
+```ruby
+ItemSchema = Validrb.schema do
+  field :id, :integer
+  field :name, :string
+end
+
+schema = Validrb.schema do
+  # Pass schema directly - no wrapper needed
+  field :items, :array, of: ItemSchema
+end
+```
+
 ## Constraints
 
 ```ruby

data/lib/validrb/field.rb

@@ -137,7 +137,13 @@ module Validrb
     def extract_type_options(type, options)
       case type
       when :array
-        { of: options[:of] }.compact
+        of_option = options[:of]
+        # If of: is a Schema, wrap it in an Object type
+        if of_option.is_a?(Schema)
+          { of: Types::Object.new(schema: of_option) }
+        else
+          { of: of_option }.compact
+        end
       when :object, :hash
         { schema: options[:schema] }.compact
       when :discriminated_union

data/lib/validrb/openapi.rb

@@ -82,8 +82,125 @@ module Validrb
         YAML.dump(generate(info: info, **options))
       end
 
+      # ============================================================
+      # Convenience Methods
+      # ============================================================
+
+      # Generate a request body structure for a schema
+      # @param schema [Validrb::Schema] The schema to use
+      # @param required [Boolean] Whether the request body is required (default: true)
+      # @param content_type [String] The content type (default: "application/json")
+      # @return [Hash] OpenAPI request body object
+      def request_body(schema, required: true, content_type: "application/json")
+        {
+          "required" => required,
+          "content" => {
+            content_type => {
+              "schema" => schema_to_openapi(schema)
+            }
+          }
+        }
+      end
+
+      # Generate query parameters from a schema
+      # @param schema [Validrb::Schema] The schema to convert to parameters
+      # @return [Array<Hash>] Array of OpenAPI parameter objects
+      def query_params(schema)
+        schema.fields.map do |name, field|
+          {
+            "name" => name.to_s,
+            "in" => "query",
+            "required" => field.required? && !field.has_default? && !field.conditional?,
+            "schema" => field_to_openapi(field)
+          }
+        end
+      end
+
+      # Generate path parameters from field names
+      # @param names [Array<Symbol, String>] Parameter names
+      # @param types [Hash] Optional type overrides { name: :integer }
+      # @return [Array<Hash>] Array of OpenAPI parameter objects
+      def path_params(*names, types: {})
+        names.map do |name|
+          type = types[name.to_sym] || :string
+          {
+            "name" => name.to_s,
+            "in" => "path",
+            "required" => true,
+            "schema" => primitive_type_schema(type)
+          }
+        end
+      end
+
+      # Generate a response schema structure
+      # @param schema [Validrb::Schema] The schema for the response
+      # @param description [String] Response description
+      # @param content_type [String] The content type (default: "application/json")
+      # @return [Hash] OpenAPI response object
+      def response_schema(schema, description: "Successful response", content_type: "application/json")
+        {
+          "description" => description,
+          "content" => {
+            content_type => {
+              "schema" => schema_to_openapi(schema)
+            }
+          }
+        }
+      end
+
+      # Generate a simple response without body
+      # @param description [String] Response description
+      # @return [Hash] OpenAPI response object
+      def response(description)
+        { "description" => description }
+      end
+
+      # Generate error response structure
+      # @param description [String] Error description
+      # @return [Hash] OpenAPI response object with standard error schema
+      def error_response(description: "Validation error")
+        {
+          "description" => description,
+          "content" => {
+            "application/json" => {
+              "schema" => {
+                "type" => "object",
+                "properties" => {
+                  "error" => { "type" => "string" },
+                  "details" => {
+                    "type" => "array",
+                    "items" => {
+                      "type" => "object",
+                      "properties" => {
+                        "path" => { "type" => "string" },
+                        "message" => { "type" => "string" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      end
+
       private
 
+      def primitive_type_schema(type)
+        case type.to_sym
+        when :string
+          { "type" => "string" }
+        when :integer
+          { "type" => "integer" }
+        when :float, :number
+          { "type" => "number" }
+        when :boolean
+          { "type" => "boolean" }
+        else
+          { "type" => "string" }
+        end
+      end
+
       def normalize_info(info)
         info = info.transform_keys(&:to_s)
         {

data/lib/validrb/schema.rb

@@ -21,11 +21,13 @@ module Validrb
     end
 
     # Parse data and raise ValidationError on failure
-    # @param data [Hash] The data to validate
+    # @param data [Hash] The data to validate (can be passed as positional arg or kwargs)
     # @param path_prefix [Array] Path prefix for error messages
     # @param context [Context, Hash, nil] Optional validation context
-    def parse(data, path_prefix: [], context: nil)
-      result = safe_parse(data, path_prefix: path_prefix, context: context)
+    def parse(data = nil, path_prefix: [], context: nil, **data_kwargs)
+      # Support both parse({ name: 'John' }) and parse(name: 'John')
+      actual_data = data.nil? ? data_kwargs : data
+      result = safe_parse(actual_data, path_prefix: path_prefix, context: context)
 
       raise ValidationError, result.errors if result.failure?
 
@@ -33,11 +35,13 @@ module Validrb
     end
 
     # Parse data and return Result (Success or Failure)
-    # @param data [Hash] The data to validate
+    # @param data [Hash] The data to validate (can be passed as positional arg or kwargs)
     # @param path_prefix [Array] Path prefix for error messages
     # @param context [Context, Hash, nil] Optional validation context
-    def safe_parse(data, path_prefix: [], context: nil)
-      normalized = normalize_input(data)
+    def safe_parse(data = nil, path_prefix: [], context: nil, **data_kwargs)
+      # Support both safe_parse({ name: 'John' }) and safe_parse(name: 'John')
+      actual_data = data.nil? ? data_kwargs : data
+      normalized = normalize_input(actual_data)
       ctx = normalize_context(context)
       errors = []
       result_data = {}
@@ -279,19 +283,45 @@ module Validrb
         @schema = schema
       end
 
-      def field(name, type, **options)
+      # Define a field with optional inline schema block
+      # @example Basic field
+      #   field :name, :string
+      # @example Object with inline schema
+      #   field :address, :object do
+      #     field :street, :string
+      #     field :city, :string
+      #   end
+      # @example Array with inline item schema
+      #   field :items, :array do
+      #     field :product_id, :integer
+      #     field :quantity, :integer
+      #   end
+      def field(name, type, **options, &block)
+        if block_given?
+          # Create inline nested schema from block
+          inline_schema = Schema.new(&block)
+
+          case type
+          when :object, :hash
+            options[:schema] = inline_schema
+          when :array
+            # For arrays, the block defines the item schema
+            options[:of] = inline_schema
+          end
+        end
+
         field = Field.new(name, type, **options)
         @schema.add_field(field)
       end
 
       # Shorthand for optional field
-      def optional(name, type, **options)
-        field(name, type, **options.merge(optional: true))
+      def optional(name, type, **options, &block)
+        field(name, type, **options.merge(optional: true), &block)
       end
 
       # Shorthand for required field (explicit)
-      def required(name, type, **options)
-        field(name, type, **options.merge(optional: false))
+      def required(name, type, **options, &block)
+        field(name, type, **options.merge(optional: false), &block)
       end
 
       # Add a custom validator block

data/lib/validrb/types/array.rb

@@ -67,6 +67,9 @@ module Validrb
           @item_type
         when Class
           @item_type.new
+        when ::Validrb::Schema
+          # Schema instance - wrap in Object type
+          Types::Object.new(schema: @item_type)
         else
           raise ArgumentError, "Invalid item type: #{@item_type.inspect}"
         end
@@ -80,6 +83,8 @@ module Validrb
           @item_type.type_name
         when Class
           @item_type.name.split("::").last.downcase
+        when ::Validrb::Schema
+          "object"
         else
           "unknown"
         end

data/lib/validrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Validrb
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/validrb.gemspec

@@ -1,43 +1,43 @@
 # frozen_string_literal: true
 
-require_relative "lib/validrb/version"
+require_relative 'lib/validrb/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "validrb"
+  spec.name = 'validrb'
   spec.version = Validrb::VERSION
-  spec.authors = ["Validrb Contributors"]
-  spec.email = ["validrb@example.com"]
+  spec.authors = ['Elysium Arc']
+  spec.email = ['imam6mouad@gmail.com']
 
-  spec.summary = "A Ruby schema validation library with type coercion"
+  spec.summary = 'A Ruby schema validation library with type coercion'
   spec.description = <<~DESC
     Validrb is a powerful Ruby schema validation library inspired by Pydantic and Zod.
     It provides type coercion, rich constraints, schema composition, union types,
     discriminated unions, custom validators, JSON Schema generation, and serialization.
-    Zero runtime dependencies, pure Ruby.
   DESC
-  spec.homepage = "https://github.com/validrb/validrb"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.homepage = 'http://github.com/Elysium-Arc/Validrb'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
 
   spec.metadata = {
-    "homepage_uri" => spec.homepage,
-    "source_code_uri" => spec.homepage,
-    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md",
-    "documentation_uri" => spec.homepage,
-    "bug_tracker_uri" => "#{spec.homepage}/issues",
-    "rubygems_mfa_required" => "true"
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    'documentation_uri' => spec.homepage,
+    'bug_tracker_uri' => "#{spec.homepage}/issues",
+    'rubygems_mfa_required' => 'true'
   }
 
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
       (File.expand_path(f) == __FILE__) ||
         f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile]) ||
-        f == "demo.rb"
+        f == 'demo.rb'
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  # Zero runtime dependencies - pure Ruby
+  # bigdecimal is used for Decimal type - required explicitly for Ruby 3.4+
+  spec.add_dependency 'bigdecimal'
 end

metadata

@@ -1,22 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: validrb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
-- Validrb Contributors
+- Elysium Arc
 autorequire:
 bindir: exe
 cert_chain: []
 date: 2026-01-31 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  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: |
   Validrb is a powerful Ruby schema validation library inspired by Pydantic and Zod.
   It provides type coercion, rich constraints, schema composition, union types,
   discriminated unions, custom validators, JSON Schema generation, and serialization.
-  Zero runtime dependencies, pure Ruby.
 email:
-- validrb@example.com
+- imam6mouad@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -59,15 +72,15 @@ files:
 - lib/validrb/types/union.rb
 - lib/validrb/version.rb
 - validrb.gemspec
-homepage: https://github.com/validrb/validrb
+homepage: http://github.com/Elysium-Arc/Validrb
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/validrb/validrb
-  source_code_uri: https://github.com/validrb/validrb
-  changelog_uri: https://github.com/validrb/validrb/blob/main/CHANGELOG.md
-  documentation_uri: https://github.com/validrb/validrb
-  bug_tracker_uri: https://github.com/validrb/validrb/issues
+  homepage_uri: http://github.com/Elysium-Arc/Validrb
+  source_code_uri: http://github.com/Elysium-Arc/Validrb
+  changelog_uri: http://github.com/Elysium-Arc/Validrb/blob/main/CHANGELOG.md
+  documentation_uri: http://github.com/Elysium-Arc/Validrb
+  bug_tracker_uri: http://github.com/Elysium-Arc/Validrb/issues
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []