tukey 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8a8ef46adf65742612a80840d3efb68edc3e3c8
-  data.tar.gz: cbc2848c54ad1f31aea26470ef20ef96177f0f7c
+  metadata.gz: 983ed9bbc18f085f8b33609ff13c6794db8140e3
+  data.tar.gz: e08a4102017038fc28cb4205ab16cb74e14f271f
 SHA512:
-  metadata.gz: 2ac224235943f1e3cd63575bb1d0098cd6f86dee0d1f7e6fe2bfcfe41986d404a8fd28b8a11d751f6165adf757175d3aaa51a2098f5a7580b766334c03989c4c
-  data.tar.gz: 4a4bbaf6322b6382e09a880871be262e92e4b7dc4c6ce05ee0672e5b9f5690c0f3d9a3dabb9e1ee110cb0f13f07489aa65c3385d0ec5b9a992b3cf585792b5b6
+  metadata.gz: 1f2f63eed3a6779330e6e5b3d6200100df1fd1046a8956d45215073ddf84b42b187c079452ac1b96aeb7bf5842c4a0aacbaadda25bdcc006348ffd39731c0667
+  data.tar.gz: 537c350faa79e346cbd2668dd4e1b68f0850d72b1bc8afc4178af9076d3659451d21e4bf3879291bd4461aaa37b3629ed0e03b3d82fcd9495776e80b031ace5d

data/lib/tukey/data_set.rb

@@ -51,12 +51,25 @@ class DataSet
     parent.children.reject { |c| c == self }
   end
 
-  def oneling?
-    siblings.none?
+  def ancestors
+    return [] if parent.nil?
+    ancs = []
+    par = parent
+    require 'pry'
+    until par.nil?
+      puts par.label.name
+      ancs.push par
+      par = par.parent
+    end
+    ancs.reverse
+  end
+
+  def label_path
+    [ancestors, self].flatten.map(&:label)
   end
 
-  def compact_onelings
-    filter(orphan_strategy: :adopt, keep_leafs: true) { |p, d| false if d.oneling? && !d.root? }
+  def oneling?
+    siblings.none?
   end
 
   def root?
@@ -94,8 +107,27 @@ class DataSet
     children.map(&:leaf_labels).flatten.uniq
   end
 
+  # Filter method that returns a new (dup) data_set with certain nodes filtered out
+  # Filtering is done through either passing:
+  #   1. a 'leaf_label_id'. All matching nodes will be present in the new set
+  #   in their original position in the tree.
+  #
+  #   2. by passing a block that returns either `true`, `nil` or `false` for a given node:
+  #         true: A node is kept, _including its children_
+  #         nil: The matcher is indifferent about the node and will continue recursing the tree
+  #               a. When at some point `true` is returned for a descendant node the whole branch will be
+  #                 kept up to and including the node for which the block returned `true`.
+  #               b. If `true` is not returned the whole branch will not be included in the filter result,
+  #                 unless the option `keep_leafs` was set to true, in which case only nodes that were cut
+  #                 off with `false` will be excluded in the result.
+  #         false: When the block returns false for a given node that node is taken out of the results
+  #                this inludes its children, unless the option `orphan_strategy` was set to `:adopt` in
+  #                which case the children will be filtered using the same block and appended to first ancestor
+  #                node that was not excluded by the filter.
+  #
   def filter(leaf_label_id = nil, keep_leafs: false, orphan_strategy: :destroy, &block)
     fail ArgumentError, 'No block and no leaf_label_id passed' if !block_given? && leaf_label_id.nil?
+
     self.data.each_with_object(DataSet.new(id: id, label: label.deep_dup)) do |set, parent_set|
       if block_given?
         condition_met = yield(parent_set, set)
@@ -103,18 +135,26 @@ class DataSet
         condition_met = set.leaf? ? (set.label.id == leaf_label_id) : nil
       end
 
+      set_dup = set.deep_dup
+
+      # We want to have this node and its children
       if condition_met == true
-        parent_set.add_item(set.deep_dup)
-      elsif condition_met.nil? && set.data_array?
-        deep_filter_result = set.deep_dup.filter(leaf_label_id, keep_leafs: keep_leafs, orphan_strategy: orphan_strategy, &block)
-        parent_set.add_item(deep_filter_result) if deep_filter_result.data
-      elsif condition_met == false && set.data_array?
-        if orphan_strategy == :adopt
-          deep_filter_result = set.deep_dup.filter(leaf_label_id, keep_leafs: keep_leafs, orphan_strategy: orphan_strategy, &block)
-          deep_filter_result.children.each { |c| parent_set.add_item(c) } if deep_filter_result.data
+        parent_set.add_item(set_dup)
+      # Complex looking clause, but useful for performance and DRY-ness
+      elsif set.data_array? && (condition_met.nil? || (condition_met == false && orphan_strategy == :adopt))
+        deep_filter_result = set_dup.filter(leaf_label_id, keep_leafs: keep_leafs, orphan_strategy: orphan_strategy, &block)
+
+        # Here is where either the taking along or adopting of nodes happens
+        if deep_filter_result.data
+          # Filtering underlying children and adding the potential filter result to parent.
+          parent_set.add_item(deep_filter_result) if condition_met.nil?
+
+          # We are losing the node, but since 'orphan_strategy' == :adopt we will adopt the orphans that match the filter
+          deep_filter_result.children.each { |c| parent_set.add_item(c) } if condition_met == false
         end
+      # We are indifferent to the match (nil), but since the node is a leaf we will keep it
       elsif condition_met.nil? && set.leaf?
-        parent_set.add_item(set) if keep_leafs
+        parent_set.add_item(set_dup) if keep_leafs
       end
 
       parent_set

data/lib/tukey/version.rb

@@ -1,3 +1,3 @@
 module Tukey
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tukey
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Achilleas Buisman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-23 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler