easy_talk 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa39fe0359df9334a186807b3e67679b752806db59eb9b03829ec875c6382818
-  data.tar.gz: 150814754a0604fc0149bf042c73d798fe042935ffde11b52c2254ac765c05e8
+  metadata.gz: d7f671ab545b8ab502b6bc9412855fa8a5c5fd45a55034e1c7eb6dba000539cc
+  data.tar.gz: 7243055ab896f4a7d73da4c6b2c9e425d71651815d1cca9cab1a23b4c5159497
 SHA512:
-  metadata.gz: ea9d64a999260983afac690850ae5095b4e2d00583feb1a6dd4baa0a0cb377a82566dae1245e1b767e5ff79549f28e60209b43fa3d765a8b51c46ee6969425bd
-  data.tar.gz: 20e3bea29ad389126937924f431f8729be43b172f8f868ae5fc0189d729e1d19642a9fa0e74a34322e1acafd2b74c6b2fad20bb8f081c7ea504364a2daaf3d99
+  metadata.gz: ba14fb1e04f2cda11bff0d72f0f8f52e27b7a04c86f182cae43cc487b5e33369abae7b9d55d5af732063ca54ffe5bfcf97bc2a14344fb329d07199cef0a1b075
+  data.tar.gz: 02ffbf919e5ab09eb253c055da2b1a787419dc5f0b9b6b60901176bac039cd323134482c6551a15730f1d9dd4a0268336a5bbce47803a7f348e85c2950f2c75e

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## [1.0.2] - 2024-13-01
+- Support "AdditionalProperties". see https://json-schema.org/understanding-json-schema/reference/object#additionalproperties
+You can now define a schema that allows any additional properties. 
+```ruby
+class Company
+  include EasyTalk::Model
+
+  define_schema do
+    property :name, String
+    additional_properties true # or false
+  end
+end
+```
+
+You can then do:
+```ruby
+company = Company.new
+company.name = "Acme Corp" # Defined property
+company.location = "New York" # Additional property
+company.employee_count = 100 # Additional property
+```
+
+company.as_json
+# => {
+#      "name" => "Acme Corp",
+#      "location" => "New York",
+#      "employee_count" => 100
+#    }
+```
+- Fix that we don't conflate nilable properties with optional properties.
+## [1.0.1] - 2024-09-01
+- Fixed that property with custom type does not ignore the constraints hash https://github.com/sergiobayona/easy_talk/issues/17
 ## [1.0.0] - 2024-06-01
 - Use `Hash` instead of `:object` for inline object schema definition.
 example:

data/README.md

@@ -176,6 +176,112 @@ class Payment
 end
 ```
 
+## Additional Properties
+
+EasyTalk supports the JSON Schema `additionalProperties` keyword, allowing you to control whether instances of your model can accept properties beyond those explicitly defined in the schema.
+
+### Usage
+
+Use the `additional_properties` keyword in your schema definition to specify whether additional properties are allowed:
+
+```ruby
+class Company
+  include EasyTalk::Model
+
+  define_schema do
+    property :name, String
+    additional_properties true  # Allow additional properties
+  end
+end
+
+# Additional properties are allowed
+company = Company.new
+company.name = "Acme Corp"        # Defined property
+company.location = "New York"     # Additional property
+company.employee_count = 100      # Additional property
+
+company.as_json
+# => {
+#      "name" => "Acme Corp",
+#      "location" => "New York",
+#      "employee_count" => 100
+#    }
+```
+
+### Behavior
+
+When `additional_properties true`:
+- Instances can accept properties beyond those defined in the schema
+- Additional properties can be set both via the constructor and direct assignment
+- Additional properties are included in JSON serialization
+- Attempting to access an undefined additional property raises NoMethodError
+
+```ruby
+# Setting via constructor
+company = Company.new(
+  name: "Acme Corp",
+  location: "New York"  # Additional property
+)
+
+# Setting via assignment
+company.rank = 1        # Additional property
+
+# Accessing undefined properties
+company.undefined_prop  # Raises NoMethodError
+```
+
+When `additional_properties false` or not specified:
+- Only properties defined in the schema are allowed
+- Attempting to set or get undefined properties raises NoMethodError
+
+```ruby
+class RestrictedCompany
+  include EasyTalk::Model
+
+  define_schema do
+    property :name, String
+    additional_properties false  # Restrict to defined properties only
+  end
+end
+
+company = RestrictedCompany.new
+company.name = "Acme Corp"     # OK - defined property
+company.location = "New York"  # Raises NoMethodError
+```
+
+### JSON Schema
+
+The `additional_properties` setting is reflected in the generated JSON Schema:
+
+```ruby
+Company.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" }
+#      },
+#      "required" => ["name"],
+#      "additionalProperties" => true
+#    }
+```
+
+### Best Practices
+
+1. **Default to Restrictive**: Unless you specifically need additional properties, it's recommended to leave `additional_properties` as false (the default) to maintain schema integrity.
+
+2. **Documentation**: If you enable additional properties, document the expected additional property types and their purpose.
+
+3. **Validation**: Consider implementing custom validation for additional properties if they need to conform to specific patterns or types.
+
+4. **Error Handling**: When working with instances that allow additional properties, use `respond_to?` or `try` to handle potentially undefined properties safely:
+
+```ruby
+# Safe property access
+value = company.try(:optional_property)
+# or
+value = company.optional_property if company.respond_to?(:optional_property)
+```
+
 ## Type Checking and Schema Constraints
 
 EasyTalk uses a combination of standard Ruby types (`String`, `Integer`), Sorbet types (`T::Boolean`, `T::Array[String]`, etc.), and custom Sorbet-style types (`T::AnyOf[]`, `T::OneOf[]`) to perform basic type checking. For example:

