duxml 0.8.8 → 0.8.9

data/lib/duxml/doc/lazy_ox.rb

@@ -1,168 +1,168 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/../ruby_ext/string')
-
-
-module Duxml
-  module LazyOx
-  # welcome to Lazy-Ox - where any method that doesn't exist, you can create on the fly and assign its methods to
-  # a corresponding Duxml::Element. see Regexp.nmtoken and String#nmtokenize and String#constantize to see how a given symbol
-  # can be converted into XML element names and vice versa. it can also use Class names as method calls to return children by type
-  #
-  # this method uses Ox::Element's :method_missing but adds an additional rescue block that:
-  #   matches namespaced Ruby module to this Element's name and extends this node with module's methods
-  #   then method matching symbol is called again with given arguments, yielding result to block if given, returning result if not
-  #   e.g.
-  #     module Duxml
-  #       module Throwable
-  #         def throw
-  #           puts 'throwing!!'
-  #         end
-  #       end
-  #     end
-  #
-  #     Element.new('throwable').throw => 'throwing!!'
-  #
-  #   if symbol name matches a class then method yields to block or returns as array child nodes that matches class
-  #   you can further refine search results by adding the symbol of the child instance variable, including name, by which to filter
-  #   if block given, returns first child for which block evaluates to true
-  #
-  #   e.g.
-#       class Child; end
-  #
-  #     n = Element.new('node')
-  #     n << 'text'
-  #     n << Element.new('child')
-  #     n << Element.new('child')
-  #     n.Element                                                      # returns Array of Element nodes
-  #         => [#<Duxml::Element:0x0002 @value="child" ...>,
-  #             #<Duxml::Element:0x0003 @value="child" ...>]
-  #
-  #     n.Element.each do |child| child << 'some text' end              # adding some text
-  #         => ['text',
-  #             #<Duxml::Element:0x0002 @value="child" ... @nodes=['some text']>,
-  #             #<Duxml::Element 0x0003 @value="child" ... @nodes=['some text']>]
-  #
-  #     n.Element do |child| child.nodes.first == 'some text' end                             # returns all children for which block is true
-  #         => [#<Duxml::Element:0x0002 @value="child" ... @nodes=['some text']>]
-  #
-  #     %w(bar mar).each_with_index do |x, i| next if i.zero?; n.Child[:foo] = x end        # adding some attributes
-  #         => ['text',
-  #             #<Duxml::Element:0x0002 @value="child" @attributes={foo: 'bar'} ...>,
-  #             #<Duxml::Element:0x0003 @value="child" @attributes={foo: 'mar'} ...>]
-  #
-  #     n.Element(:foo)                                                                       # returns array of Child nodes with attribute :foo
-  #         => [#<Duxml::Element:0x0002 @value="child" @attributes={foo: 'bar'} ...>,
-  #             #<Duxml::Element:0x0003 @value="child" @attributes={foo: 'mar'} ...>]
-  #
-  #     n.Element(foo: 'bar')                                                                 # returns array of Child nodes with attribute :foo equal to 'bar'
-  #         => [#<Duxml::Element:0xfff @value="child" @attributes={foo: 'bar'} ...>]
-  #
-  #
-  #   if element name has no matching Class or Module in namespace,
-  #     if symbol is lower case, it is made into a method, given &block as definition, then called with *args
-  #       e.g. n.change_color('blue') do |new_color|  => #<Duxml::Element:0xfff @value="node" @attributes={color: 'blue'} @nodes=[]>
-  #              @color = new_color
-  #              self
-  #            end
-  #            n.color                                => 'blue'
-  #            n.change_color('mauve').color          => 'mauve'
-  #
-  # @param sym [Symbol] method, class or module
-  # @param *args [*several_variants] either arguments to method or initializing values for instance of given class
-  # @param &block [block] if yielding result, yields to given block; if defining new method, block defines its contents
-    def method_missing(sym, *args, &block)
-      if respond_to?(:name)
-        ns = name.split(':').first
-        if ns and ns != name
-          target = locate(ns + ':' + sym.to_s).first
-          return target if target
-        end
-      end
-      super(sym, *args, &block)
-    rescue Exception => orig_error
-      begin
-        # handling Constant look up to dynamically extend or add to element
-        if lowercase?(sym)
-          if (const = look_up_const) and const.is_a?(Module)
-            extend const
-            result = method(sym).call(*args)
-            return(result) unless block_given?
-            yield(result)
-          elsif block_given?
-            new_method = proc(&block)
-            self.const_set(sym, new_method)
-            return new_method.call *args
-          else
-            raise orig_error
-          end # if (const = look_up_const) ... elsif block_given? ... else ...
-        else
-          results = filter(sym, args)
-          return results unless block_given?
-          results.keep_if do |node| yield(node) end
-        end # if lowercase? ... else ...
-      rescue Exception
-        raise orig_error
-      end
-    end # def method_missing(sym, *args, &block)
-
-    private
-
-    # @param sym [Symbol] indicates which element type is being filtered for
-    # @param args [several_variants] arguments for filtering element children that matched 'sym'
-    # @return [[Element]] Elements of type 'sym' that match criteria 'args'
-    def filter(sym, args)
-      class_nodes = nodes.select do |node|
-        node.name == sym.to_s.nmtokenize or simple_class(node) == sym.to_s
-      end
-      class_nodes.keep_if do |node|
-        if args.empty?
-          true
-        else
-          args.any? do |arg|
-            if arg.is_a?(Hash)
-              node[arg.first.first] == arg.first.last
-            else
-              !node[arg].nil?
-            end
-          end
-        end # if args.empty? ... else ...
-      end # class_nodes.keep_if do |node|
-    end # def filter(args)
-
-    # @param maudule [Module] module context in which to look for duck-called method's module
-    # @return [Module, Class] requested module or class
-    def look_up_const(maudule = Duxml)
-      mod_names = name.split(':')
-      until mod_names.empty?
-        k = mod_names.shift.constantize
-        case
-          when maudule.const_defined?(k, true)
-          when Module.const_defined?(simple_class, true)
-            k = simple_class
-          else
-            return nil
-        end
-        const = maudule.const_get(k)
-        if const.is_a?(Module)
-          maudule = const
-        end
-
-        return const if mod_names.empty? and [Module, Class].include?(const.class)
-      end
-      nil
-    end
-
-    # @param sym [Symbol] symbol for a constant
-    # @return [Boolean] is symbol lowercase?
-    def lowercase?(sym)
-      sym.to_s[0].match(/[A-Z]/).nil?
-    end
-
-    # @param obj [Object] usually Element
-    # @return [String] name of final Class or Module of self
-    def simple_class(obj=self)
-      obj.class.to_s.split('::').last
-    end
-  end # module LazyOx
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/../ruby_ext/string')
+
+
+module Duxml
+  module LazyOx
+  # welcome to Lazy-Ox - where any method that doesn't exist, you can create on the fly and assign its methods to
+  # a corresponding Duxml::Element. see Regexp.nmtoken and String#nmtokenize and String#constantize to see how a given symbol
+  # can be converted into XML element names and vice versa. it can also use Class names as method calls to return children by type
+  #
+  # this method uses Ox::Element's :method_missing but adds an additional rescue block that:
+  #   matches namespaced Ruby module to this Element's name and extends this node with module's methods
+  #   then method matching symbol is called again with given arguments, yielding result to block if given, returning result if not
+  #   e.g.
+  #     module Duxml
+  #       module Throwable
+  #         def throw
+  #           puts 'throwing!!'
+  #         end
+  #       end
+  #     end
+  #
+  #     Element.new('throwable').throw => 'throwing!!'
+  #
+  #   if symbol name matches a class then method yields to block or returns as array child nodes that matches class
+  #   you can further refine search results by adding the symbol of the child instance variable, including name, by which to filter
+  #   if block given, returns first child for which block evaluates to true
+  #
+  #   e.g.
+#       class Child; end
+  #
+  #     n = Element.new('node')
+  #     n << 'text'
+  #     n << Element.new('child')
+  #     n << Element.new('child')
+  #     n.Element                                                      # returns Array of Element nodes
+  #         => [#<Duxml::Element:0x0002 @value="child" ...>,
+  #             #<Duxml::Element:0x0003 @value="child" ...>]
+  #
+  #     n.Element.each do |child| child << 'some text' end              # adding some text
+  #         => ['text',
+  #             #<Duxml::Element:0x0002 @value="child" ... @nodes=['some text']>,
+  #             #<Duxml::Element 0x0003 @value="child" ... @nodes=['some text']>]
+  #
+  #     n.Element do |child| child.nodes.first == 'some text' end                             # returns all children for which block is true
+  #         => [#<Duxml::Element:0x0002 @value="child" ... @nodes=['some text']>]
+  #
+  #     %w(bar mar).each_with_index do |x, i| next if i.zero?; n.Child[:foo] = x end        # adding some attributes
+  #         => ['text',
+  #             #<Duxml::Element:0x0002 @value="child" @attributes={foo: 'bar'} ...>,
+  #             #<Duxml::Element:0x0003 @value="child" @attributes={foo: 'mar'} ...>]
+  #
+  #     n.Element(:foo)                                                                       # returns array of Child nodes with attribute :foo
+  #         => [#<Duxml::Element:0x0002 @value="child" @attributes={foo: 'bar'} ...>,
+  #             #<Duxml::Element:0x0003 @value="child" @attributes={foo: 'mar'} ...>]
+  #
+  #     n.Element(foo: 'bar')                                                                 # returns array of Child nodes with attribute :foo equal to 'bar'
+  #         => [#<Duxml::Element:0xfff @value="child" @attributes={foo: 'bar'} ...>]
+  #
+  #
+  #   if element name has no matching Class or Module in namespace,
+  #     if symbol is lower case, it is made into a method, given &block as definition, then called with *args
+  #       e.g. n.change_color('blue') do |new_color|  => #<Duxml::Element:0xfff @value="node" @attributes={color: 'blue'} @nodes=[]>
+  #              @color = new_color
+  #              self
+  #            end
+  #            n.color                                => 'blue'
+  #            n.change_color('mauve').color          => 'mauve'
+  #
+  # @param sym [Symbol] method, class or module
+  # @param *args [*several_variants] either arguments to method or initializing values for instance of given class
+  # @param &block [block] if yielding result, yields to given block; if defining new method, block defines its contents
+    def method_missing(sym, *args, &block)
+      if respond_to?(:name)
+        ns = name.split(':').first
+        if ns and ns != name
+          target = locate(ns + ':' + sym.to_s).first
+          return target if target
+        end
+      end
+      super(sym, *args, &block)
+    rescue Exception => orig_error
+      begin
+        # handling Constant look up to dynamically extend or add to element
+        if lowercase?(sym)
+          if (const = look_up_const) and const.is_a?(Module)
+            extend const
+            result = method(sym).call(*args)
+            return(result) unless block_given?
+            yield(result)
+          elsif block_given?
+            new_method = proc(&block)
+            self.const_set(sym, new_method)
+            return new_method.call *args
+          else
+            raise orig_error
+          end # if (const = look_up_const) ... elsif block_given? ... else ...
+        else
+          results = filter(sym, args)
+          return results unless block_given?
+          results.keep_if do |node| yield(node) end
+        end # if lowercase? ... else ...
+      rescue Exception
+        raise orig_error
+      end
+    end # def method_missing(sym, *args, &block)
+
+    private
+
+    # @param sym [Symbol] indicates which element type is being filtered for
+    # @param args [several_variants] arguments for filtering element children that matched 'sym'
+    # @return [[Element]] Elements of type 'sym' that match criteria 'args'
+    def filter(sym, args)
+      class_nodes = nodes.select do |node|
+        node.name == sym.to_s.nmtokenize or simple_class(node) == sym.to_s
+      end
+      class_nodes.keep_if do |node|
+        if args.empty?
+          true
+        else
+          args.any? do |arg|
+            if arg.is_a?(Hash)
+              node[arg.first.first] == arg.first.last
+            else
+              !node[arg].nil?
+            end
+          end
+        end # if args.empty? ... else ...
+      end # class_nodes.keep_if do |node|
+    end # def filter(args)
+
+    # @param maudule [Module] module context in which to look for duck-called method's module
+    # @return [Module, Class] requested module or class
+    def look_up_const(maudule = Duxml)
+      mod_names = name.split(':')
+      until mod_names.empty?
+        k = mod_names.shift.constantize
+        case
+          when maudule.const_defined?(k, true)
+          when Module.const_defined?(simple_class, true)
+            k = simple_class
+          else
+            return nil
+        end
+        const = maudule.const_get(k)
+        if const.is_a?(Module)
+          maudule = const
+        end
+
+        return const if mod_names.empty? and [Module, Class].include?(const.class)
+      end
+      nil
+    end
+
+    # @param sym [Symbol] symbol for a constant
+    # @return [Boolean] is symbol lowercase?
+    def lowercase?(sym)
+      sym.to_s[0].match(/[A-Z]/).nil?
+    end
+
+    # @param obj [Object] usually Element
+    # @return [String] name of final Class or Module of self
+    def simple_class(obj=self)
+      obj.class.to_s.split('::').last
+    end
+  end # module LazyOx
 end # module Duxml

