lutaml-model 0.3.2 → 0.3.4

data/lib/lutaml/model/schema/json_schema.rb

@@ -17,12 +17,20 @@ module Lutaml
         end
 
         def self.generate_definitions(klass)
+          defs = { klass.name => generate_class_schema(klass) }
+          klass.attributes.each_value do |attr|
+            if attr.type <= Lutaml::Model::Serialize
+              defs.merge!(generate_definitions(attr.type))
+            end
+          end
+          defs
+        end
+
+        def self.generate_class_schema(klass)
           {
-            klass.name => {
-              "type" => "object",
-              "properties" => generate_properties(klass),
-              "required" => klass.attributes.keys,
-            },
+            "type" => "object",
+            "properties" => generate_properties(klass),
+            "required" => klass.attributes.keys,
           }
         end
 
@@ -33,7 +41,16 @@ module Lutaml
         end
 
         def self.generate_property_schema(attr)
-          { "type" => get_json_type(attr.type) }
+          if attr.type <= Lutaml::Model::Serialize
+            { "$ref" => "#/$defs/#{attr.type.name}" }
+          elsif attr.collection?
+            {
+              "type" => "array",
+              "items" => { "type" => get_json_type(attr.type) },
+            }
+          else
+            { "type" => get_json_type(attr.type) }
+          end
         end
 
         def self.get_json_type(type)
@@ -42,7 +59,6 @@ module Lutaml
             Lutaml::Model::Type::Integer => "integer",
             Lutaml::Model::Type::Boolean => "boolean",
             Lutaml::Model::Type::Float => "number",
-            Lutaml::Model::Type::Array => "array",
             Lutaml::Model::Type::Hash => "object",
           }[type] || "string" # Default to string for unknown types
         end

data/lib/lutaml/model/schema/json_schema_parser.rb

@@ -0,0 +1,91 @@
+require "json-schema"
+
+module Lutaml
+  module Model
+    module Schema
+      class JsonSchemaParser
+        def self.parse(schema_json)
+          schema = JSON::Schema.parse(schema_json)
+          definitions = schema.schema.fetch("$defs", {})
+          definitions.map do |class_name, class_schema|
+            generate_class_definition(class_name, class_schema)
+          end.join("\n")
+        end
+
+        def self.generate_class_definition(class_name, class_schema)
+          attributes = class_schema["properties"] || {}
+          required_attributes = class_schema["required"] || []
+
+          <<~RUBY
+            class #{class_name} < Lutaml::Model::Serializable
+              #{generate_attributes(attributes, required_attributes)}
+
+              json do
+                #{generate_json_mappings(attributes)}
+              end
+            end
+          RUBY
+        end
+
+        def self.generate_attributes(attributes, required_attributes)
+          attributes.map do |name, schema|
+            type = schema["type"]
+            ruby_type = get_ruby_type(type, schema)
+            attributes = [
+              "attribute :#{name}",
+              "Lutaml::Model::Type::#{ruby_type}",
+              "required: #{required_attributes.include?(name).inspect}",
+            ]
+
+            attributes.join(", ")
+          end.join("\n  ")
+        end
+
+        def self.generate_json_mappings(attributes)
+          attributes.keys.map do |name|
+            "map '#{name}', to: :#{name}"
+          end.join("\n    ")
+        end
+
+        def self.get_ruby_type(type, schema)
+          case type
+          when "integer"
+            "Integer"
+          when "boolean"
+            "Boolean"
+          when "number"
+            "Float"
+          when "array"
+            item_schema = schema["items"]
+            item_type = get_ruby_type(item_schema["type"], item_schema)
+            "Array.of(#{item_type})"
+          when "object"
+            object_class_name(schema)
+          else
+            "String" # Default to string for unknown types
+          end
+        end
+
+        def self.object_class_name(schema)
+          nested_class_name = schema["title"] || "NestedObject"
+          nested_class_definition = generate_class_definition(
+            nested_class_name, schema
+          )
+          @nested_classes ||= []
+          @nested_classes << nested_class_definition
+          nested_class_name
+        end
+
+        def self.nested_classes
+          @nested_classes ||= []
+        end
+
+        def self.generate(schema_json)
+          @nested_classes = []
+          main_classes = parse(schema_json)
+          (nested_classes + [main_classes]).join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/relaxng_schema.rb

@@ -4,22 +4,52 @@ module Lutaml
   module Model
     module Schema
       class RelaxngSchema