data/lib/easy_talk/builders/object_builder.rb

@@ -8,7 +8,7 @@ module EasyTalk
     # into a validated JSON Schema hash. It:
     #
     # 1) Recursively processes the schema’s :properties,
-    # 2) Determines which properties are required (unless nilable or optional),
+    # 2) Determines which properties are required (unless optional),
     # 3) Handles sub-schema composition (allOf, anyOf, oneOf, not),
     # 4) Produces the final object-level schema hash.
     #
@@ -108,15 +108,9 @@ module EasyTalk
       end
 
       ##
-      # Returns true if the property is declared optional or is T.nilable(...).
+      # Returns true if the property is declared optional.
       #
       def property_optional?(prop_options)
-        # For convenience, treat :type as an object
-        type_obj = prop_options[:type]
-
-        # Check Sorbet's nilable (like T.nilable(String))
-        return true if type_obj.respond_to?(:nilable?) && type_obj.nilable?
-
         # Check constraints[:optional]
         return true if prop_options.dig(:constraints, :optional)
 
@@ -136,7 +130,6 @@ module EasyTalk
                                          nested_schema_builder(prop_options)
                                        else
                                          # Normal property: e.g. { type: String, constraints: {...} }
-                                         handle_nilable_type(prop_options)
                                          Property.new(prop_name, prop_options[:type], prop_options[:constraints])
                                        end
       end
@@ -147,24 +140,9 @@ module EasyTalk
       def nested_schema_builder(prop_options)
         child_schema_def = prop_options[:properties]
         # If user used T.nilable(...) with a block, unwrap the nilable
-        handle_nilable_type(prop_options)
         ObjectBuilder.new(child_schema_def).build
       end
 
-      ##
-      # If the type is T.nilable(SomeType), unwrap it so we produce the correct schema.
-      # This logic is borrowed from the old #handle_option_type method.
-      #
-      def handle_nilable_type(prop_options)
-        type_obj = prop_options[:type]
-        return unless type_obj.respond_to?(:nilable?) && type_obj.nilable?
-
-        # If the underlying raw_type isn't T::Types::TypedArray, then we unwrap it
-        return unless type_obj.unwrap_nilable.class != T::Types::TypedArray
-
-        prop_options[:type] = type_obj.unwrap_nilable.raw_type
-      end
-
       ##
       # Process top-level composition keywords (e.g. allOf, anyOf, oneOf),
       # converting them to definitions + references if appropriate.

data/lib/easy_talk/model.rb

@@ -38,6 +38,50 @@ module EasyTalk
       base.include ActiveModel::Validations
       base.extend ActiveModel::Callbacks
       base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def initialize(attributes = {})
