xsd-reader 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b0bde5f374f9fa52cf79ab8ad070a105006ded8
+  data.tar.gz: 3b20b79a58c606b597fbaf540b1c278030bc99c6
+SHA512:
+  metadata.gz: 2ab56370054c6373fa72c3a2f8cfc1832804e7f325d806a0e1d7c246ffc9870abc36b2aa0fb7e055421fb6c4c3b21af32adecc95553c516867eb4f3cfec24328
+  data.tar.gz: f515fa9b00bd154df2f26c001dce0b8149437b21917a23cd7480966a0c1359a1a1cdab1830b54b7b9f960879ca55c6d18118836f21d82663d42313b2c225707b

data/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    xsd-reader (0.0.1)
+      nokogiri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (5.0.0)
+      columnize (= 0.9.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    mini_portile (0.6.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  rspec
+  xsd-reader!
+
+BUNDLED WITH
+   1.10.5

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,60 @@
+# XsdReader
+
+XsdReader provides easy and flexible access to XSD information
+
+## Installation
+
+
+Rubygems:
+
+`
+gem install xsd-reader
+`
+
+Bundler: 
+
+`
+gem 'xsd-reader'
+`
+
+## Examples
+
+Load xsd
+```ruby
+reader = XsdReader::XML.new(:xsd_file => 'ddex-ern-v36.xsd')
+```
+
+Get elements and their child elements
+```ruby
+node = reader['NewReleaseMessage']
+node.elements.map(&:name) # => ['MessageHeader', 'UpdateIndicator', 'IsBackfill', 'CatalogTransfer', 'WorkList', 'CueSheetList', 'ResourceList', 'CollectionList', 'ReleaseList', 'DealList']
+```
+
+Get attributes
+```ruby
+reader['NewReleaseMessage']['MessageHeader'].attributes.map(&:name) # => ['LanguageAndScriptCode']
+```
+
+Get type information of attribute
+```ruby
+attribute = reader['NewReleaseMessage']['MessageHeader']['@LanguageAndScriptCode']
+attribute.type 				# => 'xs:string'
+attribute.type_name			# => 'string'
+attribute.type_namespace	# => 'xs'
+```
+
+Get element amount details
+```ruby
+node = @reader['NewReleaseMessage']['ResourceList']['SoundRecording']
+node.min_occurs			# => 0
+node.max_occurs			# => :unbouded
+node.multiple_allowed? # true
+node.required?			# false
+node = @reader['NewReleaseMessage']['MessageHeader']
+node.min_occurs			# => nil
+node.max_occurs			# => nil
+node.multiple_allowed? # false
+node.required?			# true
+```
+
+

data/Rakefile

@@ -0,0 +1,20 @@
+# rxsd project Rakefile
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the LGPLv3+ http://www.gnu.org/licenses/lgpl.txt
+
+require 'rdoc/task'
+require "rspec/core/rake_task"
+
+task :default => :rspec do; end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('rspec') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/site/api"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end

data/lib/xsd_reader/attribute.rb

@@ -0,0 +1,9 @@
+module XsdReader
+  class Attribute
+    include Shared
+
+    def required?
+      (node.attributes['use'] && node.attributes['use'].value == 'required') ? true : false
+    end
+  end # class Attribute
+end # module XsdReader

data/lib/xsd_reader/choice.rb

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

data/lib/xsd_reader/complex_type.rb

@@ -0,0 +1,26 @@
+module XsdReader
+
+  class ComplexType
+    include Shared
+
+    def name
+      node.attributes['name'] ? node.attributes['name'].value : nil
+    end
+
+    def attributes
+      super + (simple_content ? simple_content.attributes : [])
+    end
+
+    def parent_element
+      if parent.nil? || parent.is_a?(Schema) || !parent.is_a?(Element)
+        parent_elements.first
+      end
+    end
+
+    def parent_elements
+      elements_by_type(self.name)
+    end
+
+  end # class ComplexType
+
+end # module XsdReader

data/lib/xsd_reader/element.rb

@@ -0,0 +1,65 @@
+require 'xsd_reader/shared'
+
+module XsdReader
+  class Element
+    include Shared
+
+    def elements(opts = {})
+      return super if opts[:direct] == true
+      all_elements
+    end
+
+    def attributes
+      super + (complex_type ? complex_type.attributes : [])
+    end
+
+    def complex_type
+      super || linked_complex_type
+    end
+
+    def min_occurs
+      node.attributes['minOccurs'] ? node.attributes['minOccurs'].value.to_i : nil
+    end
+
+    def max_occurs
+      if val = node.attributes['maxOccurs'] ? node.attributes['maxOccurs'].value : nil
+        val == 'unbounded' ? :unbounded : val.to_i
+      end
+    end
+
+    def multiple_allowed?
+      max_occurs == :unbounded || max_occurs.to_i > 0
+    end
+
+    def required?
+      min_occurs.nil? || min_occurs.to_i > 0 # TODO; consider if the element is part of a choice definition?
+    end
+
+    def optional?
+      !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 
+
+      if stack.include?(name) # avoid endless recursive loop
+        # logger.debug "Element#family_tree aborting endless recursive loop at element with name: #{name} and element stack: #{stack.inspect}"
+        return nil
+      end
+
+      return "type:#{type_name}" if elements.length == 0
+
+      result = elements.inject({}) do |tree, element|
+        tree.merge element.name => element.family_tree(stack + [name])
+      end
+
+      @_cached_family_tree = result if stack == [] # only cache if this was the first one called (otherwise there will be way too many caches)
+      return result
+    end
+  end # class Element
+end # module XsdReader

data/lib/xsd_reader/extension.rb

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

data/lib/xsd_reader/schema.rb

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

data/lib/xsd_reader/sequence.rb

@@ -0,0 +1,8 @@
+module XsdReader
+
+  class Sequence
+    include Shared
+
+  end # class Sequence
+
+end # module XsdReader

data/lib/xsd_reader/shared.rb

@@ -0,0 +1,214 @@
+require 'logger'
+
+module XsdReader
+
+  module 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
+      @logger ||= options[:logger] || Logger.new(STDOUT)
+    end
+
+    def node
+      options[:node]
+    end
+
+    def nodes
+      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
+
+      # starts with an @-symbol? Then we're looking for an attribute
+
+      if name =~ /^\@/ 
+        attr_name = name.gsub(/^\@/, '')
+        return attributes.find{|attr| attr.name == attr_name}
+      end
+
+      elements.find{|el| el.name == name}
+    end
+
+    #
+    # attribute properties
+    #
+    def name
+      node.attributes['name'].value
+    end
+
+    def type
+      node.attributes['type'] ? node.attributes['type'].value : nil
+    end
+
+    def type_name
+      type ? type.split(':').last : nil
+    end
+
+    def type_namespace
+      type ? type.split(':').first : nil
+    end
+
+    #
+    # Node to class mapping
+    #
+    def class_for(n)
+      class_mapping = {
+        'xs:schema' => Schema,
+        'xs:element' => Element,
+        'xs:attribute' => Attribute,
+        'xs:choice' => Choice,
+        'xs:complexType' => ComplexType,
+        'xs:sequence' => Sequence,
+        'xs:simpleContent' => SimpleContent,
+        'xs:extension' => Extension
+      }
+
+      return class_mapping[n.is_a?(Nokogiri::XML::Node) ? n.name : n]
+    end
+
+    def node_to_object(node)
+      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))
+    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))}
+    end
+
+    def 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
+      end.flatten
+    end
+
+    def all_elements
+      ordered_elements + (linked_complex_type ? linked_complex_type.ordered_elements : [])
+    end
+
+    def child_elements?
+      elements.length > 0
+    end
+
+    def attributes
+      map_children('xs:attribute')
+    end
+
+    def sequences
+      map_children("xs:sequence",)
+    end
+
+    def choices
+      map_children("xs:choice")
+    end
+
+    def complex_types
+      map_children("xs:complexType")
+    end
+
+    def complex_type
+      complex_types.first
+    end
+
+    def linked_complex_type
+      complex_type_by_name(type) || complex_type_by_name(type_name)
+    end
+
+    def simple_contents
+      map_children("xs:simpleContent")
+    end
+
+    def simple_content
+      simple_contents.first
+    end
+
+    def extensions
+      map_children("xs:extension")
+    end
+
+    def extension
+      extensions.first
+    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)
+    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 elements_by_type(type_name)
+      els = schema.node.search("//xs:element[@type=\"#{type_name}\"]")
+
+      schema.node.search("//xs:element[@type=\"#{type_name}\"]")
+
+      while els.length == 0
+
+      end
+    end
+
+  end
+
+end # module XsdReader

