shale 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36678c1f4afd6e0cf2d6a9a9e4b5becebf11e76404cb50dba7dc5269b5ca42cc
-  data.tar.gz: 51c6c94abafe1767c579c270e3c3cb4da2ca79a2a29a9d28ea6bfe09bc4b53fb
+  metadata.gz: 26877841702bfce542b42206f519ffd1b03e2f0d3db1e70a42e37836ff0f3bff
+  data.tar.gz: 23fddba7256bc38b5d64309cf56833f47fd636ed0e9f6ec61f2a076764dad2bb
 SHA512:
-  metadata.gz: ea21dff00b6ea2663d20f9f377140250f78c29214a93f226047fe29d47680ae526652010ae268e4cf694ca1877cd8d19bfe8f0bbd767fa871fa80afaefee1c83
-  data.tar.gz: 414d45b7bcd2477bc276eee17c598efba40350e0234c32f783c73217bee65ae4260d07e8a7bcfc7f48e1f76c9af4852de1c1c109c5b807e99a945305e2de6286
+  metadata.gz: e98bd0bbb20fbbaf4a8bdbfb5e2f83ba5d7bae78ad66a8597a1fe28c0c13d9799bc3ade785105ea7261147f55590ff530e85c31da459fe8c9171ee5b68f02977
+  data.tar.gz: 54be0efe36f4d330c551f1bd8994a36b360ecec3696aafe12382408a0656e50a181b91ff54ec9f39758908d15fcf51eafc4810540cd1aeb00bda7b552382bc80

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.4.0] - 2022-05-30
+
+### Added
+- Allow to add title to JSON Schema
+- Map Shale::Type::Value to "anyType" XML Schema type
+- Map Shale::Type::Value to "any" JSON Schema type
+- Allow to generate Shale model from JSON Schema
+
+### Changed
+- Performance improvements
+- Reformat README a little bit and fix typos
+
+### Fixed
+- Fix stack overflow caused by circular dependency when generating JSON and XML schemas
+
 ## [0.3.1] - 2022-04-29
 
 ### Changed

data/README.md

@@ -1,6 +1,17 @@
 # Shale
 
-Shale is a object mapper and serializer for JSON, YAML and XML.
+Shale is a Ruby object mapper and serializer for JSON, YAML and XML.
+It allows you to parse JSON, YAML and XML data and convert it into Ruby data structures,
+as well as serialize data structures into JSON, YAML or XML.
+
+## Features
+
+* Convert JSON, YAML and XML to Ruby data model
+* Convert Ruby data model to JSON, YAML and XML
+* Generate JSON and XML Schema from Ruby models
+* Compile JSON Schema into Ruby models
+* Out of the box support for JSON, YAML, Nokogiri, REXML and Ox parsers
+* Support for custom adapters
 
 ## Installation
 
