validate_xml_xsi 0.2.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4252059ac1bc3c6ae4aa11ca57703dea71d54a107483129d76955f371a6b56b7
-  data.tar.gz: a1c8bf3d962e546e85d8a39a156d562144df7b12a6c38724e74d264287ac304c
+  metadata.gz: dbe79de11a54ebfff237869fbef6f4ccb9ce8b063dc3305299cb1fcb7856298b
+  data.tar.gz: 549031f8aa72adca7434f9294bfef40e2b2ce70b8980b04960cd20ab320dace4
 SHA512:
-  metadata.gz: dbc3ee5c3c8d136b280b8bf7414934c4b8d1e18b2f6ae37a92ff5314bd1ce9028528c69876c64b52ebe8a3d54ed579255c7de327118e5ebaf6b73ccea4b02af1
-  data.tar.gz: d1524cf149f1439ecab4215100de7718465b5a7147796382ecaf42fd08a63030a584bfe6c39d0f46cf298c07f1128b885f75c78dfe3c0d4566a1a0f47ae4a97c
+  metadata.gz: 1336127c5245a94b7a8915f5d87372e17ab52bad43c32d1c07ef165d26db0ca1182baefcc826bd58cd401e213a2f7c04129dfea28d7c950d9fe1e06e2bb6780a
+  data.tar.gz: b60f8dcc6904c9b706f338a7afa7438fd98b7029a2a06b9f07010a63e3cddd1f0913bad0bc5ec2d608c3446c137339bb2ae8640251e7b4775ac006b9799e0c75

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## v0.3.0
+
+* Change overall structure to make XML_XSI::Schema a normal class (not just a singleton)
+* Allow the Schema to return the xsd document string (so it can be used externally to build a XSD document tree)
+
+## v0.2.4
+
+* Fix some silly syntax errors
+
 ## v0.2.3
 
 * Rename XML_XSI::Schema::parse_schema to just XML_XSI::Schema::parse

data/README.md

@@ -1,12 +1,12 @@
 # validate_xml_xsi
 
-This gem validates XML against it's xsi using the xsi:schemaLocation elements to define the location of XSD documents.
+This gem validates XML against it's XSD that is created from xsi:schemaLocation elements.
 
-It does this by first parsing the XML and searching for xsi:schemaLocation elements and then creating a schema document that imports the XSD's identified in the XML.
+It does this by first parsing the XML and searching for elements that include xsi:schemaLocation attributes. It then creates an XSD schema document that includes the root namespace and further imports additional namespaces discovered in the XML.
 
-It then validates the document against that schema and outputs any error messages.
+It then validates the document against that constructed schema document and outputs any error messages.
 
