xsd-populator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a1fbb89bcd1d5fe7c9625230958c20b87d5b342c
+  data.tar.gz: 8a73b16dcb2de6df15f5f39a7c31e7a748f01343
+SHA512:
+  metadata.gz: ddf9a33da6ed9f56877f073f620cfa40d67a619e89b84070f77dfb25074c36af12b040842bbd997cdc09668c4cdeb6245a7b3931c29f137bdbfd2110581aa8e3
+  data.tar.gz: ffd6b497de51f6cda4af3e8f2d6597961cc686db808ce559ba26617fa3dd7599e68a95492ab30c80ce81751290ca9deb6c2a18fd2f35e1f6b62529c2a9a1962e

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,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'xsd-reader', :path => '/srv/xsd-reader'
+gem 'data-provider', :path => '/srv/data-provider'

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    xsd-populator (0.0.1)
+      builder
+      data-provider (>= 0.0.1)
+      xsd-reader (>= 0.0.1)
+
+PATH
+  remote: /srv/data-provider
+  specs:
+    data-provider (0.0.1)
+
+PATH
+  remote: /srv/xsd-reader
+  specs:
+    xsd-reader (0.1.0)
+      nokogiri
+      rest-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    byebug (5.0.0)
+      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)
+      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)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  data-provider!
+  nokogiri
+  rspec
+  xsd-populator!
+  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,2 @@
+# xsd-populator
+A Ruby gem to produce XML data from XSD schemas

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/ddex_provider.rb

@@ -0,0 +1,84 @@
+require 'data_provider'
+
+module DdexProvider
+
+  module MessageSender
+    include DataProvider::Base
+
+    provider '@LanguageAndScriptCode' do 'EN' end
+    provider 'PartyId' do 404 end
+
+  end # module MessageSender
+
+  module MessageRecipient
+    include DataProvider::Base
+
+    # provides multiple party ids; this will result in 3 <PartyId> nodes
+    # within the <MessageRecipient> node
+    provider 'PartyId' do
+      [12, 34, 56]
+    end
+
+    # Because the 'PartyId' provides 3 values, 3 nodes will be created
+    # because the ['PartyId', '@IsDPID'] provider provides only one value,
+    # all 3 PartyId nodes will get the same value for their IsDPID attribute
+    provider ['PartyId', '@IsDPID'] do
+      'TRUTH'
+    end
+
+  end # module MessageRecipient
+
+  module SentOnBehalfOf
+    include DataProvider::Base
+
+    # provides multiple party ids; this will result in 3 <PartyId> nodes
+    # within the <SentOnBehalfOf> node
+    provider 'PartyId' do
+      [9,8,7]
+    end
+
+    # Because the 'PartyId' provides 3 values, 3 nodes will be created
+    # because the ['PartyId', '@IsDPID'] provider provides only two values for the third,
+    # nil value will be assumed and a warning will be logged
+    provider ['PartyId', '@IsDPID'] do
+      ['true', 'false']
+    end
+
+  end # module SentOnBehalfOf
+
+
+  module MessageHeader
+    include DataProvider::Base
+
+    provider '@LanguageAndScriptCode' do
+      'NL'
+    end
+
+    provider 'MessageThreadId' do
+      123.to_s
+    end
+
+    add_scoped MessageSender, :scope => 'MessageSender'
+    add_scoped SentOnBehalfOf, :scope => 'SentOnBehalfOf'
+    add_scoped MessageRecipient, :scope => 'MessageRecipient'
+
+    provider ['MessageAuditTrail', 'MessageAuditTrailEvent'] do
+      # gives three new data providers with each their own :name
+      ['John', 'Billy', 'Bob'].map do |name|
+        self.give(:name => name)
+      end
+    end
+
+    provider ['MessageAuditTrail', 'MessageAuditTrailEvent', 'MessagingPartyDescriptor', 'PartyName', 'FullName'], :requires => [:name] do
+      given(:name)
+    end
+
+  end # module MessageHeader
+
+
+  class MessageHeaderProvider
+    include DataProvider::Base
+    add_scoped MessageHeader, :scope => 'MessageHeader'
+  end # class Provider
+
+end # module DdexProvider

data/lib/xsd_explanation_provider.rb

@@ -0,0 +1,28 @@
+require 'data_provider'
+
+class XsdExplanationProvider
+  include DataProvider::Base
+
+  provider_missing do
+    raise 'XsdExplanationProvider needs an xsd reader' if (reader = get_data(:xsd_reader)).nil?
+
+    logger.debug "XsdExplanationProvider got provider id: #{missing_provider}"
+    item = reader[missing_provider]
+
+    if item.is_a?(XsdReader::Attribute)
+      item.type
+    elsif item.is_a?(XsdReader::Element) && item.child_elements?
+      # return self, the data provider, so the populator can continue with the child elements
+      self
+    elsif item
+      if item.complex_type && item.complex_type.simple_content && item.complex_type.simple_content.extension
+        item.complex_type.simple_content.extension.base
+      else
+        item.type
+      end
+    else
+      logger.warn "XsdExplanationProvider could not find XSD information for provider `#{missing_provider.inspect}` in XSD file `#{reader.options[:xsd_file]}`"
+      nil
+    end
+  end
+end # class XsdExplanationProvider

