xsd 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3b12830c536c37e72b109727f470d45de29b6c852e62476cd3aa5578dd3b9c7
-  data.tar.gz: 248b65a3794a6c83a6aca695b0d565d55b971991272fd5f7f0a8a841fb8847ec
+  metadata.gz: dce377d21632c6a26b8cf654ec519d7fa7664a6518b136280433a1411580159c
+  data.tar.gz: 57ff6cd7eb787f93d1ab51b8ebcc170da4f9726105a584a3a9d69f24711fdd0d
 SHA512:
-  metadata.gz: ac15d2c2c163bd70f007fd76b5c007fbc786ed09d5609a2d6dba5aa8836144917a5159a32c1b7f47aa250bd18034d8339f445180fc4cd330745138ec60283e32
-  data.tar.gz: 7db0b9ac2ba0c97aab16d84db5145b4a8a18c901f3c24c8fd13a73b96a1998083a41cff38c3b0f7098dc53457b693e0ee5d3d941ceb1712f38a54924d32ce544
+  metadata.gz: 95c494a1699eee86c90989c1de42ef8f1532ea805273e1f35b2b7f2f6d68cc74f4a056ba1c71b5b3f3e9b7b80d9500b206fc684d4bddf4cb3563dda59d21fc48
+  data.tar.gz: d58a3a37ebd8104cbcd58eb416f127bd862f2c9e510bafafc83ffbefb257ce5ef1093d56db8a6ad0682137fbe9de04d67fa8d0e5d2b32f38a56e1b1a3fe0e0cc

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [2.3.0] - 2023-09-06
+
+- Fixed reading of SimpleType in List
+- Add support for Restriction without base
+- Support Any generation in simple scenarios
+
+## [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

data/Gemfile

@@ -12,4 +12,5 @@ group :development do
   gem 'rubocop-performance', '~> 1.17'
   gem 'rubocop-rake', '~> 0.6'
   gem 'rubocop-rspec', '~> 2.10'
+  gem 'wasabi', '~> 4.0'
 end

data/lib/xsd/base_object.rb

@@ -32,14 +32,6 @@ module XSD
       end
     end
 
-    # Optional. Specifies a unique ID for the element
-    # @!attribute id
-    # @return String
-    # property :id, :string
-    def id
-      node['id']
-    end
-
     def initialize(options = {})
       @options = options
       @cache   = {}
@@ -53,6 +45,20 @@ module XSD
       options[:node]
     end
 
+    # Get object string representation
+    # @return String
+    def inspect
+      "#<#{self.class.name} path=#{node.path}>"
+    end
+
+    # Optional. Specifies a unique ID for the element
+    # @!attribute id
+    # @return String
+    # property :id, :string
+    def id
+      node['id']
+    end
+
     # Get current namespaces
     # @return Hash
     def namespaces
@@ -62,20 +68,20 @@ module XSD
     # Get child nodes
     # @param [Symbol] name
     # @return Nokogiri::XML::NodeSet
-    def nodes(name = :*)
-      node.xpath("./xs:#{name}", { 'xs' => XML_SCHEMA })
+    def nodes(name = :*, deep = false)
+      node.xpath("./#{deep ? '/' : ''}xs:#{name}", { 'xs' => XML_SCHEMA })
     end
 
-    # Get schema by namespace or namespace prefix
-    # @param [String, nil] namespace
+    # Get schemas by namespace or prefix
+    # @param [String, nil] ns_or_prefix
     # @return Array<Schema>
-    def schemas_for_namespace(namespace)
-      if schema.targets_namespace?(namespace)
+    def schemas_for_namespace(ns_or_prefix)
+      if schema.targets_namespace?(ns_or_prefix)
         [schema, *schema.includes.map(&:imported_schema)]
-      elsif (import = schema.import_by_namespace(namespace))
+      elsif (import = schema.import_by_namespace(ns_or_prefix))
         [import.imported_schema]
       else
-        raise Error, "Schema not found for namespace '#{namespace}' in '#{schema.id || schema.target_namespace}'"
+        raise Error, "Schema not found for namespace '#{ns_or_prefix}' in '#{schema.id || schema.target_namespace}'"
       end
     end
 
@@ -187,7 +193,7 @@ module XSD
     # @param [Nokogiri::XML::Node] node
     # @return Array<String>
     def documentation_for(node)
-      node.xpath('./xs:annotation/xs:documentation/text()', { 'xs' => XML_SCHEMA }).map(&:to_s).map(&:strip)
+      node.xpath('./xs:annotation/xs:documentation/text()', { 'xs' => XML_SCHEMA }).map { |x| x.to_s.strip }
     end
 
     # Get all available elements on the current stack level
@@ -315,6 +321,9 @@ module XSD
         name = link[:property] ? send(link[:property]) : nil
         if name
           return @cache[method] = object_by_name(link[:type], name)
+        elsif is_a?(Restriction) && method == :base_simple_type
+          # handle restriction without base
+          return nil
         end
       end
 
@@ -346,5 +355,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/generator.rb

@@ -59,13 +59,13 @@ module XSD
       # configure namespaces
       # TODO: попытаться использовать collect_namespaces?
       attributes = {}
-      collect_attributes = element.collect_attributes
+      all_attributes = element.collect_attributes
       if element.complex?
-        collect_elements = element.collect_elements
+        all_elements = element.collect_elements
 
         # get namespaces for current element and it's children
         prefix = nil
-        [*collect_elements, element].each do |elem|
+        [*all_elements, element].each do |elem|
           prefix = get_namespace_prefix(elem, attributes, namespaces)
         end
       else
