xsd 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee4b9e2059eeb7c7109e687ca866c3617514e167f2d93de816d452fdf01be85b
-  data.tar.gz: ee5451af6e745dbdfffc55fa26329fd2c68b3257699a6e65fd923da3278769ea
+  metadata.gz: ab9eaf4eb6b8aacde5379acdc08cc16c3d85e3dc9d75a5887b2f1db05ea6ed58
+  data.tar.gz: 8c5fdbf108a6867689ff3292a5e208a33160f232b4a3d3a96eb55e42e9b6da7e
 SHA512:
-  metadata.gz: c937c9501cac27b7d1a003d34feec5fc927663656793c0e2a4abb62112f7b36ee7001532eccc1f1557913c23355feddab616a9df493fe2c7556fb3eaa74d50ce
-  data.tar.gz: 588d4649a016ed883a401447435a3a01512a610d1bc5b46b8abae0d6b0367ffe2369073f4f0f8bdb834643321f2a22eda196d89315d6e84f3b0222f4eee0c622
+  metadata.gz: d75af5531e7763eb3bc9359b2992e03704d963cfbc394a863022a3ff8db87d97db368409666bc7540f2fc772b78e2b25ab59905301e19d370827750050823462
+  data.tar.gz: 2b06fd643f69e41017683b689e614dbef7c42dca4fefbdec753f7f8edcc0978caf80eefe8c7d68e4acdc86aadd2777160a5cd7105a776d13ebfc2c57fc5af45c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [2.2.0] - 2023-07-10
+
+- Fixed built-in types detection for unprefixed schema namespace
+- Move validation to Schema object
+
+## [2.1.0] - 2023-07-10
+
+- Add support for <xs:include> element
+- Changed method "schema_for_namespace(namespace) -> XSD::Schema" signature to "schemas_for_namespace(namespace) -> Array<XSD::Schema>"
+
 ## [2.0.0] - 2023-07-07
 
 - Change XSD::XML.new(file, **options) -> XSD::XML.open(file, **options)

data/README.md

@@ -28,20 +28,29 @@ require 'xsd'
 # Load ruby-xsd
 reader = XSD::XML.open('some.xsd')
 
+# Get elements and their child elements
+element = reader['NewReleaseMessage']
+element.collect_elements.map(&:name) # => ['MessageHeader', 'UpdateIndicator', 'IsBackfill', 'CatalogTransfer', 'WorkList', 'CueSheetList', 'ResourceList', 'CollectionList', 'ReleaseList', 'DealList']
+
 # Get attributes
 attribute = reader['NewReleaseMessage']['@MessageSchemaVersionId']
 
-# Get atrribute information
+# Get attribute information
 attribute.name # => 'MessageSchemaVersionId'
 attribute.type # => 'xs:string'
 attribute.required? # => true
+attribute.optional? # => false
+attribute.prohibited? # => true
 
 # Get element information
-element = reader['NewReleaseMessage']['ResourceList']['SoundRecording']
+element = reader['NewReleaseMessage']['ResourceList']['SoundRecording'] # => XSD::Element
 element.min_occurs # => 0
 element.max_occurs # => :unbounded
 element.type # => 'ern:SoundRecording'
 element.complex_type # => XSD::ComplexType
