blockify 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8af64338fc8a469e61f4286ef0703d40d3368365
-  data.tar.gz: 667d48278b272ed5910fb3fe8afc777d13bcc2c9
+  metadata.gz: 4b73edc9fd1a25fe3131053307024a16de9f9a92
+  data.tar.gz: cf99a22f3fcd8a06c7ed740ba78f528b6afdda76
 SHA512:
-  metadata.gz: f6b6f7afec83d58d134b771598b9cb69d9424842d9b1f5eaa7038dfd765757186127843300c287cfbb39dc6c1015337525281ae155473e40b4d0af9eac76ee13
-  data.tar.gz: e06d7a2a90c69ab54f032da75392a260abc49b34d61a139227a9e6a60404c2483d99f3c0506e42915d8f1bc40470f11ccc38c66b8f80112a6334bb20a2fe2514
+  metadata.gz: d7d64123af21e5470a94613e56aa319e1fc096702a63dd0a4a7ddcebf638ec76b80745c9abf189adda392c205314afae7cf16874d8544b01b1329f7981870158
+  data.tar.gz: 51a82f92c05408e016ab9a311e53297298b061e52d604c3a1a5078caba631ab9eed679bb651807a5fc2d63ced5271600802895247437fcab0605c84493b240d6

data/README.md

@@ -24,8 +24,8 @@ Or install it yourself as:
 
 ## Usage
 
-This first release includes a module that inserts itself with the Array and Hash classes.
-This same module could be used to service custom container classes as well so long as they look Array-like or Hash-like.
+Blockify includes a module that inserts itself with the Array and Hash classes.
+This same module could be used to service custom container classes as well, so long as they look Array-like or Hash-like.
 As a practical point of view, examine the following code:
 
 ```ruby
@@ -46,9 +46,53 @@ The `blockify` gem uses recursion to step through the entire structure. If we pe
 ```
 The `#blockify_elements` method travels through the structure and calls our block whenever it encounters an element that is not an Array or a Hash.
 Whatever the block returns, the element in question will be modified with that result. In this case, each element is converted to a string.
-All the recursion magic is performed by the gem.
+All the recursion magic is performed by the gem. There are many other tools as well as will be detailed in the following sections.
 
-Another tool is an element locator. This is best shown by example as follows:
+### instance.blockify_elements { |element| expression_to_replace_element }
+The `#blockify` method is included in both Hash and Array. This method returns an identical structure of nested Hash and Array elements
+and allows each element to be modified on an element by element basis.
+The following example searches the structure and replaces nil elements with empty strings:
+
+```ruby
+require 'blockify'
+
+my_structure  = [0,nil,nil,"string",{a:nil, b:"a string", c:[nil,nil,"good",nil,"bad"]}]
+new_structure = my_structure.blockify_elements { |elm| elm.nil? ? "" : elm }
+# new_structure == [0, "", "", "string", {:a=>"", :b=>"a string", :c=>["", "", "good", "", "bad"]}]
+```
+
+### instance.blockify_elements! { |element| expression_to_replace_element }
+This method works identically to `#blockify` except it self-modifies. It also returns what it changes.
+
+### instance.scan_elements { |key,obj| statements }
+This method scans the entire Hash-Array structure and provides a means of examining elements in each substructure.
+Unlike the `#blockify` method, `#scan_elements` does not attempt to create a new structure; 
+instead, you have the opportunity to either read, or update each element in place.
+
+In the passed block, the parameter `key` is either the `Hash` key or the `Array` index depending on what type `obj` happens to be.
+The expression `obj[key]` gives us the element. We could also update the element by assignment such as: `obj[key]=expr`.
+We can also find out what type our sub-structure currently is with: `obj.class`.
+In our block, we do not know and don't care about the structure; instead, we just want to work with each element in the current substructure.
+We can modify the element in place or extract its content into some external object, or a combination of the two.
+Although we have access to the sub-structure, we should not delete or add elements on this sub-structure as unexpected things might happen.
+We could implement a self-modifying version of `stringify_elements` using `scan_elements` this way:
+
+```ruby
+require 'blockify'
+
+my_structure  = [0,1,[{a:{a:88}},[6,{a:[1,2,3]},[4,5],4],3],2,1]
+my_structure.scan_elements { |key,obj| obj[key] = obj[key].to_s  }
+# my_structure == ["0", "1", [{:a=>{:a=>"88"}}, ["6", {:a=>["1", "2", "3"]}, ["4", "5"], "4"], "3"], "2", "1"]
+```
+
+If we wanted to create a non-destructive version of `stringify` using the `#scan_elements` method, we would first have to duplicate the structure
+and return the modified duplicate.
+
+### instance.find_element_path { |elm| boolean_statement }
+
+This method returns the location path of the first occurrence of when the block returns true. 
+A path is defined as a sequence of indexes that access the underlying Hash-Array structure.
+This is best seen by example as follows: 
 
 ```ruby
 require 'blockify'
@@ -65,12 +109,14 @@ old = nested_thingee.path_put "Fred" path   # old == 17
 elm = nested_thingee.path_get path          # elm =="Fred"
 # nested_thingee == [0,1,2,[3,4,5,[6,7,8,[9,10,11,12,[13,{:a=>[16,"Fred"],:b=>[18,19,20]}]]]],14,15]
 ```
