duxml 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a443f0b41070e85e05a9042711af460f1a9de0ce
-  data.tar.gz: c25d6801574a1730e3a38a5ccab2ed91b482d37b
+  metadata.gz: 5cfc64bf0a2a0fc7d5dfa7eddf824a91de78019e
+  data.tar.gz: 68539178080588cf391bd98619dd994f2e55fd6a
 SHA512:
-  metadata.gz: 2804f997a7fa48f9bd6c24ddef5e8b84df058b4bfbc1f6a41cbda340646378ef0d94a95a32b89cc1160819bb2d9bf37926c8196e2e8f5d9d70950a5baa973f3b
-  data.tar.gz: d2cac9f2b2c16c07b754f98224eea4da660857a73345215bed10824818cd837de15ce2fe98bb06a2100eb69171537fd270ae27dd6199710c1e740c88fd3d2711
+  metadata.gz: f176dc33c32a6293ff8d3df5e04ac7e48b9fd6edf275b1fe0260c56b18e5baa24366f9335bad203367d1f2aee5413be9dd17e92be4f4bccb1190f92428ac8bbc
+  data.tar.gz: cc453d524c27917c4ad689023e4622090edc17c3a08b4ecb42383a93c7c0516422fcb958ad29333e04d859a48efe88939c26db1125491fc47aaba925cf6f7ec0

data/bin/validate_xml

@@ -16,4 +16,16 @@ puts "loaded grammar file: #{DITA_GRAMMAR_FILE}"
 validate
 puts "validation complete"
 log log_file
-puts "logged errors to #{log_file}"
+puts "logged errors to #{log_file}"
+
+
+if conditions
+
+end
+
+
+def conditions
+  asdf and b and c
+end
+
+File

data/lib/duxml/doc/element.rb

@@ -25,7 +25,7 @@ module Duxml
     # in Ruby mode, args are some combination of new attributes/values and/or child nodes (text or XML) with which to initialize this node
     #
     # @param name [String] name of element, in both Ruby and file modes
-    # @param _line_content [Fixnum, Array, Hash] line number of element file mode; if Array, new child nodes; if Hash, attributes; can be nil
+    # @param _line_or_content [Fixnum, Array, Hash] line number of element file mode; if Array, new child nodes; if Hash, attributes; can be nil
     # @param _col_or_children [Fixnum, Array] column position in file mode; if Array, new child nodes; can be nil
     def initialize(name, _line_or_content=nil, _col_or_children=nil)
       super name
@@ -51,18 +51,31 @@ module Duxml
     # @see Ox::Element#<<
     # this override reports changes to history; NewText for Strings, Add for elements
     #
-    # @param obj [Element] element or string to add to this Element
+    # @param obj [Element, Array] element or string to add to this Element; can insert arrays which are always inserted in order
     # @return [Element] self
     def <<(obj)
+      add(obj)
+    end
+
+    # @see #<<
+    # this version of the method allows insertions between existing elements
+    #
+    # @param obj [Element, Array] element or string to add to this Element; can insert arrays which are always inserted in order
+    # @param index [Fixnum] index at which to insert new node; inserts at end of element by default; when inserting arrays, index is incremented for each item to avoid reversing array order
+    # @return [Element] self
+    def add(obj, index=-1)
       case
         when obj.is_a?(Array), obj.is_a?(NodeSet)
-          obj.each do |e| self << e end
+          obj.each_with_index do |e, i|
+            add(e, index == -1 ? index : index+i)
+          end
         when obj.is_a?(String)
           type = :NewText
-          super(obj)
+          nodes.insert(index, obj)
+          report(type, nodes.size-1)
         else
           type = :Add
-          super(obj)
+          nodes.insert(index, obj)
           if nodes.last.count_observers < 1 && @observer_peers
             nodes.last.add_observer(@observer_peers.first.first)
           end
@@ -71,10 +84,21 @@ module Duxml
       self
     end
 
-    # @param attr_sym [String, Symbol] name of attribute
-    # @param val [String]
+    # @param index_or_attr [String, Symbol, Fixnum] string or symbol of attribute or index of child node
+    # @return [Element, String] string if attribute value or text node; Element if XML node
+    def [](index_or_attr)
+      index_or_attr.is_a?(Fixnum) ? nodes[index_or_attr] : super(index_or_attr)
+    end
+
+    # @param attr_sym [String, Symbol, Fixnum] name of attribute or index of child to replace
+    # @param val [String] new attribute value or replacement child node
     # @return [Element] self
     def []=(attr_sym, val)