-Note: this gem utilizes the 'nokogiri' gem for XML parsing and schema validation.
+Note: this gem utilizes the 'nokogiri' gem (which in turn relies on Gnome's libxml2) for the XML parsing and schema validation.
 
 ## Installation
 

data/bin/validate_xml_xsi

@@ -3,7 +3,7 @@ require 'validate_xml_xsi'
 
 while ARGV.size > 0
   fname = ARGV.shift
-  errors = XML_XSI::Schema::validate(fname)
+  errors = XML_XSI::Schema::new(XML_XSI.parse(fname)).validate
   if errors.empty?
     puts "XML Schema check complete - NO ERRORS!"
   else

data/lib/validate_xml_xsi.rb

@@ -14,63 +14,119 @@ class XML_XSI
   class Schema
     class DocumentError < StandardError; end
     class ValidationError < StandardError
-      Params = [:type, :file, :line, :column, :message, :err]
-      attr_reader *Params, :description
-      def initialize(*args)
-        Params.each.with_index { |param, idx| instance_variable_set("@#{param.to_s}", args[idx]) }
-        @description = "#{@type.to_s} ERROR [#{@file}:#{@line}:#{@column}]: #{@message}".freeze
+      attr_reader :type, :file, :line, :column, :level, :message, :description, :error
+      def initialize(type, err, filename = nil)
+        @type = type
+        @error = err
+        @file = filename.nil? ? @error.file : filename
+        @line = @error.line
+        @column = @error.column
+        if /((?:ERROR)|(?:WARNING)): /.match(@error.message)
+          @level = $1
+          @message = $'
+          @description = "#{@type.to_s} #{@level.to_s} [#{@file}:#{@line}:#{@column}]: #{@message}".freeze
+        else
+          @level = ''
+          @message = @error.message
+          @description = "#{@type.to_s} #{@message}".freeze
+        end
         super(@description)
       end
     end
 
-    def self.parse(xml_doc)
+    attr_reader :xsd
+    def initialize(xml_doc, parent_xml_doc = nil)
       unless xml_doc.is_a?(Nokogiri::XML::Document)
-        raise DocumentError.new("not a Nokogiri::XML::Document (class: #{xml_doc.class.name})!")
+        raise DocumentError.new("invalid Nokogiri::XML::Document - #{xml_doc.class.name}")
+      end
+      unless parent_xml_doc.nil? || parent_xml_doc.is_a?(Nokogiri::XML::Document)
+        raise DocumentError.new("invalid parent Nokogiri::XML::Document - #{parent_xml_doc.class.name}")
+      end
+      @document = xml_doc
+      ## Determine default/top/root namespace
+      target_ns_href = nil
+      @document.namespaces.each do |ns_prefix, ns_href|
+        target_ns_href = ns_href if ns_prefix.nil? || ns_prefix.empty? || ns_prefix.eql?('xmlns')
+      end
+      if target_ns_href.nil? || target_ns_href.empty?
+        raise DocumentError.new("Unable to determine a default (xmlns) namespace!")
       end
+
+      ## Determine schema locations, optionally inheriting their location declarations from a parent document
+      schema_locations = parent_xml_doc.nil? ? {} : self.class.find_schema_locations(parent_xml_doc)
+      schema_locations.merge!(self.class.find_schema_locations(@document))
+
+      ## If we still don't have a file location for the target namespace, attempt to look for
+      ## one based on the name of the root node (assuming that where the namespace was declared).
+      if !schema_locations.include?(target_ns_href) &&
+          @document.root.namespace.href.eql?(target_ns_href)
+        root_file_xsd = "#{@document.root.name}.xsd"
+        schema_locations[target_ns_href] = root_file_xsd if File.exist?(root_file_xsd)
+      end
+
+      unless schema_locations.include?(target_ns_href)
+        ## XXX - Another possibility would be to default to a file named after the node name declaring the xmlns
+        raise DocumentError.new("Unable to locate a source/file for the default (xmlns) namespace schema!")
+      end
+
       ## Build an all-in-one XSD document that imports all of the separate schema locations
-      xsd_doc = "<?xml version=\"1.0\"?>\n"
-      xsd_doc << "<xsd:schema targetNamespace=\"http://www.w3.orig/XML/1998/namespace\"\n" \
-                 "            xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"\n" \
+      @xsd = "<?xml version=\"1.0\"?>\n"
+      @xsd << "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"\n" \
+                 "            targetNamespace=\"#{target_ns_href}\"\n" \
                  "            version=\"1.0\">\n"
-      ## Iterate over all the elements and find any xsi:schemaLocation attributes
-      ## and build a hash of all of the namespaces and locations
-      schemata_by_ns = {}
-      xml_doc.search('//*[@xsi:schemaLocation]').each do |elem|
-        elem['xsi:schemaLocation'].scan(/(\S+)\s+(\S+)/).each do |ns_set|
-          if ns_loc = schemata_by_ns[ns_set.first]
-            unless ns_loc.eql?(ns_set.last)
-              raise DocumentError.new("MISMATCHING XMLNS XSI: #{ns_set.first} -> #{ns_loc} VS #{ns_set.last}")
-            end
-          else
-            schemata_by_ns[ns_set.first] = ns_set.last
-          end
-        end
-      end
-      schemata_by_ns.each do |ns_href, ns_file|
-        xsd_doc << "  <xsd:import namespace=\"#{ns_href}\" schemaLocation=\"#{ns_file}\"/>\n"
+
+      ## Minimally we need the target namespace location or we have nothing to include
+      target_ns_file = schema_locations.delete(target_ns_href)
+      @xsd << "  <xsd:include schemaLocation=\"#{target_ns_file}\"/>\n" unless target_ns_file.nil?
+
+      ## Now add imports for the other defined schemaLocations
+      schema_locations.each do |ns_href, ns_file|
+        @xsd << "  <xsd:import namespace=\"#{ns_href}\" schemaLocation=\"#{ns_file}\"/>\n"
       end
-      xsd_doc << "</xsd:schema>\n"
-      Nokogiri::XML::Schema.new(xsd_doc)
+      @xsd << "</xsd:schema>\n"
+
+      ## Create the Schema objects
+      @schema = Nokogiri::XML::Schema.new(@xsd)
     end
 
-    def self.validate(xml_doc, xsd = nil)
-      xml_doc = XML_XSI::parse(xml_doc) unless xml_doc.is_a?(Nokogiri::XML::Document)
+    def validate
       errors = []
-      unless xsd.nil? || xsd.is_a?(Nokogiri::XML::Schema)
-        raise DocumentError.new("Invalid XSD - not a Nokogiri::XML::Schema (class: #{xsd.class.name})!")
+      @schema.errors.each do |err|
+        errors << ValidationError.new(:XSD, err)
       end
-      xsd = self.parse(xml_doc) if xsd.nil?
-      xsd.errors.each do |err|
-        err_msg = (/ERROR: /.match(err.message)) ? $' : err.message
-        errors << ValidationError.new(:XSD, err.file, err.line, err.column, err_msg, err)
-      end
-      errs = xsd.validate(xml_doc)
+      errs = @schema.validate(@document)
       errs.each do |err|
-        err_msg = (/ERROR: /.match(err.message)) ? $' : err.message
-        fname = (err.file.nil?) ? xml_doc.filename : err.file
-        errors << ValidationError.new(:XML, fname, err.line, err.column, err_msg, err)
+        fname = (err.file.nil?) ? @document.filename : err.file
+        errors << ValidationError.new(:XML, err, fname)
       end
       errors
     end
+
+    def self.find_schema_locations(xml_doc)
+      ## Include the default xml namespace
+      schema_locations = {}
+
+      ## Determine if the document has reference to the namespace "http://www.w3.org/2001/XMLSchema-instance"
+      ## which is used for defining schemaLocations
+      xsi_prefix = xml_doc.namespaces.invert['http://www.w3.org/2001/XMLSchema-instance']&.delete_prefix('xmlns:')
+
+      ## Iterate over all the elements and find any xsi:schemaLocation attributes
+      ## and build a hash of all of the namespaces and locations
+      unless xsi_prefix.nil?
+        xsi_loc = "#{xsi_prefix}:schemaLocation"
+        xml_doc.search("//*[@#{xsi_loc}]").each do |elem|
+          elem[xsi_loc].scan(/(\S+)\s+(\S+)/).each do |ns_set|
+            if ns_loc = schema_locations[ns_set.first]
+              unless ns_loc.eql?(ns_set.last)
+                raise DocumentError.new("MISMATCHING namespace: #{ns_set.first} -> #{ns_loc} VS #{ns_set.last}")
+              end
+            else
+              schema_locations[ns_set.first] = ns_set.last
+            end
+          end
+        end
+      end
+      schema_locations
+    end
   end
 end

data/validate_xml_xsi.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "validate_xml_xsi"
-  spec.version       = "0.2.4"
+  spec.version       = "0.4.0"
   spec.authors       = ["David Hansen"]
   spec.email         = ["david@hansen4.net"]
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: validate_xml_xsi
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.4.0
 platform: ruby
 authors:
 - David Hansen
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.13.2
-description: 
 email:
 - david@hansen4.net
 executables:
@@ -76,7 +74,6 @@ metadata:
   homepage_uri: https://github.com/d-hansen/validate_xml_xsi
   source_code_uri: https://github.com/d-hansen/validate_xml_xsi
   changelog_uri: https://github.com/d-hansen/validate_xml_xsi/blob/master/CHANGELOG.md
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.8
-signing_key: 
+rubygems_version: 4.0.2
 specification_version: 4
 summary: Validate XML against it's embedded XSI elements that define the XSD's.
 test_files: []