+
 It is up to your imagination what you put in the block. When the block returns true, the recursion is done, and you get the path.
-Each method in the `blockify` gem is imported into both `Hash` and `Array`.
-The gem also includes three access methods that utilize the returned path. The above example shows two of them called `#path_put` and `#path_get`.
-Instead of searching for the first find, we have a means of finding every match as well; this is called: `#find_element_paths`.
-This methods returns an array of paths where each path is an array of indicies.
-We can access everything with `#paths_get` which will return an array of every found element.
+As a spoiler alert, we see two path related access methods which will be explained later.
+
+### instance.find_element_paths { |elm| boolean_statement }
+
+This method works similarly as `#find_element_path` except that an array of paths are found.
+Instead of stopping on the first find, the search considers the entire structure.
 See the example below:
 
 ```ruby
@@ -82,56 +128,254 @@ paths.first  # [3,0]
 paths.last   # [5]
 paths[5]     # [3, 3, 3, 0]
 nested_thingee.path_get paths[5]  #  9
+
+# access elements from all paths that match the criteria:
 nested_thingee.paths_get paths    #  [13, 15, 6, 7, 8, 9, 10, 11, 12, 14, 5]
 ```
 
-One of the methods of of the `blockify` gem utilizes the `#find_element_path` is called `#includify?`.
-This is defined as follows:
+And another spoiler alert from the above example comprises the `#paths_get` method.
+
+### instance.path_get(index_list)
+
+This method is a short-handed way of accessing the Hash-Array structure with a list of indexes rather than a chain of access operators.
+This is typically used to access an element from the `#find_element_path` method. It can also be used to return part of the structure itself.
+If we pass an empty array, we get the entire structure. The `index_list` is simply an array of indexes where an index is either an Integer, or a Hash key.
+
+### instance.path_put(data, index_list)
+
+This method replaces the element found at the `#index_list` with new data. This could also be used to replace the Hash-Array substructure with
+either data, or another substructure. 
+Unlike `#path_get` passing an empty array as the index_list is not legal.
+
+### instance.paths_get(index_lists)
+
+This method returns an element or a sub-structure for each `index_list`.
+The parameter `index_lists` is defined as an array of path indexes. Structurally, this is an array of an array of indexes.
+It is typically used in conjunction with the `#find_element_paths` method. See the example below: 
+
+```ruby
+nested_thingee = [0,1,2,[13,4,15,[6,7,8,[9,10,11,12,[3,{:a=>[16,17],:b=>[18,19,20]}]]]],14,5]
+index_lists = []
+index_lists.push [3,0]
+index_lists.push [5]
+index_lists.push [3, 3, 3, 0]
+index_lists.push [3, 3, 3, 4, 1, :b, 2]
+data = nested_thingee.paths_get index_lists  # data == [13, 5, 9, 20]
+```
+
+### instance.circular?(path=[])
+
+A circular Hash-Array structure contains paths that point back to itself in an never-ending loop.
+Using such a structure with some of the methods above will cause a stack overload to occur.
+This method detects such anomalies. You can also get the first violation path by passing an array.
+If there are multiple violations, you must remove all violations one-by-one before calling
+one of the recursive methods above. The example below demonstrates this as follows:
 
 ```ruby
-  def includify?(search_string)
-    path = find_element_path { |elm| elm.to_s.include? search_string }
-    !path.empty?
-  end
+
+abc = [:a, :b, :c]
+xyz = [1,2,3]
+example = [0, {first: abc, second: xyz }]
+
+example.circular?  # false
+
+abc.push example   # create a circular structure
+
+example.circular?  # true
+abc.circular?      # true
+
+path = []
+abc.circular? path      #  true ... path == [3, 1]
+path = []
+example.circular? path  #  true ... path == [1, :first, 3]
+
+xyz.push abc   # now a second violation 
+xyz.circular?  # true
+path = []
+xyz.circular? path  # true ... path == [3, 3, 1]
+
+example[0] = [[xyz,abc]]  # third violation
+path = []
+example.circular? path  # true ... path == [3, 3, 0, 0, 0]
 ```
 