+        @additional_properties = {}
+        super
+      end
+
+      def method_missing(method_name, *args)
+        method_string = method_name.to_s
+        if method_string.end_with?('=')
+          property_name = method_string.chomp('=')
+          if self.class.additional_properties_allowed?
+            @additional_properties[property_name] = args.first
+          else
+            super
+          end
+        elsif self.class.additional_properties_allowed? && @additional_properties.key?(method_string)
+          @additional_properties[method_string]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_string = method_name.to_s
+        method_string.end_with?('=') ? method_string.chomp('=') : method_string
+        self.class.additional_properties_allowed? || super
+      end
+
+      # Add to_hash method to convert defined properties to hash
+      def to_hash
+        return {} unless self.class.properties
+
+        self.class.properties.each_with_object({}) do |prop, hash|
+          hash[prop.to_s] = send(prop)
+        end
+      end
+
+      # Override as_json to include both defined and additional properties
+      def as_json(_options = {})
+        to_hash.merge(@additional_properties)
+      end
     end
 
     # Module containing class-level methods for defining and accessing the schema of a model.
@@ -92,6 +136,10 @@ module EasyTalk
         @schema_definition ||= {}
       end
 
+      def additional_properties_allowed?
+        @schema_definition&.schema&.fetch(:additional_properties, false)
+      end
+
       private
 
       # Builds the schema using the provided schema definition.

data/lib/easy_talk/property.rb

@@ -76,15 +76,17 @@ module EasyTalk
     #
     # @return [Object] The built property.
     def build
-      # return type.respond_to?(:schema) ? type.schema : 'object' unless builder
-
-      # args = builder.collection_type? ? [name, type, constraints] : [name, constraints]
-      # builder.new(*args).build
-      if builder
+      if nilable_type?
+        build_nilable_schema
+      elsif builder
         args = builder.collection_type? ? [name, type, constraints] : [name, constraints]
         builder.new(*args).build
+      elsif type.respond_to?(:schema)
+        # merge the top-level constraints from *this* property
+        # e.g. :title, :description, :default, etc
+        type.schema.merge!(constraints)
       else
-        type.respond_to?(:schema) ? type.schema : 'object'
+        'object'
       end
     end
 
@@ -105,5 +107,27 @@ module EasyTalk
     def builder
       @builder ||= TYPE_TO_BUILDER[type.class.name.to_s] || TYPE_TO_BUILDER[type.name.to_s]
     end
+
+    private
+
+    def nilable_type?
+      return unless type.respond_to?(:types)
+      return unless type.types.all? { |t| t.respond_to?(:raw_type) }
+
+      type.types.any? { |t| t.raw_type == NilClass }
+    end
+
+    def build_nilable_schema
+      # Extract the non-nil type from the Union
+      actual_type = type.types.find { |t| t != NilClass }
+
+      # Create a property with the actual type
+      non_nil_schema = Property.new(name, actual_type, constraints).build
+
+      # Merge the types into an array
+      non_nil_schema.merge(
+        type: [non_nil_schema[:type], 'null']
+      )
+    end
   end
 end

data/lib/easy_talk/schema_definition.rb

@@ -4,13 +4,13 @@ require_relative 'keywords'
 
 module EasyTalk
   class InvalidPropertyNameError < StandardError; end
+
   #
   #= EasyTalk \SchemaDefinition
   # SchemaDefinition provides the methods for defining a schema within the define_schema block.
   # The @schema is a hash that contains the unvalidated schema definition for the model.
   # A SchemaDefinition instanace is the passed to the Builder.build_schema method to validate and compile the schema.
   class SchemaDefinition
-
     extend T::Sig
     extend T::AnyOf
     extend T::OneOf
@@ -56,9 +56,10 @@ module EasyTalk
     end
 
     def validate_property_name(name)
-      unless name.to_s.match?(/^[A-Za-z_][A-Za-z0-9_]*$/)
-        raise InvalidPropertyNameError, "Invalid property name '#{name}'. Must start with letter/underscore and contain only letters, numbers, underscores"
-      end
+      return if name.to_s.match?(/^[A-Za-z_][A-Za-z0-9_]*$/)
+
+      raise InvalidPropertyNameError,
+            "Invalid property name '#{name}'. Must start with letter/underscore and contain only letters, numbers, underscores"
     end
 
     def optional?

data/lib/easy_talk/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Sergio Bayona
 bindir: bin
 cert_chain: []
-date: 2025-01-09 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel