duxml 0.8.8 → 0.8.9

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

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

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

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

@@ -1,35 +1,35 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require 'rubyXL'
-
-module Duxml
-  # contains helper methods to convert spreadsheet of DTD rules into Duxml::Rules
-  module Spreadsheet
-    private
-  # @param path [String] spreadsheet file
-    def self.sheet_to_xml(path)
-      worksheet = RubyXL::Parser.parse(path)[0]
-      attr_val_rule_hash = {}
-      g = GrammarClass.new
-      worksheet.each_with_index do |row, index|
-        next if index == 0
-        break if row[3].nil? || row[4].nil?
-        element_name = row[3].value
-        statement_str = row[4].value
-        g << ChildrenRuleClass.new(element_name, statement_str)
-        attribute_rules = row[5].value.split(/\n/)
-        attribute_rules.each_with_index do |rule, i|
-          next if i == 0 or rule.empty?
-          attr_name, value_expr, attr_req = *rule.split
-          next if [attr_name, value_expr, attr_req].any? do |s| s.empty? or s.match(/\w/).nil? end
-          g << AttrsRuleClass.new(element_name, attr_name, attr_req)
-          unless attr_val_rule_hash[attr_name]
-            g << ValueRuleClass.new(attr_name, value_expr)
-            attr_val_rule_hash[attr_name] = true
-          end
-        end # attribute_rules.each_with_index
-      end # worksheet.each_with_index
-      g
-    end # def sheet_to_xml(path)
-  end # module Spreadsheet
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require 'rubyXL'
+
+module Duxml
+  # contains helper methods to convert spreadsheet of DTD rules into Duxml::Rules
+  module Spreadsheet
+    private
+  # @param path [String] spreadsheet file
+    def self.sheet_to_xml(path)
+      worksheet = RubyXL::Parser.parse(path)[0]
+      attr_val_rule_hash = {}
+      g = GrammarClass.new
+      worksheet.each_with_index do |row, index|
+        next if index == 0
+        break if row[3].nil? || row[4].nil?
+        element_name = row[3].value
+        statement_str = row[4].value
+        g << ChildrenRuleClass.new(element_name, statement_str)
+        attribute_rules = row[5].value.split(/\n/)
+        attribute_rules.each_with_index do |rule, i|
+          next if i == 0 or rule.empty?
+          attr_name, value_expr, attr_req = *rule.split
+          next if [attr_name, value_expr, attr_req].any? do |s| s.empty? or s.match(/\w/).nil? end
+          g << AttrsRuleClass.new(element_name, attr_name, attr_req)
+          unless attr_val_rule_hash[attr_name]
+            g << ValueRuleClass.new(attr_name, value_expr)
+            attr_val_rule_hash[attr_name] = true
+          end
+        end # attribute_rules.each_with_index
+      end # worksheet.each_with_index
+      g
+    end # def sheet_to_xml(path)
+  end # module Spreadsheet
 end # module Duxml

data/lib/duxml/meta/history.rb

@@ -1,89 +1,89 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/history/add')
-require File.expand_path(File.dirname(__FILE__) + '/history/remove')
-require File.expand_path(File.dirname(__FILE__) + '/history/validate_error')
-require File.expand_path(File.dirname(__FILE__) + '/history/qualify_error')
-require File.expand_path(File.dirname(__FILE__) + '/history/new_attr')
-require File.expand_path(File.dirname(__FILE__) + '/history/change_attr')
-require File.expand_path(File.dirname(__FILE__) + '/history/new_text')
-require File.expand_path(File.dirname(__FILE__) + '/history/change_text')
-require File.expand_path(File.dirname(__FILE__) + '/history/undo')
-require File.expand_path(File.dirname(__FILE__) + '/../doc')
-require 'forwardable'
-
-module Duxml
-  # monitors XML Elements for changes and GrammarClass for errors, recording them and saving to Meta file
-  module History
-    include Duxml
-    include Reportable
-  end
-
-  # as an object, HistoryClass holds events latest first, earliest last
-  # it also has delegators that allow the use of Array-style notation e.g. '[]' and #each to search the history.
-  class HistoryClass
-    include History
-    extend Forwardable
-
-    def_delegators :@nodes, :[], :each
-
-    # @param strict_or_false [Boolean] by default strict i.e. true so that if this History detects an error it will raise an Exception; otherwise not
-    def initialize(strict_or_false = true)
-      @nodes = []
-      @strict = strict_or_false
-    end
-
-    attr_reader :nodes
-    alias_method :events, :nodes
-  end
-
-  module History
-    # used when creating a new metadata file for a static XML file
-    #
-    # @return [Doc] returns self as XML document
-    def xml
-      h = Element.new('history')
-      events.each do |event| h << event.xml end
-      h
-    end
-
-    # @return [Boolean] toggles (true by default) whether History will raise exception or tolerate qualify errors
-    def strict?(strict_or_false=nil)
-      @strict = strict_or_false.nil? ? @strict : strict_or_false
-    end
-
-    # @return [ChangeClass, ErrorClass] the latest event
-    def latest
-      events[0]
-    end
-
-    # @return [GrammarClass] grammar that is observing this history's events
-    def grammar
-      @observer_peers.first.first if @observer_peers and @observer_peers.any? and @observer_peers.first.any?
-    end
-
-    # @return [String] shortened self description for debugging
-    def inspect
-      "#<#{self.class.to_s} #{object_id}: @events=#{nodes.size}>"
-    end
-
-    # @return [String] returns entire history, calling #description on each event in chronological order
-    def description
-      "history follows: \n" +
-      events.reverse.collect do |change_or_error|
-        change_or_error.description
-      end.join("\n")
-    end
-
-    # @param type [Symbol] category i.e. class symbol of changes/errors reported
-    # @param *args [*several_variants] information needed to accurately log the event; varies by change/error class
-    def update(type, *args)
-      change_class = Duxml::const_get "#{type.to_s}Class".to_sym
-      change_comp = change_class.new *args
-      @nodes.unshift change_comp
-      changed
-      notify_observers(change_comp) unless change_comp.respond_to?(:error?)
-      raise(Exception, change_comp.description) if strict? && type == :QualifyError
-    end
-  end # module History
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/history/add')
+require File.expand_path(File.dirname(__FILE__) + '/history/remove')
+require File.expand_path(File.dirname(__FILE__) + '/history/validate_error')
+require File.expand_path(File.dirname(__FILE__) + '/history/qualify_error')
+require File.expand_path(File.dirname(__FILE__) + '/history/new_attr')
+require File.expand_path(File.dirname(__FILE__) + '/history/change_attr')
+require File.expand_path(File.dirname(__FILE__) + '/history/new_text')
+require File.expand_path(File.dirname(__FILE__) + '/history/change_text')
+require File.expand_path(File.dirname(__FILE__) + '/history/undo')
+require File.expand_path(File.dirname(__FILE__) + '/../doc')
+require 'forwardable'
+
+module Duxml
+  # monitors XML Elements for changes and GrammarClass for errors, recording them and saving to Meta file
+  module History
+    include Duxml
+    include Reportable
+  end
+
+  # as an object, HistoryClass holds events latest first, earliest last
+  # it also has delegators that allow the use of Array-style notation e.g. '[]' and #each to search the history.
+  class HistoryClass
+    include History
+    extend Forwardable
+
+    def_delegators :@nodes, :[], :each
+
+    # @param strict_or_false [Boolean] by default strict i.e. true so that if this History detects an error it will raise an Exception; otherwise not
+    def initialize(strict_or_false = true)
+      @nodes = []
+      @strict = strict_or_false
+    end
+
+    attr_reader :nodes
+    alias_method :events, :nodes
+  end
+
+  module History
+    # used when creating a new metadata file for a static XML file
+    #
+    # @return [Doc] returns self as XML document
+    def xml
+      h = Element.new('history')
+      events.each do |event| h << event.xml end
+      h
+    end
+
+    # @return [Boolean] toggles (true by default) whether History will raise exception or tolerate qualify errors
+    def strict?(strict_or_false=nil)
+      @strict = strict_or_false.nil? ? @strict : strict_or_false
+    end
+
+    # @return [ChangeClass, ErrorClass] the latest event
+    def latest
+      events[0]
+    end
+
+    # @return [GrammarClass] grammar that is observing this history's events
+    def grammar
+      @observer_peers.first.first if @observer_peers and @observer_peers.any? and @observer_peers.first.any?
+    end
+
+    # @return [String] shortened self description for debugging
+    def inspect
+      "#<#{self.class.to_s} #{object_id}: @events=#{nodes.size}>"
+    end
+
+    # @return [String] returns entire history, calling #description on each event in chronological order
+    def description
+      "history follows: \n" +
+      events.reverse.collect do |change_or_error|
+        change_or_error.description
+      end.join("\n")
+    end
+
+    # @param type [Symbol] category i.e. class symbol of changes/errors reported
+    # @param *args [*several_variants] information needed to accurately log the event; varies by change/error class
+    def update(type, *args)
+      change_class = Duxml::const_get "#{type.to_s}Class".to_sym
+      change_comp = change_class.new *args
+      @nodes.unshift change_comp
+      changed
+      notify_observers(change_comp) unless change_comp.respond_to?(:error?)
+      raise(Exception, change_comp.description) if strict? && type == :QualifyError
+    end
+  end # module History
 end # module Duxml