-When you have a deeply nested array_hash system, the standard `#include?` method is no help.
-Instead of looking one-level deep for an exact match, `#includify?` examines each element
-until it finds what it is looking for. Internally, we are looking for a substring on one of the elements.
+### instance.unloopify
+
+This method repeatedly calls `#circular?` and replaces the offending substructure with a container object
+that sort of looks the the offending substructure. This container is called `CircularObjectContainer`.
+If the contained element happens to be a `Hash` object, then the container will appear `Hash` like
+and will include the methods such as `#each_pair` and `#each`. The `Array` like instance will implement the method `#each`.
+All instances of `CircularObjectContainer` are frozen read-only entities. All container elements of a `CircularObjectContainer`
+instance will be empty; this effectively breaks the loop. Also, the `#[]` access operator is available, but `#[]=` is forbidden.
+This object is detailed later in this document.
+
+### instance.stringify_elements
+
+This method creates a new structure with every element converted to strings. It is the same as: `instance.blockify_elements {|elm| elm.to_s}`.
+
+### instance.stringify_elements!
+
+This bang version of `#stringify_elements` self-modifies the current structure; additionally, it returns the modified structure.
+
+### instance.inspectify_elements
+
+This method creates a new structure with every element replaced with `#inspect` called on that element.
+It is the same as: `instance.blockify_elements {|elm| elm.inspect}`.
+
+### instance.inspectify_elements!
+
+This is a self-modifying version of `#inspectify_elements` which also returns the modified self.
+
+### instance.deep_duplify
+
+This creates an identical deep copy of the original Hash-Array structure where each sub-structure is reconstructed from a new Hash or Array.
+Each element in the structure additionally calls `#dup` if permitted.
+This will covert internal `CircularObjectContainer` objects back into Hash or Array objects.
+It is a good idea to call this method after you call `unloopify` because `CircularObjectContainer` objects cannot be modified.
+This method internally calls `#blockify_elements`.
+
+### instance.flattenify
+
+This method extracts every element from the Hash-Array structure and places each element in a one-level deep array.
 See the example below:
 
 ```ruby
-require 'blockify'
+structure = ["zero",{m:[{t:["one", "two"],v:["three","four"]}],z:"five"}]
+flat = structure.flattenify  # flat == ["zero", "one", "two", "three", "four", "five"]
+```
 
-nasty_array_hash = [{:quick=>{:a=>"tool", :b=>["xray","tent"]}, :quicker=>{:a=>:mess}, "green"=>"fox in socks", :empty=>[{}]},"fred"]
+### instance.extractify(cls)
 
-nasty_array_hash.includify? "tool"   # true
-nasty_array_hash.includify? "mess"   # true
-nasty_array_hash.includify? "quick"  # false, :quick is a key, not an element
-nasty_array_hash.includify? "green"  # false, "green" is a key, not an element
-nasty_array_hash.includify? "fox"    # true, "fox" is a substring of "fox in socks"
-ep = nasty_array_hash.find_element_path { |elm| elm.to_s.include? "fox"}  # [0, "green"]
-str = nasty_array_hash.path_get ep                                        # str == "fox in socks"
+This method extracts elements that belong to the type of its parent container; the parameter `cls` is either `Array` or `Hash`.
+See the example below:
 
+```ruby
+structure = [1,3,5,{a:2,b:4,c:6,d:[55,777],e:8},{t:[999],a:"even"}]
+even = structure.extractify(Hash)  # even == {:a=>"even", :b=>4, :c=>6, :e=>8}
+odd  = structure.extractify(Array) # odd == [999, 777, 5]
 ```
 
