shale 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e3b4d27ab7e8cc9b4873dfa60b52bdbafe50c2885085c4ec77ac6887351aab1
-  data.tar.gz: 6ce71a10ebf53633930b6d5a92ebb5f736aab44c47d6910a25238209192a4b92
+  metadata.gz: 60a0f059693d5ea371ffca8b475ebb261ee99096509e588d2f1163a96bf8fbc0
+  data.tar.gz: c1af0c61c7d9a93bd601188c50916d4f702228052541adee34456c4d7dac8b9a
 SHA512:
-  metadata.gz: 23c3b182c72c0e1d5102eb667541caccfb56e836e636bd083027425a60a12ed39ffce1ab3540adc0659c6b1bcbcf5255d192bbdc2d39bfc10c762ee4bdaaaa1e
-  data.tar.gz: ef7481e6076cc8f426c1dd0fb002d984594cbf3d59743a31450e8989048ffdd6cdc8fc735e90b7529c1935d7251c6751e70f7c3734d5c3f7df4b8124cc4b8256
+  metadata.gz: 31bd59c352febaf287eda07a79f56e5fe942fd86623f532e48c25ff5e946bb53fc879c3f8bb13121989268057beb4ee740f8aac7b1275dda8b9a2d21a5f75aaf
+  data.tar.gz: 127b46cdeb0960643aa60410597f7ace1815dd19e3845cd0cb7c2ea3d2d44b4326333656bdf96209effcf17daabbc5a70de9f430acd42e21d961e2c356d9be9f

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [1.1.0] - 2024-02-17
+
+### Added
+- [bkjohnson] Add support for JSON Schema validation keywords (#29)
+- Add support for Ruby 3.3
+
+### Changed
+- Drop support for Ruby 2.6 and Ruby 2.7
+
+### Fixed
+- Fix Ox adapter incorrectly handling documents with XML declaration
+
 ## [1.0.0] - 2023-07-15
 
 ### Added

data/README.md

@@ -17,7 +17,7 @@ Documentation with interactive examples is available at [Shale website](https://
 
 ## Installation
 
-Shale supports Ruby (MRI) 2.6+
+Shale supports Ruby (MRI) 3.0+
 
 Add this line to your application's Gemfile:
 
@@ -353,6 +353,25 @@ person.to_xml
 
 ### Converting CSV to object
 
+To use CSV with Shale you have to set adapter.
+Shale comes with adapter for [csv](https://github.com/ruby/csv).
+For details see [Adapters](#adapters) section.
+
+To set it, first make sure CSV gem is installed:
+
+```
+$ gem install csv
+```
+
+then setup adapter:
+
+```ruby
+require 'shale/adapter/csv'
+Shale.csv_adapter = Shale::Adapter::CSV
+```
+
+Now you can use CSV with Shale.
+
 CSV represents a flat data structure, so you can't map properties to complex types directly,
 but you can use methods to map properties to complex types
 (see [Using methods to extract and generate data](#using-methods-to-extract-and-generate-data)
@@ -1155,7 +1174,7 @@ end
 ### Adapters
 
 Shale uses adapters for parsing and generating documents.
-By default Ruby's standard JSON, YAML, CSV parsers are used for handling JSON YAML, CSV documents.
+By default Ruby's standard JSON and YAML parsers are used for handling JSON and YAML documents.
 
 You can change it by providing your own adapter. For JSON, YAML, TOML and CSV adapter must
 implement `.load` and `.dump` class methods.
@@ -1183,6 +1202,14 @@ require 'shale/adapter/toml_rb'
 Shale.toml_adapter = Shale::Adapter::TomlRB
 ```
 
+To handle CSV documents you have to set CSV adapter. Shale provides adapter for `csv` parser:
+
+```ruby
+require 'shale'
+require 'shale/adapter/csv'
+Shale.csv_adapter = Shale::Adapter::CSV
+```
+
 To handle XML documents you have to explicitly set XML adapter.
 Shale provides adapters for most popular Ruby XML parsers:
 
@@ -1288,6 +1315,75 @@ end
 Shale::Schema::JSONGenerator.register_json_type(MyEmailType, MyEmailJSONType)
 ```
 
+To add validation keywords to the schema, you can use a custom model and do this:
+
+```ruby
+require 'shale/schema'
+
+class PersonMapper < Shale::Mapper
+  model Person
+
+  attribute :first_name, Shale::Type::String
+  attribute :last_name, Shale::Type::String
+  attribute :address, Shale::Type::String
+  attribute :age, Shale::Type::Integer
+
+  json do
+    properties max_properties: 5
+
+    map "first_name", to: :first_name, schema: { required: true }
+    map "last_name", to: :last_name, schema: { required: true }
+    map "address", to: :age, schema: { max_length: 128 }
+    map "age", to: :age, schema: { minimum: 1, maximum: 150 }
+  end
+end
+
+Shale::Schema.to_json(
+  PersonMapper,
+  pretty: true
+)
+
+# =>
+#
+# {
+#   "$schema": "https://json-schema.org/draft/2020-12/schema",
+#   "description": "My description",
+#   "$ref": "#/$defs/Person",
+#   "$defs": {
+#     "Person": {
+#       "type": "object",
+#       "maxProperties": 5,
+#       "properties": {
+#         "first_name": {
+#           "type": "string"
+#         },
+#         "last_name": {
+#           "type": "string"
+#         },
+#         "age": {
+#           "type": [
+#             "integer",
+#             "null"
+#           ],
+#          "minimum": 1,
+#          "maximum": 150
+#        },
+#         "address": {
+#           "type": [
+#             "string",
+#             "null"
+#           ],
+#           "maxLength": 128
+#         }
+#       },
+#       "required": ["first_name", "last_name"]
+#     }
+#   }
+# }
+```
+
+Validation keywords are supported for all types, only the global `enum` and `const` types are not supported.
+
 ### Compiling JSON Schema into Shale model
 
 :warning: Only **[Draft 2020-12](https://json-schema.org/draft/2020-12/schema)** JSON Schema is supported

data/lib/shale/adapter/nokogiri.rb

@@ -61,7 +61,7 @@ module Shale
         result = doc.to_xml(save_with: save_with)
 
         unless pretty
-          result = result.sub(/\n/, '')
+          result = result.sub("\n", '')
         end
 
         result

data/lib/shale/adapter/ox.rb

@@ -22,7 +22,8 @@ module Shale
       #
       # @api private
       def self.load(xml)
-        Node.new(::Ox.parse(xml))
+        element = ::Ox.parse(xml)
+        Node.new(element.respond_to?(:root) ? element.root : element)
       rescue ::Ox::ParseError => e
         raise ParseError, "Document is invalid: #{e.message}"
       end

data/lib/shale/error.rb

@@ -38,6 +38,18 @@ module Shale
     Shale.xml_adapter = Shale::Adapter::Ox
   MSG
 
+  # Error message displayed when CSV adapter is not set
+  # @api private
+  CSV_ADAPTER_NOT_SET_MESSAGE = <<~MSG
+    CSV Adapter is not set.
+    To use Shale with CSV documents you have to install parser and set adapter.
+
+    # To use csv gem:
+    # Make sure csv is installed eg. execute: gem install csv
+    require 'shale/adapter/csv'
+    Shale.csv_adapter = Shale::Adapter::CSV
+  MSG
+
   # Error for assigning value to not existing attribute
   #
   # @api private

data/lib/shale/mapping/descriptor/dict.rb

@@ -49,6 +49,13 @@ module Shale
         # @api private
         attr_reader :group
 
+        # Return schema hash
+        #
+        # @return [Hash]
+        #
+        # @api private
+        attr_reader :schema
+
         # Initialize instance
         #
         # @param [String] name
@@ -57,14 +64,16 @@ module Shale
         # @param [Hash, nil] methods
         # @param [String, nil] group
         # @param [true, false] render_nil
+        # @param [Hash, nil] schema
         #
         # @api private
-        def initialize(name:, attribute:, receiver:, methods:, group:, render_nil:)
+        def initialize(name:, attribute:, receiver:, methods:, group:, render_nil:, schema: nil)
           @name = name
           @attribute = attribute
           @receiver = receiver
           @group = group
           @render_nil = render_nil
+          @schema = schema
 
           if methods
             @method_from = methods[:from]

data/lib/shale/mapping/dict.rb

@@ -16,12 +16,13 @@ module Shale
       # @param [Symbol, nil] receiver
       # @param [Hash, nil] using
       # @param [true, false, nil] render_nil
+      # @param [Hash, nil] schema
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
-      # @api private
-      def map(key, to: nil, receiver: nil, using: nil, render_nil: nil)
-        super(key, to: to, receiver: receiver, using: using, render_nil: render_nil)
+      # @api public
+      def map(key, to: nil, receiver: nil, using: nil, render_nil: nil, schema: nil)
+        super(key, to: to, receiver: receiver, using: using, render_nil: render_nil, schema: schema)
       end
 
       # Set render_nil default

data/lib/shale/mapping/dict_base.rb

@@ -16,6 +16,13 @@ module Shale
       # @api private
       attr_reader :keys
 
+      # Return hash for hash with properties for root Object
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :root
+
       # Initialize instance
       #
       # @param [true, false] render_nil_default
@@ -23,6 +30,7 @@ module Shale
       # @api private
       def initialize(render_nil_default: false)
         @keys = {}
+        @root = {}
         @finalized = false
         @render_nil_default = render_nil_default
       end
@@ -35,11 +43,12 @@ module Shale
       # @param [Hash, nil] using
       # @param [String, nil] group
       # @param [true, false, nil] render_nil
+      # @param [Hash, nil] schema
       #
       # @raise [IncorrectMappingArgumentsError] when arguments are incorrect
       #
       # @api private
-      def map(key, to: nil, receiver: nil, using: nil, group: nil, render_nil: nil)
+      def map(key, to: nil, receiver: nil, using: nil, group: nil, render_nil: nil, schema: nil)
         Validator.validate_arguments(key, to, receiver, using)
 
         @keys[key] = Descriptor::Dict.new(
@@ -48,10 +57,26 @@ module Shale
           receiver: receiver,
           methods: using,
           group: group,
-          render_nil: render_nil.nil? ? @render_nil_default : render_nil
+          render_nil: render_nil.nil? ? @render_nil_default : render_nil,
+          schema: schema
         )
       end
 
+      # Allow schema properties to be set on the object
+      #
+      # @param [Integer] min_properties
+      # @param [Integer] max_properties
+      # @param [Hash] dependent_required
+      #
+      # @api public
+      def properties(min_properties: nil, max_properties: nil, dependent_required: nil)
+        @root = {
+          min_properties: min_properties,
+          max_properties: max_properties,
+          dependent_required: dependent_required,
+        }
+      end
+
       # Set the "finalized" instance variable to true
       #
       # @api private

data/lib/shale/schema/json_generator/base.rb

@@ -12,15 +12,21 @@ module Shale
         # @api private
         attr_reader :name
 
-        # Return nullable
+        # Return schema hash
+        #
+        # @api private
+        attr_reader :schema
+
+        # Set nullable
         #
         # @api private
         attr_writer :nullable
 
-        def initialize(name, default: nil)
+        def initialize(name, default: nil, schema: nil)
           @name = name.gsub('::', '_')
           @default = default
-          @nullable = true
+          @schema = schema || {}
+          @nullable = !schema&.[](:required)
         end
 
         # Return JSON Schema fragment as Ruby Hash

data/lib/shale/schema/json_generator/collection.rb

@@ -7,13 +7,20 @@ module Shale
       #
       # @api private
       class Collection
+        # Return schema hash
+        #
+        # @api private
+        attr_reader :schema
+
         # Initialize Collection object
         #
         # @param [Shale::Schema::JSONGenerator::Base] type
+        # @param [Hash] schema
         #
         # @api private
-        def initialize(type)
+        def initialize(type, schema: nil)
           @type = type
+          @schema = schema
         end
 
         # Delegate name to wrapped type object
@@ -31,7 +38,15 @@ module Shale
         #
         # @api private
         def as_json
-          { 'type' => 'array', 'items' => @type.as_type }
+          schema = @schema || {}
+
+          { 'type' => 'array',
+            'items' => @type.as_type,
+            'minItems' => schema[:min_items],
+            'maxItems' => schema[:max_items],
+            'uniqueItems' => schema[:unique],
+            'minContains' => schema[:min_contains],
+            'maxContains' => schema[:max_contains] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/float.rb

@@ -15,7 +15,12 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'number' }
+          { 'type' => 'number',
+            'exclusiveMinimum' => schema[:exclusive_minimum],
+            'exclusiveMaximum' => schema[:exclusive_maximum],
+            'minimum' => schema[:minimum],
+            'maximum' => schema[:maximum],
+            'multipleOf' => schema[:multiple_of] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/integer.rb

@@ -15,7 +15,12 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'integer' }
+          { 'type' => 'integer',
+            'exclusiveMinimum' => schema[:exclusive_minimum],
+            'exclusiveMaximum' => schema[:exclusive_maximum],
+            'minimum' => schema[:minimum],
+            'maximum' => schema[:maximum],
+            'multipleOf' => schema[:multiple_of] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/object.rb

@@ -16,10 +16,12 @@ module Shale
         #   Array<Shale::Schema::JSONGenerator::Base,
         #   Shale::Schema::JSONGenerator::Collection>
         # ] properties
+        # @param [Hash] root
         #
         # @api private
-        def initialize(name, properties)
+        def initialize(name, properties, root)
           super(name)
+          @root = root
           @properties = properties
         end
 
@@ -29,10 +31,16 @@ module Shale
         #
         # @api private
         def as_type
+          required_props = @properties.filter_map { |prop| prop.name if prop&.schema&.[](:required) }
+
           {
             'type' => 'object',
             'properties' => @properties.to_h { |el| [el.name, el.as_json] },
-          }
+            'required' => required_props.empty? ? nil : required_props,
+            'minProperties' => @root[:min_properties],
+            'maxProperties' => @root[:max_properties],
+            'dependentRequired' => @root[:dependent_required],
+          }.compact
         end
       end
     end

data/lib/shale/schema/json_generator/string.rb

@@ -15,7 +15,11 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'string' }
+          { 'type' => 'string',
+            'format' => schema[:format],
+            'minLength' => schema[:min_length],
+            'maxLength' => schema[:max_length],
+            'pattern' => schema[:pattern] }.compact
         end
       end
     end

data/lib/shale/schema/json_generator.rb

@@ -96,14 +96,18 @@ module Shale
                 default = attribute.type.as_json(value)
               end
 
-              json_type = json_klass.new(mapping.name, default: default)
+              json_type = json_klass.new(
+                mapping.name,
+                default: default,
+                schema: mapping.schema
+              )
             end
 
-            json_type = Collection.new(json_type) if attribute.collection?
+            json_type = Collection.new(json_type, schema: mapping.schema) if attribute.collection?
             properties << json_type
           end
 
-          objects << Object.new(type.model.name, properties)
+          objects << Object.new(type.model.name, properties, type.json_mapping.root)
         end
 
         Schema.new(objects, id: id, title: title, description: description).as_json

data/lib/shale/schema/xml_compiler.rb

@@ -34,51 +34,51 @@ module Shale
 
       # XML Schema "schema" element name
       # @api private
-      XS_SCHEMA = "#{XS_NAMESPACE_URI}:schema"
+      XS_SCHEMA = "#{XS_NAMESPACE_URI}:schema".freeze
 
       # XML Schema "element" element name
       # @api private
-      XS_ELEMENT = "#{XS_NAMESPACE_URI}:element"
+      XS_ELEMENT = "#{XS_NAMESPACE_URI}:element".freeze
 
       # XML Schema "attribute" element name
       # @api private
-      XS_ATTRIBUTE = "#{XS_NAMESPACE_URI}:attribute"
+      XS_ATTRIBUTE = "#{XS_NAMESPACE_URI}:attribute".freeze
 
       # XML Schema "attribute" element name
       # @api private
-      XS_SIMPLE_TYPE = "#{XS_NAMESPACE_URI}:simpleType"
+      XS_SIMPLE_TYPE = "#{XS_NAMESPACE_URI}:simpleType".freeze
 
       # XML Schema "simpleContent" element name
       # @api private
-      XS_SIMPLE_CONTENT = "#{XS_NAMESPACE_URI}:simpleContent"
+      XS_SIMPLE_CONTENT = "#{XS_NAMESPACE_URI}:simpleContent".freeze
 
       # XML Schema "restriction" element name
       # @api private
-      XS_RESTRICTION = "#{XS_NAMESPACE_URI}:restriction"
+      XS_RESTRICTION = "#{XS_NAMESPACE_URI}:restriction".freeze
 
       # XML Schema "group" element name
       # @api private
-      XS_GROUP = "#{XS_NAMESPACE_URI}:group"
+      XS_GROUP = "#{XS_NAMESPACE_URI}:group".freeze
 
       # XML Schema "attributeGroup" element name
       # @api private
-      XS_ATTRIBUTE_GROUP = "#{XS_NAMESPACE_URI}:attributeGroup"
+      XS_ATTRIBUTE_GROUP = "#{XS_NAMESPACE_URI}:attributeGroup".freeze
 
       # XML Schema "complexType" element name
       # @api private
-      XS_COMPLEX_TYPE = "#{XS_NAMESPACE_URI}:complexType"
+      XS_COMPLEX_TYPE = "#{XS_NAMESPACE_URI}:complexType".freeze
 
       # XML Schema "complexContent" element name
       # @api private
-      XS_COMPLEX_CONTENT = "#{XS_NAMESPACE_URI}:complexContent"
+      XS_COMPLEX_CONTENT = "#{XS_NAMESPACE_URI}:complexContent".freeze
 
       # XML Schema "extension" element name
       # @api private
-      XS_EXTENSION = "#{XS_NAMESPACE_URI}:extension"
+      XS_EXTENSION = "#{XS_NAMESPACE_URI}:extension".freeze
 
       # XML Schema "anyType" type
       # @api private
-      XS_TYPE_ANY = "#{XS_NAMESPACE_URI}:anyType"
+      XS_TYPE_ANY = "#{XS_NAMESPACE_URI}:anyType".freeze
 
       # XML Schema "date" types
       # @api private

data/lib/shale/type/complex.rb

@@ -373,6 +373,7 @@ module Shale
         #
         # @api public
         def from_csv(csv, only: nil, except: nil, context: nil, headers: false, **csv_options)
+          validate_csv_adapter
           data = Shale.csv_adapter.load(csv, **csv_options.merge(headers: csv_mapping.keys.keys))
 
           data.shift if headers
@@ -398,6 +399,7 @@ module Shale
         #
         # @api public
         def to_csv(instance, only: nil, except: nil, context: nil, headers: false, **csv_options)
+          validate_csv_adapter
           data = as_csv([*instance], only: only, except: except, context: context)
 
           cols = csv_mapping.keys.values
@@ -892,6 +894,15 @@ module Shale
           raise AdapterError, XML_ADAPTER_NOT_SET_MESSAGE unless Shale.xml_adapter
         end
 
+        # Validate CSV adapter
+        #
+        # @raise [AdapterError]
+        #
+        # @api private
+        def validate_csv_adapter
+          raise AdapterError, CSV_ADAPTER_NOT_SET_MESSAGE unless Shale.csv_adapter
+        end
+
         # Convert array with attributes to a hash
         #
         # @param [Array] ary

data/lib/shale/utils.rb

@@ -31,7 +31,7 @@ module Shale
     # @api private
     def self.classify(str)
       # names may include a period, which will need to be stripped out
-      str = str.to_s.gsub(/\./, '')
+      str = str.to_s.gsub('.', '')
 
       str = str.sub(/^[a-z\d]*/) { |match| upcase_first(match) || match }
 

data/lib/shale/version.rb

@@ -2,5 +2,5 @@
 
 module Shale
   # @api private
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/shale.rb

@@ -3,7 +3,6 @@
 require 'yaml'
 
 require_relative 'shale/mapper'
-require_relative 'shale/adapter/csv'
 require_relative 'shale/adapter/json'
 require_relative 'shale/type/boolean'
 require_relative 'shale/type/date'
@@ -52,6 +51,12 @@ require_relative 'shale/version'
 #   Shale.xml_adapter = Shale::Adapter::Ox
 #   Shale.xml_adapter # => Shale::Adapter::Ox
 #
+# @example setting CSV adapter for handling CSV documents
+#   require 'shale/adapter/csv'
+#
+#   Shale.csv_adapter = Shale::Adapter::CSV
+#   Shale.csv_adapter # => Shale::Adapter::CSV
+#
 # @api public
 module Shale
   class << self
@@ -93,11 +98,15 @@ module Shale
     #
     # @param [.load, .dump] adapter
     #
-    # @example
+    # @example setting adapter
     #   Shale.csv_adapter = Shale::Adapter::CSV
     #
+    # @example getting adapter
+    #   Shale.csv_adapter
+    #   # => Shale::Adapter::CSV
+    #
     # @api public
-    attr_writer :csv_adapter
+    attr_accessor :csv_adapter
 
     # XML adapter accessor. Available adapters are Shale::Adapter::REXML,
     # Shale::Adapter::Nokogiri and Shale::Adapter::Ox
@@ -139,18 +148,5 @@ module Shale
     def yaml_adapter
       @yaml_adapter || YAML
     end
-
-    # Return CSV adapter. By default CSV is used
-    #
-    # @return [.load, .dump]
-    #
-    # @example
-    #   Shale.csv_adapter
-    #   # => Shale::Adapter::CSV
-    #
-    # @api public
-    def csv_adapter
-      @csv_adapter || Adapter::CSV
-    end
   end
 end

data/shale.gemspec

@@ -26,5 +26,7 @@ Gem::Specification.new do |spec|
   spec.bindir = 'exe'
   spec.executables = 'shaleb'
 
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.add_runtime_dependency 'bigdecimal'
+
+  spec.required_ruby_version = '>= 3.0.0'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: shale
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kamil Giszczak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-15 00:00:00.000000000 Z
-dependencies: []
+date: 2024-02-17 00:00:00.000000000 Z
+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: Ruby object mapper and serializer for XML, JSON, TOML, CSV and YAML.
 email:
 - beerkg@gmail.com
@@ -118,14 +132,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Ruby object mapper and serializer for XML, JSON, TOML, CSV and YAML.