forester 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 617105460b435e325d7fdc13dfe7b9361fc2bddc
+  data.tar.gz: 6adf0a77fa3d486dd08b60f38ca4cce64c98de5b
+SHA512:
+  metadata.gz: 018d6aef999f11fe3b815957a8a34d67661b5824b703caea5905c27b964203e939766a759fd7f5d75352c1b4b85b4a830026606df2122de38491dd73f6780858
+  data.tar.gz: f7716b917ce1657d4ad50b13a68cc105ee9efc6319873c3f99d0dabe15777c7d0729473caf64025a18511b7796b588275ff0db1fbd49a6c9a2f00cba549fe31e

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in forester.gemspec
+gemspec
+
+group :development, :test do
+  gem "rake", "~> 11.2"
+  gem "minitest", "~> 5.9"
+  gem 'pry-byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    forester (0.0.1)
+      enzymator (~> 0.0)
+      rubytree (~> 0.9)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    byebug (9.0.5)
+    coderay (1.1.1)
+    enzymator (0.0.1)
+    json (1.8.3)
+    method_source (0.8.2)
+    minitest (5.9.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.0)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rake (11.2.2)
+    rubytree (0.9.7)
+      json (~> 1.8)
+      structured_warnings (~> 0.2)
+    slop (3.6.0)
+    structured_warnings (0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  forester!
+  minitest (~> 5.9)
+  pry-byebug
+  rake (~> 11.2)
+
+BUNDLED WITH
+   1.12.5

data/README.md

@@ -0,0 +1,47 @@
+# Forester
+
+Based on *rubytree* and *enzymator*, this gem lets you build trees and run queries against them.
+
+## FAQ
+
+- What's the difference between forester and rubytree?
+
+The main class provided by the *rubytree* gem is **Tree::TreeNode**. In the case of forester, it is **Forester::TreeNode**, which is nothing more than a subclass of the former.
+
+- Why is this a separate gem and not just a pull request in rubytree?
+
+Because I needed to develop a certain feature on top of TreeNode in a time-sensitive manner. Rubytree devs should feel free to take anything they like from this project.
+
+- Why is forester not a fork of rubytree?
+
+Because I didn't feel the need to copy the whole codebase. All I needed was to extend the functionality of a class.
+
+- What can I do with forester?
+
+Everything you can do with rubytree, possibly in a more intention-revealing way, plus arbitrary, configurable aggregations on trees. Read the specs for more details.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'forester'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install forester
+
+## Usage
+
+Build your tree with any of the factory methods in TreeFactory, and then start messaging the resulting instance of TreeNode.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/forester.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'forester/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'forester'
+  s.version     = '0.0.1'
+  s.date        = '2016-07-17'
+  s.summary     = "A gem to represent and interact with tree data structures"
+  s.description = "Based on rubytree and enzymator, this gem lets you build trees and run queries against them."
+  s.authors     = ["Eugenio Bruno"]
+  s.email       = 'eugeniobruno@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/forester'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'rubytree', ['~> 0.9']
+  s.add_runtime_dependency 'enzymator', ['~> 0.0']
+end

data/lib/forester/aggregators.rb

@@ -0,0 +1,42 @@
+module Forester
+  module Aggregators
+
+    def aggregate(config)
+      Enzymator::Aggregation.new(config).run_on(self)
+    end
+
+    def values_by_subtree_of_level(options = {})
+      default_options = {
+        level:                    1,
+        group_field:              'name',
+        aggregation_field:        'value',
+        if_field_missing:         lambda { |c| [] },
+        include_ancestry_in_keys: false, # if false, with_root is ignored
+        with_root:                false,
+      }
+
+      options = default_options.merge(options)
+
+      Enzymator::Aggregation.new({
+        null_result:       lambda { Hash.new },
+        initial_clusters:  lambda { |tree| tree.nodes_of_level(options[:level]) },
+        map:               lambda do |node|
+                              key_nodes = if options[:include_ancestry_in_keys]
+                                            node.ancestry(options[:with_root], true)
+                                          else
+                                            [node]
+                                          end
+                              key = key_nodes.map { |kn| kn.get(options[:group_field]) { |n| n.object_id } }
+                              key = key.first if key.one?
+                              key
+                            end,
+        enumerator:        lambda { |level| level.each_node },
+        map_each:          lambda { |node| node.get(options[:aggregation_field], &options[:if_field_missing]) },
+        reduce_each:       lambda { |acum, value| Array(acum).concat(Array(value)) },
+        reduce:            lambda { |prev, group, result| prev.merge( { group => result } ) },
+
+      }).run_on(self, options)
+    end
+
+  end
+end

data/lib/forester/hash_with_indifferent_access.rb

@@ -0,0 +1,28 @@
+module Forester
+  class HashWithIndifferentAccess < SimpleDelegator
+
+    def has_key?(key)
+      equivs(key).any? { |k| super(k) }
+    end
+
+    def fetch(key, default = nil, &block)
+      maybe_key = equivs(key).select { |k| __getobj__.has_key?(k) }
+      if maybe_key.empty?
+        super(key)
+      else
+        super(maybe_key.first)
+      end
+    end
+
+    def [](key)
+      equivs(key).map { |k| super(k) }.compact.first || super
+    end
+
+    protected
+
+    def equivs(key)
+      [key.to_sym, key.to_s]
+    end
+
+  end
+end

data/lib/forester/node_content.rb

@@ -0,0 +1,23 @@
+module Forester
+  class NodeContent
+
+    def initialize(hash)
+      @hash = HashWithIndifferentAccess.new(hash)
+    end
+
+    def method_missing(name, *args, &block)
+      if @hash.has_key?(name)
+        @hash.fetch(name)
+      elsif block_given?
+        yield self
+      else
+        raise ArgumentError.new("the node \"#{self.name}\" does not have any \"#{name}\"")
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @hash.has_key?(name) || super
+    end
+
+  end
+end

data/lib/forester/node_content_factory.rb

@@ -0,0 +1,19 @@
+module Forester
+  class NodeContentFactory
+
+    class << self
+
+      def from_hash(hash, children_key)
+        NodeContent.new(HashWithIndifferentAccess.new(without_key(hash, children_key)))
+      end
+
+      private
+
+      def without_key(hash, key)
+        hash.reject { |k, _| k == key }
+      end
+
+    end
+
+  end
+end

data/lib/forester/tree_factory.rb

@@ -0,0 +1,47 @@
+module Forester
+  class TreeFactory
+
+    class << self
+
+      def from_yaml_file(file)
+        from_hash_with_root_key(YAML.load_file(file))
+      end
+
+      def from_root_hash(hash, children_key = :children)
+        from_hash_with_root_key({ root: hash }, children_key)
+      end
+
+      def from_hash_with_root_key(hash, children_key = :children, root_key = :root)
+        dummy_root = TreeNode.new('<TEMP>')
+        real_root  = fetch_indifferently(hash, root_key)
+
+        tree = with_children(dummy_root, [real_root], children_key).first_child
+        tree.detached_subtree_copy
+      end
+
+      def from_hash(hash, children_key, uid = SecureRandom.uuid)
+        name = uid
+        content = NodeContentFactory.from_hash(hash, children_key)
+        TreeNode.new(name, content)
+      end
+
+      private
+
+      def fetch_indifferently(hash, key, default = nil)
+        [key.to_sym, key.to_s].map { |k| hash[k] }.compact.first || default || hash.fetch(root_key)
+      end
+
+      def with_children(tree_node, children, children_key)
+        children.each do |child|
+          child_node = TreeFactory.from_hash(child, children_key)
+          child_children = fetch_indifferently(child, children_key, []) # nth level
+
+          tree_node << with_children(child_node, child_children, children_key)
+        end
+        tree_node
+      end
+
+    end
+
+  end
+end

data/lib/forester/tree_node.rb

@@ -0,0 +1,38 @@
+module Forester
+  class TreeNode < Tree::TreeNode
+
+    include Aggregators
+
+    def ancestry(include_root = true, include_self = false, descending = true)
+      ancestors = self.parentage          || []
+      ancestors = ancestors[0...-1]       unless include_root
+      ancestors = ancestors.unshift(self) if     include_self
+      if descending then ancestors.reverse else ancestors end
+    end
+
+    def nodes_of_level(l)
+      if l.between?(0, max_level) then each_level.take(l + 1).last else [] end
+    end
+
+    def max_level
+      node_height
+    end
+
+    def each_level
+      breadth_each.slice_when { |prev_node, next_node| prev_node.level < next_node.level }
+    end
+
+    def get(field, &block)
+      content.public_send(field, &block)
+    end
+
+    def contents
+      each_node.map(&:content)
+    end
+
+    def each_node
+      breadth_each
+    end
+
+  end
+end

data/lib/forester/version.rb

@@ -0,0 +1,18 @@
+module Forester
+  class Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+    PRE = nil
+
+    class << self
+
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+
+    end
+
+  end
+end

data/lib/forester.rb

@@ -0,0 +1,11 @@
+require 'tree'
+require 'enzymator'
+require 'securerandom'
+require 'yaml'
+
+require 'forester/aggregators'
+require 'forester/tree_node'
+require 'forester/tree_factory'
+require 'forester/node_content'
+require 'forester/node_content_factory'
+require 'forester/hash_with_indifferent_access'

data/test/test_treenode.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'forester'
+
+class TreeNodeTest < Minitest::Test
+
+  def test_tree_node
+
+    path_to_trees = "#{File.dirname(__FILE__)}/trees"
+    tree = Forester::TreeFactory.from_yaml_file("#{path_to_trees}/simple_tree.yml")
+
+    assert_equal 10, tree.size
+
+    assert_equal (0..9).reduce(:+), tree.reduce(0) { |acum, node| acum + node.get('value') }
+
+    expected = {
+      ["First node of level 1", "First node of level 2"]  => ["Already in level 2", "I want to be the very best", "like no one ever was"],
+      ["First node of level 1", "Second node of level 2"] => ["I have a sibling to my left", "She wants to catch them all"],
+      ["Second node of level 1", "Third node of level 2"] => ["Reached level 3", "It's dark", "A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]}
+
+    aggregation_result = tree.values_by_subtree_of_level(level: 2, aggregation_field: 'strings', include_ancestry_in_keys: true)
+
+    assert_equal expected, aggregation_result
+  end
+
+end

data/test/trees/simple_tree.yml

@@ -0,0 +1,45 @@
+---
+root:
+  name: root
+  value: 0
+  strings:
+    - This is the root
+  children:
+  - name: First node of level 1
+    value: 1
+    children:
+    - name: First node of level 2
+      value: 2
+      strings:
+        - Already in level 2
+        - I want to be the very best
+        - like no one ever was
+    - name: Second node of level 2
+      value: 3
+      strings:
+        - I have a sibling to my left
+        - She wants to catch them all
+  - name: Second node of level 1
+    value: 4
+    children:
+    - name: Third node of level 2
+      value: 5
+      children:
+      - name: First node of level 3
+        value: 6
+        strings:
+          - Reached level 3
+          - It's dark
+      - name: Second node of level 3
+        value: 7
+        strings:
+          - A hidden secret lies in the deepest leaves...
+          - Just kidding.
+        children:
+        - name: First node of level 4
+          value: 8
+        - name: Second child of level 3
+          value: 9
+          strings:
+            - Could forester handle trees with hundreds of levels?
+            - Maybe.

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: forester
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eugenio Bruno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: enzymator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: Based on rubytree and enzymator, this gem lets you build trees and run
+  queries against them.
+email: eugeniobruno@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- forester.gemspec
+- lib/forester.rb
+- lib/forester/aggregators.rb
+- lib/forester/hash_with_indifferent_access.rb
+- lib/forester/node_content.rb
+- lib/forester/node_content_factory.rb
+- lib/forester/tree_factory.rb
+- lib/forester/tree_node.rb
+- lib/forester/version.rb
+- test/test_treenode.rb
+- test/trees/simple_tree.yml
+homepage: http://rubygems.org/gems/forester
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A gem to represent and interact with tree data structures
+test_files:
+- test/test_treenode.rb
+- test/trees/simple_tree.yml