xsd-reader 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b0bde5f374f9fa52cf79ab8ad070a105006ded8
-  data.tar.gz: 3b20b79a58c606b597fbaf540b1c278030bc99c6
+  metadata.gz: bdb069eb93be08cacdb61072c710f0571fc294ea
+  data.tar.gz: 96031d641025b2f75e88ed7dcc8dd3f4c0a017d4
 SHA512:
-  metadata.gz: 2ab56370054c6373fa72c3a2f8cfc1832804e7f325d806a0e1d7c246ffc9870abc36b2aa0fb7e055421fb6c4c3b21af32adecc95553c516867eb4f3cfec24328
-  data.tar.gz: f515fa9b00bd154df2f26c001dce0b8149437b21917a23cd7480966a0c1359a1a1cdab1830b54b7b9f960879ca55c6d18118836f21d82663d42313b2c225707b
+  metadata.gz: 3dfdb49aa63bac9c31d62a773ff00bf9c5cdf4bf355dc0e41e68edba097776c369d372175c4f59c9bb8e34cc015ca0b29cf4871d925f7368e8d596838953cc09
+  data.tar.gz: 1ec845bc1fa7a027f61ee03fff370b8947ad8598f4e53c9093c383a773e5580aab52811479964e804c029703e88fbce9f70c7df49b120bbd9b92d239086f1e96

data/Gemfile.lock

@@ -3,6 +3,7 @@ PATH
   specs:
     xsd-reader (0.0.1)
       nokogiri
+      rest-client
 
 GEM
   remote: https://rubygems.org/
@@ -11,9 +12,19 @@ GEM
       columnize (= 0.9.0)
     columnize (0.9.0)
     diff-lcs (1.2.5)
+    domain_name (0.5.24)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    mime-types (2.6.1)
     mini_portile (0.6.2)