-The current methods for this first release are as follows:
+Note that if a Hash key is repeated, or an Array index is repeated, the returned element will replace previous elements at that key or that index.
+The returned structure is always flat.
+
+### instance.extractifirstify(cls)
+
+Unlike `#extractify` which returns the last found element in the returned flatten structure, 
+`#extractifirstify` fills the return structure with the first found element. See the example below:
 
 ```ruby
-#  new_array_hash = ary_hash.blockify_elements { |elm| some_expression_using_elm_that_gets_saved_to_elm }
-#  ary_hash.blockify_elements! { your_block_here }  # ... self-modified ary_hash
-#  path_array = ary_hash.find_element_path { |elm| some_true_false_method_here_operating_on_elm }
-#  result = ary_hash.stringify_elements  # creates same structure with elements converted to strings
-#  ary_hash.stringify_elements!          # self-modified version of the above
-#  result = ary_hash.inspectify_elements # all elements replaced with a call to #inspect
-#  ary_hash.inspectify_elements!         # self-modified version of the above
-#  ary_hash.includify? substring         # true if substring is found in one of the elements
-#  ary_hash.find_element_paths { ... }   # returns array of found paths
-#  ary_hash.path_get path_array          # returns the element or structure found by the path array ... path_get([]) returns the entire structure
-#  ary_hash.paths_get array_paths        # paths looks like this: [[],[],[],[],...]  returns an array of each path_get
-#  ary_hash.path_put(data, path)         # replaces current path element with data, where path is an ordered list of keys
+structure = [1,3,5,{a:2,b:4,c:6,d:[55,777],e:8},{t:[999],a:"even"}]
+even = structure.extractifirstify(Hash)  # even == {:a=>2, :b=>4, :c=>6, :e=>8}
+odd  = structure.extractifirstify(Array) # odd == [1, 3, 5]
 ```
 
+### instance.extractistacktify(cls)
+
+This method returns a two-level structure and places all compatible data into the second-level structure.
+The secondary structure is always an array. The primary structure is either `Array` or `Hash` depending on the parameter `cls`
+This is best seen by example as follows:
+
+```ruby
+structure = [1,3,5,{a:2,b:4,c:6,d:[55,777],e:8},{t:[999],a:"even"}]
+even = structure.extractistacktify(Hash)  # even == {:a=>[2, "even"], :b=>[4], :c=>[6], :e=>[8]}
+odd  = structure.extractistacktify(Array) # odd == [[1, 55, 999], [3, 777], [5]]
+```
+
+From the example above, we have effectively captured and reorganized all the elements into two bins.
+
+### instance.includify?(search_string)
+This method searches the Hash-Array structure's elements for a matching substring.
+The element is first converted to a string before examining the match.
+See the example below:
+
+```ruby
+haystack = [555,"123",{a:"apple", b:"banana", c:[567,"needle",:fred]}]
+haystack.includify? "needle"  # true
+haystack.includify? "need"    # true
+haystack.includify? "6"       # true
+haystack.includify? "red"     # true
+haystack.includify? "24"      # false
+haystack.includify? ":"       # false  ... :fred.to_s == "fred"
+```
+
+### CircularObjectContainer
+
+CircularObjectContainer instances are created automatically within the Hash-Array structure when `#unloopify` encounters a circular construct.
+This object is further detailed the the following subsections:
+
+#### construction
+
+CircularObjectContainer can contain any object, but its purpose is to contain Hash-like or Array-like entities.
+It takes this form: `CircularObjectContainer.new(item_to_be_contained)`.
+The constructor then exposes methods such as `#each`, `#each_pair`, and `#[]` depending on the contained type.
+The internal object is not saved, but instead saves a reconstructed version of the original. Only the original `object_id` is preserved.
+Non-container objects will use the original if `#dup` is not permitted. The internal reconstructed object calls `#freeze` as well as the
+newly constructed returned object.
+
+#### [] array access postfix operator
+
+This method is added as a singleton method if and only if the contained entity is Hash-like or Array-like.
+Note that `:[]=` is never implemented. This method calls the internal access operator of the contained object.
+
+#### each
+This method is added as a singleton method if and only if the contained entity implements `#each`.
+This method calls the contained object's `#each` method. 
+
+#### each_pair
+This method is added as a singleton method if and only if the contained entity implements `#each_pair`.
+This method calls the contained object's `#each_pair` method.
+
+#### id
+
+This method returns the original `object_id` during construction.
+
+#### type
+
+This method returns the class of the contained reconstructed entity.
+
+#### dup
+
+Instead of duplicating a CircularObjectContainer instance, the internal element is duplicated and returned.
+This will most likely be a Hash or an Array.
+
+#### taboo?
+
+This always returns true.
+
+#### def circular?
+
+This returns false and allows `CircularObjectContainer` objects to be used within a structure and still be able to call `#circular?`.
+
+#### blockify_elements
+
+This calls `#blockify_elements` from the contained entity.
+
+#### find_element_path
+
+This calls `#find_element_path` from the contained entity.
+
+#### find_element_paths
+
+This calls `#find_element_paths` from the contained entity.
+
+#### scan_elements
+
+This calls `#scan_elements` from the contained entity.
+
+### Incidental Methods Added to Standard Objects
+The main class `Object` has the method `#taboo?` added which returns false. The object `Hash` has two methods added:
+`incrementify(key_name)` and `decrementify(key_name)`. These add or subtract the `Integer` `1` to the indexed element.
+
+### Adding blockify to custom objects
+If your custom object is Hash-like, or Array-like, it can have the methods of `blockify` included. The following attributes must be present:
+
+1. Must be able to be constructed as a blank-slate (`#new` without parameters).
+2. Must implement `:[]` and `:[]=` access operators.
+3. Must implement `#each`
+4. If `#each_pair` is implemented, `#each` must behave the way `Hash` behaves.
+5. If array-like (`#each_pair` not implemented), must implement `#push` and `#pop`
+6. Call this: `MyCustomClass.include Blockify`
+
 ## Development
 
 I need to control this for the time being, so stay tuned! I will add more goodies in later releases.

data/lib/blockify.rb

@@ -32,13 +32,13 @@ module Blockify
         if val.respond_to? :each
           path.push key
           val.find_element_path(path, done, &block)
-          return path if done.first
+          return path.self_or_empty_as_nil if done.first
           path.pop
         else
           if block.call(val)
             path.push key
             done[0]=true
-            return path
+            return path.self_or_empty_as_nil
           end
         end
       end
@@ -48,19 +48,19 @@ module Blockify
         if val.respond_to? :each
           path.push idx
           val.find_element_path(path, done, &block)
-          return path if done.first
+          return path.self_or_empty_as_nil if done.first
           path.pop
         else
           if block.call(val)
             path.push idx
             done[0]=true
-            return path
+            return path.self_or_empty_as_nil
           end
         end
         idx += 1
       end
     end # if-else
-    return path
+    return path.self_or_empty_as_nil
   end
 
   def find_element_paths(path=[],paths=[], &block)
@@ -123,9 +123,119 @@ module Blockify
     return rtn
   end
   
+  # read elements and yield everything
+  def scan_elements(&block)
+    if self.respond_to? :each_pair
+      self.each_pair do |key,val|
+        if val.respond_to? :each
+          val.scan_elements(&block)
+        else
+          block.call(key,self)
+        end
+      end
+    elsif self.respond_to? :each
+      ii = 0
+      self.each do |val|
+        if val.respond_to? :each
+          val.scan_elements(&block)
+        else
+          block.call(ii,self)
+        end
+        ii += 1
+      end    
+    end 
+  end
+  
+  # add path later to see where things break down
+  def circular? (path = [], stack = {}, rtn = [false])
+    my_id = self.object_id
+    stack.incrementify(my_id)
+    if self.respond_to? :each_pair
+      self.each_pair do |key,val|
+        if val.respond_to? :each
+          x_id = val.object_id
+          if stack[x_id]
+            rtn[0]=true
+            return rtn.first
+          else
+            path.push key
+            return rtn.first if val.circular?(path, stack, rtn)
+            path.pop
+          end
+        end
+      end
+    elsif self.respond_to? :each    
+      ii = 0
+      self.each do |val|
+        if val.respond_to? :each
+          x_id = val.object_id
+          if stack[x_id]
+            rtn[0]=true
+            path.push ii
+            return rtn.first
+          else
+            path.push ii
+              return rtn.first if val.circular?(path, stack, rtn)
+            path.pop  
+          end
+        end
+        ii += 1
+      end
+    end
+    stack.decrementify(my_id)
+    rtn.first
+  end
+  
+  def unloopify
+    path = []
+    while circular? path do
+      obj = path_get path
+      nobj = CircularObjectContainer.new obj
+      path_put(nobj, path)
+      path = []
+    end
+  end
+  
+  def flattenify
+    rtn = []
+    scan_elements { |key, inst| rtn.push inst[key] }
+    return rtn
+  end
+  
+  def extractify(cls)
+    col = cls.new
+    scan_elements do |key, inst|
+      col[key] = inst[key] if (inst.kind_of? cls)
+    end
+    return col    
+  end
+  
+  def extractifirstify(cls)
+    col = cls.new
+    scan_elements do |key, inst|
+      if (inst.kind_of? cls)
+        if col[key].nil?
+          col[key] = inst[key]
+        end
+      end
+    end
+    return col    
+  end
+
+  def extractistacktify(cls)
+    col = cls.new
+    scan_elements do |key, inst|
+      if (inst.kind_of? cls)
+        col[key] ||= []
+        col[key].push inst[key]
+      end
+    end
+    return col    
+  end
+  
   def includify?(search_string)
     path = find_element_path { |elm| elm.to_s.include? search_string }
