shale 1.0.0 → 1.2.0

data/lib/shale/adapter/tomlib.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'tomlib'
+
+module Shale
+  module Adapter
+    # Tomlib adapter
+    #
+    # @api public
+    class Tomlib
+      # Parse TOML into Hash
+      #
+      # @param [String] toml TOML document
+      # @param [Hash] options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def self.load(toml, **_options)
+        ::Tomlib.load(toml)
+      end
+
+      # Serialize Hash into TOML
+      #
+      # @param [Hash] obj Hash object
+      # @param [Hash] options
+      #
+      # @return [String]
+      #
+      # @api private
+      def self.dump(obj, **options)
+        ::Tomlib.dump(obj, **options)
+      end
+    end
+  end
+end

data/lib/shale/error.rb

@@ -9,7 +9,8 @@ module Shale
 
     # To use Tomlib:
     # Make sure tomlib is installed eg. execute: gem install tomlib
-    Shale.toml_adapter = Tomlib
+    require 'shale/adapter/tomlib'
+    Shale.toml_adapter = Shale::Adapter::Tomlib
 
     # To use toml-rb:
     # Make sure toml-rb is installed eg. execute: gem install toml-rb
@@ -38,6 +39,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
@@ -92,6 +105,18 @@ module Shale
   class NotAShaleMapperError < ShaleError
   end
 
+  # Error for registering class that is not a valid Type::Value
+  #
+  # @api private
+  class NotATypeValueError < ShaleError
+  end
+
+  # Error for using unknown symbol type
+  #
+  # @api private
+  class UnknownTypeError < ShaleError
+  end
+
   # Raised when receiver attribute is not defined
   #
   # @api private

data/lib/shale/mapper.rb

@@ -5,6 +5,7 @@ require_relative 'error'
 require_relative 'utils'
 require_relative 'mapping/dict'
 require_relative 'mapping/xml'
+require_relative 'type'
 require_relative 'type/complex'
 
 module Shale
@@ -12,16 +13,16 @@ module Shale
   #
   # @example
   #   class Address < Shale::Mapper
-  #     attribute :city, Shale::Type::String
-  #     attribute :street, Shale::Type::String
-  #     attribute :state, Shale::Type::Integer
-  #     attribute :zip, Shale::Type::String
+  #     attribute :city, :string
+  #     attribute :street, :string
+  #     attribute :state, :string
+  #     attribute :zip, :string
   #   end
   #
   #   class Person < Shale::Mapper
-  #     attribute :first_name, Shale::Type::String
-  #     attribute :last_name, Shale::Type::String
-  #     attribute :age, Shale::Type::Integer
+  #     attribute :first_name, :string
+  #     attribute :last_name, :string
+  #     attribute :age, :integer
   #     attribute :address, Address
   #   end
   #
@@ -144,18 +145,19 @@ module Shale
       # Define attribute on class
       #
       # @param [Symbol] name Name of the attribute
-      # @param [Shale::Type::Value] type Type of the attribute
+      # @param [Symbol, Class<Shale::Type::Value>] type Type of the attribute
       # @param [Boolean] collection Is the attribute a collection
       # @param [Proc] default Default value for the attribute
       #
       # @raise [DefaultNotCallableError] when attribute's default is not callable
+      # @raise [UnknownTypeError] when type is a symbol and not found in the registry
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer, default: -> { 1 }
-      #     attribute :hobbies, Shale::Type::String, collection: true
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer, default: -> { 1 }
+      #     attribute :hobbies, :string, collection: true
       #   end
       #
       #   person = Person.new
@@ -177,6 +179,10 @@ module Shale
           raise DefaultNotCallableError.new(to_s, name)
         end
 
+        if type.is_a?(Symbol)
+          type = Type.lookup(type)
+        end
+
         @attributes[name] = Attribute.new(name, type, collection, default)
 
         @hash_mapping.map(name.to_s, to: name) unless @hash_mapping.finalized?
@@ -201,9 +207,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     hsh do
       #       map 'firstName', to: :first_name
@@ -225,9 +231,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     json do
       #       map 'firstName', to: :first_name
@@ -249,9 +255,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     yaml do
       #       map 'first_name', to: :first_name
@@ -273,9 +279,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     toml do
       #       map 'first_name', to: :first_name
@@ -297,9 +303,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     csv do
       #       map 'first_name', to: :first_name
@@ -321,9 +327,9 @@ module Shale
       #
       # @example
       #   class Person < Shale::Mapper
-      #     attribute :first_name, Shale::Type::String
-      #     attribute :last_name, Shale::Type::String
-      #     attribute :age, Shale::Type::Integer
+      #     attribute :first_name, :string
+      #     attribute :last_name, :string
+      #     attribute :age, :integer
       #
       #     xml do
       #       root 'Person'

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,28 @@ 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
+      # @param [Boolean] additional_properties
+      #
+      # @api public
+      def properties(min_properties: nil, max_properties: nil, dependent_required: nil, additional_properties: nil)
+        @root = {
+          min_properties: min_properties,
+          max_properties: max_properties,
+          dependent_required: dependent_required,
+          additional_properties: additional_properties,
+        }
+      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/boolean.rb

@@ -15,7 +15,8 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'boolean' }
+          { 'type' => 'boolean',
+            'description' => schema[:description] }.compact
         end
       end
     end

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,16 @@ 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],
+            'description' => schema[:description] }.compact
         end
       end
     end

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

@@ -15,7 +15,9 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'string', 'format' => 'date' }
+          { 'type' => 'string',
+            'format' => 'date',
+            'description' => schema[:description] }.compact
         end
       end
     end

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

@@ -15,7 +15,13 @@ 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],
+            'description' => schema[:description] }.compact
         end
       end
     end

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

@@ -15,7 +15,13 @@ 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],
+            'description' => schema[:description] }.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,18 @@ 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],
+            'description' => @root[:description],
+            'additionalProperties' => @root[:additional_properties],
+          }.compact
         end
       end
     end

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

@@ -15,7 +15,12 @@ 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],
+            'description' => schema[:description] }.compact
         end
       end
     end

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

@@ -15,7 +15,9 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => 'string', 'format' => 'date-time' }
+          { 'type' => 'string',
+            'format' => 'date-time',
+            'description' => schema[:description] }.compact
         end
       end
     end

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

@@ -15,7 +15,8 @@ module Shale
         #
         # @api private
         def as_type
-          { 'type' => %w[boolean integer number object string] }
+          { 'type' => %w[boolean integer number object string],
+            'description' => schema[:description] }.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/boolean.rb

@@ -29,5 +29,7 @@ module Shale
         !FALSE_VALUES.include?(value) unless value.nil?
       end
     end
+
+    register(:boolean, Boolean)
   end
 end