duxml 0.8.0 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cfc64bf0a2a0fc7d5dfa7eddf824a91de78019e
-  data.tar.gz: 68539178080588cf391bd98619dd994f2e55fd6a
+  metadata.gz: e9a620bcdd50c48d3b01ee43b5df3227820036c2
+  data.tar.gz: f0702e3d79fbfb2365bdfeec0c2cb5fa6c4f539e
 SHA512:
-  metadata.gz: f176dc33c32a6293ff8d3df5e04ac7e48b9fd6edf275b1fe0260c56b18e5baa24366f9335bad203367d1f2aee5413be9dd17e92be4f4bccb1190f92428ac8bbc
-  data.tar.gz: cc453d524c27917c4ad689023e4622090edc17c3a08b4ecb42383a93c7c0516422fcb958ad29333e04d859a48efe88939c26db1125491fc47aaba925cf6f7ec0
+  metadata.gz: 16aa187942b52c19196771bb213650351148fff1e2ba675247ec65829ca4ca812ce824bfe9fbbc44ae88ff0b9b4dd66c068aafb48a6d440a45dc435c96016e64
+  data.tar.gz: 14fa01c704c3db5e73613871f94d57bae6b999d3b2d33eba2bd86761910993abe778b586738ca5165880380b8bbeee97434106e940a0e7e36efc99b2786df49c

data/lib/duxml/doc/element.rb

@@ -70,17 +70,20 @@ module Duxml
             add(e, index == -1 ? index : index+i)
           end
         when obj.is_a?(String)
-          type = :NewText
-          nodes.insert(index, obj)
-          report(type, nodes.size-1)
+          if obj[0] == '<' and obj[-1] == '>' and (s = Ox.parse(obj))
+            add dclone s
+          else
+            type = :NewText
+            nodes.insert(index, obj)
+          end
         else
           type = :Add
           nodes.insert(index, obj)
-          if nodes.last.count_observers < 1 && @observer_peers
-            nodes.last.add_observer(@observer_peers.first.first)
+          if obj.count_observers < 1 && @observer_peers
+            obj.add_observer(@observer_peers.first.first)
           end
       end
-      report(type, nodes.size - 1)
+      report(type, obj, index)
       self
     end
 
@@ -150,19 +153,19 @@ module Duxml
     # pre-order traverse through this node and all of its descendants
     #
     # @param &block [block] code to execute for each yielded node
-    def traverse(&block)
+    def traverse(node=nil, &block)
       return self.to_enum unless block_given?
-      node_stack = [self]
+      node_stack = [node || self]
 
       until node_stack.empty?
         current = node_stack.shift
         if current
           yield current
-          node_stack = node_stack.concat(current.nodes) if current.respond_to?(:nodes)
+          node_stack = node_stack.insert(0, *current.nodes) if current.respond_to?(:nodes)
         end
       end
 
-      self if block_given?
+      node || self if block_given?
     end
 
     # traverse through just the children of this node
@@ -177,5 +180,50 @@ module Duxml
       return nil unless (i = name.index(':'))
       name[0..i-1]
     end
+
+
+    # @param source [Element] if not explicitly provided, creates deep clone of this element; source can be any XML element (not only Duxml) that responds to traverse with pre-order traversal
+    # @return [Element] deep clone of source, including its attributes and recursively cloned children
+    def dclone(source = self)
+      input_stack = []
+      output_stack = []
+      traverse(source) do |node|
+        if node.is_a?(String)
+          output_stack.last << node
+          next
+        end
+        copy = Element.new(node.name, node.attributes)
+        if output_stack.empty?
+          output_stack << copy
+          input_stack << node
+        else
+
+          if input_stack.last.nodes.none? do |n| n === node end
+            input_stack.pop
+            output_stack.pop
+          end
+
+          output_stack.last << copy
+          if node.nodes.any?
+            output_stack << copy
+            input_stack << node
+          end
+
+        end
+      end
+      output_stack.pop
+    end
+
+    # @return [Element] shallow clone of this element, with all attributes and children only if none are Elements
+    def sclone
+      stub = Element.new(name, attributes)
+      stub << nodes if text?
+      stub
+    end
+
+    # @return [true, false] true if all child nodes are text only; false if any child nodes are XML
+    def text?
+      nodes.all? do |node| node.is_a?(String) end
+    end
   end # class Element < Node
 end # module Ox