@@ -75,7 +75,7 @@ module XSD
       # iterate through each item
       data.each do |item|
         # prepare attributes
-        collect_attributes.each do |attribute|
+        all_attributes.each do |attribute|
           value = item["@#{attribute.name}"]
           if value
             attributes[attribute.name] = value
@@ -88,13 +88,18 @@ module XSD
         if element.complex?
           # generate tag recursively
           xml.tag!("#{prefix}:#{element.name}", attributes) do
-            collect_elements.each do |elem|
+            all_elements.each do |elem|
               build_element(xml, elem, item, namespaces.dup)
             end
           end
         else
-          value  = item.is_a?(Hash) ? item['#text'] : item
-          xml.tag!("#{prefix}:#{element.name}", attributes, (value == '' ? nil : value))
+          has_text = item.is_a?(Hash)
+          if has_text && element.complex_type&.nodes(:any, true)&.any?
+            xml.tag!("#{prefix}:#{element.name}", attributes) { |res| res << item['#text'].to_s }
+          else
+            value = has_text ? item['#text'] : item
+            xml.tag!("#{prefix}:#{element.name}", attributes, (value == '' ? nil : value))
+          end
         end
       end
     end
@@ -108,7 +113,7 @@ module XSD
       namespace = (element.referenced? ? element.reference : element).target_namespace
       prefix    = namespaces.key(namespace)
       unless prefix
-        prefix             = "tns#{@namespace_index += 1}"
+        prefix             = "n#{@namespace_index += 1}"
         namespaces[prefix] = attributes["xmlns:#{prefix}"] = namespace
       end
 
@@ -119,7 +124,7 @@ module XSD
     # @param [String, Array<String>, nil] lookup
     def find_root_element(lookup)
       if lookup
-        element = schema[*lookup]
+        element = self[*lookup]
         raise Error, "Cant find start element #{lookup}" unless element.is_a?(Element)
 
         element

data/lib/xsd/objects/list.rb

@@ -5,7 +5,7 @@ module XSD
   # Parent elements: simpleType
   # https://www.w3schools.com/xml/el_list.asp
   class List < BaseObject
-    TYPE_PROPERTY = :itemType
+    TYPE_PROPERTY = :item_type
 
     include SimpleTyped
 

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
@@ -108,23 +111,23 @@ 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, 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 loaded schemas
@@ -151,11 +154,121 @@ module XSD
       end.compact.flatten
     end
 
-    # Get import by namespace
+    # Get import by namespace or prefix
+    # @param [String, nil] ns_or_prefix
     # @return Import
-    def import_by_namespace(ns)
-      aliases = [ns, namespaces["xmlns:#{(ns || '').gsub(/^xmlns:/, '')}"], reader.namespace_prefixes[ns]].compact
+    def import_by_namespace(ns_or_prefix)
+      aliases = [
+        ns_or_prefix,
+        namespaces["xmlns:#{(ns_or_prefix || '').gsub(/^xmlns:/, '')}"]
+      ].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
+      return if processed.include?(schema.target_namespace)
+
+      processed.add(schema.target_namespace)
+
+      # prepare schema XML with all namespaces included, clone node to avoid mutating original schema
+      node = schema.node
+      if node.namespaces.size != node.namespace_definitions.size
+        prefixes = node.namespace_definitions.map(&:prefix)
+        node = schema.node.dup
+
+        schema.node.namespaces.each do |attr, ns|
+          prefix = attr == 'xmlns' ? nil : attr.sub('xmlns:', '')
+          # does not work!
+          # node.add_namespace_definition(prefix, ns) unless prefixes.include?(prefix)
+          node[attr] = ns unless prefixes.include?(prefix)
+        end
+      end
+
+      data = 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.1.0'
+  VERSION = '2.3.0'
 end

data/lib/xsd/xml.rb

@@ -6,9 +6,8 @@ require 'net/http'
 module XSD
   class XML
     include Generator
-    include Validator
 
-    attr_reader :options, :object_cache, :schemas, :namespace_prefixes
+    attr_reader :options, :object_cache, :schemas
 
     DEFAULT_RESOURCE_RESOLVER = proc do |location, namespace|
       if location =~ /^https?:/
@@ -75,10 +74,9 @@ module XSD
     end
 
     def initialize(**options)
-      @options            = options
-      @object_cache       = {}
-      @schemas            = []
-      @namespace_prefixes = {}
+      @options      = options
+      @object_cache = {}
+      @schemas      = []
     end
 
     def logger
@@ -116,24 +114,16 @@ module XSD
       new_schema
     end
 
-    # Add prefixes defined outside of processed schemas, for example in WSDL document
-    # @param [String] prefix
-    # @param [String] namespace
-    def add_namespace_prefix(prefix, namespace)
-      @namespace_prefixes[prefix] = namespace
-    end
-
     # Get first added (considered primary) schema
     # @return Schema, nil
     def schema
       schemas.first
     end
 
-    # Get schema by namespace or namespace prefix
+    # Get schemas by namespace
     # @param [String, nil] namespace
     # @return Array<Schema>
     def schemas_for_namespace(namespace)
-      namespace = namespace_prefixes[namespace] if namespace_prefixes.key?(namespace)
       schemas.select { |schema| schema.target_namespace == namespace }
     end
 

data/lib/xsd.rb

@@ -38,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.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - d.arkhipov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-10 00:00:00.000000000 Z
+date: 2023-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -109,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
@@ -135,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: The Ruby XSD library is an XML Schema implementation for Ruby.

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