duxml 0.7.2

data/lib/duxml/meta/grammar/pattern_maker.rb

@@ -0,0 +1,69 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/pattern/child_pattern')
+require File.expand_path(File.dirname(__FILE__) + '/pattern/text_pattern')
+require File.expand_path(File.dirname(__FILE__) + '/pattern/attr_name_pattern')
+require File.expand_path(File.dirname(__FILE__) + '/pattern/attr_val_pattern')
+
+module Duxml
+  # helper methods to create Patterns from a given Element's relationships with its members
+  module PatternMaker
+    include Duxml
+    # @param node [Duxml::Element] doc whose relationships are to be made into patterns
+    # @return [Array[Duxml::Pattern]] array of patterns representing every relationship of this XMl node and its members
+    def get_relationships(node)
+      [get_child_patterns(node),
+       get_null_child_patterns(node),
+       get_existing_attr_patterns(node),
+      get_null_attr_patterns(node)].flatten
+    end
+
+    # @param node [Duxml::Element] doc whose relationships are to be made into patterns
+    # @return [Array[Duxml::AttrNamePattern, Duxml::AttrValPattern]] one pattern for each existing attribute
+    def get_existing_attr_patterns(node)
+      # check existing attributes
+      node.attributes.collect do |k, v|
+        [AttrNamePatternClass.new(node, k), AttrValPatternClass.new(node, k)]
+      end.flatten
+    end
+
+    # @param node [Element] doc whose relationships are to be made into patterns
+    # @return [Array[AttrNamePattern]] one pattern for each attribute that should but does not exist
+    def get_null_attr_patterns(node)
+      self.AttrsRuleClass.collect do |attr_rule|
+        if attr_rule.required? && node.name == attr_rule.subject
+          AttrNamePatternClass.new(node, attr_rule.attr_name) unless node[attr_rule.attr_name]
+        end
+      end.compact
+    end
+
+    # @param node [Duxml::Element] doc whose relationships are to be made into patterns
+    # @return [Array[ChildPattern]] one pattern for each child that should be there but isn't
+    def get_null_child_patterns(node)
+      self.ChildrenRuleClass.each do |child_rule|
+        if node.name == child_rule.subject
+          return child_rule.required_children.collect do |required_child_type|
+            unless node.nodes.any? do |n| n.name == required_child_type end
+              NullChildPatternClass.new(node, required_child_type)
+            end
+          end.compact
+        end
+      end
+      []
+    end
+
+    # @param node [Duxml::Element] object whose relationships are to be made into patterns
+    # @return [Array[Duxml::ChildPattern, Duxml::ContentPattern]] one pattern for each child that exists
+    def get_child_patterns(node)
+      i = -1
+      node.nodes.collect do |child|
+        i += 1
+        if child.is_a?(String)
+          TextPatternClass.new(node, i)
+        else
+          ChildPatternClass.new(node, i)
+        end
+      end
+    end # def get_child_patterns
+  end # module PatternMaker
+end # module Duxml

data/lib/duxml/meta/grammar/relax_ng/attrs_rule.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule/attrs_rule')
+require File.expand_path(File.dirname(__FILE__) + '/../../../doc/lazy_ox')
+require 'ox'
+
+module Duxml
+  module RngAttrsRule; end
+
+  class AttrsRuleClass
+    include RngAttrsRule
+  end
+
+  module RngAttrsRule
+    include Duxml::LazyOx
+    include Ox
+
+    # @param parent [Nokogiri::XML::Node] should be <grammar>
+    # @return [Nokogiri::XML::Node] parent, but with additions of <define><attribute> to parent if does not already exist and <ref> to respective <define><doc>
+    def relaxng(parent)
+      # TODO this is here just to skip generation from namespaced attributes - fix later!!!
+      return parent if attr_name.include?(':')
+      # TODO
+
+      # if new attribute declaration needed
+      unless parent.Define(name: attr_name).any?
+        new_def = Element.new('define')
+        new_def[:name] = attr_name
+        new_attr_def = Element.new('attribute')
+        new_attr_def[:name] = attr_name
+        new_def << new_attr_def
+        parent << new_def
+      end
+
+      # update doc with ref, updating previous <optional> if available
+      parent.nodes.reverse.each do |define|
+        if define[:name] == subject
+          element_def = define.nodes.first
+          if requirement == '#REQUIRED'
+            cur_element = element_def
+          else
+            if element_def.nodes.any? and element_def.nodes.last.name == 'optional'
+              cur_element = element_def.nodes.last
+            else
+              cur_element = Element.new('optional')
+              element_def << cur_element
+            end
+          end # if self[:requirement]=='#REQUIRED'
+          new_ref = Element.new('ref')
+          new_ref[:name] = attr_name
+          cur_element << new_ref
+          break
+        end # if define[:name] == subject
+      end # parent.element_children.any?
+      parent
+    end # def relaxng(parent)
+  end # module RngAttrsRule
+end # module Duxml