-        def self.generate(klass, _options = {})
-          schema = Nokogiri::XML::Builder.new do |xml|
-            xml.element(name: klass.name) do
-              xml.complexType do
-                xml.sequence do
-                  generate_elements(klass, xml)
+        def self.generate(klass, options = {})
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+            xml.grammar(xmlns: "http://relaxng.org/ns/structure/1.0") do
+              generate_start(xml, klass)
+              generate_define(xml, klass)
+            end
+          end
+
+          options[:pretty] ? builder.to_xml(indent: 2) : builder.to_xml
+        end
+
+        def self.generate_start(xml, klass)
+          xml.start do
+            xml.ref(name: klass.name)
+          end
+        end
+
+        def self.generate_attributes(xml, klass)
+          klass.attributes.each do |name, attr|
+            if attr.type <= Lutaml::Model::Serialize
+              xml.ref(name: attr.type.name)
+            elsif attr.collection?
+              xml.zeroOrMore do
+                xml.element(name: name) do
+                  xml.data(type: get_relaxng_type(attr.type))
                 end
               end
+            else
+              xml.element(name: name) do
+                xml.data(type: get_relaxng_type(attr.type))
+              end
             end
           end
-          schema.to_xml
         end
 
-        def self.generate_elements(klass, xml)
-          klass.attributes.each do |name, attr|
-            xml.element(name: name, type: get_relaxng_type(attr.type))
+        def self.generate_define(xml, klass)
+          xml.define(name: klass.name) do
+            xml.element(name: klass.name) do
+              generate_attributes(xml, klass)
+            end
+          end
+
+          klass.attributes.each_value do |attr|
+            if attr.type <= Lutaml::Model::Serialize
+              generate_define(xml, attr.type)
+            end
           end
         end
 
@@ -29,8 +59,8 @@ module Lutaml
             Lutaml::Model::Type::Integer => "integer",
             Lutaml::Model::Type::Boolean => "boolean",
             Lutaml::Model::Type::Float => "float",
-            Lutaml::Model::Type::Array => "array",
-            Lutaml::Model::Type::Hash => "object",
+            Lutaml::Model::Type::Decimal => "decimal",
+            Lutaml::Model::Type::Hash => "string",
           }[type] || "string" # Default to string for unknown types
         end
       end

data/lib/lutaml/model/schema/xsd_schema.rb

@@ -4,22 +4,41 @@ module Lutaml
   module Model
     module Schema
       class XsdSchema
-        def self.generate(klass, _options = {})
-          schema = Nokogiri::XML::Builder.new do |xml|
+        def self.generate(klass, options = {})
+          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             xml.schema(xmlns: "http://www.w3.org/2001/XMLSchema") do
-              xml.element(name: klass.name) do
-                xml.complexType do
-                  xml.sequence { generate_elements(klass, xml) }
-                end
+              generate_complex_type(xml, klass)
+            end
+          end
+
+          options[:pretty] ? builder.to_xml(indent: 2) : builder.to_xml
+        end
+
+        def self.generate_complex_type(xml, klass, element_name = nil)
+          xml.element(name: element_name || klass.name) do
+            xml.complexType do
+              xml.sequence do
+                generate_elements(xml, klass)
               end
             end
           end
-          schema.to_xml
         end
 
-        def self.generate_elements(klass, xml)
+        def self.generate_elements(xml, klass)
           klass.attributes.each do |name, attr|
-            xml.element(name: name, type: get_xsd_type(attr.type))
+            if attr.type <= Lutaml::Model::Serialize
+              generate_complex_type(xml, attr.type, name)
+            elsif attr.collection?
+              xml.element(name: name, minOccurs: "0", maxOccurs: "unbounded") do
+                xml.complexType do
+                  xml.sequence do
+                    xml.element(name: "item", type: get_xsd_type(attr.type))
+                  end
+                end
+              end
+            else
+              xml.element(name: name, type: get_xsd_type(attr.type))
+            end
           end
         end
 
@@ -30,8 +49,7 @@ module Lutaml
             Lutaml::Model::Type::Boolean => "xs:boolean",
             Lutaml::Model::Type::Float => "xs:float",
             Lutaml::Model::Type::Decimal => "xs:decimal",
-            Lutaml::Model::Type::Array => "xs:array",
-            Lutaml::Model::Type::Hash => "xs:object",
+            Lutaml::Model::Type::Hash => "xs:anyType",
           }[type] || "xs:string" # Default to string for unknown types
         end
       end

data/lib/lutaml/model/schema/yaml_schema.rb

@@ -4,17 +4,34 @@ module Lutaml
   module Model
     module Schema
       class YamlSchema
-        def self.generate(klass, _options = {})
-          schema = {
+        def self.generate(klass, options = {})
+          schema = generate_schema(klass)
+          options[:pretty] ? schema.to_yaml : YAML.dump(schema)
+        end
+
+        def self.generate_schema(klass)
+          {
             "type" => "map",
             "mapping" => generate_mapping(klass),
           }
-          YAML.dump(schema)
         end
 
         def self.generate_mapping(klass)
           klass.attributes.each_with_object({}) do |(name, attr), mapping|
-            mapping[name.to_s] = { "type" => get_yaml_type(attr.type) }
+            mapping[name.to_s] = generate_attribute_schema(attr)
+          end
+        end
+
+        def self.generate_attribute_schema(attr)
+          if attr.type <= Lutaml::Model::Serialize
+            generate_schema(attr.type)
+          elsif attr.collection?
+            {
+              "type" => "seq",
+              "sequence" => [{ "type" => get_yaml_type(attr.type) }],
+            }
+          else
+            { "type" => get_yaml_type(attr.type) }
           end
         end
 
@@ -24,9 +41,7 @@ module Lutaml
             Lutaml::Model::Type::Integer => "int",
             Lutaml::Model::Type::Boolean => "bool",
             Lutaml::Model::Type::Float => "float",
-            # YAML does not have a separate decimal type, so we use float
             Lutaml::Model::Type::Decimal => "float",
-            Lutaml::Model::Type::Array => "seq",
             Lutaml::Model::Type::Hash => "map",
           }[type] || "str" # Default to string for unknown types
         end

data/lib/lutaml/model/serializable.rb

@@ -7,3 +7,5 @@ module Lutaml
     end
   end
 end
+
+require_relative "comparable_nil"

data/lib/lutaml/model/serialize.rb

@@ -8,12 +8,15 @@ require_relative "mapping_hash"
 require_relative "xml_mapping"
 require_relative "key_value_mapping"
 require_relative "json_adapter"
+require_relative "comparable_model"
 
 module Lutaml
   module Model
     module Serialize
       FORMATS = %i[xml json yaml toml].freeze
 
+      include ComparableModel
+
       def self.included(base)
         base.extend(ClassMethods)
       end
@@ -50,11 +53,8 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
-            unless self.class.attr_value_valid?(name, value)
-              raise Lutaml::Model::InvalidValueError.new(name, value, options[:values])
-            end
-
             instance_variable_set(:"@#{name}", value)
+            validate
           end
         end
 
@@ -64,9 +64,13 @@ module Lutaml
 
           return true unless attr.options[:values]
 
-          # If value validation failed but there is a default value, do not
-          # raise a validation error
-          attr.options[:values].include?(value || attr.default)
+          # Allow nil values if there's no default
+          return true if value.nil? && !attr.default
+
+          # Use the default value if the value is nil
+          value = attr.default if value.nil?
+
+          attr.options[:values].include?(value)
         end
 
         FORMATS.each do |format|
@@ -403,6 +407,8 @@ module Lutaml
 
           send(:"#{name}=", self.class.ensure_utf8(value))
         end
+
+        validate
       end
 
       def ordered?
@@ -419,6 +425,7 @@ module Lutaml
 
       FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
+          validate
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
           representation = if format == :xml
                              self
@@ -429,6 +436,15 @@ module Lutaml
           adapter.new(representation).public_send(:"to_#{format}", options)
         end
       end
+
+      def validate
+        self.class.attributes.each do |name, attr|
+          value = send(name)
+          unless self.class.attr_value_valid?(name, value)
+            raise Lutaml::Model::InvalidValueError.new(name, value, attr.options[:values])
+          end
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/type.rb

@@ -42,14 +42,6 @@ module Lutaml
         HEREDOC
       end
 
-      # TODO: Remove this. The XSD code depends on this but actually should
-      # be converted into a collection, not a specific Array type.
-      class Array
-        def initialize(array)
-          Array(array)
-        end
-      end
-
       UUID_REGEX = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\z/
 
       def self.cast(value, type)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.2"
+    VERSION = "0.3.4"
   end
 end

data/lib/lutaml/model/xml_adapter/nokogiri_adapter.rb

@@ -48,7 +48,8 @@ module Lutaml
                            xml
                          end
 
-          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          prefixed_xml.public_send(tag_name, attributes) do
             if options.key?(:namespace_prefix) && !options[:namespace_prefix]
               xml.parent.namespace = nil
             end