data/lib/xsd_reader/simple_content.rb

@@ -0,0 +1,9 @@
+module XsdReader
+  class SimpleContent
+    include Shared
+
+    def attributes
+      super + (extension ? extension.attributes : [])
+    end
+  end # class Schema
+end

data/lib/xsd_reader/xml.rb

@@ -0,0 +1,38 @@
+require 'nokogiri'
+# require 'open-uri'
+
+module XsdReader
+
+  class XML
+    include Shared
+
+    def xsd_from_uri
+      # @xsd_from_uri ||= options[:xsd_uri].nil ? nil : open(options[:xsd_uri])
+    end
+
+    def xsd_from_file
+      @xsd_from_file ||= options[:xsd_file].nil? ? nil : File.read(options[:xsd_file])
+    end
+
+    def xml
+      @xsd_xml ||= options[:xsd_xml] || options[:xsd_data] || options[:xsd_raw] || xsd_from_file || xsd_from_uri
+    end
+
+    def doc
+      @doc ||= Nokogiri.XML(xml)
+    end
+
+    def schema_node
+      doc.root.name == 'schema' ? doc.root : nil
+    end
+
+    def schema
+      node_to_object(schema_node)
+    end
+
+    def elements
+      schema.elements
+    end
+  end # class XML
+
+end # module XsdReader

data/lib/xsd_reader.rb

@@ -0,0 +1,11 @@
+require 'xsd_reader/shared'
+require 'xsd_reader/xml'
+require 'xsd_reader/schema'
+require 'xsd_reader/element'
+require 'xsd_reader/attribute'
+require 'xsd_reader/sequence'
+require 'xsd_reader/choice'
+require 'xsd_reader/complex_type'
+require 'xsd_reader/simple_content'
+require 'xsd_reader/extension'
+

data/spec/attribute_spec.rb

@@ -0,0 +1,35 @@
+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
+
+  describe XsdReader::Attribute do
+    before :each do
+      @attribute = @reader['NewReleaseMessage']['@MessageSchemaVersionId']
+    end
+
+    it "gives a name" do
+      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'
+    end
+
+    it "gives a boolean required indication" do
+      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']
+      expect(attribute.type).to eq 'xs:string'
+      expect(attribute.required?).to eq false
+    end
+  end
+end # describe XsdReader