lutaml-xsd 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85cb4cbd82c07c758dcc239a61c3a6d302ae093e407862a5429090e11af6e266
-  data.tar.gz: 3fb08c6d788f5ae48022d088412fd7c084c680ec49276289b65e5b1654bf8072
+  metadata.gz: a4296cdc53ac951e9dabd94e87350ea4d82e7691fcd879e5ea38d9ac619c620e
+  data.tar.gz: a9e1191c508dabc0bc942e86b210f06d4c27815ab10cf5fbdc322bbde0b59f68
 SHA512:
-  metadata.gz: 5d186b892aaa8b12959bf93f5eb8cd587301cabb7c7dd6dd72d93a2faa2df126bdf7086e2b66f012ced853f7998502f07b9869c2cb73b904869ae1d9685ea0fa
-  data.tar.gz: 165670c5135e86c953ca6a3a40812f31b1acaaa3155eb221e022531192cdb24ca938834ab94d39c58c5093742eb0c12c198f46696b4017a8443ca84923c63d1a
+  metadata.gz: 2d69274700a75e1756c82103c095a0bf3b5b56fb0c9d9c35da98112afcbca422e37cfed00d46579f0969fec4392ae04b993f57e58f1aaea35e513d6ae39577ff
+  data.tar.gz: 7ffa3d40825726c740a29cac23685e32aff7f4295603634361524305b7579bbf4b02194582b78f12da42c6923657c682b7182d863b08bbd9267ce3190bef6149

data/.rubocop.yml

@@ -6,3 +6,6 @@ Style/StringLiterals:
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+Documentation:
+  Enabled: false

data/Gemfile

@@ -5,8 +5,14 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in lutaml-xsd.gemspec
 gemspec
 
+gem "equivalent-xml"
+
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
 gem "rubocop", "~> 1.21"
+
+gem "nokogiri"
+
+gem "xml-c14n"

data/LICENSE.md

@@ -0,0 +1,33 @@
+Licenses & Copyright
+====================
+
+This license file adheres to the formatting guidelines of
+[readable-licenses](https://github.com/nevir/readable-licenses).
+
+
+Ribose's BSD 2-Clause License
+-----------------------------
+
+Copyright (c) 2024, [Ribose Inc](https://www.ribose.com).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.adoc

@@ -0,0 +1,141 @@
+= Lutaml::Xsd
+
+== Overview
+
+**Lutaml::Xsd** is a *Ruby* gem designed to parse and build *XML Schema Definition (XSD)* objects. It provides a robust framework for handling *XSD* *elements*, *attributes*, and *complex types*, allowing users to manipulate and generate *XSD* objects programmatically.
+
+== Installation
+
+To install *Lutaml::Xsd*, add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'lutaml-xsd'
+----
+
+And then execute:
+
+[source,bash]
+----
+bundle install
+----
+
+Or install it by running:
+
+[source,bash]
+----
+gem install lutaml-xsd
+----
+
+== Usage
+
+=== Parsing XSD Files
+
+To parse an *XSD* file, you can use the `Lutaml::Xsd.parse` method. This method takes the content of an *XSD* file as a string and optional parameters such as the location of the *XSD* file for resolving relative paths.
+
+[source,ruby]
+----
+require 'lutaml/xsd'
+
+xsd_content = File.read('path/to/your/schema.xsd')
+parsed_schema = Lutaml::Xsd.parse(xsd_content, location: 'path/to/your/')
+----
+
+=== Working with Parsed Data
+
+Once parsed, the data is represented as instances of various classes such as `Lutaml::Xsd::Schema`, `Lutaml::Xsd::Element`, and others. These objects reflect the structure of the *XSD* and can be manipulated or inspected in *Ruby*.
+
+[source,ruby]
+----
+schema = <<~SCHEMA
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <xsd:element name="root">
+    ...
+  </xsd:element>
+  <xsd:element name="root1">
+    ...
+  </xsd:element>
+</xsd:schema>
+SCHEMA
+
+parsed_schema = Lutaml::Xsd.parse(schema, location: 'http://example.com/')
+
+# Accessing elements of the schema
+elements = parsed_schema.element
+elements.each do |element|
+  puts "Element Name: #{element.name}"
+end
+# the output will be:
+> Element Name: root
+> Element Name: root1
+----
+
+=== Serialization
+
+The gem supports serializing the schema back to *XML*. Each class like `Lutaml::Xsd::Schema` has a method `to_xml` that generates the *XML* representation of the object.
+
+[source,ruby]
+----
+xml_output = parsed_schema.to_xml
+puts xml_output
+----
+
+== Key Components
+
+=== Schema Representation
+
+The *Lutaml::Xsd::Schema* class represents an *XSD* schema. It includes attributes for various schema properties like target namespace, element form default, and others.
+
+- **Attributes and Elements**: The schema object contains collections of elements, complex types, simple types, etc., which are all accessible via attributes on the `Schema` object.
+
+=== Include and Import Handling
+
+The path provided in `location` via `Lutaml::Xsd.parse(schema, location: 'path/to/your/directory/')` is used for resolving relative paths provided in *include* and *import* element's *schemaLocation* attribute.
+
+Make sure to provide the directory *path*/*URL* in `location` parameter, as it will be used as base path for resolving relative paths.
+
+For example, if *URL* is provided:
+
+[source,ruby]
+----
+Lutaml::Xsd.parse(xsd_content, location: 'http://example.com/directory/')
+----
+
+If local path is provided:
+
+[source,ruby]
+----
+Lutaml::Xsd.parse(xsd_content, location: 'path/to/your/directory/')
+----
+
+[source, xml]
+----
+<xs:include schemaLocation="<location>/directory2/metaschema.xsd"/>
+<!-- AND/OR -->
+<xs:import schemaLocation="<location>/metaschema.xsd"/>
+----
+
+All schemas specified in the *include* and/or *import* elements will be fetched from their *schemaLocation*, parsed and added to their parent *Lutaml::Xsd::Schema* object.
+
+== Development
+
+- **Dependencies**: The gem depends on other gems like `zeitwerk` for autoloading and `lutaml-model` for model serialization. See the `Gemfile` and `lutaml-xsd.gemspec` for details on dependencies.
+
+- **Testing**: Tests are written using RSpec. Test files and fixtures are located in the `spec` directory.
+
+== About LutaML
+
+The name "LutaML" is pronounced as "Looh-tah-mel".
+
+The name "LutaML" comes from the Latin word for clay, "Lutum", and "ML"
+for "Markup Language". Just as clay can be molded and modeled into beautiful and
+practical end products, the Lutaml::Model gem is used for data modeling,
+allowing you to shape and structure your data into useful forms.
+
+
+== License and Copyright
+
+This project is licensed under the BSD 2-clause License.
+See the link:LICENSE.md[] file for details.
+
+Copyright Ribose.

data/lib/lutaml/xsd/all.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class All < Model::Serializable
+      attribute :id, :string
+      attribute :max_occurs, :string
+      attribute :min_occurs, :string
+      attribute :annotation, Annotation
+      attribute :element, Element, collection: true
+
+      xml do
+        root "all", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :max_occurs, to: :max_occurs
+        map_attribute :min_occurs, to: :min_occurs
+        map_element :annotation, to: :annotation
+        map_element :element, to: :element
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/annotation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Annotation < Model::Serializable
+      attribute :id, :string
+      attribute :documentation, Documentation, collection: true
+      attribute :appinfo, Appinfo, collection: true
+
+      xml do
+        root "annotation", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_element :documentation, to: :documentation
+        map_element :appinfo, to: :appinfo
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/any.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Any < Model::Serializable
+      attribute :id, :string
+      attribute :min_occurs, :string
+      attribute :max_occurs, :string
+      attribute :namespace, :string
+      attribute :process_contents, :string
+      attribute :annotation, Annotation
+
+      xml do
+        root "any", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :namespace, to: :namespace
+        map_attribute :minOccurs, to: :min_occurs
+        map_attribute :maxOccurs, to: :max_occurs
+        map_attribute :processContents, to: :process_contents
+        map_element :annotation, to: :annotation
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/any_attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class AnyAttribute < Model::Serializable
+      attribute :id, :string
+      attribute :namespace, :string
+      attribute :process_contents, :string
+      attribute :annotation, Annotation
+
+      xml do
+        root "anyAttribute", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :namespace, to: :namespace
+        map_attribute :processContents, to: :process_contents
+        map_element :annotation, to: :annotation
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/appinfo.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Appinfo < Model::Serializable
+      attribute :source, :string
+      attribute :text, :string
+
+      xml do
+        root "appinfo", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_content to: :text
+        map_attribute :source, to: :source
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/attribute.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Attribute < Model::Serializable
+      attribute :id, :string
+      attribute :use, :string, values: %w[required prohibited optional], default: -> { "optional" }
+      attribute :ref, :string
+      attribute :name, :string
+      attribute :type, :string
+      attribute :form, :string
+      attribute :fixed, :string
+      attribute :default, :string
+      attribute :annotation, Annotation
+      attribute :simple_type, SimpleType
+
+      xml do
+        root "attribute", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :use, to: :use
+        map_attribute :ref, to: :ref
+        map_attribute :name, to: :name
+        map_attribute :type, to: :type
+        map_attribute :form, to: :form
+        map_attribute :fixed, to: :fixed
+        map_attribute :default, to: :default
+        map_element :annotation, to: :annotation
+        map_element :simpleType, to: :simple_type
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/attribute_group.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class AttributeGroup < Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+      attribute :ref, :string
+      attribute :annotation, Annotation
+      attribute :any_attribute, AnyAttribute
+      attribute :attribute, Attribute, collection: true
+      attribute :attribute_group, AttributeGroup, collection: true
+
+      xml do
+        root "attributeGroup", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :ref, to: :ref
+        map_attribute :name, to: :name
+        map_element :attribute, to: :attribute
+        map_element :annotation, to: :annotation
+        map_element :anyAttribute, to: :any_attribute
+        map_element :attributeGroup, to: :attribute_group
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/choice.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Sequence < Model::Serializable; end
+    class Group < Model::Serializable; end
+
+    class Choice < Model::Serializable
+      attribute :id, :string
+      attribute :min_occurs, :string
+      attribute :max_occurs, :string
+      attribute :annotation, Annotation
+      attribute :any, Any, collection: true
+      attribute :group, Group, collection: true
+      attribute :choice, Choice, collection: true
+      attribute :element, Element, collection: true
+      attribute :sequence, Sequence, collection: true
+
+      xml do
+        root "choice", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :minOccurs, to: :min_occurs
+        map_attribute :maxOccurs, to: :max_occurs
+        map_element :annotation, to: :annotation
+        map_element :sequence, to: :sequence
+        map_element :element, to: :element
+        map_element :choice, to: :choice
+        map_element :group, to: :group
+        map_element :any, to: :any
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/complex_content.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class ExtensionComplexContent < Model::Serializable; end
+
+    class ComplexContent < Model::Serializable
+      attribute :id, :string
+      attribute :mixed, :boolean
+      attribute :extension, ExtensionComplexContent
+      attribute :annotation, Annotation
+      attribute :restriction, RestrictionComplexContent
+
+      xml do
+        root "complexContent", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :mixed, to: :mixed
+        map_element :extension, to: :extension
+        map_element :annotation, to: :annotation
+        map_element :restriction, to: :restriction
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/complex_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class ComplexType < Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+      attribute :final, :string
+      attribute :block, :string
+      attribute :mixed, :boolean, default: -> { false }
+      attribute :abstract, :boolean, default: -> { false }
+      attribute :all, All
+      attribute :group, Group
+      attribute :choice, Choice
+      attribute :sequence, Sequence
+      attribute :annotation, Annotation
+      attribute :simple_content, SimpleContent
+      attribute :complex_content, ComplexContent
+      attribute :attribute, Attribute, collection: true
+      attribute :attribute_group, AttributeGroup, collection: true
+
+      xml do
+        root "complexType", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :name, to: :name
+        map_attribute :final, to: :final
+        map_attribute :block, to: :block
+        map_attribute :mixed, to: :mixed
+        map_attribute :abstract, to: :abstract
+        map_element :all, to: :all
+        map_element :group, to: :group
+        map_element :choice, to: :choice
+        map_element :sequence, to: :sequence
+        map_element :attribute, to: :attribute
+        map_element :annotation, to: :annotation
+        map_element :attributeGroup, to: :attribute_group
+        map_element :simpleContent, to: :simple_content
+        map_element :complexContent, to: :complex_content
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/documentation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Documentation < Model::Serializable
+      attribute :lang, :string
+      attribute :source, :string
+      attribute :content, :string
+
+      xml do
+        root "documentation"
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_all to: :content
+        map_attribute :lang, to: :lang
+        map_attribute :source, to: :source
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/element.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Element < Model::Serializable
+      attribute :id, :string
+      attribute :ref, :string
+      attribute :name, :string
+      attribute :type, :string
+      attribute :form, :string
+      attribute :block, :string
+      attribute :final, :string
+      attribute :fixed, :string
+      attribute :default, :string
+      attribute :nillable, :string
+      attribute :abstract, :boolean, default: -> { false }
+      attribute :min_occurs, :string
+      attribute :max_occurs, :string
+      attribute :substitution_group, :string
+      attribute :annotation, Annotation
+      attribute :simple_type, SimpleType
+      attribute :complex_type, ComplexType
+      attribute :key, Key, collection: true
+      attribute :keyref, Keyref, collection: true
+      attribute :unique, Unique, collection: true
+
+      xml do
+        root "element", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :ref, to: :ref
+        map_attribute :name, to: :name
+        map_attribute :type, to: :type
+        map_attribute :form, to: :form
+        map_attribute :block, to: :block
+        map_attribute :final, to: :final
+        map_attribute :fixed, to: :fixed
+        map_attribute :default, to: :default
+        map_attribute :nillable, to: :nillable
+        map_attribute :abstract, to: :abstract
+        map_attribute :minOccurs, to: :min_occurs
+        map_attribute :maxOccurs, to: :max_occurs
+        map_attribute :substitutionGroup, to: :substitution_group
+        map_element :complexType, to: :complex_type
+        map_element :simpleType, to: :simple_type
+        map_element :annotation, to: :annotation
+        map_element :keyref, to: :keyref
+        map_element :unique, to: :unique
+        map_element :key, to: :key
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/enumeration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Enumeration < Model::Serializable
+      attribute :value, :string
+      attribute :annotation, Annotation
+
+      xml do
+        root "enumeration", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :value, to: :value
+        map_element :annotation, to: :annotation
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/extension_complex_content.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class ExtensionComplexContent < Model::Serializable
+      attribute :id, :string
+      attribute :base, :string
+      attribute :all, All
+      attribute :group, Group
+      attribute :choice, Choice
+      attribute :sequence, Sequence
+      attribute :annotation, Annotation
+      attribute :any_attribute, AnyAttribute
+      attribute :attribute, Attribute, collection: true
+      attribute :attribute_group, AttributeGroup, collection: true
+
+      xml do
+        root "extension", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :base, to: :base
+        map_element :all, to: :all
+        map_element :group, to: :group
+        map_element :choice, to: :choice
+        map_element :sequence, to: :sequence
+        map_element :attribute, to: :attribute
+        map_element :annotation, to: :annotation
+        map_element :any_attribute, to: :any_attribute
+        map_element :attributeGroup, to: :attribute_group
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/extension_simple_content.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class ExtensionSimpleContent < Model::Serializable
+      attribute :id, :string
+      attribute :base, :string
+      attribute :annotation, Annotation
+      attribute :any_attribute, AnyAttribute
+      attribute :attribute, Attribute, collection: true
+      attribute :attribute_group, AttributeGroup, collection: true
+
+      xml do
+        root "extension", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :base, to: :base
+        map_element :attribute, to: :attribute
+        map_element :annotation, to: :annotation
+        map_element :any_attribute, to: :any_attribute
+        map_element :attributeGroup, to: :attribute_group
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/field.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xsd
+    class Field < Model::Serializable
+      attribute :id, :string
+      attribute :xpath, :string
+
+      xml do
+        root "field", mixed: true
+        namespace "http://www.w3.org/2001/XMLSchema", "xsd"
+
+        map_attribute :id, to: :id
+        map_attribute :xpath, to: :xpath
+      end
+    end
+  end
+end