+    netrc (0.10.3)
     nokogiri (1.6.6.2)
       mini_portile (~> 0.6.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
     rspec (3.3.0)
       rspec-core (~> 3.3.0)
       rspec-expectations (~> 3.3.0)
@@ -27,6 +38,9 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.3.0)
     rspec-support (3.3.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -7,20 +7,21 @@ XsdReader provides easy and flexible access to XSD information
 
 Rubygems:
 
-`
+```
 gem install xsd-reader
-`
+```
 
 Bundler: 
 
-`
+```ruby
 gem 'xsd-reader'
-`
+````
 
 ## Examples
 
 Load xsd
 ```ruby
+require 'xsd_reader'
 reader = XsdReader::XML.new(:xsd_file => 'ddex-ern-v36.xsd')
 ```
 

data/lib/xsd_reader/choice.rb

@@ -1,8 +1,5 @@
 module XsdReader
-
   class Choice
     include Shared
-
   end # class Choice
-
 end # module XsdReader

data/lib/xsd_reader/complex_content.rb

@@ -0,0 +1,5 @@
+module XsdReader
+  class ComplexContent
+    include Shared
+  end # class ComplexContent
+end

data/lib/xsd_reader/element.rb

@@ -10,11 +10,11 @@ module XsdReader
     end
 
     def attributes
-      super + (complex_type ? complex_type.attributes : [])
+      @_element_attributes ||= super + (complex_type ? complex_type.attributes : [])
     end
 
     def complex_type
-      super || linked_complex_type
+      @_element_complex_type ||= super || linked_complex_type
     end
 
     def min_occurs
@@ -39,10 +39,6 @@ module XsdReader
       !required?
     end
 
-    def parent
-      node.parent
-    end
-
     def family_tree(stack = [])
       logger.warn('Usage of the family tree function is not recommended as it can take very long to execute and is very memory intensive')
       return @_cached_family_tree if @_cached_family_tree 

data/lib/xsd_reader/extension.rb

@@ -1,5 +1,13 @@
 module XsdReader
   class Extension
     include Shared
+
+    def linked_complex_type
+      @linked_complex_type ||= (schema_for_namespace(base_namespace) || schema).complex_types.find{|ct| ct.name == (base_name)}
+    end
+
+    def ordered_elements
+      (linked_complex_type ? linked_complex_type.ordered_elements : []) + super
+    end
   end # class Schema
 end

data/lib/xsd_reader/import.rb

@@ -0,0 +1,56 @@
+require 'rest-client'
+
+module XsdReader
+  class Import
+    include Shared
+
+    def namespace
+      node.attributes['namespace'] ? node.attributes['namespace'].value : nil
+    end
+
+    def schema_location
+      node.attributes['schemaLocation'] ? node.attributes['schemaLocation'].value : nil
+    end
+
+    def reader
+      return @reader || options[:reader] if @reader || options[:reader]
+      if download_path
+        File.write(download_path, download) if !File.file?(download_path)
+        return @reader = XsdReader::XML.new(:xsd_file => download_path)
+      end
+
+      return @reader = XsdReader::XML.new(:xsd_xml => download) 
+    end
+
+    def uri
+      if namespace =~ /\.xsd$/
+        namespace
+      else
+        namespace.gsub(/#{File.basename(schema_location, '.*')}$/, '').to_s + schema_location
+      end
+    end
+
+    def download
+      @download ||= download_uri(self.uri)
+    end
+
+    def download_path
+      # we need the parent XSD's path
+      return nil if options[:xsd_file].nil?
+      parent_path = File.dirname(options[:xsd_file])
+      File.join(parent_path, File.basename(schema_location))
+    end
+
+    def local_xml
+      File.file?(download_path) ? File.read(download_path) : download
+    end
+
+    private
+
+    def download_uri(uri)
+      logger.info "Downloading import schema from (uri)"
+      response = RestClient.get uri
+      return response.body
+    end
+  end # class Import
+end

data/lib/xsd_reader/schema.rb

@@ -1,5 +1,40 @@
 module XsdReader
   class Schema
     include Shared
+
+    def schema
+      return self
+    end
+
+    def target_namespace
+      node && node.attributes['targetNamespace'] ? node.attributes['targetNamespace'].value : nil
+    end
+
+    def namespaces
+      self.node ? self.node.namespaces : {}
+    end
+
+    def targets_namespace?(ns)
+      target_namespace == ns || target_namespace == namespaces["xmlns:#{ns}"]
+    end
+
+    def imports
+      @imports ||= map_children("xs:import")
+    end
+
+    def mappable_children(xml_name)
+      result = super
+      result += import_mappable_children(xml_name) if xml_name != 'xs:import'
+      return result.to_a
+    end
+
+    def import_mappable_children(xml_name)
+      self.imports.map{|import| import.reader.schema.mappable_children(xml_name)}.flatten
+    end
+
+    def import_by_namespace(ns)
+      aliases = [ns, namespaces["xmlns:#{(ns || '').gsub(/^xmlns\:/, '')}"]].compact
+      return imports.find{|import| aliases.include?(import.namespace)}
+    end
   end # class Schema
 end

data/lib/xsd_reader/shared.rb

@@ -12,7 +12,10 @@ module XsdReader
     end
 
     def logger
+      return @logger if @logger
       @logger ||= options[:logger] || Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+      return @logger
     end
 
     def node
@@ -23,22 +26,23 @@ module XsdReader
       node.search("./*")
     end
 
-    def [](name)
-      # got an array of name? recursive search through generations
-      if name.is_a?(Array)
-        el = self
-        name.each{|child_name| el = el.nil? ? nil : el.elements.find{|child| child.name == child_name}}
-        return el
-      end
+    def [](*args)
+      # now name is always an array
+      names = args.flatten
 
-      # starts with an @-symbol? Then we're looking for an attribute
+      result = self
 
-      if name =~ /^\@/ 
-        attr_name = name.gsub(/^\@/, '')
-        return attributes.find{|attr| attr.name == attr_name}
+      names.each do |curname|
+        next if result.nil?
+        if curname.to_s =~ /^\@/ 
+          attr_name = curname.to_s.gsub(/^\@/, '')
+          result = result.attributes.find{|attr| attr.name == attr_name}
+        else
+          result = result.elements.find{|child| child.name == curname.to_s}
+        end
       end
 
-      elements.find{|el| el.name == name}
+      return result
     end
 
     #
@@ -60,6 +64,19 @@ module XsdReader
       type ? type.split(':').first : nil
     end
 
+    # base stuff belongs to extension type objects only, but let's be flexible
+    def base
+      node.attributes['base'] ? node.attributes['base'].value : nil
+    end
+
+    def base_name
+      base ? base.split(':').last : nil
+    end
+
+    def base_namespace
+      base ? base.split(':').first : nil
+    end
+
     #
     # Node to class mapping
     #
@@ -72,7 +89,10 @@ module XsdReader
         'xs:complexType' => ComplexType,
         'xs:sequence' => Sequence,
         'xs:simpleContent' => SimpleContent,
-        'xs:extension' => Extension
+        'xs:complexContent' => ComplexContent,
+        'xs:extension' => Extension,
+        'xs:import' => Import,
+        'xs:simpleType' => SimpleType
       }
 
       return class_mapping[n.is_a?(Nokogiri::XML::Node) ? n.name : n]
@@ -82,41 +102,40 @@ module XsdReader
       fullname = [node.namespace ? node.namespace.prefix : nil, node.name].reject{|str| str.nil? || str == ''}.join(':')
       klass = class_for(fullname)
       # logger.debug "node_to_object, klass: #{klass.to_s}, fullname: #{fullname}"
-      klass.nil? ? nil : klass.new(options.merge(:node => node))
+      klass.nil? ? nil : klass.new(options.merge(:node => node, :schema => schema))
     end
 
-
     #
     # Child objects
     #
 
-    def map_children(xml_name, klass = nil)
-      klass ||= class_for(xml_name)
-      node.search("./#{xml_name}").map{|node| klass.new(options.merge(:node => node))}
+    def mappable_children(xml_name)
+      node.search("./#{xml_name}").to_a
+    end
+
+    def map_children(xml_name)
+      # puts "Map Children with #{xml_name} for #{self.class.to_s}"
+      mappable_children(xml_name).map{|current_node| node_to_object(current_node)}
     end
 
     def direct_elements
-      map_children("xs:element")
+      @direct_elements ||= map_children("xs:element")
     end
 
     def elements
       direct_elements
     end
 
-    def unordered_elements
-      direct_elements + (complex_type ? complex_type.all_elements : []) + sequences.map(&:all_elements).flatten + choices.map(&:all_elements).flatten
-    end
-
     def ordered_elements
       # loop over each interpretable child xml node, and if we can convert a child node
       # to an XsdReader object, let it give its compilation of all_elements
       nodes.map{|node| node_to_object(node)}.compact.map do |obj|
-        obj.is_a?(Element) ? obj : obj.all_elements
+        obj.is_a?(Element) ? obj : obj.ordered_elements
       end.flatten
     end
 
     def all_elements
-      ordered_elements + (linked_complex_type ? linked_complex_type.ordered_elements : [])
+      @all_elements ||= ordered_elements + (linked_complex_type ? linked_complex_type.ordered_elements : [])
     end
 
     def child_elements?
@@ -124,91 +143,109 @@ module XsdReader
     end
 
     def attributes
-      map_children('xs:attribute')
+      @attributes ||= map_children('xs:attribute')
     end
 
     def sequences
-      map_children("xs:sequence",)
+      @sequences ||= map_children("xs:sequence",)
     end
 
     def choices
-      map_children("xs:choice")
+      @choices ||= map_children("xs:choice")
     end
 
     def complex_types
-      map_children("xs:complexType")
+      @complex_types ||= map_children("xs:complexType")
     end
 
     def complex_type
-      complex_types.first
+      complex_types.first || linked_complex_type
     end
 
     def linked_complex_type
-      complex_type_by_name(type) || complex_type_by_name(type_name)
+      @linked_complex_type ||= (schema_for_namespace(type_namespace) || schema).complex_types.find{|ct| ct.name == (type_name || type)}
+      #@linked_complex_type ||= object_by_name('xs:complexType', type) || object_by_name('xs:complexType', type_name) 
     end
 
     def simple_contents
-      map_children("xs:simpleContent")
+      @simple_contents ||= map_children("xs:simpleContent")
     end
 
     def simple_content
       simple_contents.first
     end
 
+    def complex_contents
+      @complex_contents ||= map_children("xs:complexContent")
+    end
+
+    def complex_content
+      complex_contents.first
+    end
+
     def extensions
-      map_children("xs:extension")
+      @extensions ||= map_children("xs:extension")
     end
 
     def extension
       extensions.first
     end
 
+    def simple_types
+      @simple_types ||= map_children("xs:simpleType")
+    end
+
+    def linked_simple_type
+      @linked_simple_type ||= object_by_name('xs:simpleType', type) || object_by_name('xs:simpleType', type_name)
+      # @linked_simple_type ||= (type_namespace ? schema_for_namespace(type_namespace) : schema).simple_types.find{|st| st.name == (type_name || type)}
+    end
+
     #
     # Related objects
     #
 
     def parent
       if node && node.respond_to?(:parent) && node.parent
+
         return node_to_object(node.parent)
       end
 
       nil
     end
 
-    # def ancestors
-    #   result = [parent]
-
-    #   while result.first != nil
-    #     result.unshift (result.first.respond_to?(:parent) ? result.first.parent : nil)
-    #   end
-
-    #   result.compact
-    # end
-
     def schema
-      p = node.parent
-
-      while p.name != 'schema' && !p.nil?
-        p = p.parent
-      end
-      p.nil? ? nil : node_to_object(p)
+      return options[:schema] if options[:schema]
+      schema_node = node.search('//xs:schema')[0]
+      return schema_node.nil? ? nil : node_to_object(schema_node)
     end
 
-    def complex_type_by_name(name)
-      ct = node.search("//xs:complexType[@name=\"#{name}\"]").first
-      ct.nil? ? nil : ComplexType.new(options.merge(:node => ct))
-    end
+    def object_by_name(xml_name, name)
+      # find in local schema, then look in imported schemas
+      nod = node.search("//#{xml_name}[@name=\"#{name}\"]").first
+      return node_to_object(nod) if nod
 
-    def elements_by_type(type_name)
-      els = schema.node.search("//xs:element[@type=\"#{type_name}\"]")
+      # try to find in any of the importers
+      self.schema.imports.each do |import|
+        if obj = import.reader.schema.object_by_name(xml_name, name)
+          return obj
+        end
+      end
 
-      schema.node.search("//xs:element[@type=\"#{type_name}\"]")
+      return nil
+    end
 
-      while els.length == 0
+    def schema_for_namespace(_namespace)
+      logger.debug "Shared#schema_for_namespace with _namespace: #{_namespace}"
+      return schema if schema.targets_namespace?(_namespace)
 
+      if import = schema.import_by_namespace(_namespace)
+        logger.debug "Shared#schema_for_namespace found import schema"
+        return import.reader.schema
       end
-    end
 
+      logger.debug "Shared#schema_for_namespace no result"
+      return nil
+    end
   end
 
 end # module XsdReader

data/lib/xsd_reader/simple_type.rb

@@ -0,0 +1,7 @@
+module XsdReader
+
+  class SimpleType
+    include Shared
+  end # class SimpleType
+
+end # module XsdReader

data/lib/xsd_reader/xml.rb

@@ -4,7 +4,19 @@ require 'nokogiri'
 module XsdReader
 
   class XML
-    include Shared
+    attr_reader :options
+
+    def initialize(_opts = {})
+      @options = _opts || {}
+      raise "#{self.class.to_s}.new expects a hash parameter" if !@options.is_a?(Hash)
+    end
+
+    def logger
+      return @logger if @logger
+      @logger ||= options[:logger] || Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+      return @logger
+    end
 
     def xsd_from_uri
       # @xsd_from_uri ||= options[:xsd_uri].nil ? nil : open(options[:xsd_uri])
@@ -22,17 +34,38 @@ module XsdReader
       @doc ||= Nokogiri.XML(xml)
     end
 
+    def node
+      nil
+    end
+
     def schema_node
       doc.root.name == 'schema' ? doc.root : nil
     end
 
     def schema
-      node_to_object(schema_node)
+      @schema ||= Schema.new(self.options.merge(:node => schema_node, :logger => logger))
+    end
+
+    # forwards most functions to schema
+    def [](*args)
+      schema[*args]
     end
 
     def elements
       schema.elements
     end
+
+    def imports
+      schema.imports
+    end
+
+    def simple_types
+      schema.simple_types
+    end
+
+    def schema_for_namespace(_ns)
+      schema.schema_for_namespace(_ns)
+    end
   end # class XML
 
 end # module XsdReader

data/lib/xsd_reader.rb

@@ -7,5 +7,8 @@ require 'xsd_reader/sequence'
 require 'xsd_reader/choice'
 require 'xsd_reader/complex_type'
 require 'xsd_reader/simple_content'
+require 'xsd_reader/complex_content'
 require 'xsd_reader/extension'
+require 'xsd_reader/import'
+require 'xsd_reader/simple_type'
 

data/spec/attribute_spec.rb

@@ -1,33 +1,33 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe XsdReader do
-  before :all do
-    @reader ||= XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-ern-v36.xsd')))
-  end
+  let(:reader){
+    XsdReader::XML.new(:xsd_file => File.expand_path(File.join(File.dirname(__FILE__), 'examples', 'ddex-v36', 'ddex-ern-v36.xsd')))
+  }
 
   describe XsdReader::Attribute do
-    before :each do
-      @attribute = @reader['NewReleaseMessage']['@MessageSchemaVersionId']
-    end
+    let(:attribute){
+      reader['NewReleaseMessage']['@MessageSchemaVersionId']
+    }
 
     it "gives a name" do
-      expect(@attribute.name).to eq 'MessageSchemaVersionId'
+      expect(attribute.name).to eq 'MessageSchemaVersionId'
     end
 
     it "gives a type information" do
-      expect(@attribute.type).to eq 'xs:string'
-      expect(@attribute.type_name).to eq 'string'
-      expect(@attribute.type_namespace).to eq 'xs'
+      expect(attribute.type).to eq 'xs:string'
+      expect(attribute.type_name).to eq 'string'
+      expect(attribute.type_namespace).to eq 'xs'
     end
 
     it "gives a boolean required indication" do
-      expect(@attribute.required?).to eq true
+      expect(attribute.required?).to eq true
     end
   end
 
   describe "[] operator" do
     it "gives attribute objects through the square brackets ([]) operator" do
-      attribute = @reader['NewReleaseMessage']['MessageHeader']['@LanguageAndScriptCode']
+      attribute = reader['NewReleaseMessage']['MessageHeader']['@LanguageAndScriptCode']
       expect(attribute.type).to eq 'xs:string'
       expect(attribute.required?).to eq false
     end