data/lib/duxml/doc/lazy_ox.rb

@@ -73,26 +73,30 @@ module Duxml
   # @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
+    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
-          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 ...
+          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
@@ -124,16 +128,20 @@ module Duxml
     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)
+        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

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

@@ -10,14 +10,14 @@ module Duxml
     include ChildPattern
 
     # @param _subject [Duxml::Element] parent element
-    # @param _index [Fixnum] index of child
-    def initialize(_subject, _index)
-      @index = _index
+    # @param _child [Fixnum] child node
+    def initialize(_subject, _child, _index)
+      @child, @index = _child, _index
       super _subject
     end
 
     alias_method :parent, :subject
-    attr_reader :index
+    attr_reader :child, :index
   end # class ChildPatternClass
 
   # null child patterns represent and parent child relationship where the child
@@ -27,16 +27,11 @@ module Duxml
 
     # @param _subject [Element] parent element
     # @param _missing_child [String] nmtoken for missing child element
-    def initialize(_subject, _missing_child)
-      @missing_child = _missing_child
+    def initialize(_subject, _missing_child, _index=-1)
+      @missing_child, @index = _missing_child, _index
       super _subject
     end
 
-    # @return [-1] class must respond to #index; only NullChildPatternClass is allowed to have a negative index
-    def index
-      -1
-    end
-
     def relationship
       'missing child'
     end
@@ -46,19 +41,12 @@ module Duxml
       "#{subject.description} #{relationship} <#{child}>"
     end
 
-    attr_reader :missing_child
+    attr_reader :missing_child, :index
     alias_method :child, :missing_child
     alias_method :parent, :subject
   end
 
   module ChildPattern
-    # @return [Element] child element
-    def child
-      subject.nodes[index]
-    end
-
-    alias_method :object, :child
-
     # @return [String] describes relationship between parent and child
     def relationship
       "#{(index+1).ordinal_name} #{super}"

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

@@ -10,12 +10,13 @@ module Duxml
 
     # @param _subject [Ox::Element] parent of text node
     # @param _index [Fixnum] index of text node
-    def initialize(_subject, _index)
+    def initialize(_subject, _str, _index)
       @index = _index
+      @string = _str
       super _subject
     end
 
-    attr_reader :subject, :index
+    attr_reader :subject, :index, :str
   end
 
   module TextPattern

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

@@ -44,7 +44,7 @@ module Duxml
         if node.name == child_rule.subject
           return child_rule.required_children.collect do |required_child_type|
             unless node.nodes.any? do |n| n.name == required_child_type end
-              NullChildPatternClass.new(node, required_child_type)
+              NullChildPatternClass.new(node, required_child_type, -1)
             end
           end.compact
         end
@@ -59,9 +59,9 @@ module Duxml
       node.nodes.collect do |child|
         i += 1
         if child.is_a?(String)
-          TextPatternClass.new(node, i)
+          TextPatternClass.new(node, child, i)
         else
-          ChildPatternClass.new(node, i)
+          ChildPatternClass.new(node, child, i)
         end
       end
     end # def get_child_patterns

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

@@ -122,10 +122,9 @@ module Duxml
       child_index == object.index
     end
 
-    # @return [Fixnum] index of child currenlty being scanned
+    # @return [Fixnum] index of child currently being scanned
     def child_index
-      i = object.parent.nodes.size-child_stack.size-1
-      i
+      object.parent.nodes.size-child_stack.size-1
     end
 
     # @return [Element] previous element to the one being scanned