data/lib/xsd_populator.rb

@@ -0,0 +1,272 @@
+require 'bundler/setup'
+require 'builder'
+require 'xsd_reader'
+require 'xsd_explanation_provider'
+
+class XsdPopulator
+
+  class ElementNotFoundException < Exception
+  end
+
+  attr_reader :options
+
+  def initialize(_opts = {})
+    configure _opts
+  end
+
+  def configure _opts = {}
+    @options = (@options || {}).merge(_opts.is_a?(Hash) ? _opts : {})
+    # remove some cached values
+    @logger = nil if _opts[:logger]
+    @xsd_reader = nil if _opts[:xsd_reader] || _opts[:reader]
+    uncache if _opts[:strategy]
+  end
+
+  def uncache
+    @populated_xml = nil
+  end
+
+  def logger
+    return @logger || options[:logger] if @logger || options[:logger]
+    @logger = Logger.new(STDOUT)
+    @logger.level = Logger::WARN
+    return @logger
+  end
+
+  def xsd_file
+    options[:xsd_file] || options[:xsd]
+  end
+
+  def xsd_reader
+    @xsd_reader ||= options[:xsd_reader] || options[:reader] || (xsd_file.nil? ? nil : XsdReader::XML.new(:xsd_file => xsd_file, :logger => logger))
+  end
+
+  alias :reader :xsd_reader
+
+  def provider
+    options[:provider] || options[:data_provider] || default_provider
+  end
+
+  def default_provider
+    @default_provider ||= XsdExplanationProvider.new(:data => {:xsd_reader => xsd_reader}, :logger => logger)
+  end
+
+  def populated_xml
+    @populated_xml ||= populate_xml
+  end
+
+  def populate_element(element_specifier = nil)
+    element_specifier.nil? ? populated_xml : populate_xml(element_specifier)
+  end
+
+  def write_file(path)
+    # logger.debug "XsdPopulator#write_file to: #{path}"
+    File.write(path, populated_xml)
+  end
+
+  private
+
+  def populate_xml(element_specifier = nil)
+    if (root_el = root_xsd_element(element_specifier)).nil?
+      logger.warn "Couldn't find element definition, aborting"
+      return nil
+    end
+
+    xml = Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct!
+
+    stack = options[:relative_provider] == true ? [] : [element_specifier || options[:element]].flatten.compact
+    stack.pop
+    build_element(xml, root_el, self.provider, stack)
+
+    return xml.target!
+  end
+
+  def build_element(xml, element, provider = self.provider, stack = [])
+    # TODO; more sophisticated recursion detection;
+    # multiple elements of the same name should be able
+    # to occur insid the stack
+    if stack.include?(element.name)
+      logger.warn("XsdPopulator#build_element aborting because of potential endless recursion\n - Current element: #{element.name}\n - stack: #{stack.inspect}")
+      return
+    end
+
+    # let's log positive stuff as well
+    logger.debug("XsdPopulator#build_element element: #{element.name}, stack: #{stack.inspect}")
+
+    # get node content data from provider
+    content_data = provider.nil? ? nil : provider.try_take(stack + [element.name])
+    # get attributes content from the provider
+    attributes_data_hash = attributes_data_hash_for(element, provider, stack)
+
+    if explain_xml? && element.multiple_allowed?
+      xml.comment!("Multiple instances of #{element.name} allowed here")
+    end 
+
+    # just log a warning if we got an array value for an element that is not allowed
+    # to occurs multiple times according to the XSD schema (but still allow data provider to generate the xml)
+    if content_data.is_a?(Array) && !element.multiple_allowed?
+      logger.warn("Got array value (provider id: #{(stack + [element.name]).inspect}) but element definition doesn't allow multiple instances")
+    end
+
+    # make sure it's an array
+    content_data = [content_data].flatten # if element.multiple_allowed? && content_data.is_a?(Array)
+    # NOTE: this doesn't array-values for single elements, which we don't support (would be turned into a string anway)
+
+    content_data.each_with_index do |node_content, idx|
+      # let's see if the provided data is good for building this node, accoridng to the current strategy
+      next if !build?(element, provider, stack, :content => node_content)
+
+      attributes_hash = attributes_hash_for_index(attributes_data_hash, idx)
+
+      # simple node; name, value, attributes
+      if !element.child_elements?
+        xml.tag!(element.name, node_content, attributes_hash)
+        next
+      end
+
+      # complex node
+      if node_content.respond_to?(:try_take)
+        child_provider = node_content
+      else
+        logger.warn "Got non-nil and non-provider value for element with child elements (value: #{node_content}, element: #{element.name}, stack: #{stack.inspect})" if node_content
+        # strategy dictates to continue; just use the current element's provider for its children
+        child_provider = provider
+      end
+
+      # create complex node
+      xml.tag!(element.name, attributes_hash) do
+        # loop over all child node definitions
+        element.elements.each do |child|
+          # this method call itself recursively for every child node definition of the current element
+          build_element(xml, child, child_provider, stack + [element.name])
+        end
+      end
+    end
+  end
+
+
+  #
+  # Attribute data
+  #
+
+  def attributes_data_hash_for(element, provider, stack)
+    element.attributes.inject({}) do |result, attribute|
+      attribute_data = provider.nil? ? nil : provider.try_take(stack + [element.name, "@#{attribute.name}"])  
+      # attribute_data ||= attribute.type if provider.nil? # assume demo xml
+      if add_attribute?(attribute, provider, stack, :content => attribute_data)
+        result.merge(attribute.name => attribute_data)
+      else
+        result
+      end
+    end
+  end
+
+  def attribute_value_for_index(values, idx)
+    # if the provided attribute content is an array, just use the appropriate element
+    # if the array does not have enough element, this will default to nil
+    # if values is not an array, just always use its singular value
+    values.is_a?(Array) ? values[idx] : values
+  end
+
+  def attributes_hash_for_index(attribute_data_hash, idx)
+    # each of the attribute values can be an array as well. If not,
+    # we'll just use it's singular value for all instances of this node
+    # if there 
+    current_attrs = attribute_data_hash.to_a.inject({}) do |result, key_value|
+      key = key_value[0]
+      value = key_value[1]
+      logger.warn "XsdPopulator#attributes_hash_for_index - got an array with insufficient values for attribute `#{key}`. Attribute data hash: #{attribute_data_hash}, index: #{idx}" if value.is_a?(Array) && value.length <= idx
+      attr_value = attribute_value_for_index(value, idx)
+      result.merge(key => attr_value)
+    end
+  end
+
+
+  #
+  # Root element
+  #
+  def specified_xsd_element(specifier = nil)
+    # nothing specified
+    return nil if (specifier || options[:element]).nil?
+    # find specified element
+    el = xsd_reader[[(specifier || options[:element])].flatten.compact]
+    raise ElementNotFoundException.new(:message => "Could not find specified root element (#{(specifier || options[:element]).inspect}).") if el.nil?
+    # log warning if specified element not found
+    logger.warn "XsdPopulator#populate_xml - Specified element (#{options[:element].inspect}) not found, reverting to default" if el.nil?
+    # return result
+    return el
+  end
+
+  def root_xsd_element(specifier = nil)
+    el = specified_xsd_element(specifier)
+
+    # no element specified? (or found)
+    if el
+      # log inform notice that we're using the explicitly specified element
+      logger.info "XsdPopulator#populate_xml - Starting at specified element: #{el.name}"
+    else
+      # default: just take the first defined element
+      el ||= xsd_reader.elements.first
+
+      # if there are multiple root-level elements in the xsd, let the user know, we're only processing the fist one
+      if el && xsd_reader.elements.length > 1
+        logger.info "XsdPopulator#populate_xml - Multiple root-level element definitions found in XSD schema, only processing the first one (#{el.name})"
+      end
+    end
+
+    return el
+  end
+
+  #
+  # Strategy
+  #
+  public
+
+  def strategy
+    options[:strategy] || (explain_xml? ? :complete : :smart)
+  end
+
+  def explain_xml?
+    provider == default_provider
+  end
+
+  def build_node_without_provider?
+    strategy == :complete
+  end
+
+  def add_simple_nodes_without_data?
+    strategy == :nil_to_empty || strategy == :complete
+  end
+
+  def build?(element, provider, stack, opts = {})
+    content = opts[:content] || provider.try_take([stack, element.name].flatten.compact)
+
+    # For comlex nodes we need either;
+    # - a data provider or
+    # - explicit confirmation to build without providers or
+    # - providers available for offspring elements
+    if element.child_elements? 
+      return content.respond_to?(:try_take) || build_node_without_provider? || provider.has_providers_with_scope?(stack + [element.name])
+    end
+
+    # we got a non-nil value for a simple node? Go ahead
+    return true if content || add_simple_nodes_without_data?
+
+    return false
+
+    # !build_node_without_provider? || 
+    # return true if provider
+  end
+
+  def add_empty_attributes?
+    strategy == :nil_to_empty || strategy == :complete
+  end
+
+  def add_attribute?(attribute, provider, stack = [], opts = {})
+    return true if attribute.required?
+    content = opts[:content] || provider.try_take(stack + ["@#{attribute.name}"])
+    return (!content.nil?) || add_empty_attributes?
+  end
+end # class XsdPopulator
+