data/lib/duxml/meta/grammar/relax_ng/children_rule.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule/children_rule')
+
+module Duxml
+  module RngChildrenRule; end
+
+  class ChildrenRuleClass
+    include RngChildrenRule
+  end
+
+  module RngChildrenRule
+    include Duxml::LazyOx
+    include Ox
+
+    # @param parent [Ox::Element] parent from RelaxNG document under construction (should be <grammar/>)
+    # @return [Ox::Element] same parent but with addition of <define><doc> with #statement converted into <ref>'s
+    #   these are wrapped as needed in <zeroOrMore>,<oneOrMore>, or <optional>
+    def relaxng(parent)
+      nodes = parent.Define(name: subject)
+      raise Exception if nodes.size > 1
+
+      if nodes.first.nil?
+        element_def = Element.new('element')
+        element_def[:name] = subject
+        define = Element.new('define')
+        define[:name] = subject
+        define << element_def
+        parent << define
+      else
+        element_def = nodes.first.nodes.first
+      end
+
+      # loop through child requirements
+      get_scanners.each do |scanner|
+        # wrap in requirement node if needed
+        operator_name = case scanner[:operator]
+                          when '?' then :optional
+                          when '*' then :zeroOrMore
+                          when '+' then :oneOrMore
+                          else nil
+                        end
+        if operator_name
+          cur_element = Element.new(operator_name.to_s)
+          element_def << cur_element
+        else
+          cur_element = element_def
+        end
+
+        # if child requirement has enumerated options, wrap in <choice>
+        element_array = scanner[:match].source.gsub('\b','').scan(Regexp.nmtoken).flatten.keep_if do |e| !e.empty? end
+        if element_array.size > 1
+          choice_el = Element.new 'choice'
+          cur_element << choice_el
+          cur_element = choice_el
+        end
+
+        # adding enumerated options as new element defs if needed
+        element_array.each do |element_name|
+          existing_defs = parent.Define(name: element_name)
+          raise Exception if existing_defs.size > 1
+          if existing_defs.empty?
+            new_def = Element.new('define')
+            new_def[:name] = element_name
+            child_el_def = Element.new('element')
+            child_el_def[:name] = element_name
+            new_def << child_el_def
+            parent << new_def
+          end
+
+          if element_name == '#PCDATA'
+            cur_element << Element.new('text')
+          else
+            ref_node = Element.new('ref')
+            ref_node[:name] = element_name
+            cur_element << ref_node
+          end
+        end # element_array.each
+      end # get_scanners.each
+      parent
+    end # def relaxng
+  end # module RngChildrenRule
+end # module Duxml

data/lib/duxml/meta/grammar/relax_ng/value_rule.rb

@@ -0,0 +1,44 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule/value_rule')
+
+module Duxml
+  module RngValueRule; end
+
+  class ValueRuleClass
+    include RngValueRule
+  end
+
+  module RngValueRule
+    include Duxml::LazyOx
+    # @param parent [Nokogiri::XML::Node] <grammar> i.e. parent node in RelaxNG document, NOT this Rule's document
+    # @return [Nokogiri::XML::Node] parent, but adds to corresponding <define><attribute> a child <data type="#{statement}">
+    #   where #statement can be 'CDATA', 'NMTOKEN', etc.
+    def relaxng(parent)
+      parent.Define.each do |define|
+        if define[:name] == attr_name
+          attr_def = define.nodes.first
+          unless attr_def.nodes.any?
+            data_type = statement == 'CDATA' ? 'string' : statement
+            if data_type.include?('|')
+              choice_node = Element.new('choice')
+              attr_def << choice_node
+              data_type.split(/[\(\|\)]/).each do |en_val|
+                if !en_val.empty? && Regexp.nmtoken.match(en_val)
+                  value_def = Element.new('value')
+                  value_def << en_val
+                  choice_node << value_def
+                end
+              end
+            else
+              data_def = Element.new('data')
+              data_def[:type] = data_type
+              attr_def << data_def
+            end
+          end # unless attr_def.nodes.any?
+          return parent
+        end # if define[:name] == attr_name
+      end # parent.nodes.each
+    end # def relaxng
+  end # module RngValuesRule
+end # module Duxml

data/lib/duxml/meta/grammar/relax_ng.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/relax_ng/children_rule')
+require File.expand_path(File.dirname(__FILE__) + '/relax_ng/attrs_rule')
+require File.expand_path(File.dirname(__FILE__) + '/relax_ng/value_rule')
+require File.expand_path(File.dirname(__FILE__) + '/../../doc')
+
+module Duxml
+  # contains methods to convert Rules into a valid RelaxNG schema file
+  module RelaxNG
+    include Duxml
+    # @param output_path [String] optional, output path for .rng file
+    # @return [Nokogiri::XML::RelaxNG] RelaxNG schema object
+    def relaxng(output_path=nil)
+      doc = Doc.new
+      doc << Element.new('grammar')
+      doc.grammar[:xmlns] = 'http://relaxng.org/ns/structure/1.0'
+      doc.grammar[:datatypeLibrary] = 'http://www.w3.org/2001/XMLSchema-datatypes'
+      start = Element.new('start')
+      start[:combine] = 'choice'
+      ref = Element.new('ref')
+      ref[:name] = rules.first.subject
+      start << ref
+      doc.grammar << start
+      rules.each do |rule|
+        rule.relaxng doc.grammar
+      end
+
+      # fill in empty doc definitions to make them legal
+      element_defs = doc.grammar.Define.collect do |d|
+        d.element if d.nodes.first.name == 'element' and d.element.nodes.empty?
+      end.compact
+      element_defs.each do |element_def|
+        element_def << Element.new('empty')
+      end
+      doc.write_to output_path if output_path
+      doc
+    end # def relaxng
+  end # module RelaxNG
+end # module Duxml

data/lib/duxml/meta/grammar/rule/attrs_rule.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule')
+
+module Duxml
+  # methods for applying a rule on what attribute names a given Element is allowed to have
+  module AttrsRule; end
+
+  # do not subclass this! as object, consists of subject and a Regexp describing allowable attribute names
+  # as well as a String indicating with DTD symbols for whether the given attributes are allowed or required
+  class AttrsRuleClass < RuleClass
+    include AttrsRule
+
+    # @param _subject [String] name of the Element
+    # @param attrs [String] the attribute name pattern in Regexp form
+    # @param required [String] the requirement level - optional i.e. #IMPLIED by default
+    def initialize(_subject, attrs, required='#IMPLIED')
+      formatted_statement = attrs.gsub('-', '__dash__').gsub(/\b/, '\b').gsub('-', '__dash__')
+      @requirement = required
+      super(_subject, formatted_statement)
+    end
+
+    attr_reader :requirement
+  end
+
+  module AttrsRule
+    # @param change_or_pattern [Duxml::Pattern] checks an doc of type change_or_pattern.subject against change_or_pattern
+    # @return [Boolean] whether or not given pattern passed this test
+    def qualify(change_or_pattern)
+      @object = change_or_pattern
+      result = pass change_or_pattern
+      super change_or_pattern unless result
+      @object = nil
+      result
+    end
+
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern that rule may apply to
+    # @return [Boolean] whether this rule does in fact apply
+    def applies_to?(change_or_pattern)
+      return false unless change_or_pattern.respond_to?(:attr_name)
+      return false unless super(change_or_pattern)
+      return false if change_or_pattern.respond_to?(:value) && !change_or_pattern.respond_to?(:time_stamp)
+      statement.include?(change_or_pattern.attr_name.to_s)
+    end
+
+    # @return [Boolean] whether or not this attribute is required
+    def required?
+      requirement == '#REQUIRED'
+    end
+
+    # @return [String] name of attribute to which this rule applies
+    def attr_name
+      statement.gsub('\b','')
+    end
+
+    # @return [String] describes relationship in a word
+    def relationship
+      'attributes'
+    end
+
+    # @return [String] description of self; overrides super to account for cases of missing, required attributes
+    def description
+      %(#{relationship.capitalize} Rule that <#{subject}>'s #{relationship} #{required? ? 'must':'can'} include '#{attr_name}')
+    end
+
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern to be evaluated
+    # @return [Boolean] true if this rule does not apply to param; false if pattern is for a missing required attribute
+    #   otherwise returns whether or not any illegal attributes exist
+    def pass(change_or_pattern)
+      if change_or_pattern.respond_to?(:time_stamp)
+        an = change_or_pattern.attr_name.to_s
+        attr_name.include?(an) && !change_or_pattern.abstract?
+      else
+        !change_or_pattern.abstract?
+      end
+    end # def pass
+  end # class AttributesRule
+end # module Duxml

data/lib/duxml/meta/grammar/rule/children_rule.rb

@@ -0,0 +1,137 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule')
+require File.expand_path(File.dirname(__FILE__) + '/../../../doc/element')
+
+module Duxml
+  # methods to apply rule on what children an Element may have
+  module ChildrenRule; end
+
+  # do not subclass! rule that states what children and how many a given element is allowed to have where @statement
+  # is a DTD/Regexp of what children are allowed, how many, in what order and whether they are required
+  class ChildrenRuleClass < RuleClass
+    include ChildrenRule
+    # child rules are initialized from DTD doc declarations e.g. (zeroOrMore|other-first-child)*,second-child-optional?,third-child-gt1+
+    #
+    # @param _subject [String] name of the doc the rule applies
+    # @param _statement [String] DTD-style statement of the rule
+    def initialize(_subject, _statement)
+      formatted_statement = _statement
+                                .gsub(/[\<>]/, '')
+                                .gsub(/#PCDATA/, 'PCDATA')
+                                .gsub('-','_dash_')
+                                .gsub(/\b/,'\b')
+                                .gsub(/PCDATA/, '#PCDATA')
+                                .gsub('_dash_', '-')
+                                .gsub(/\s/,'')
+      super(_subject, formatted_statement)
+    end
+  end # class ChildrenRuleClass
+
+  module ChildrenRule
+    # @param change_or_pattern [Duxml::ChildPattern, Duxml::Add, Duxml::Remove] to be evaluated to see if it follows this rule
+    # @return [Boolean] whether or not change_or_pattern#subject is allowed to have #object as its child
+    #   if false, Error is reported to History
+    def qualify(change_or_pattern)
+      @object = change_or_pattern
+      result = pass
+      super change_or_pattern unless result
+      @object = nil
+      result
+    end
+
+    # @return [Array[String]] in order, array of child doc types required by this rule
+    def required_children
+      req_scans = get_scanners.select do |scanner| scanner[:operator].match(/[\*\?]/).nil? end
+      req_scans.collect do |req_scan|
+        get_child_name req_scan unless get_child_name(req_scan) == 'EMPTY'
+      end.compact
+    end
+
+    # @param change_or_pattern [Duxml::Pattern, Duxml::Change] change or pattern to be evaluated
+    # @return [Boolean] whether subjects agree, and change or pattern is not a Rule and responds to #affected_parent
+    def applies_to?(change_or_pattern)
+      case
+        when change_or_pattern.is_a?(Duxml::Rule) then false
+        when super(change_or_pattern) && change_or_pattern.respond_to?(:parent)
+          true
+        else
+          false
+      end
+    end
+
+    private
+
+    # @param req_scan [Struct::Scanner] scanner with which to identify a child name within @statement
+    # @return [String] name of child that is currently being checked for by this rule
+    def get_child_name(req_scan)
+      req_scan[:match].inspect.split(/[\/(\\b)]/).select do |word| !word.empty? end.first
+    end
+
+    # @return [[Struct::Scanner]] array of scanners for each logical component of @statement to be applied to target Element's children
+    def get_scanners
+      statement.split(',').collect do |rule|
+        r = rule.gsub(/[\(\)]/, '')
+        operator = r[-1].match(/[\?\+\*]/) ? r[-1] : ''
+        r = r[0..-2] unless operator.empty?
+        Struct::Scanner.new Regexp.new(r), operator
+      end
+    end
+
+    attr_reader :child_stack
+
+    # @return [Boolean] whether or not this rule has been passed
+    def pass
+      @child_stack = object.child.nil? ? [] : object.parent.nodes.clone
+      scanners = get_scanners
+      scanner = scanners.shift
+      result = false
+      loop do
+        child = @child_stack.shift
+        case
+          when child.nil?, scanner.nil? then break
+          when child.is_a?(String)
+            result = scanner[:match].inspect.include?('#PCDATA')
+          when child.name.match(scanner[:match]) # scanner matches this child
+            if scanner[:operator]=='?' or scanner[:operator]=='' # shift scanners if we only need one child of this type
+              scanner = scanners.shift
+              result = previous_child.nil? || (previous_child.name != child.name)
+            else
+              result = true
+            end
+          # scanner does not match this child...
+          when %w(? *).include?(scanner[:operator]) # optional scanner so try next scanner on same child
+            scanner = scanners.shift
+            @child_stack.unshift child
+            result = !scanner.nil?
+          else
+            result = false # else, this scanner will report false
+        end # case
+        return result unless child.is_a?(String) or !matching_index?# don't need to keep looping because we've scanned our target
+      end # loop do
+
+      # checking to see if any required children were not present
+      result = false if child_stack.empty? && scanners.any? do |scanner|
+        scanner[:operator] != '*' or scanner[:operator] != '?'
+      end
+      result
+    end # def pass
+
+    # @return [Boolean] whether the child currently being scanned is the one in the pattern we are testing now
+    def matching_index?
+      child_index == object.index
+    end
+
+    # @return [Fixnum] index of child currenlty being scanned
+    def child_index
+      i = object.parent.nodes.size-child_stack.size-1
+      i
+    end
+
+    # @return [Element] previous element to the one being scanned
+    def previous_child
+      index = child_index - 1
+      index < 0 ? nil : object.parent.nodes[index]
+    end
+  end # module ChildrenRule
+end # module Duxml

data/lib/duxml/meta/grammar/rule/text_rule.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule')
+
+module Duxml
+  module TextRule; end
+
+  class TextRuleClass < RuleClass
+    include TextRule
+  end
+
+  module TextRule
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern that rule may apply to
+    # @return [Boolean] whether this rule does in fact apply
+    def applies_to?(change_or_pattern)
+      super(change_or_pattern) &&
+          change_or_pattern.respond_to?(:text)
+    end
+
+    # applies Regexp statement to text content of this node; returns false if content has XML
+    def qualify(change_or_pattern)
+      @object = change_or_pattern
+      result = pass
+      super change_or_pattern unless result
+      @object = nil
+      result
+    end
+
+    private
+
+    def pass
+      return false unless object.text.is_a?(String)
+      get_scanner.match(object.text).to_s == object.text
+    end
+
+    def get_scanner
+      Regexp.new(statement)
+    end
+  end # module TextRule
+end # module Duxml

data/lib/duxml/meta/grammar/rule/value_rule.rb

@@ -0,0 +1,111 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../rule')
+
+module Duxml
+  module ValueRule; end
+
+  # rule that states what values a given attribute name is allowed to have
+  class ValueRuleClass < RuleClass
+    include ValueRule
+
+    # @param _attr_name [String] the attribute name
+    # @param _statement [String] data type or expression of the rule for the given attribute's value
+    def initialize(_attr_name, _statement)
+      @attr_name, @statement = _attr_name, _statement
+    end
+
+    attr_reader :attr_name
+  end
+
+  module ValueRule
+    CDATA_EXPR = /(\]\]>)/
+    ENTITY_EXPR = /(\b[\S]+\b)/
+    ID_EXPR = Regexp.nmtoken
+    NMTOKEN_EXPR = ID_EXPR
+    NOTATION_EXPR = //
+
+    # @return [true]
+    def abstract?
+      true
+    end
+
+    # @return [String] description of this rule
+    def description
+      %(#{relationship.capitalize} Rule that @#{attr_name}'s #{relationship} must match '#{statement}')
+    end
+
+    # @param change_or_pattern [Duxml::Pattern, Duxml::Change] change or pattern to be evaluated
+    # @return [Boolean] whether change_or_pattern#subject is allowed to have value of type #object
+    #   if false, reports Error to History
+    def qualify(change_or_pattern)
+      value = change_or_pattern.value
+      s = change_or_pattern.subject
+      raise Exception if value.nil?
+      result = pass value
+      super change_or_pattern unless result
+      result
+    end
+
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern that rule may apply to
+    # @return [Boolean] whether this rule does in fact apply
+    def applies_to?(change_or_pattern)
+          return false unless change_or_pattern.respond_to?(:attr_name)
+          return false unless change_or_pattern.respond_to?(:value)
+          change_or_pattern.attr_name == attr_name
+    end
+
+    private
+
+    def pass(value)
+      matcher = find_method_or_expr
+      if matcher.respond_to?(:match)
+        matcher.match(value).to_s == value
+      else
+        matcher.call(value)
+      end
+    end
+
+    def find_method_or_expr
+      s = statement
+      case s
+        when 'CDATA'                      # unparsed character data e.g. '<not-xml>'; may not contain string ']]>'
+          proc do |val| val.match(CDATA_EXPR).nil? end
+        when 'ID'       then ID_EXPR # does not check for uniqueness!
+        when 'IDREF'                      # id of another doc
+          proc do |val| val.match(ID_EXPR) && resolve_ref(val, subject.meta) end
+        when 'IDREFS'                     # ids of other elements
+          proc do |val|
+            separate_list val do |sub_val|
+              sub_val.match(ID_EXPR) && resolve_ref(sub_val, subject.meta)
+            end
+          end
+        when 'NMTOKEN'  then NMTOKEN_EXPR # valid XML name
+        when 'NMTOKENS'                   # a list of valid XML names
+          proc do |val|
+            separate_list val do |sub_val|
+              sub_val.match NMTOKEN_EXPR
+            end
+          end
+        when 'ENTITY'   then ENTITY_EXPR	# an entity
+        when 'ENTITIES'                   # list of entities
+          proc do |val|
+            separate_list val do |sub_val|
+              sub_val.match ENTITY_EXPR
+            end
+          end
+        when 'NOTATION' then //	# TODO name of a notation
+        when 'xml:'     then // # TODO predefined XML value
+        else                    # '|'-separated list of allowable values i.e. Regexp-style DTD declaration
+          Regexp.new(s)
+      end
+    end # def find_method_or_expr
+
+    def separate_list(spc_sep_vals, &block)
+      spc_sep_vals.split(' ').any? do |sub_val|
+        result = block.call sub_val
+        !result
+      end
+    end
+  end # module ValueRule
+end # module Duxml