data/lib/duxml/meta/history/add.rb

@@ -9,28 +9,23 @@ module Duxml
   class AddClass < ChangeClass
     include Add
 
-    def initialize(_subject, _index)
+    def initialize(_subject, _child, _index)
       super _subject
-      @index = _index
+      @child, @index = _child, _index
     end
 
+    attr_reader :subject, :child, :index
     alias_method :parent, :subject
-    attr_reader :subject, :index
+    alias_method :object, :child
   end
 
   module Add
     def description
-      %(#{super} #{child.description} added to #{parent.description}.)
+      %(#{super} #{child.description} added to #{parent.description} at index #{index == -1 ? '0' : index.to_s}.)
     end
 
     def parent
       subject
     end
-
-    def child
-      subject.nodes[index]
-    end
-
-    alias_method :object, :child
   end # class Add
 end # module Duxml

data/lib/duxml/meta/history/new_text.rb

@@ -11,12 +11,12 @@ module Duxml
 
     # @param _subject [Duxml::Element] doc that has gained new text
     # @param _index [Fixnum] index of new text node
-    def initialize(_subject, _index)
+    def initialize(_subject, _str, _index)
       super _subject
-      @index = _index
+      @index, @str = _index, _str
     end
 
-    attr_reader :index
+    attr_reader :index, :str
   end
 
   module NewText

data/lib/duxml/meta.rb

@@ -37,11 +37,22 @@ module Duxml
     # @param g [String, GrammarClass] either a grammar object or path to one
     # @return [GrammarClass] grammar object
     def grammar=(g)
-      @grammar = if g.is_a?(GrammarClass)
-                   g
-                 else
-                   @grammar_path = g if File.exists?(g)
-                   Grammar.import(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)

data/lib/duxml/ruby_ext/string.rb

@@ -5,25 +5,33 @@ class String
   # @return [String] converts string into Ruby constant. self must be String with no whitespaces and match Regexp.nmtoken
   #   'foo-bar'.constantize => 'Foo_bar'
   #   'foo_bar'.constantize => 'FooBar'
+  #   'fooBar'.constantize  => 'FooBar'
   def constantize
     return self if Regexp.constant.match(self)
     raise Exception unless Regexp.nmtoken.match(self)
-    s = split('_').collect do |word| word.capitalize unless word == '_' end.join.gsub('-', '_')
+    s = split('_').collect do |word| word[0] = word[0].upcase; word unless word == '_' end.join.gsub('-', '_')
     raise Exception unless s.match(Regexp.constant)
     s
   end
 
+  # @param sym [Symbol] optional setting for what type of nmtoken desired: either :snakeCase or :under_score
   # @return [String] does reverse of #constantize e.g.
   #   'Foo_b'.nmtokenize  => 'foo-bar'
   #   'FooBar'.nmtokenize => 'foo_bar'
-  def nmtokenize
+  def nmtokenize(sym = :under_score)
     split('::').collect do |word|
-      word.gsub(/(?!^)[A-Z_]/) do |match|
-        case match
-          when '_' then '-'
-          else "_#{match.downcase}"
+      s = word.gsub(/(?!^)[A-Z_]/) do |match|
+        case
+          when match == '_' then '-'
+          when sym == :snakeCase
+            match
+          when sym == :under_score
+            "_#{match.downcase}"
+          else
         end
-      end.downcase
+      end
+      s[0] = s[0].downcase
+      s
     end.join(':')
   end
 end # class String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duxml
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.4
 platform: ruby
 authors:
 - Peter Kong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-17 00:00:00.000000000 Z
+date: 2016-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox
@@ -89,7 +89,7 @@ files:
 - lib/duxml/saxer.rb
 - lib/duxml.rb
 - bin/validate_xml
-homepage: http://www.github.com/ruby-dita/duxml
+homepage: http://www.github.com/Ludocracy/duxml
 licenses:
 - MIT
 metadata: {}