data/lib/duxml/doc/node_set.rb

@@ -1,39 +1,39 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require 'observer'
-
-module Duxml
-  # subclass of Array that is Observable by History
-  # used to track changes in String nodes of XML Element
-  class NodeSet < Array
-    include Observable
-
-    @parent
-
-    attr_reader :parent
-
-    # @param _parent [Element] Element that is parent to this NodeSet's elements
-    # @param ary [[String, Element]] child nodes with which to initialize this NodeSet
-    def initialize(_parent, ary=[])
-      super ary
-      @parent = _parent
-    end
-
-    # @return [HistoryClass] object that observes this NodeSet for changes
-    def history
-      @observer_peers.first.first if @observer_peers and @observer_peers.first.any?
-    end
-
-    # @param index [Fixnum] index of array where old String is to be replaced
-    # @param str [String] replacing String
-    # @return [self] reports old String and index to history
-    def []=(index, str)
-      raise Exception if count_observers < 1
-      old_str = self[index]
-      super(index, str)
-      changed
-      notify_observers(:ChangeText, parent, index, old_str)
-      self
-    end
-  end # class NodeSet < Array
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require 'observer'
+
+module Duxml
+  # subclass of Array that is Observable by History
+  # used to track changes in String nodes of XML Element
+  class NodeSet < Array
+    include Observable
+
+    @parent
+
+    attr_reader :parent
+
+    # @param _parent [Element] Element that is parent to this NodeSet's elements
+    # @param ary [[String, Element]] child nodes with which to initialize this NodeSet
+    def initialize(_parent, ary=[])
+      super ary
+      @parent = _parent
+    end
+
+    # @return [HistoryClass] object that observes this NodeSet for changes
+    def history
+      @observer_peers.first.first if @observer_peers and @observer_peers.first.any?
+    end
+
+    # @param index [Fixnum] index of array where old String is to be replaced
+    # @param str [String] replacing String
+    # @return [self] reports old String and index to history
+    def []=(index, str)
+      raise Exception if count_observers < 1
+      old_str = self[index]
+      super(index, str)
+      changed
+      notify_observers(:ChangeText, parent, index, old_str)
+      self
+    end
+  end # class NodeSet < Array
 end # module Duxml