@@ -94,7 +95,8 @@ module Lutaml
                            xml
                          end
 
-          prefixed_xml.public_send(xml_mapping.root_element, attributes) do
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          prefixed_xml.public_send(tag_name, attributes) do
             if options.key?(:namespace_prefix) && !options[:namespace_prefix]
               xml.parent.namespace = nil
             end

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -36,12 +36,13 @@ module Lutaml
 
           attributes = build_attributes(element, xml_mapping).compact
 
+          tag_name = options[:tag_name] || xml_mapping.root_element
           prefixed_name = if options.key?(:namespace_prefix)
-                            [options[:namespace_prefix], xml_mapping.root_element].compact.join(":")
+                            [options[:namespace_prefix], tag_name].compact.join(":")
                           elsif xml_mapping.namespace_prefix
-                            "#{xml_mapping.namespace_prefix}:#{xml_mapping.root_element}"
+                            "#{xml_mapping.namespace_prefix}:#{tag_name}"
                           else
-                            xml_mapping.root_element
+                            tag_name
                           end
 
           builder.element(prefixed_name, attributes) do |el|
@@ -84,7 +85,8 @@ module Lutaml
 
           attributes = build_attributes(element, xml_mapping).compact
 
-          builder.element(xml_mapping.root_element, attributes) do |el|
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          builder.element(tag_name, attributes) do |el|
             index_hash = {}
 
             element.element_order.each do |name|

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -60,6 +60,7 @@ module Lutaml
 
           options[:namespace_prefix] = rule.prefix if rule&.namespace_set?
           options[:mixed_content] = rule.mixed_content
+          options[:tag_name] = rule.name
 
           options[:mapper_class] = attribute&.type if attribute
 

data/lib/lutaml/model/xml_mapping.rb

@@ -9,8 +9,8 @@ module Lutaml
                   :mixed_content
 
       def initialize
-        @elements = []
-        @attributes = []
+        @elements = {}
+        @attributes = {}
         @content_mapping = nil
         @mixed_content = false
       end
@@ -47,7 +47,7 @@ module Lutaml
         prefix: nil,
         mixed: false
       )
-        @elements << XmlMappingRule.new(
+        @elements[name] = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
@@ -70,7 +70,7 @@ module Lutaml
                     nil),
         prefix: nil
       )
-        @attributes << XmlMappingRule.new(
+        @attributes[name] = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
@@ -102,11 +102,11 @@ module Lutaml
       end
 
       def elements
-        @elements
+        @elements.values
       end
 
       def attributes
-        @attributes
+        @attributes.values
       end
 
       def content_mapping

data/lutaml-model.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/lutaml/lutaml-model"
   spec.license = "BSD-2-Clause"
 
-  spec.bindir = "bin"
+  spec.bindir = "exe"
   spec.require_paths = ["lib"]
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
@@ -30,8 +30,5 @@ Gem::Specification.new do |spec|
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
-  # spec.add_runtime_dependency "expressir"
-  # spec.add_runtime_dependency "metanorma-cli"
-  # spec.add_runtime_dependency "shale"
-  # spec.add_runtime_dependency "thor", ">= 0.20"
+  spec.add_dependency "thor"
 end

metadata

@@ -1,21 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2024-08-15 00:00:00.000000000 Z
-dependencies: []
+date: 2024-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  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: 'LutaML creating data models in Ruby
 
   '
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- lutaml-model
 extensions: []
 extra_rdoc_files: []
 files:
@@ -31,8 +46,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/lutaml-model
 - lib/lutaml/model.rb
 - lib/lutaml/model/attribute.rb
+- lib/lutaml/model/cli.rb
+- lib/lutaml/model/comparable_model.rb
+- lib/lutaml/model/comparable_nil.rb
+- lib/lutaml/model/comparison.rb
 - lib/lutaml/model/config.rb
 - lib/lutaml/model/error.rb
 - lib/lutaml/model/error/invalid_value_error.rb
@@ -47,6 +67,7 @@ files:
 - lib/lutaml/model/mapping_rule.rb
 - lib/lutaml/model/schema.rb
 - lib/lutaml/model/schema/json_schema.rb
+- lib/lutaml/model/schema/json_schema_parser.rb
 - lib/lutaml/model/schema/relaxng_schema.rb
 - lib/lutaml/model/schema/xsd_schema.rb
 - lib/lutaml/model/schema/yaml_schema.rb