@@ -47,6 +58,7 @@ $ gem install shale
 * [Writing your own type](#writing-your-own-type)
 * [Adapters](#adapters)
 * [Generating JSON Schema](#generating-json-schema)
+* [Compiling JSON Schema into Shale model](#compiling-json-schema-into-shale-model)
 * [Generating XML Schema](#generating-xml-schema)
 
 ## Usage
@@ -126,6 +138,7 @@ DATA
 
 ```ruby
 person.to_json
+
 # =>
 #
 # {
@@ -164,6 +177,7 @@ DATA
 
 ```ruby
 person.to_yaml
+
 # =>
 #
 # ---
@@ -201,6 +215,7 @@ person = Person.from_hash(
 
 ```ruby
 person.to_hash
+
 # =>
 #
 # {
@@ -237,6 +252,7 @@ DATA
 
 ```ruby
 person.to_xml
+
 # =>
 #
 # <person>
@@ -256,7 +272,7 @@ person.to_xml
 
 ### Mapping JSON keys to object attributes
 
-By default keys are named the same as attributes. To use custom key names use:
+By default keys are named the same as attributes. To use custom keys use:
 
 ```ruby
 class Person < Shale::Mapper
@@ -300,7 +316,7 @@ end
 
 ### Mapping XML elements and attributes to object attributes
 
-XML is more complcated format than JSON or YAML. To map elements, attributes and content use:
+XML is more complicated format than JSON or YAML. To map elements, attributes and content use:
 
 ```ruby
 class Address < Shale::Mapper
@@ -356,8 +372,6 @@ DATA
 
 ### Using XML namespaces
 
-:warning: **Ox doesn't support XML namespaces**
-
 To map namespaced elements and attributes use `namespace` and `prefix` properties on
 `map_element` and `map_attribute`
 
@@ -385,7 +399,7 @@ DATA
 ```
 
 To define default namespace for all elements use `namespace` declaration
-(this will define namespace only on elements, if you want to define namespace on an attribute
+(this will define namespace on elements only, if you want to define namespace on an attribute
 explicitly declare it on `map_attribute`).
 
 ```ruby
@@ -590,6 +604,8 @@ Shale.yaml_adapter = MyYamlAdapter
 
 Shale provides adapters for most popular Ruby XML parsers:
 
+:warning: **Ox doesn't support XML namespaces**
+
 ```ruby
 require 'shale'
 
@@ -611,14 +627,19 @@ Shale.xml_adapter = Shale::Adapter::Ox
 
 ### Generating JSON Schema
 
-To generate JSON Schema from you Shale data model use:
+:warning: Only **[Draft 2020-12](https://json-schema.org/draft/2020-12/schema)** JSON Schema is supported
 
-:warning: Shale only supports **[Draft 2020-12](https://json-schema.org/draft/2020-12/schema)** JSON Schema
+To generate JSON Schema from your Shale data model use:
 
 ```ruby
 require 'shale/schema'
 
-Shale::Schema.to_json(Person, id: 'http://foo.bar/schema/person', description: 'My description', pretty: true)
+Shale::Schema.to_json(
+  Person,
+  id: 'http://foo.bar/schema/person',
+  description: 'My description',
+  pretty: true
+)
 
 # =>
 #
@@ -663,7 +684,7 @@ Shale::Schema.to_json(Person, id: 'http://foo.bar/schema/person', description: '
 You can also use a command line tool to do it:
 
 ```
-$ shaleb -i data_model.rb -c Person -p
+$ shaleb -i data_model.rb -r Person -p
 ```
 
 If you want to convert your own types to JSON Schema types use:
@@ -676,13 +697,83 @@ class MyEmailType < Shale::Type::Value
   ...
 end
 
-class MyEmailJSONType < Shale::Schema::JSON::Base
+class MyEmailJSONType < Shale::Schema::JSONGenerator::Base
   def as_type
     { 'type' => 'string', 'format' => 'email' }
   end
 end
 
-Shale::Schema::JSON.register_json_type(MyEmailType, MyEmailJSONType)
+Shale::Schema::JSONGenerator.register_json_type(MyEmailType, MyEmailJSONType)
+```
+
+### Compiling JSON Schema into Shale model
+
+:warning: Only **[Draft 2020-12](https://json-schema.org/draft/2020-12/schema)** JSON Schema is supported
+
+To generate Shale data model from JSON Schema use:
+
+```ruby
+require 'shale/schema'
+
+schema = <<~SCHEMA
+{
+  "type": "object",
+  "properties": {
+    "firstName": { "type": "string" },
+    "lastName": { "type": "string" },
+    "address": {
+      "type": "object",
+      "properties": {
+        "street": { "type": "string" },
+        "city": { "type": "string" }
+      }
+    }
+  }
+}
+SCHEMA
+
+Shale::Schema.from_json([schema], root_name: 'Person')
+
+# =>
+#
+# {
+#   "address" => "
+#     require 'shale'
+#
+#     class Address < Shale::Mapper
+#       attribute :street, Shale::Type::String
+#       attribute :city, Shale::Type::String
+#
+#       json do
+#         map 'street', to: :street
+#         map 'city', to: :city
+#       end
+#     end
+#   ",
+#   "person" => "
+#     require 'shale'
+#
+#     require_relative 'address'
+#
+#     class Person < Shale::Mapper
+#       attribute :first_name, Shale::Type::String
+#       attribute :last_name, Shale::Type::String
+#       attribute :address, Address
+#
+#       json do
+#         map 'firstName', to: :first_name
+#         map 'lastName', to: :last_name
+#         map 'address', to: :address
+#       end
+#     end
+#   "
+# }
+```
+
+You can also use a command line tool to do it:
+
+```
+$ shaleb -c -i schema.json -r Person
 ```
 
 ### Generating XML Schema
@@ -735,7 +826,7 @@ Shale::Schema.to_xml(Person, pretty: true)
 You can also use a command line tool to do it:
 
 ```
-$ shaleb -i data_model.rb -c Person -p -f xml
+$ shaleb -i data_model.rb -r Person -p -f xml
 ```
 
 If you want to convert your own types to XML Schema types use:
@@ -748,7 +839,7 @@ class MyEmailType < Shale::Type::Value
   ...
 end
 
-Shale::Schema::XML.register_xml_type(MyEmailType, 'myEmailXMLType')
+Shale::Schema::XMLGenerator.register_xml_type(MyEmailType, 'myEmailXMLType')
 ```
 
 ## Contributing

data/exe/shaleb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'optparse'
 
 base_path = File.expand_path('../lib', __dir__)
@@ -16,11 +17,17 @@ params = {}
 ARGV << '-h' if ARGV.empty?
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: shaleb [options]\nexample: shaleb -i data_model.rb -c MyRoot"
-
-  opts.on('-i INPUT', '--input', 'Input file')
-  opts.on('-o OUTPUT', '--output', 'Output file (defaults to STDOUT)')
-  opts.on('-c CLASS', '--class CLASS', 'Shale model class name')
+  opts.banner = <<~BANNER
+    Usage: shaleb [options]
+    example generate schema from Shale model: shaleb -g -i data_model.rb -c MyRoot
+    example generate Shale model from schema: shaleb -c -i schema1.json,schema2.json -c MyRoot
+  BANNER
+
+  opts.on('-g', '--generate', 'generate schema from Shale model')
+  opts.on('-c', '--compile', 'compile schema into Shale model')
+  opts.on('-i INPUT', '--input', Array, 'Input file')
+  opts.on('-o OUTPUT', '--output', 'Output (defaults to STDOUT)')
+  opts.on('-r ROOT', '--root ROOT', 'Shale model class name')
   opts.on('-f FORMAT', '--format FORMAT', 'Schema format: JSON (default), XML')
   opts.on('-p', '--pretty', 'Pretty print generated schema')
 
@@ -30,46 +37,87 @@ OptionParser.new do |opts|
   end
 end.parse!(into: params)
 
-input_path = File.expand_path(params[:input], Dir.pwd)
-
-unless File.exist?(input_path)
-  puts "File '#{input_path}' does not exist"
-  exit
-end
+if params[:compile]
+  unless params[:input]
+    puts 'Input file is required: shaleb -c -i schema1.json,schema2.json'
+    exit
+  end
 
-unless params[:class]
-  puts 'Model class is required'
-  exit
-end
+  schemas = params[:input].map do |file|
+    path = File.expand_path(file, Dir.pwd)
 
-require input_path
+    if File.exist?(path)
+      File.read(path)
+    else
+      puts "File '#{path}' does not exist"
+      exit
+    end
+  end
 
-klass = Object.const_get(params[:class])
+  models = Shale::Schema.from_json(schemas, root_name: params[:root])
 
-if params[:format] == 'xml'
   if params[:output]
-    base_name = File.basename(params[:output], File.extname(params[:output]))
-    schemas = Shale::Schema.to_xml(klass, base_name, pretty: params[:pretty])
+    dir = File.expand_path(params[:output], Dir.pwd)
+    FileUtils.mkdir_p(dir) unless File.directory?(dir)
 
-    schemas.map do |name, xml|
-      File.write(File.expand_path(name, Dir.pwd), xml)
+    models.each do |name, model|
+      output_path = File.join(dir, "#{name}.rb")
+      File.write(output_path, model)
     end
   else
-    schemas = Shale::Schema.to_xml(klass, pretty: params[:pretty])
-
-    output = schemas.map do |name, xml|
-      "<!-- #{name} -->\n#{xml}\n"
+    output = models.map do |name, model|
+      "# --- #{name}.rb ---\n#{model}\n"
     end.join("\n")
 
     puts output
   end
 else
-  schema = Shale::Schema.to_json(klass, pretty: params[:pretty])
+  unless params[:input]
+    puts 'Input file is required: shaleb -i model.rb -r MyClass'
+    exit
+  end
 
-  if params[:output]
-    output_path = File.expand_path(params[:output], Dir.pwd)
-    File.write(output_path, schema)
+  input_path = File.expand_path(params[:input][0], Dir.pwd)
+
+  unless File.exist?(input_path)
+    puts "File '#{input_path}' does not exist"
+    exit
+  end
+
+  unless params[:root]
+    puts 'Model class is required: shaleb -i model.rb -r MyClass'
+    exit
+  end
+
+  require input_path
+
+  klass = Object.const_get(params[:root])
+
+  if params[:format] == 'xml'
+    if params[:output]
+      base_name = File.basename(params[:output], File.extname(params[:output]))
+      schemas = Shale::Schema.to_xml(klass, base_name, pretty: params[:pretty])
+
+      schemas.map do |name, xml|
+        File.write(File.expand_path(name, Dir.pwd), xml)
+      end
+    else
+      schemas = Shale::Schema.to_xml(klass, pretty: params[:pretty])
+
+      output = schemas.map do |name, xml|
+        "<!-- #{name} -->\n#{xml}\n"
+      end.join("\n")
+
+      puts output
+    end
   else
-    puts schema
+    schema = Shale::Schema.to_json(klass, pretty: params[:pretty])
+
+    if params[:output]
+      output_path = File.expand_path(params[:output], Dir.pwd)
+      File.write(output_path, schema)
+    else
+      puts schema
+    end
   end
 end

data/lib/shale/attribute.rb

@@ -20,6 +20,11 @@ module Shale
     # @api private
     attr_reader :default
 
+    # Return setter name
+    #
+    # @api private
+    attr_reader :setter
+
     # Initialize Attribute object
     #
     # @param [Symbol] name Name of the attribute
@@ -30,6 +35,7 @@ module Shale
     # @api private
     def initialize(name, type, collection, default)
       @name = name
+      @setter = "#{name}="
       @type = type
       @collection = collection
       @default = collection ? -> { [] } : default

data/lib/shale/error.rb

@@ -42,4 +42,10 @@ module Shale
   # @api private
   class NotAShaleMapperError < StandardError
   end
+
+  # JSON Schema compilation error
+  #
+  # @api private
+  class JSONSchemaError < StandardError
+  end
 end

data/lib/shale/mapper.rb

@@ -272,9 +272,11 @@ module Shale
     def initialize(**props)
       super()
 
-      props.each_key do |name|
-        unless self.class.attributes.keys.include?(name)
-          raise UnknownAttributeError.new(self.class.to_s, name.to_s)
+      unless props.empty?
+        unknown_attributes = props.keys - self.class.attributes.keys
+
+        unless unknown_attributes.empty?
+          raise UnknownAttributeError.new(self.class.to_s, unknown_attributes[0].to_s)
         end
       end
 
@@ -285,7 +287,7 @@ module Shale
           value = attribute.default.call
         end
 
-        public_send("#{name}=", value)
+        send(attribute.setter, value)
       end
     end
   end

data/lib/shale/schema/json_compiler/boolean.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Boolean type
+      #
+      # @api private
+      class Boolean
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Boolean'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Date type
+      #
+      # @api private
+      class Date
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Date'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Float type
+      #
+      # @api private
+      class Float
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Float'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class that maps Schema type to Shale Integer type
+      #
+      # @api private
+      class Integer
+        # Return name of the Shale type
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          'Shale::Type::Integer'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module Shale
+  module Schema
+    class JSONCompiler
+      # Class representing Shale's comosite type
+      #
+      # @api private
+      class Object
+        # Return id
+        #
+        # @return [String]
+        #
+        # @api private
+        attr_reader :id
+
+        # Return properties
+        #
+        # @return [Array<Shale::Schema::JSONCompiler::Property>]
+        #
+        # @api private
+        attr_reader :properties
+
+        # Name setter
+        #
+        # @param [String] val
+        #
+        # @api private
+        attr_writer :name
+
+        # Initialize object
+        #
+        # @param [String] id
+        # @param [String] name
+        #
+        # @api private
+        def initialize(id, name)
+          @id = id
+          @name = name
+          @properties = []
+        end
+
+        # Return name
+        #
+        # @return [String]
+        #
+        # @api private
+        def name
+          Utils.classify(@name)
+        end
+
+        # Return file name
+        #
+        # @return [String]
+        #
+        # @api private
+        def file_name
+          Utils.snake_case(@name)
+        end
+
+        # Return references
+        #
+        # @return [Array<Shale::Schema::JSONCompiler::Property>]
+        #
+        # @api private
+        def references
+          @properties
+            .filter { |e| e.type.is_a?(self.class) && e.type != self }
+            .uniq { |e| e.type.id }
+        end
+
+        # Add property to Object
+        #
+        # @param [Shale::Schema::JSONCompiler::Property] property
+        #
+        # @api private
+        def add_property(property)
+          @properties << property
+        end
+      end
+    end
+  end
+end