data/lib/duxml/meta.rb

@@ -1,73 +1,73 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-
-require File.expand_path(File.dirname(__FILE__) + '/meta/grammar')
-require File.expand_path(File.dirname(__FILE__) + '/meta/history')
-require File.expand_path(File.dirname(__FILE__) + '/saxer')
-
-module Duxml
-  module Meta
-
-    FILE_EXT = '.duxml'
-  end
-
-  # all XML files ready by Duxml have a metadata file generated with a modified, matching file name
-  # @see #Meta.meta_path
-  class MetaClass
-    include Meta
-
-    # @param grammar_path [String] optional path of grammar file which can be a spreadsheet or Duxml::Grammar file
-    def initialize(grammar_path=nil)
-      @history = HistoryClass.new
-      self.grammar = grammar_path ? Grammar.import(grammar_path) : GrammarClass.new
-      @grammar_path = grammar_path
-    end
-
-    attr_reader :history, :grammar, :grammar_path
-  end
-
-  module Meta
-    # @param path [String] path of XML-content file
-    # @return [String] full path of metadata file based on content file's name e.g.
-    #   'design.xml' => '.design.xml.duxml'
-    def self.meta_path(path)
-      dir = File.dirname(path)
-      "#{dir}/.#{File.basename(path)}#{FILE_EXT}"
-    end
-
-    # @param g [String, GrammarClass] either a grammar object or path to one
-    # @return [GrammarClass] grammar object
-    def grammar=(g)
-      @grammar = case g
-                   when GrammarClass then g
-                   when String
-                     if File.exists?(g)
-                       @grammar_path = g
-                       Grammar.import(g)
-                     else
-                       maudule, meth = *g.split('.')
-                       if Module.const_defined?(maudule.to_sym)
-                         Module.const_get(maudule.to_sym).send(meth.to_sym)
-                       else
-                         raise ArgumentError, "#{g.to_s} is not a valid module/grammar symbol"
-                       end
-                     end
-                   else
-                     raise ArgumentError, "#{g.to_s} is not a valid Grammar or path to one"
-                 end
-      history.delete_observers if history.respond_to?(:delete_observers)
-      history.add_observer(grammar, :qualify)
-      grammar.add_observer history
-      grammar
-    end
-
-    def xml
-      if grammar_path
-        g = Duxml::Element.new('grammar')
-        g[:ref] = grammar_path
-      else
-        g = grammar.xml
-      end
-      Duxml::Element.new('meta') << g << history.xml
-    end
-  end # module Meta
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+
+require File.expand_path(File.dirname(__FILE__) + '/meta/grammar')
+require File.expand_path(File.dirname(__FILE__) + '/meta/history')
+require File.expand_path(File.dirname(__FILE__) + '/saxer')
+
+module Duxml
+  module Meta
+
+    FILE_EXT = '.duxml'
+  end
+
+  # all XML files ready by Duxml have a metadata file generated with a modified, matching file name
+  # @see #Meta.meta_path
+  class MetaClass
+    include Meta
+
+    # @param grammar_path [String] optional path of grammar file which can be a spreadsheet or Duxml::Grammar file
+    def initialize(grammar_path=nil)
+      @history = HistoryClass.new
+      self.grammar = grammar_path ? Grammar.import(grammar_path) : GrammarClass.new
+      @grammar_path = grammar_path
+    end
+
+    attr_reader :history, :grammar, :grammar_path
+  end
+
+  module Meta
+    # @param path [String] path of XML-content file
+    # @return [String] full path of metadata file based on content file's name e.g.
+    #   'design.xml' => '.design.xml.duxml'
+    def self.meta_path(path)
+      dir = File.dirname(path)
+      "#{dir}/.#{File.basename(path)}#{FILE_EXT}"
+    end
+
+    # @param g [String, GrammarClass] either a grammar object or path to one
+    # @return [GrammarClass] grammar object
+    def grammar=(g)
+      @grammar = case g
+                   when GrammarClass then g
+                   when String
+                     if File.exists?(g)
+                       @grammar_path = g
+                       Grammar.import(g)
+                     else
+                       maudule, meth = *g.split('.')
+                       if Module.const_defined?(maudule.to_sym)
+                         Module.const_get(maudule.to_sym).send(meth.to_sym)
+                       else
+                         raise ArgumentError, "#{g.to_s} is not a valid module/grammar symbol"
+                       end
+                     end
+                   else
+                     raise ArgumentError, "#{g.to_s} is not a valid Grammar or path to one"
+                 end
+      history.delete_observers if history.respond_to?(:delete_observers)
+      history.add_observer(grammar, :qualify)
+      grammar.add_observer history
+      grammar
+    end
+
+    def xml
+      if grammar_path
+        g = Duxml::Element.new('grammar')
+        g[:ref] = grammar_path
+      else
+        g = grammar.xml
+      end
+      Duxml::Element.new('meta') << g << history.xml
+    end
+  end # module Meta
 end # module Duxml