tree_hierarchy 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86e5d35dc28014de283c41a8a4d1e83fba1e859a
-  data.tar.gz: 51dd70bd650b5e10e6dc0f7f0f7dbeaed923db08
+  metadata.gz: cd96e4fd227c305f65ee064919210b1b90578a4e
+  data.tar.gz: e06bf8a983ee4c7d4306f306284f5391c373e323
 SHA512:
-  metadata.gz: 3a8a5553c660f79e8b53ab1bb8735d0b27e81a62a548766c4128b42ee07e5c49b896796bf30f469eab062c3ac6a280a3d21e7966380a2ad359f0a52cc87b07b5
-  data.tar.gz: be6fec718b992fccc79a97031b7325de17468c28c837ffc1dc62bf002b1fa011bd27d413574378ae86f808cc57412908b12cf90569eabeedbf68ed1d4838bf35
+  metadata.gz: 81ea22e4fdb6b6d54f90463557e51f428db8ebf928578f0009ec9f3e91e401411bc56130092b2e5f67635e671290a2633f406362eb0417e0f5c80917b50c07d9
+  data.tar.gz: 8f45cdabd4c66953ef4608e3bf1d601848dd4d01bd91c15632ff8748d0ec845a0f0609e3cfa3d90a45d3b5bb4c94bbe78f75a278b8ac0d433a960fc00e567cd0

data/lib/helper/support_method.rb

@@ -1,7 +1,7 @@
 module SupportMethod
 
   def group_result_set(result_set)
-    result_set.group_by{|x| x.parent_id ? x.parent_id.to_i : x.parent_id }
+    result_set.group_by{|x| nil_check(x.parent_id) }
   end
 
   def total_calc(result_group,field_set)
@@ -19,4 +19,9 @@ module SupportMethod
   def compare(arg1,arg2)
     arg1 > arg2
   end
+  
+  def nil_check(value)
+    value ? value.to_i : value
+  end
+  
 end

data/lib/hierarchy/added_hierarchy_level.rb

@@ -4,63 +4,73 @@ module AddedHierarchyLevel
   @@linear = []
 
   def added_hierarchy(result_set,args,depth = 0)
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
-    level_check(depth) ? self.tree_structure(result_set,@@result_group) : self.tree_structure_depth(result_set,@@result_group,depth.to_i)
+    added_hierarchy_calc(result_set,args,depth,'tree_structure')
   end
  
   def added_hierarchy_level(result_set,args,depth = 0)
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
-    level_check(depth) ? self.tree_structure_level(result_set,@@result_group) : self.tree_structure_depth_level(result_set,@@result_group,depth.to_i)
+    added_hierarchy_calc(result_set,args,depth,'tree_structure_level')
   end
- 
+  
+  def added_hierarchy_calc(result_set,args,depth,type)
+    initial = initial_load(result_set,args)
+    method_detection(result_set,depth,type,self,@@result_group)
+  end
+
   def added_hchildren(result_set,args)
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
+    children_group(result_set,args)
     self.hchildren_structure(result_set,@@result_group)
   end
   
   def added_hchildren_ids(result_set,args)
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
+    children_group(result_set,args)
     self.hchildren_structure_ids(result_set,@@result_group)
   end
 
   def linear_level(result_set,depth = 0)
-    @@linear = []
-    result_group = group_result_set(result_set)
-    level_check(depth) ? self.linear_structure_level(result_set,result_group) : self.linear_structure_depth_level(result_set,result_group,depth.to_i)
-    return @@linear
+    linear_calc(result_set,depth,'linear_structure_level')
   end
 
   def linear(result_set,depth = 0)
-    @@linear = []
-    result_group = group_result_set(result_set)
-    level_check(depth) ? self.linear_structure(result_set,result_group) : self.linear_structure_depth(result_set,result_group,depth.to_i)
-    return @@linear
+    linear_calc(result_set,depth,'linear_structure')
   end
 
-  def added_linear(result_set,args,depth = 0)
-    @@linear = []
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
-    level_check(depth) ? self.linear_structure(result_set,@@result_group) : self.linear_structure_depth(result_set,@@result_group,depth.to_i)
+  def linear_calc(result_set,depth,type)  
+    result_group = linear_load(result_set)
+    method_detection(result_set,depth,type,self,result_group)
     return @@linear
   end
+ 
+  def added_linear(result_set,args,depth = 0)
+    added_calc(result_set,args,depth,'linear_structure')
+  end
   
   def added_linear_level(result_set,args,depth = 0)
-    @@linear = []
-    @@result_group = group_result_set(result_set)
-    parent_child_add(args)
-    level_check(depth) ? self.linear_structure_level(result_set,@@result_group) : self.linear_structure_depth_level(result_set,@@result_group,depth.to_i)
+    added_calc(result_set,args,depth,'linear_structure_level')
+  end
+
+  def added_calc(result_set,args,depth,type)
+    initial = added_linear_load(result_set,args)
+    method_detection(result_set,depth,type,initial,@@result_group)
     return @@linear