+      if attr_sym.is_a?(Fixnum)
+        remove nodes[attr_sym]
+        add(val, attr_sym)
+        return self
+      end
       attr = attr_sym.to_s
       raise "argument to [] must be a Symbol or a String." unless attr.is_a?(Symbol) or attr.is_a?(String)
       args = [attr]

data/lib/duxml/doc/lazy_ox.rb

@@ -1,153 +1,153 @@
-# 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)
-      super(sym, *args, &block)
-    rescue NoMethodError
-      # 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 NoMethodError, "undefined method `#{sym.to_s}' for #{description}"
-        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 ...
-    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?
-        word = mod_names.shift
-        k = word.constantize
-        if maudule.const_defined?(k, true) or Module.const_defined?(simple_class, true)
-          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
-      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)
+      super(sym, *args, &block)
+    rescue NoMethodError
+      # 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 NoMethodError, "undefined method `#{sym.to_s}' for #{description}"
+        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 ...
+    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?
+        word = mod_names.shift
+        k = word.constantize
+        if maudule.const_defined?(k, true) or Module.const_defined?(simple_class, true)
+          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
+      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/doc.rb

@@ -1,26 +1,86 @@
 # Copyright (c) 2016 Freescale Semiconductor Inc.
 
 require File.expand_path(File.dirname(__FILE__) + '/doc/element')
+require File.expand_path(File.dirname(__FILE__) + '/meta')
 
 module Duxml
   class Doc < ::Ox::Document
     include ElementGuts
+
+    # path of file where this Doc is saved to
+    @path
+
+    # meta data for this Doc; contains reference to grammar if it exists and history
+    @meta
+
+    attr_reader :meta, :path
+
     def initialize(prolog={})
       super(prolog)
       self[:version] ||= '1.0'
+      @meta = MetaClass.new
       @nodes = NodeSet.new(self)
-      # TODO should also create new metadata!!
+      add_observer meta.history
     end
 
-    def write_to(path)
-      s = attributes.collect do |k, v| %( #{k}="#{v}") end.join
-      %(<?xml #{s}?>)+nodes.first.to_s
-      File.write(path, s)
-      self
+    # @param _path [String] assigns file path to document, creating it if it does not already exist along with metadata file
+    def path=(_path)
+      @path = _path
+      set_meta _path unless path
+      unless File.exists?(path)
+        write_to(path)
+      end
     end
 
+    # @return [String] summary of XML document as Ruby object and description of root element
     def to_s
       "#<#{self.class.to_s} @object_id='#{object_id}' @root='#{root.nil? ? '' : root.description}'>"
     end
+
+    # @param path_or_obj [String, MetaClass] metadata object itself or path of metadata for this file; if none given, saves existing metadata to file using @path
+    # @return [Doc] self
+    def set_meta(path_or_obj=nil)
+      @meta = case path_or_obj
+                when MetaClass, Element then path_or_obj
+                when String && File.exists?(path_or_obj)
+                  Ox.parse_obj(path_or_obj)
+                else
+                  File.write(Meta.meta_path(path), Ox.dump(meta)) if path
+                  meta
+              end
+      self
+    end
+
+    # shortcut method @see Meta#grammar
+    def grammar
+      meta.grammar
+    end
+
+    # shortcut method @see Meta#grammar=
+    def grammar=(grammar_or_file)
+      meta.grammar = grammar_or_file
+    end
+
+    # shortcut method @see Meta#history
+    def history
+      meta.history
+    end
+
+    # @return [String] one word description of what this object is: 'document'
+    def description
+      'document'
+    end
+
+    # @param path [String] document's file path
+    # @return [Doc] returns self after writing contents to file
+    def write_to(path)
+      s = attributes.collect do |k, v| %( #{k}="#{v}") end.join
+      File.write(path, %(<?xml #{s}?>\n) + root.to_s)
+      x = meta.xml
+      File.write(Meta.meta_path(path), meta.xml.to_s)
+      self
+    end
   end # class Document < Element
-end
+end
+
+Hash

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

@@ -31,6 +31,20 @@ module Duxml
   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