duxml 0.8.8 → 0.8.9

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

@@ -1,59 +1,59 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/pattern')
-require File.expand_path(File.dirname(__FILE__) + '/../../reportable')
-
-module Duxml
-  # scans DTD statements for XML rule operators
-  Struct.new 'Scanner', :match, :operator
-
-  # contains methods to apply Duxml::RuleClass to XML edit or validate events
-  module Rule
-    include Reportable
-  end
-
-  # as an object, Rules consist of a subject, representing the XML Element, and a statement representing the Rule's logic
-  # this class cannot be used alone and is rather subclassed, one for each type of possible XML changes
-  class RuleClass < PatternClass
-    include Rule
-
-    # @param subj [String] NMTOKEN name of element this rule applies to
-    # @param _statement [String, Regexp] string statement of rule in DTD declaration form or Regexp
-    def initialize(subj, _statement)
-      @statement = _statement
-      @object = nil
-      super subj
-    end
-
-    attr_reader :statement, :object
-  end
-
-  module Rule
-    # Duxml::Rule's #qualify is only used to report errors found by its subclasses' #qualify methods
-    # @param change_or_pattern [Duxml::Pattern, Duxml::Change] Change or Pattern to be reported for Rule violation
-    # @return [Boolean] always false; this method should always be subclassed to apply that specific rule type's #qualify
-    def qualify(change_or_pattern)
-      type = (change_or_pattern.respond_to?(:time_stamp)) ? :QualifyError : :ValidateError
-      report(type, change_or_pattern)
-      false
-    end
-
-    # @return [HistoryClass] history to which this rule will report errors
-    def history
-      @observer_peers.first.first if @observer_peers.any? and @observer_peers.first.any?
-    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)
-      pattern_type = change_or_pattern.subject.name
-      subject == pattern_type
-    end
-
-    # @return [String] default description for a Rule
-    def description
-      statement_str = (statement.is_a?(String) ? statement : statement.inspect).gsub('\b','')
-      %(#{relationship.capitalize} Rule that <#{subject}>'s #{relationship} must match '#{statement_str}')
-    end
-  end # module Rule
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/pattern')
+require File.expand_path(File.dirname(__FILE__) + '/../../reportable')
+
+module Duxml
+  # scans DTD statements for XML rule operators
+  Struct.new 'Scanner', :match, :operator
+
+  # contains methods to apply Duxml::RuleClass to XML edit or validate events
+  module Rule
+    include Reportable
+  end
+
+  # as an object, Rules consist of a subject, representing the XML Element, and a statement representing the Rule's logic
+  # this class cannot be used alone and is rather subclassed, one for each type of possible XML changes
+  class RuleClass < PatternClass
+    include Rule
+
+    # @param subj [String] NMTOKEN name of element this rule applies to
+    # @param _statement [String, Regexp] string statement of rule in DTD declaration form or Regexp
+    def initialize(subj, _statement)
+      @statement = _statement
+      @object = nil
+      super subj
+    end
+
+    attr_reader :statement, :object
+  end
+
+  module Rule
+    # Duxml::Rule's #qualify is only used to report errors found by its subclasses' #qualify methods
+    # @param change_or_pattern [Duxml::Pattern, Duxml::Change] Change or Pattern to be reported for Rule violation
+    # @return [Boolean] always false; this method should always be subclassed to apply that specific rule type's #qualify
+    def qualify(change_or_pattern)
+      type = (change_or_pattern.respond_to?(:time_stamp)) ? :QualifyError : :ValidateError
+      report(type, change_or_pattern)
+      false
+    end
+
+    # @return [HistoryClass] history to which this rule will report errors
+    def history
+      @observer_peers.first.first if @observer_peers.any? and @observer_peers.first.any?
+    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)
+      pattern_type = change_or_pattern.subject.name
+      subject == pattern_type
+    end
+
+    # @return [String] default description for a Rule
+    def description
+      statement_str = (statement.is_a?(String) ? statement : statement.inspect).gsub('\b','')
+      %(#{relationship.capitalize} Rule that <#{subject}>'s #{relationship} must match '#{statement_str}')
+    end
+  end # module Rule
 end # module Duxml

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

@@ -1,78 +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
+# 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

@@ -1,136 +1,136 @@
-# 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 currently being scanned
-    def child_index
-      object.parent.nodes.size-child_stack.size-1
-    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
+# 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 currently being scanned
+    def child_index
+      object.parent.nodes.size-child_stack.size-1
+    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