duxml 0.8.8 → 0.8.9

data/lib/duxml/meta/grammar.rb

@@ -1,134 +1,134 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/../reportable')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/spreadsheet')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/pattern_maker')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/children_rule')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/attrs_rule')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/value_rule')
-require File.expand_path(File.dirname(__FILE__) + '/../doc/lazy_ox')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/text_rule')
-require File.expand_path(File.dirname(__FILE__) + '/grammar/relax_ng')
-require 'forwardable'
-
-module Duxml
-  # module shares name with <grammar> to activate its methods when that XML Element is encountered in a Meta file
-  module Grammar
-    include Reportable
-    include Duxml
-    include Spreadsheet
-    include PatternMaker
-    include LazyOx
-    include RelaxNG
-  end
-  # contains Duxml::Rules and can apply them by validating XML or qualifying user input
-  # reporting Duxml::Errors to History as needed
-  class GrammarClass
-    extend Forwardable
-    include Grammar
-
-    # @param rules [[RuleClass]] optional, can initialize grammar with rules
-    def initialize(rules=[])
-      @rules = rules
-    end
-
-    def_delegators :@rules, :<<, :[], :each
-    attr_reader :rules
-    alias_method :nodes, :rules
-  end
-
-  module Grammar
-    # @param path [String] path of grammar file; can be in .xlsx, .csv or Duxml GrammarClass file
-    # @return [GrammarClass, Element] XML Element named <grammar> and GrammarClass object are functionally equivalent
-    def self.import(path)
-      if %w(.xlsx .csv).include?(File.extname path)
-        doc = Spreadsheet.sheet_to_xml path
-        File.write(File.basename(path)+'.xml', Ox.dump(doc)) #TODO make optional!
-        doc
-      else
-        Ox.parse_obj(File.read path)
-      end
-    end
-
-    # @return [Doc] returns self as XML document
-    def xml
-      Element.new('grammar') << rules.collect do |rule| rule.xml end
-    end
-
-    # @return [History] history that this grammar is currently reporting to
-    def history
-      @observer_peers.first.first if @observer_peers and @observer_peers.any? and @observer_peers.first.any?
-    end
-
-    # @return [Boolean] whether or not any rules have been defined yet in this grammar
-    def defined?
-      !rules.empty?
-    end
-
-    # @param obj [Object] object that will observe this grammar's rules, usually the History
-    def add_observer(obj, sym=nil)
-      super(obj, sym || :update)
-      @rules.each do |r| r.add_observer(obj, :update)end
-    end
-
-    # @return [String] lists XML schema and content rules in order of precedence
-    def description
-    "grammar follows: \n" +
-        rules.collect do |change_or_error|
-          change_or_error.description
-        end.join("\n")
-    end
-
-    # @return [String] formatted to appear in tight spaces e.g. debugger
-    def inspect
-      "#<#{self.class.to_s} #{object_id}: @rules=#{rules.size}>"
-    end
-
-    # @return [String] 'grammar'
-    def name
-      'grammar'
-    end
-
-    # @param node [Duxml::Object] applies grammar rules to all relationships of the given object
-    # @result [Boolean] whether all rules qualified
-    def validate(node)
-      rels = get_relationships(node)
-      results = rels.collect do |rel|
-        qualify rel
-      end
-      any_disqualified = results.any? do |qualified| !qualified end
-      !any_disqualified
-    end # def validate
-
-    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] applies applicable rule type and subject
-    #   to given change_or_pattern and generates errors when disqualified
-    # @return [Boolean] false if any rule disqualifies; true if they all pass
-    def qualify(change_or_pattern)
-      return true unless self.defined?
-      rules = get_rule(change_or_pattern)
-
-      # define behaviors for when there are no rules applying to a given pattern
-      if rules.empty?
-
-        if change_or_pattern.respond_to?(:text) or
-            change_or_pattern.respond_to?(:value) or
-            change_or_pattern.subject.is_a?(Doc)
-          return true
-        end
-        report(:ValidateError, change_or_pattern)
-        return false
-      end
-      results = rules.collect do |rule|
-        rule.qualify change_or_pattern
-      end
-      !results.any? do |qualified| !qualified end
-    end # def qualify
-
-    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern to be qualified
-    # @return [Array[Duxml::Rule]] rules that match the pattern type (e.g. :change_content => :content_rule)
-    #   and subject (e.g. change_or_pattern.subject.type => 'blobs' && rule.subject => 'blobs')
-    def get_rule(change_or_pattern)
-      rules.select do |rule| rule.applies_to?(change_or_pattern) end
-    end # def get_rules
-  end # module Grammar
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../reportable')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/spreadsheet')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/pattern_maker')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/children_rule')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/attrs_rule')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/value_rule')
+require File.expand_path(File.dirname(__FILE__) + '/../doc/lazy_ox')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/rule/text_rule')
+require File.expand_path(File.dirname(__FILE__) + '/grammar/relax_ng')
+require 'forwardable'
+
+module Duxml
+  # module shares name with <grammar> to activate its methods when that XML Element is encountered in a Meta file
+  module Grammar
+    include Reportable
+    include Duxml
+    include Spreadsheet
+    include PatternMaker
+    include LazyOx
+    include RelaxNG
+  end
+  # contains Duxml::Rules and can apply them by validating XML or qualifying user input
+  # reporting Duxml::Errors to History as needed
+  class GrammarClass
+    extend Forwardable
+    include Grammar
+
+    # @param rules [[RuleClass]] optional, can initialize grammar with rules
+    def initialize(rules=[])
+      @rules = rules
+    end
+
+    def_delegators :@rules, :<<, :[], :each
+    attr_reader :rules
+    alias_method :nodes, :rules
+  end
+
+  module Grammar
+    # @param path [String] path of grammar file; can be in .xlsx, .csv or Duxml GrammarClass file
+    # @return [GrammarClass, Element] XML Element named <grammar> and GrammarClass object are functionally equivalent
+    def self.import(path)
+      if %w(.xlsx .csv).include?(File.extname path)
+        doc = Spreadsheet.sheet_to_xml path
+        File.write(File.basename(path)+'.xml', Ox.dump(doc)) #TODO make optional!
+        doc
+      else
+        Ox.parse_obj(File.read path)
+      end
+    end
+
+    # @return [Doc] returns self as XML document
+    def xml
+      Element.new('grammar') << rules.collect do |rule| rule.xml end
+    end
+
+    # @return [History] history that this grammar is currently reporting to
+    def history
+      @observer_peers.first.first if @observer_peers and @observer_peers.any? and @observer_peers.first.any?
+    end
+
+    # @return [Boolean] whether or not any rules have been defined yet in this grammar
+    def defined?
+      !rules.empty?
+    end
+
+    # @param obj [Object] object that will observe this grammar's rules, usually the History
+    def add_observer(obj, sym=nil)
+      super(obj, sym || :update)
+      @rules.each do |r| r.add_observer(obj, :update)end
+    end
+
+    # @return [String] lists XML schema and content rules in order of precedence
+    def description
+    "grammar follows: \n" +
+        rules.collect do |change_or_error|
+          change_or_error.description
+        end.join("\n")
+    end
+
+    # @return [String] formatted to appear in tight spaces e.g. debugger
+    def inspect
+      "#<#{self.class.to_s} #{object_id}: @rules=#{rules.size}>"
+    end
+
+    # @return [String] 'grammar'
+    def name
+      'grammar'
+    end
+
+    # @param node [Duxml::Object] applies grammar rules to all relationships of the given object
+    # @result [Boolean] whether all rules qualified
+    def validate(node)
+      rels = get_relationships(node)
+      results = rels.collect do |rel|
+        qualify rel
+      end
+      any_disqualified = results.any? do |qualified| !qualified end
+      !any_disqualified
+    end # def validate
+
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] applies applicable rule type and subject
+    #   to given change_or_pattern and generates errors when disqualified
+    # @return [Boolean] false if any rule disqualifies; true if they all pass
+    def qualify(change_or_pattern)
+      return true unless self.defined?
+      rules = get_rule(change_or_pattern)
+
+      # define behaviors for when there are no rules applying to a given pattern
+      if rules.empty?
+
+        if change_or_pattern.respond_to?(:text) or
+            change_or_pattern.respond_to?(:value) or
+            change_or_pattern.subject.is_a?(Doc)
+          return true
+        end
+        report(:ValidateError, change_or_pattern)
+        return false
+      end
+      results = rules.collect do |rule|
+        rule.qualify change_or_pattern
+      end
+      !results.any? do |qualified| !qualified end
+    end # def qualify
+
+    # @param change_or_pattern [Duxml::Change, Duxml::Pattern] change or pattern to be qualified
+    # @return [Array[Duxml::Rule]] rules that match the pattern type (e.g. :change_content => :content_rule)
+    #   and subject (e.g. change_or_pattern.subject.type => 'blobs' && rule.subject => 'blobs')
+    def get_rule(change_or_pattern)
+      rules.select do |rule| rule.applies_to?(change_or_pattern) end
+    end # def get_rules
+  end # module Grammar
 end # module Duxml

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

@@ -1,112 +1,112 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/../../ruby_ext/string')
-
-module Duxml
-  # Patterns represent a relationship between a specific XML Element and
-  # a specific or hypothetical attribute, attribute value, text value or child Element
-  # For example, given an XML Element: '<element attr='value'/>', there exists a valid PatternClass
-  # that represents the relationship betweeen <element> and the attribute value 'value'
-  # There can also exists a hypothetical relationship between <element> and a new child <child/> that
-  # is defined as an allowed child Element in the Rules that apply to this Element.
-  module Pattern; end
-
-  # as an object, a Pattern consists of a subject and may or may not have an object
-  # a Pattern without an object represents a childless empty node with no attributes
-  # this class must be subclassed to be used; there is one for each type of XML relationship
-  # that an Element can have up to one degree of separation, that is, grandparent relationships are not considered
-  # and neither are the attributes of children
-  class PatternClass
-    include Pattern
-    @subject
-
-    # @param subj [Element] specific Element that is the subject of this pattern
-    def initialize(subj)
-      @subject = subj
-    end
-
-    attr_reader :subject
-  end
-
-  module Pattern
-    include Duxml
-
-    def xml
-      p = Element.new(simple_name)
-      instance_variables.each do |sym|
-        val = instance_variable_get(sym)
-        if val.respond_to?(:nodes)
-          d = Element.new(sym.to_s) << val
-          p << d
-        else
-          p[sym.to_s[1..-1].to_sym] = val.to_s unless sym == :@observer_peers
-        end
-      end
-      p
-    end
-
-    # @return [String] nmtoken name of this pattern without namespace prefix e.g. ChildPattern.new(parent, child).name => 'child_pattern'
-    def simple_name
-      name.split(':').last
-    end
-
-    # @return [Boolean] if either subject or object points to a name/type i.e. not an Element
-    def abstract?
-      subject.is_a?(String) or object.nil?
-    end
-
-    # @return [Boolean] if both subject and at least one object point to an actual XML Element
-    def concrete?
-      !abstract?
-    end
-
-    # @return [String] nmtoken name of this pattern e.g. ChildPattern.new(parent, child).name => 'duxml:child_pattern'
-    def name
-      c = self.class.to_s
-      return c.nmtokenize unless c.include?('::')
-      a =  c.split('::')
-      a[-2..-1].collect do |word|
-        word.nmtokenize
-      end.join(':')
-    end
-
-    # returns relationship description as string by subtracting super class name
-    # (e.g. 'pattern' or 'rule') from simple_class
-    # Duxml::ChildrenRule#relationship => 'children'
-    # Duxml::TextPattern#relationship => 'text'
-    # can be overridden if class name does not match human-readable string
-    # @return [String] single word to describe relationship of subject to object
-    def relationship
-      simple_name.split('_').first
-    end
-
-    # @return [String] "#{object.description} is #{relationship} of #{subject.description}"
-    def description
-      "#{object.description} is #{relationship} of #{subject.description}"
-    end
-
-    # @return [Element] will only return non-nil value when pattern represents relationship with a child Element
-    def object
-      return @object if instance_variable_defined?(:@object)
-      instance_variables.each do |var|
-        target = instance_variable_get(var)
-        return target unless target.is_a?(String) or target == subject
-      end
-      nil
-    end
-
-    # @param pattern [Duxml::Pattern] pattern or any subclass object
-    # @return [Fixnum] first applies <=> to subjects, and if equal, applies <=> to objects
-    def <=>(pattern)
-      return 1 unless pattern.respond_to?(:subject)
-      case subject <=> pattern.subject
-        when -1 then
-          -1
-        when 0 then
-          object <=> pattern.object
-        else
-          -1
-      end
-    end # def <=>
-  end # module Pattern
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../../ruby_ext/string')
+
+module Duxml
+  # Patterns represent a relationship between a specific XML Element and
+  # a specific or hypothetical attribute, attribute value, text value or child Element
+  # For example, given an XML Element: '<element attr='value'/>', there exists a valid PatternClass
+  # that represents the relationship betweeen <element> and the attribute value 'value'
+  # There can also exists a hypothetical relationship between <element> and a new child <child/> that
+  # is defined as an allowed child Element in the Rules that apply to this Element.
+  module Pattern; end
+
+  # as an object, a Pattern consists of a subject and may or may not have an object
+  # a Pattern without an object represents a childless empty node with no attributes
+  # this class must be subclassed to be used; there is one for each type of XML relationship
+  # that an Element can have up to one degree of separation, that is, grandparent relationships are not considered
+  # and neither are the attributes of children
+  class PatternClass
+    include Pattern
+    @subject
+
+    # @param subj [Element] specific Element that is the subject of this pattern
+    def initialize(subj)
+      @subject = subj
+    end
+
+    attr_reader :subject
+  end
+
+  module Pattern
+    include Duxml
+
+    def xml
+      p = Element.new(simple_name)
+      instance_variables.each do |sym|
+        val = instance_variable_get(sym)
+        if val.respond_to?(:nodes)
+          d = Element.new(sym.to_s) << val
+          p << d
+        else
+          p[sym.to_s[1..-1].to_sym] = val.to_s unless sym == :@observer_peers
+        end
+      end
+      p
+    end
+
+    # @return [String] nmtoken name of this pattern without namespace prefix e.g. ChildPattern.new(parent, child).name => 'child_pattern'
+    def simple_name
+      name.split(':').last
+    end
+
+    # @return [Boolean] if either subject or object points to a name/type i.e. not an Element
+    def abstract?
+      subject.is_a?(String) or object.nil?
+    end
+
+    # @return [Boolean] if both subject and at least one object point to an actual XML Element
+    def concrete?
+      !abstract?
+    end
+
+    # @return [String] nmtoken name of this pattern e.g. ChildPattern.new(parent, child).name => 'duxml:child_pattern'
+    def name
+      c = self.class.to_s
+      return c.nmtokenize unless c.include?('::')
+      a =  c.split('::')
+      a[-2..-1].collect do |word|
+        word.nmtokenize
+      end.join(':')
+    end
+
+    # returns relationship description as string by subtracting super class name
+    # (e.g. 'pattern' or 'rule') from simple_class
+    # Duxml::ChildrenRule#relationship => 'children'
+    # Duxml::TextPattern#relationship => 'text'
+    # can be overridden if class name does not match human-readable string
+    # @return [String] single word to describe relationship of subject to object
+    def relationship
+      simple_name.split('_').first
+    end
+
+    # @return [String] "#{object.description} is #{relationship} of #{subject.description}"
+    def description
+      "#{object.description} is #{relationship} of #{subject.description}"
+    end
+
+    # @return [Element] will only return non-nil value when pattern represents relationship with a child Element
+    def object
+      return @object if instance_variable_defined?(:@object)
+      instance_variables.each do |var|
+        target = instance_variable_get(var)
+        return target unless target.is_a?(String) or target == subject
+      end
+      nil
+    end
+
+    # @param pattern [Duxml::Pattern] pattern or any subclass object
+    # @return [Fixnum] first applies <=> to subjects, and if equal, applies <=> to objects
+    def <=>(pattern)
+      return 1 unless pattern.respond_to?(:subject)
+      case subject <=> pattern.subject
+        when -1 then
+          -1
+        when 0 then
+          object <=> pattern.object
+        else
+          -1
+      end
+    end # def <=>
+  end # module Pattern
 end # module Duxml