+  end 
+  
+  def method_detection(result_set,depth,type,initial,result_group)
+    level_check(depth) ? initial.send(type,result_set,result_group) : initial.send(type+'_depth',result_set,@@result_group,depth.to_i)
+  end
+
+  def added_linear_load(result_set,args)   
+    @@linear = initialise_array()
+    initial_load(result_set,args)
   end
  
+  def initialise_array()
+    []
+  end
+  
   def parent_child_add(field_set)
     unless presence_check(@@result_group[self.id])
       @@result_group[self.id].map{|x| x.parent_child_add(field_set)}
-        @@result_group[self.parent_id].each do|x| 
+        @@result_group[nil_check(self.parent_id)].each do|x| 
           next unless x.id == self.id
             for i in 0..field_set.length-1
               x[field_set[i]] = total_calc(@@result_group[self.id],field_set[i])
@@ -70,16 +80,14 @@ module AddedHierarchyLevel
   end
 
   def linear_structure_level(result_set,result_group,increment = 1)
-    self.attributes.merge(:level => increment)
-    @@linear << self
+    @@linear <<  self.attributes.merge(:level => increment)
     result_group[self.id].map{|x| x.linear_structure_level(result_set,result_group,increment+1)} unless presence_check(result_group[self.id])
   end
 
-  def linear_structure_depth_level(result_set,result_group,depth,increment = 1)
+  def linear_structure_level_depth(result_set,result_group,depth,increment = 1)
     unless compare(increment,depth)
-      self.attributes.merge({:level => increment})
-      @@linear << self
-      result_group[self.id].map{|x| x.linear_structure_depth(result_set,result_group,depth,increment + 1)} unless presence_check(result_group[self.id]) 
+      @@linear << self.attributes.merge({:level => increment})
+      linear_method_detection(result_set,result_group,depth,increment,'linear_structure_level_depth')
     end
   end
 
@@ -91,8 +99,39 @@ module AddedHierarchyLevel
   def linear_structure_depth(result_set,result_group,depth,increment = 1)
     unless compare(increment,depth)
       @@linear << self
-      result_group[self.id].map{|x| x.linear_structure_depth(result_set,result_group,depth,increment + 1)} unless presence_check(result_group[self.id]) 
+      linear_method_detection(result_set,result_group,depth,increment,'linear_structure_depth')
     end
   end
 
+  def linear_method_detection(result_set,result_group,depth,increment,type)
+    result_group[self.id].map{|x| x.send(type,result_set,result_group,depth,increment + 1)} unless presence_check(result_group[self.id]) 
+  end
+
+private
+
+
+  def initial_load(result_set,args)
+    children_group(result_set,args)
+    @@result_group[nil_check(self.parent_id)].select{|x| x.id == self.id}.first
+  end 
+  
+  def children_group(result_set,args)
+    @@result_group = group_result_set(result_set)
+    parent_child_add(args)
+  end
+
+  def linear_load(result_set)
+    @@linear = initialise_array()
+    group_result_set(result_set)
+  end
+
+  def added_linear_load(result_set,args)   
+    @@linear = initialise_array()
+    initial_load(result_set,args)
+  end
+ 
+  def initialise_array()
+    []
+  end
+  
 end

data/lib/hierarchy/hierarchy_with_level.rb

@@ -2,15 +2,15 @@ module HierarchyWithLevel
 
   def hierarchy_level(result_set,depth = 0)
     result_group = group_result_set(result_set)
-    level_check(depth) ? self.tree_structure_level(result_set,result_group) : self.tree_structure_depth_level(result_set,result_group,depth.to_i)
+    level_check(depth) ? self.tree_structure_level(result_set,result_group) : self.tree_structure_level_depth(result_set,result_group,depth.to_i)
   end
 
   def tree_structure_level(result_set,result_group,increment = 1)
     presence_check(result_group[self.id]) ? self.attributes.merge({:level => increment}) : self.attributes.merge({:level => increment, :children => result_group[self.id].map{|x| x.tree_structure_level(result_set,result_group,increment + 1)}}) 
   end
 
-  def tree_structure_depth_level(result_set,result_group,depth,increment = 1)
-    presence_check(result_group[self.id]) ? self.attributes.merge({:level => increment}) : self.attributes.merge({:level => increment, :children => result_group[self.id].map{|x| x.tree_structure_depth_level(result_set,result_group,depth,increment + 1)}}) unless compare(increment,depth)
+  def tree_structure_level_depth(result_set,result_group,depth,increment = 1)
+    presence_check(result_group[self.id]) ? self.attributes.merge({:level => increment}) : self.attributes.merge({:level => increment, :children => result_group[self.id].map{|x| x.tree_structure_level_depth(result_set,result_group,depth,increment + 1)}}) unless compare(increment,depth)
   end
 
   def hchildren(result_set)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tree_hierarchy
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Dheenadhayalan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-15 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies: []
 description: "  \n  Tree_hierarchy allows to form a tree structure based on parent-child
   relationship \n  with simple and fast computation for large records. Additional