+element.complex? # => true
+element.multiple_allowed? # => true
+element.required? # => false
 ```
 
 ## Development

data/lib/xsd/base_object.rb

@@ -67,13 +67,13 @@ module XSD
     end
 
     # Get schema by namespace or namespace prefix
-    # @param [String] namespace
-    # @return Schema
-    def schema_for_namespace(namespace)
+    # @param [String, nil] namespace
+    # @return Array<Schema>
+    def schemas_for_namespace(namespace)
       if schema.targets_namespace?(namespace)
-        schema
+        [schema, *schema.includes.map(&:imported_schema)]
       elsif (import = schema.import_by_namespace(namespace))
-        import.imported_schema
+        [import.imported_schema]
       else
         raise Error, "Schema not found for namespace '#{namespace}' in '#{schema.id || schema.target_namespace}'"
       end
@@ -112,12 +112,15 @@ module XSD
       return nil if schema.namespace_prefix == name_prefix
 
       # determine schema for namespace
-      search_schema = schema_for_namespace(name_prefix)
+      search_schemas = schemas_for_namespace(name_prefix)
 
       # find element in target schema
-      result = search_schema.node.xpath("./xs:#{node_name}[@name=\"#{name_local}\"]", { 'xs' => XML_SCHEMA }).first
+      search_schemas.each do |s|
+        node = s.node.xpath("./xs:#{node_name}[@name=\"#{name_local}\"]", { 'xs' => XML_SCHEMA }).first
+        return s.node_to_object(node) if node
+      end
 
-      result ? search_schema.node_to_object(result) : nil
+      nil
     end
 
     # Get reader object for node
@@ -169,9 +172,9 @@ module XSD
 
     # Get namespace prefix from node name
     # @param [String, nil] name Name to strip from
-    # @return String
+    # @return String, nil
     def get_prefix(name)
-      name&.include?(':') ? name.split(':').first : ''
+      name&.include?(':') ? name.split(':').first : nil
     end
 
     # Return element documentation
@@ -343,5 +346,12 @@ module XSD
         name.to_sym
       end
     end
+
+    # Return string if it is not empty, or nil otherwise
+    # @param [String, nil] string
+    # @return String, nil
+    def nil_if_empty(string)
+      string&.empty? ? nil : string
+    end
   end
 end

data/lib/xsd/objects/extension.rb

@@ -8,7 +8,26 @@ module XSD
     TYPE_PROPERTY = nil
 
     include Based
-    include SimpleTyped
     include AttributeContainer
+
+    # Nested group
+    # @!attribute group
+    # @return Group
+    child :group, :group
+
+    # Nested all
+    # @!attribute all
+    # @return All
+    child :all, :all
+
+    # Nested choice
+    # @!attribute choice
+    # @return Choice
+    child :choice, :choice
+
+    # Nested sequence
+    # @!attribute sequence
+    # @return Sequence
+    child :sequence, :sequence
   end
 end

data/lib/xsd/objects/import.rb

@@ -16,23 +16,23 @@ module XSD
     property :schemaLocation, :string
 
     # Get imported schema
-    # @return XSD:Schema
+    # @return Schema
     def imported_schema
-      schema = reader.schema_for_namespace(namespace)
-      return schema if schema
+      known_schemas = reader.schemas_for_namespace(namespace)
+      return known_schemas.first if known_schemas.any?
 
       unless schema_location
         raise ImportError, "Schema location not provided for namespace '#{namespace}', use add_schema_xml()/add_schema_node()"
       end
 
       xml = reader.resource_resolver.call(schema_location, namespace)
-      schema = reader.add_schema_xml(xml)
+      new_schema = reader.add_schema_xml(xml)
 
-      unless namespace == schema.target_namespace
-        raise ImportError, 'Import location does not match imported schema targetNamespace'
+      unless namespace == new_schema.target_namespace
+        raise ImportError, 'Import namespace does not match imported schema targetNamespace'
       end
 
-      schema
+      new_schema
     end
   end
 end

data/lib/xsd/objects/include.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module XSD
+  # The include element is used to add multiple schemas with the same target namespace to a document.
+  # Parent elements: schema
+  # https://www.w3schools.com/xml/el_include.asp
+  class Include < BaseObject
+    # Required. Specifies the URI to the schema to include in the target namespace of the containing schema
+    # @!attribute schema_location
+    # @return String
+    property :schemaLocation, :string
+
+    # Get imported schema
+    # @return Schema
+    def imported_schema
+      # cache included schema locally as it has no unique namespace to check in global registry
+      return @imported_schema if @imported_schema
+
+      xml = reader.resource_resolver.call(schema_location)
+      new_schema = reader.add_schema_xml(xml)
+
+      unless schema.target_namespace == new_schema.target_namespace
+        raise ImportError, 'Schema targetNamespace does not match included schema targetNamespace'
+      end
+
+      @imported_schema = new_schema
+    end
+  end
+end

data/lib/xsd/objects/restriction.rb

@@ -16,6 +16,26 @@ module XSD
       fractionDigits length minLength maxLength enumeration whiteSpace pattern
     ].freeze
 
+    # Nested group
+    # @!attribute group
+    # @return Group
+    child :group, :group
+
+    # Nested all
+    # @!attribute all
+    # @return All
+    child :all, :all
+
+    # Nested choice
+    # @!attribute choice
+    # @return Choice
+    child :choice, :choice
+
+    # Nested sequence
+    # @!attribute sequence
+    # @return Sequence
+    child :sequence, :sequence
+
     # Get restriction facets
     # @return Hash
     def facets

data/lib/xsd/objects/schema.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'tmpdir'
+require 'securerandom'
+
 module XSD
   # The schema element defines the root element of a schema.
   # Parent elements: NONE
@@ -85,6 +88,11 @@ module XSD
     # @return Array<Import>
     child :imports, [:import]
 
+    # Schema includes
+    # @!attribute includes
+    # @return Array<Include>
+    child :includes, [:include]
+
     # Get current schema object
     # @return Schema
     def schema
@@ -103,43 +111,44 @@ module XSD
       attributes
     end
 
-    # Get target namespace prefix. There may be more than one prefix, but we return only first defined
-    # @return String
+    # Get target namespace prefix
+    # @return String, nil
     def target_namespace_prefix
-      @target_namespace_prefix ||= namespaces.key(target_namespace)&.sub(/^xmlns:?/, '') || ''
+      nil_if_empty(@target_namespace_prefix ||= namespaces.key(target_namespace)&.sub(/^xmlns:?/, '') || '')
     end
 
     # Get schema namespace prefix
-    # @return String
+    # @return String, nil
     def namespace_prefix
-      @namespace_prefix ||= namespaces.key(XML_SCHEMA).sub(/^xmlns:?/, '')
+      nil_if_empty(@namespace_prefix ||= namespaces.key(XML_SCHEMA).sub(/^xmlns:?/, ''))
     end
 
     # Check if namespace is a target namespace
-    # @param [String] namespace
+    # @param [String, nil] namespace
     # @return Boolean
     def targets_namespace?(namespace)
-      namespace == target_namespace || namespaces[namespace.empty? ? 'xmlns' : "xmlns:#{namespace}"] == target_namespace
+      namespace == target_namespace || namespaces[namespace.nil? ? 'xmlns' : "xmlns:#{namespace}"] == target_namespace
     end
 
-    # Override map_children on schema to get objects from all imported schemas
+    # Override map_children on schema to get objects from all loaded 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
+    # Get children from all loaded schemas
     # @param [Symbol] name
     # @return Array<BaseObject>
     def import_map_children(name, cache)
-      return [] if name.to_sym == :import
+      return [] if %i[import include].include?(name.to_sym)
 
-      imports.map do |import|
-        if cache[import.namespace]
+      (includes + imports).map do |import|
+        key = import.respond_to?(:namespace) && import.namespace ? import.namespace : import.schema_location
+        if cache.key?(key)
           nil
         else
-          cache[import.namespace] = true
+          cache[key] = true
           import.imported_schema.map_children(name, cache)
         end
       end.compact.flatten
@@ -151,5 +160,97 @@ module XSD
       aliases = [ns, namespaces["xmlns:#{(ns || '').gsub(/^xmlns:/, '')}"], reader.namespace_prefixes[ns]].compact
       imports.find { |import| aliases.include?(import.namespace) }
     end
+
+    # Validate XML against current schema
+    # @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 current schema against 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', reader.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(schema.node.to_xml)
+      # end
+
+      @schema_validator
+    end
+
+    # Сформировать имена файлов и содержимое XSD схем для корректной валидации
+    # @param [Schema] schema
+    # @param [String] file
+    # @param [Set] processed
+    def recursive_import_xsd(schema, file, processed, &block)
+      # handle recursion
+      namespace = schema.target_namespace
+      return if processed.include?(namespace)
+
+      processed.add(namespace)
+
+      data = schema.node.to_xml
+
+      schema.imports.each do |import|
+        name      = "#{::SecureRandom.urlsafe_base64}.xsd"
+        location  = import.schema_location
+        namespace = import.namespace
+
+        if location
+          data = data.sub("schemaLocation=\"#{location}\"", "schemaLocation=\"#{name}\"")
+        else
+          data = data.sub("namespace=\"#{namespace}\"", "namespace=\"#{namespace}\" schemaLocation=\"#{name}\"")
+        end
+        recursive_import_xsd(import.imported_schema, name, processed, &block)
+      end
+
+      block.call(file, data)
+    end
+
+    # Create Nokogiri XML Schema instance with preconfigured options
+    # @param [IO, String] io
+    def create_xml_schema(io)
+      Nokogiri::XML::Schema(io, Nokogiri::XML::ParseOptions.new.nononet)
+    end
   end
 end

data/lib/xsd/version.rb

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

data/lib/xsd/xml.rb

@@ -6,7 +6,6 @@ require 'net/http'
 module XSD
   class XML
     include Generator
-    include Validator
 
     attr_reader :options, :object_cache, :schemas, :namespace_prefixes
 
@@ -31,6 +30,7 @@ module XSD
       'complexContent' => ComplexContent,
       'extension'      => Extension,
       'import'         => Import,
+      'include'        => Include,
       'simpleType'     => SimpleType,
       'all'            => All,
       'restriction'    => Restriction,
@@ -63,6 +63,10 @@ module XSD
       'pattern'        => Facet
     }.freeze
 
+    # Create reader from a file path
+    # @param [String] path
+    # @param [Hash] options
+    # @return XML
     def self.open(path, **options)
       reader = new(**options)
       reader.add_schema_xml(File.read(path))
@@ -92,8 +96,8 @@ module XSD
       Nokogiri::XML(xml)
     end
 
-    # Get imported schema
-    # @return XSD:Schema
+    # Add schema xml to reader instance
+    # @return Schema
     def add_schema_xml(xml)
       doc = read_document(xml)
       raise Error, 'Schema node not found, xml does not seem to be a valid XSD' unless doc.root&.name == 'schema'
@@ -101,15 +105,14 @@ module XSD
       add_schema_node(doc.root)
     end
 
-    # Get imported schema
+    # Add schema node to reader instance
     # @return Schema
     def add_schema_node(node)
       raise Error, 'Added schema must be of type Nokogiri::XML::Node' unless node.is_a?(Nokogiri::XML::Node)
 
-      schema = Schema.new(self.options.merge(node: node, reader: self))
-      schemas.push(schema)
-
-      schema
+      new_schema = Schema.new(options.merge(node: node, reader: self))
+      schemas.push(new_schema)
+      new_schema
     end
 
     # Add prefixes defined outside of processed schemas, for example in WSDL document
@@ -126,10 +129,11 @@ module XSD
     end
 
     # Get schema by namespace or namespace prefix
-    # @return Schema, nil
-    def schema_for_namespace(namespace)
+    # @param [String, nil] namespace
+    # @return Array<Schema>
+    def schemas_for_namespace(namespace)
       namespace = namespace_prefixes[namespace] if namespace_prefixes.key?(namespace)
-      schemas.find { |schema| schema.target_namespace == namespace }
+      schemas.select { |schema| schema.target_namespace == namespace }
     end
 
     def [](*args)

data/lib/xsd.rb

@@ -18,6 +18,7 @@ require 'xsd/objects/simple_content'
 require 'xsd/objects/complex_content'
 require 'xsd/objects/extension'
 require 'xsd/objects/import'
+require 'xsd/objects/include'
 require 'xsd/objects/restriction'
 require 'xsd/objects/group'
 require 'xsd/objects/all'
@@ -37,6 +38,5 @@ require 'xsd/objects/any_attribute'
 require 'xsd/objects/key'
 require 'xsd/objects/keyref'
 require 'xsd/generator'
-require 'xsd/validator'
 require 'xsd/exceptions'
 require 'xsd/xml'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xsd
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - d.arkhipov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -90,6 +90,7 @@ files:
 - lib/xsd/objects/field.rb
 - lib/xsd/objects/group.rb
 - lib/xsd/objects/import.rb
+- lib/xsd/objects/include.rb
 - lib/xsd/objects/key.rb
 - lib/xsd/objects/keyref.rb
 - lib/xsd/objects/list.rb
@@ -108,7 +109,6 @@ files:
 - lib/xsd/shared/min_max_occurs.rb
 - lib/xsd/shared/referenced.rb
 - lib/xsd/shared/simple_typed.rb
-- lib/xsd/validator.rb
 - lib/xsd/version.rb
 - lib/xsd/xml.rb
 - xsd.gemspec

data/lib/xsd/validator.rb

@@ -1,90 +0,0 @@
-# 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