-    !path.empty?
+    !path.nil?
   end
   
   def blockify_elements!(&block)
@@ -143,8 +253,124 @@ module Blockify
   def inspectify_elements!
     replace inspectify_elements
   end
+  
+  def deep_duplify
+    blockify_elements do |t|
+      t.dup rescue t
+    end
+  end
+  
+  def self_or_empty_as_nil
+    return nil if empty?
+    self
+  end
 
 end # module
 
 Array.include Blockify
 Hash.include Blockify
+
+class Hash
+  def incrementify(kv) #values assumed to be integers
+    if self[kv].nil?
+      self[kv] = 0
+    else
+      self[kv] += 1
+    end
+  end
+  def decrementify(kv) #values assumed to be integers
+    if self[kv].nil?
+      self[kv] = nil 
+    elsif self[kv]==0
+      self[kv] = nil      
+    else
+      self[kv] -= 1
+    end
+  end
+end
+
+class Object
+  def taboo?
+    false
+  end
+end
+
+class CircularObjectContainer
+  def initialize(obj)
+    @id = obj.object_id
+    if obj.respond_to? :each_pair
+      @obj = obj.class.new  # create a blank slate
+      obj.each_pair do |key,val|
+        if val.respond_to? :each
+          @obj[key] = val.class.new  # go no further
+        else
+          tval = val.dup  rescue val
+          @obj[key] = tval
+        end
+      end
+      self.instance_eval do # yes we want a singleton method here!
+        def each_pair(&block)
+          @obj.each_pair &block
+        end
+        def each(&block)
+          @obj.each &block
+        end
+        def [](key)
+          @obj[key]
+        end
+      end 
+    elsif obj.respond_to? :each
+      @obj = obj.class.new  # create a blank slate
+      obj.each do |val|
+        if val.respond_to? :each
+          @obj.push val.class.new
+        else
+          tval = val.dup rescue val
+          @obj.push tval
+        end
+      end
+      self.instance_eval do  # yes we want a singleton method here!
+        def each(&block)
+          @obj.each &block
+        end
+        def [](idx)
+          @obj[idx]
+        end        
+      end 
+    else
+      @obj = obj.dup rescue obj  
+    end
+    @obj.freeze
+    self.freeze
+    self
+  end  
+  def id  # get the original object_id
+    @id
+  end
+  def type
+    @obj.class
+  end
+  def dup  # get the innards and discard container
+    @obj.dup rescue @obj
+  end
+  def taboo?
+    true
+  end
+  def circular? (path = [], stack = {}, rtn = [false])
+    return rtn.first
+  end
+  def blockify_elements(&block)
+    @obj.dup.blockify_elements(&block) 
+  end
+  def find_element_path(path=[],done=[false], &block)
+    @obj.dup.find_element_path(path,done, &block) 
+  end
+  def find_element_paths(path=[],paths=[], &block)
+    @obj.dup.find_element_paths(path,paths, &block)
+  end
+  def scan_elements(&block)
+    @obj.dup.scan_elements(&block)
+  end
+end
+
+

data/lib/blockify/version.rb

@@ -1,3 +1,3 @@
 module Blockify
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blockify
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-27 00:00:00.000000000 Z
+date: 2018-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler