xsd 1.0.0

data/lib/xsd/objects/schema.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module XSD
+  # The schema element defines the root element of a schema.
+  # Parent elements: NONE
+  # https://www.w3schools.com/xml/el_schema.asp
+  class Schema < BaseObject
+    include AttributeContainer
+    include ElementContainer
+
+    # Optional. The form for attributes declared in the target namespace of this schema. The value must be "qualified"
+    # or "unqualified". Default is "unqualified". "unqualified" indicates that attributes from the target namespace
+    # are not required to be qualified with the namespace prefix. "qualified" indicates that attributes from the target
+    # namespace must be qualified with the namespace prefix
+    # @!attribute attribute_form_default
+    # @return [String]
+    property :attributeFormDefault, :string, default: 'unqualified'
+
+    # Optional. The form for elements declared in the target namespace of this schema. The value must be "qualified"
+    # or "unqualified". Default is "unqualified". "unqualified" indicates that elements from the target namespace are
+    # not required to be qualified with the namespace prefix. "qualified" indicates that elements from the target
+    # namespace must be qualified with the namespace prefix
+    # @!attribute element_form_default
+    # @return [String]
+    property :elementFormDefault, :string, default: 'unqualified'
+
+    # Optional. Specifies the default value of the block attribute on element and complexType elements in the target
+    # namespace. The block attribute prevents a complex type (or element) that has a specified type of derivation from
+    # being used in place of this complex type. This value can contain #all or a list that is a subset of extension,
+    # restriction, or substitution:
+    #   extension - prevents complex types derived by extension
+    #   restriction - prevents complex types derived by restriction
+    #   substitution - prevents substitution of elements
+    #   #all - prevents all derived complex types
+    # @!attribute block_default
+    # @return [String]
+    property :blockDefault, :string
+
+    # Optional. Specifies the default value of the final attribute on element, simpleType, and complexType elements in
+    # the target namespace. The final attribute prevents a specified type of derivation of an element, simpleType, or
+    # complexType element. For element and complexType elements, this value can contain #all or a list that is a subset
+    # of extension or restriction. For simpleType elements, this value can additionally contain list and union:
+    #   extension - prevents derivation by extension
+    #   restriction - prevents derivation by restriction
+    #   list - prevents derivation by list
+    #   union - prevents derivation by union
+    #   #all - prevents all derivation
+    # @!attribute final_default
+    # @return [String]
+    property :finalDefault, :string
+
+    # Optional. A URI reference of the namespace of this schema
+    # @!attribute target_namespace
+    # @return [String]
+    property :targetNamespace, :string
+
+    # Optional. Specifies the version of the schema
+    # @!attribute version
+    # @return [String]
+    property :version, :string
+
+    # A URI reference that specifies one or more namespaces for use in this schema. If no prefix is assigned, the schema
+    # components of the namespace can be used with unqualified references
+    # @!attribute xmlns
+    # @return [String]
+    property :xmlns, :string
+
+    # Global complex types
+    # @!attribute complex_types
+    # @return [Array<ComplexType>]
+    child :complex_types, [:complexType]
+
+    # Global simple types
+    # @!attribute simple_types
+    # @return [Array<SimpleType>]
+    child :simple_types, [:simpleType]
+
+    # Global groups
+    # @!attribute groups
+    # @return [Array<Group>]
+    child :groups, [:group]
+
+    # Get nested groups
+    # @!attribute imports
+    # @return [Array<Import>]
+    child :imports, [:import]
+
+    # Get current schema object
+    # @return [Schema]
+    def schema
+      self
+    end
+
+    # Get all available root elements. Overrides base implementation for better speed
+    # @return [Array<Element>]
+    def all_elements(*)
+      elements
+    end
+
+    # Get all available root attributes. Overrides base implementation for better speed
+    # @return [Array<Attribute>]
+    def all_attributes(*)
+      attributes
+    end
+
+    # Get target namespace prefix. There may be more than one prefix, but we return only first defined
+    # @return [String]
+    def target_namespace_prefix
+      @target_namespace_prefix ||= namespaces.key(target_namespace)&.sub(/^xmlns:?/, '') || ''
+    end
+
+    # Get schema namespace prefix
+    # @return [String]
+    def namespace_prefix
+      @namespace_prefix ||= namespaces.key(XML_SCHEMA).sub(/^xmlns:?/, '')
+    end
+
+    # Check if namespace is a target namespace
+    # @param [String] prefix
+    # @return [Boolean]
+    def targets_namespace?(prefix)
+      namespaces[prefix.empty? ? 'xmlns' : "xmlns:#{prefix}"] == target_namespace
+    end
+
+    # Override map_children on schema to get objects from all imported schemas
+    # @param [Symbol] name
+    # @return [Array<BaseObject>]
+    def map_children(name, cache = {})
+      super(name) + import_map_children(name, cache)
+    end
+
+    # Get children from all imported schemas
+    # @param [Symbol] name
+    # @return [Array<BaseObject>]
+    # TODO: better recursion handling, may be refactor needed 1 reader for all schemas with centralized cache
+    def import_map_children(name, cache)
+      return [] if name.to_sym == :import
+
+      imports.map do |import|
+        if cache[import.namespace]
+          reader.logger.debug(XSD) { "Schema '#{import.namespace}' already parsed, skiping" }
+          nil
+        else
+          cache[import.namespace] = true
+          import.imported_reader.schema.map_children(name, cache)
+        end
+      end.compact.flatten
+    end
+
+    def import_by_namespace(ns)
+      aliases = [ns, namespaces["xmlns:#{(ns || '').gsub(/^xmlns:/, '')}"]].compact
+      imports.find { |import| aliases.include?(import.namespace) }
+    end
+  end
+end

data/lib/xsd/objects/selector.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module XSD
+  # The selector element specifies an XPath expression that selects a set of elements for an identity constraint
+  # (unique, key, and keyref elements).
+  # Parent elements: key, keyref, unique
+  # https://www.w3schools.com/xml/el_selector.asp
+  class Selector < BaseObject
+    # Required. Specifies an XPath expression, relative to the element being declared, that identifies the child
+    # elements to which the identity constraint applies
+    # @!attribute xpath
+    # @return [String]
+    property :xpath, :string, required: true
+  end
+end

data/lib/xsd/objects/sequence.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module XSD
+  # The sequence element specifies that the child elements must appear in a sequence.
+  # Each child element can occur from 0 to any number of times.
+  # Parent elements: group, choice, sequence, complexType, restriction (both simpleContent and complexContent),
+  # extension (both simpleContent and complexContent)
+  # https://www.w3schools.com/xml/el_sequence.asp
+  class Sequence < BaseObject
+    include MinMaxOccurs
+    include ElementContainer
+
+    # Nested groups
+    # @!attribute groups
+    # @return [Array<Group>]
+    child :groups, [:group]
+
+    # Nested choices
+    # @!attribute choices
+    # @return [Array<Choice>]
+    child :choices, [:choice]
+
+    # Nested sequences
+    # @!attribute sequences
+    # @return [Array<Sequence>]
+    child :sequences, [:sequence]
+
+    # Nested anys
+    # @!attribute anys
+    # @return [Array<Any>]
+    child :anys, [:any]
+  end
+end

data/lib/xsd/objects/simple_content.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module XSD
+  # The simpleContent element contains extensions or restrictions on a text-only complex type or on a simple type as
+  # content and contains no elements.
+  # Parent elements: complexType
+  # https://www.w3schools.com/xml/el_simpleContent.asp
+  class SimpleContent < BaseObject
+    # Nested extension
+    # @!attribute extension
+    # @return [Extension, nil]
+    child :extension, :extension
+
+    # Nested restriction
+    # @!attribute restriction
+    # @return [Restriction, nil]
+    child :restriction, :restriction
+  end
+end

data/lib/xsd/objects/simple_type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module XSD
+  # The simpleType element defines a simple type and specifies the constraints and information about the values
+  # of attributes or text-only elements.
+  # Parent elements: attribute, element, list, restriction, schema, union
+  # https://www.w3schools.com/xml/el_simpletype.asp
+  class SimpleType < BaseObject
+    # Optional. Specifies the name of the attribute. Name and ref attributes cannot both be present
+    # @!attribute name
+    # @return [String]
+    property :name, :string
+
+    # Nested restriction
+    # @!attribute restriction
+    # @return [Restriction, nil]
+    child :restriction, :restriction
+
+    # Nested union
+    # @!attribute union
+    # @return [Union, nil]
+    child :union, :union
+
+    # Nested list
+    # @!attribute list
+    # @return [List, nil]
+    child :list, :list
+
+    # Determine if this is a linked type
+    # @return [Boolean]
+    def linked?
+      !name.nil?
+    end
+  end
+end

data/lib/xsd/objects/union.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module XSD
+  # The union element defines a simple type as a collection (union) of values from specified simple data types.
+  # Parent elements: simpleType
+  # https://www.w3schools.com/xml/el_union.asp
+  class Union < BaseObject
+    # Optional. Specifies a list of built-in data types or simpleType elements defined in a schema
+    # @!attribute member_types
+    # @return [Array<String>]
+    property :memberTypes, :array, default: [] do |union|
+      union.node['memberTypes']&.split(' ')
+    end
+
+    # Nested simple and built-in types
+    # @return [Array<SimpleType, String>]
+    def types
+      @types ||= map_children(:simpleType) + member_types.map do |name|
+        object_by_name(:simpleType, name) || name
+      end
+    end
+  end
+end

data/lib/xsd/objects/unique.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module XSD
+  # The unique element defines that an element or an attribute value must be unique within the scope.
+  # Parent elements: element
+  # https://www.w3schools.com/xml/el_unique.asp
+  class Unique < BaseObject
+    # Get nested selector object
+    # @!attribute selector
+    # @return [Selector]
+    child :selector, :selector
+
+    # Get nested field objects
+    # @!attribute fields
+    # @return [Array<Field>]
+    child :fields, [:field]
+  end
+end

data/lib/xsd/shared/attribute_container.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module XSD
+  module AttributeContainer
+    # Nested attributes
+    # @!attribute attributes
+    # @return [Array<Attribute>]
+
+    # Nested attribute groups
+    # @!attribute attribute_groups
+    # @return [Array<AttributeGroup>]
+    def self.included(obj)
+      obj.child :attributes, [:attribute]
+      obj.child :attribute_groups, [:attributeGroup]
+    end
+  end
+end

data/lib/xsd/shared/based.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module XSD
+  # Used by extension and restriction elements
+  module Based
+    # Required. Specifies the name of a built-in data type, a simpleType element, or a complexType element
+    # @!attribute base
+    # @return [String]
+
+    # Base complexType
+    # @!attribute base_complex_type
+    # @return [ComplexType, nil]
+
+    # Base simpleType
+    # @!attribute base_simple_type
+    # @return [SimpleType, nil]
+    def self.included(obj)
+      obj.property :base, :string, required: true
+      obj.link :base_complex_type, :complexType, property: :base
+      obj.link :base_simple_type, :simpleType, property: :base
+    end
+
+    # Get all available elements on the current stack level, optionally including base type elements
+    # @param [Boolean] include_base
+    # @return [Array<Element>]
+    def all_elements(include_base = true)
+      (include_base && base_complex_type ? base_complex_type.all_elements : []) + super
+    end
+
+    # Get all available attributes on the current stack level, optionally including base type attributes
+    # @param [Boolean] include_base
+    # @return [Array<Attribute>]
+    def all_attributes(include_base = true)
+      (include_base && base_complex_type ? base_complex_type.all_attributes : []) + super
+    end
+  end
+end

data/lib/xsd/shared/complex_typed.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module XSD
+  # Provides object an ability to have complex type (nested or linked)
+  module ComplexTyped
+    # Child/linked complex type
+    # @!attribute complex_type
+    # @return [ComplexType, nil]
+    def self.included(obj)
+      obj.child :complex_type, :complexType
+      obj.link :complex_type, :complexType, property: obj::TYPE_PROPERTY
+    end
+
+    # Get all available elements on the current stack level or linked type elements
+    # @param [Boolean] linked_type
+    # @return [Array<Element>]
+    def all_elements(linked_type = true)
+      (linked_type && complex_type&.linked? ? complex_type.all_elements : super)
+    end
+
+    # Get all available attributes on the current stack level or linked type attributes
+    # @param [Boolean] linked_type
+    # @return [Array<Attribute>]
+    def all_attributes(linked_type = true)
+      (linked_type && complex_type&.linked? ? complex_type.all_attributes : super)
+    end
+  end
+end

data/lib/xsd/shared/element_container.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module XSD
+  module ElementContainer
+    # Nested elements
+    # @!attribute elements
+    # @return [Array<Element>]
+    def self.included(obj)
+      obj.child :elements, [:element]
+    end
+  end
+end

data/lib/xsd/shared/min_max_occurs.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module XSD
+  module MinMaxOccurs
+    # Optional. Specifies the minimum number of times the choice element can occur in the parent the element.
+    # The value can be any number >= 0. Default value is 1
+    # @!attribute min_occurs
+    # @return [Integer]
+
+    # Optional. Specifies the maximum number of times the choice element can occur in the parent element.
+    # The value can be any number >= 0, or if you want to set no limit on the maximum number, use the value "unbounded".
+    # Default value is 1
+    # @!attribute max_occurs
+    # @return [Integer, Symbol]
+    def self.included(obj)
+      obj.property :minOccurs, :integer, default: 1
+      obj.property :maxOccurs, :integer, default: 1
+    end
+
+    # Compute actual max_occurs accounting parents
+    # @return [Integer, Symbol]
+    def computed_max_occurs
+      @computed_max_occurs ||= if parent.is_a?(MinMaxOccurs)
+                                 if max_occurs == :unbounded || parent.computed_max_occurs == :unbounded
+                                   :unbounded
+                                 else
+                                   [max_occurs, parent.computed_max_occurs].max
+                                 end
+                               else
+                                 max_occurs
+                               end
+    end
+
+    # Compute actual min_occurs accounting parents
+    # @return [Integer]
+    def computed_min_occurs
+      @computed_min_occurs ||= if parent.is_a?(Choice)
+                                 0
+                               elsif parent.is_a?(MinMaxOccurs)
+                                 [min_occurs, parent.computed_min_occurs].min
+                               else
+                                 min_occurs
+                               end
+    end
+  end
+end

data/lib/xsd/shared/referenced.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module XSD
+  module Referenced
+    # Optional. Specifies a reference to a named attribute. Name and ref attributes cannot both be present.
+    # If ref is present, simpleType element, form, and type cannot be present
+    # @!attribute ref
+    # @return [String]
+
+    # Reference object
+    # @!attribute reference
+    # @return [BaseObject]
+    def self.included(obj)
+      obj.property :ref, :string
+      obj.link :reference, obj.mapped_name, property: :ref
+    end
+
+    # Is object referenced?
+    # @return [Boolean]
+    def referenced?
+      !ref.nil?
+    end
+  end
+end

data/lib/xsd/shared/simple_typed.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module XSD
+  # Provides object an ability to have simple type (nested or linked)
+  module SimpleTyped
+    # Get child/linked simple type
+    # @!attribute simple_type
+    # @return [SimpleType, nil]
+    def self.included(obj)
+      obj.child :simple_type, :simpleType
+      obj.link :simple_type, :simpleType, property: obj::TYPE_PROPERTY
+    end
+  end
+end

data/lib/xsd/validator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module XSD
+  module Validator
+    # Validate XML against XSD
+    # @param [String, Pathname, Nokogiri::XML::Document] xml
+    def validate_xml(xml)
+      # validate input
+      raise ValidationError unless xml.is_a?(Nokogiri::XML::Document) || xml.is_a?(Pathname) || xml.is_a?(String)
+
+      begin
+        document = xml.is_a?(Nokogiri::XML::Document) ? xml : Nokogiri::XML(xml)
+      rescue Nokogiri::XML::SyntaxError => e
+        raise ValidationError, e
+      end
+
+      errors = schema_validator.validate(document)
+      raise ValidationError, errors.map(&:message).join('; ') if errors.any?
+    end
+
+    # Validate XSD against another XSD (by default uses XMLSchema 1.0)
+    def validate
+      begin
+        schema_validator
+      rescue Nokogiri::XML::SyntaxError => e
+        # TODO: display import map name for imported_xsd
+        message = e.message + (e.file ? " in file '#{File.basename(e.file)}'" : '')
+        raise ValidationError, message
+      end
+    end
+
+    private
+
+    # Get Nokogiri::XML::Schema object to validate against
+    # @return [Nokogiri::XML::Schema]
+    def schema_validator
+      return @schema_validator if @schema_validator
+
+      if !imported_xsd.empty?
+        # imports are explicitly provided - put all files in one tmpdir and update import paths appropriately
+        # TODO: save file/path map to display in errors
+        Dir.mktmpdir('XSD', tmp_dir) do |dir|
+          # create primary xsd file
+          file = "#{SecureRandom.urlsafe_base64}.xsd"
+
+          # create imported xsd files
+          recursive_import_xsd(self, file, Set.new) do |f, data|
+            File.write("#{dir}/#{f}", data)
+          end
+
+          # read schema from tmp file descriptor
+          io = File.open("#{dir}/#{file}")
+          @schema_validator = create_xml_schema(io)
+        end
+      else
+        @schema_validator = create_xml_schema(self.xsd)
+      end
+
+      @schema_validator
+    end
+
+    # Сформировать имена файлов и содержимое XSD схем для корректной валидации
+    # @param [XML] reader
+    # @param [String] file
+    # @param [Set] processed
+    def recursive_import_xsd(reader, file, processed, &block)
+      # handle recursion
+      namespace = reader.schema.target_namespace
+      return if processed.include?(namespace)
+
+      processed.add(namespace)
+
+      data = reader.xml
+
+      reader.imports.each do |import|
+        name = "#{SecureRandom.urlsafe_base64}.xsd"
+        data = data.sub("schemaLocation=\"#{import.schema_location}\"", "schemaLocation=\"#{name}\"")
+        recursive_import_xsd(import.imported_reader, name, processed, &block)
+      end
+
+      block.call(file, data)
+    end
+
+    # Create Nokogiri XML Schema instance with preconfigured options
+    # @param [IO] io
+    def create_xml_schema(io)
+      Nokogiri::XML::Schema(io, Nokogiri::XML::ParseOptions.new.nononet)
+    end
+  end
+end

data/lib/xsd/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module XSD
+  VERSION = '1.0.0'
+end