snapshot_tree 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec
+spec/db/database.yml

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snapshot_tree.gemspec
+gemspec
+
+gem 'awesome_print'

data/Guardfile

@@ -0,0 +1,11 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', version: 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch(%r{^lib/(.+)\.yml$})    { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('spec/setup.rb')        { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Godwin Ko
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# Snapshot Tree
+
+Yet another tree implementation of adjacency list structure using recursive query of Postgresql >= 8.4.
+
+The main implementation different among others similar gems is the support
+of handling multiple effective tree snapshot, for which the parent/child relationship
+history can all be kept in a single relationship table with different effective date.
+
+Since ActiveRecord doesn't support update of relation table through has_many :through association,
+the creation of child and parent directly through association are not suported by this gem.
+Please reference other gems in case if multiple snapshot with effective date handling is not necessary.
+
+## Requirements
+
+* PostgreSQL version >= 8.4
+* ActiveRecord
+
+## Setup
+
+1.  Add this line to your application's Gemfile: ```gem 'snapshot_tree'```
+
+2.  Run ```bundle install```
+
+3.  Add ```acts_as_tree``` to your hierarchical model(s), see configuration section below.
+
+    The ActiveRecord associations ```parent_tree_nodes``` and ```child_tree_nodes``` will be
+    added automatically to ease the creation of tree association records
+
+    ```ruby
+    class Node < ActiveRecord::Base
+      include SnapshotTree::ActsAsTree
+      acts_as_tree
+    end
+    ```
+
+4.  Add a database migration to store the hierarchy relation for your model.
+    Relation table's name must be the model's table name, followed by "_tree".
+
+    ```ruby
+    class CreateModelTrees < ActiveRecord::Migration
+      def change
+        create_table :model_trees do |t|
+          t.integer  :child_id
+          t.integer  :parent_id
+          t.boolean  :is_active       # default field name for :is_active_field option
+          t.date     :effective_on    # default field name for :snapshot_field option
+
+          t.timestamps
+        end
+      end
+    end
+    ```
+
+5.  Run ```rake db:migrate```
+
+## Configuration
+
+When you include ```acts_as_tree``` in your model, you can provide a hash to override the following defaults:
+
+* ```:child_key``` to override the column name of the child foreign key in relation table. (default: ```child_id```)
+* ```:parent_key``` to override the column name of the parent foreign key in relation table. (default: ```parent_id```)
+* ```:node_prefix``` to override the field name prefix of generated field after getting descendent_nodes or ancestor_nodes. (default: ```node```) 
+* ```:snapshot_field``` to override the column name of snapshot effective date in relations table. (default: ```effective_on```)
+    - set it to ```nil``` will disable effective date filtering when getting tree snapshot.
+* ```:is_active_field``` to override the column name of snapshot record active status in relation table. (default: ```is_active```)
+    - set it to ```nil``` will disable active status checking.
+* ```:dependent``` determines what happens when a node is destroyed. Defaults to ```nullify```.
+    * ```:nullify``` will simply set the parent column to null. Each child node will be considered a "root" node. This is the default.
+    * ```:delete_all``` will delete all descendant nodes (which circumvents the destroy hooks)
+    * ```:destroy``` will destroy all descendant nodes (which runs the destroy hooks on each child node)
+
+## Usage
+
+### Creation tree association:
+
+  ```ruby
+  grandpa = Node.create(:name => 'grandpa')
+  parent  = Node.create(:name => 'parent')
+  child   = Node.create(:name => 'child')
+
+  grandpa.child_tree_nodes.create(:child_id => parent.id, :effective_on => '2012-01-01')
+  child.parent_tree_nodes.create(:parent_id => parent.id, :effective_on => Date.today)
+
+  ```
+
+Accessing the tree:
+
+#### Class methods
+
+* ```Node.root_nodes``` returns all root nodes
+* ```Node.leaf_nodes``` returns all leaf nodes
+* ```Node.descendent_nodes``` returns all descendent nodes, including children, children's children, ... etc.
+* ```Node.ancestor_nodes``` returns all ancestor nodes, including parent, grandparent, great grandparent, ... etc.
+
+#### Instance methods
+
+* ```Node.root_node``` returns the root node for this node
+* ```Node.root_node?``` returns true if this is a root node
+* ```Node.leaf_node?``` returns true if this is a leaf node
+* ```Node.parent_node``` returns the parent node for this node
+* ```Node.child_nodes``` returns an array of direct children node for this node
+* ```Node.descendent_nodes``` returns all descendent nodes for this node, including children, children's children, ... etc.
+* ```Node.ancestor_nodes``` returns all ancestor nodes for this node, including parent, grandparent, great grandparent, ... etc.
+
+#### Extra options
+
+When calling the instance/class methods, you can pass a hash of options to override the default behavour:
+
+* ```:as_of``` to query the snapsot tree as of specify effective date, the latest effective date <= this parameter will be used to filter records. This defaults to today.
+* ```:depth``` to limit to number of level to query, 0 for all levels, 1 for direct children only, 2 for direct children and grand children, ... etc. This defaults to 0.
+
+When calling the class methods, you must pass an model or model id in order to query tree nodes:
+
+```Node.descendent_nodes(grandpa, :depth => 1, :as_of => '2010-01-01')```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Thanks to
+
+* https://github.com/chrisroberts/acts_as_sane_tree
+
+* https://github.com/mceachen/closure_tree
+
+* [Bill Karwin](http://karwin.blogspot.com/)'s excellent
+[Models for hierarchical data presentation](http://www.slideshare.net/billkarwin/models-for-hierarchical-data)
+for a description of different tree storage algorithms.

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+desc 'Open an irb console'
+task :console do
+  sh 'pry -Ilib -Ispec -rsetup'
+end

data/lib/snapshot_tree/acts_as_tree.rb

@@ -0,0 +1,179 @@
+module SnapshotTree
+  module ActsAsTree
+    extend ActiveSupport::Concern
+
+    def descendent_nodes(*args)
+      self.class.descendent_nodes(id, *args)
+    end
+
+    alias_method :descendant_nodes, :descendent_nodes
+
+    def ancestor_nodes(*args)
+      self.class.ancestor_nodes(id, *args)
+    end
+
+    def root_node?(*args)
+      self.class.root_nodes(id, *args).where(id: id).size > 0
+    end
+
+    def leaf_node?(*args)
+      self.class.leaf_nodes(id, *args).where(id: id).size > 0
+    end
+
+    def root_node(*args)
+      if root_node?(*args)
+        self
+      else
+        ancestor_nodes(*args).limit(1).first
+      end
+    end
+
+    def parent_node(*args)
+      ancestor_nodes(*args).try(:last)
+    end
+
+    def child_nodes(*args)
+      opts = args.detect { |x| x.is_a?(Hash) }
+      opts ? opts.merge!(depth: 1) : args << {depth: 1}
+
+      descendent_nodes(*args)
+    end
+
+    module ClassMethods
+      def acts_as_tree(opts = {})
+        options = {
+          parent_key:      :parent_id,
+          child_key:       :child_id,
+          snapshot_field:  :effective_on,
+          is_active_field: :is_active,
+          node_prefix:     :node,
+          dependent:       :nullify
+        }.merge(opts)
+
+        options[:model_class] = self.name
+        options[:model_table] = options[:model_class].tableize
+        options[:join_class]  = "#{self.name}Tree" unless options[:join_class]
+        options[:join_class]  = options[:join_class].to_s
+        options[:join_table]  = options[:join_class].tableize
+
+        instance_variable_set :@tree_helper, TreeHelper.new(options)
+
+        has_many :parent_tree_nodes,
+          class_name:  options[:join_class],
+          foreign_key: options[:child_key],
+          autosave:    true,
+          dependent:   options[:dependent],
+          conditions:  options[:is_active_field] ? {options[:is_active_field].to_sym => true} : nil
+
+        has_many :child_tree_nodes,
+          class_name:  options[:join_class],
+          foreign_key: options[:parent_key],
+          autosave:    true,
+          dependent:   options[:dependent],
+          conditions:  options[:is_active_field] ? {options[:is_active_field].to_sym => true} : nil
+
+        "#{options[:node_prefix]}_depth".to_sym.tap do |field|
+          define_method(field) do
+            read_attribute(field).try(:to_i)
+          end
+        end
+
+        "#{options[:node_prefix]}_path".to_sym.tap do |field|
+          define_method(field) do
+            read_attribute(field).gsub(/[{}]/, '').split(',').map(&:to_i) if read_attribute(field)
+          end
+        end
+      end
+
+      def root_nodes(*args)
+        opts = @tree_helper.parse_args(*args)
+
+        sql = @tree_helper.nodes_query(:root)
+        sql = sql.gsub(/__snapshot_value__/, opts[:as_of].to_s(format: :db)) if @tree_helper.snapshot_field?
+
+        self.unscoped.from(sql).order('1')
+      end
+
+      def leaf_nodes(*args)
+        opts = @tree_helper.parse_args(*args)
+
+        sql = @tree_helper.nodes_query(:leaf)
+        sql = sql.gsub(/__snapshot_value__/, opts[:as_of].to_s(format: :db)) if @tree_helper.snapshot_field?
+
+        self.unscoped.from(sql).order('1')
+      end
+
+      def descendent_nodes(*args)
+        opts = @tree_helper.parse_args(*args)
+
+        sql = @tree_helper.nodes_query(:descendent)
+        sql = sql.gsub(/__model_id__/, opts[:model_id].to_s)
+        sql = sql.gsub(/__snapshot_value__/, opts[:as_of].to_s(format: :db)) if @tree_helper.snapshot_field?
+
+        query = self.unscoped.from(sql)
+        query = query.where("#{@tree_helper.node_field(:depth)} <= #{opts[:depth]}") if opts[:depth] > 0
+        query = query.order("#{@tree_helper.node_field(:path)}")
+      end
+
+      alias_method :descendant_nodes, :descendent_nodes
+
+      def ancestor_nodes(*args)
+        opts = @tree_helper.parse_args(*args)
+
+        sql = @tree_helper.nodes_query(:ancestor)
+        sql = sql.gsub(/__model_id__/, opts[:model_id].to_s)
+        sql = sql.gsub(/__snapshot_value__/, opts[:as_of].to_s(format: :db)) if @tree_helper.snapshot_field?
+
+        query = self.unscoped.from(sql)
+        query = query.where("#{@tree_helper.node_field(:depth)} <= #{opts[:depth]}") if opts[:depth] > 0
+        query = query.order("#{@tree_helper.node_field(:depth)} DESC")
+      end
+    end
+
+    class TreeHelper
+      def initialize(opts)
+        @opts = opts
+        @query = {}
+        @template = YAML::load(File.open(File.dirname(__FILE__) + '/template.yml'))
+      end
+
+      def nodes_query(query_type)
+        return @query[query_type] if @query[query_type]
+
+        @query[query_type] = Handlebars.compile(
+          @template["#{query_type}_query"]
+        ).call(
+          {
+            model_table:     @opts[:model_table],
+            join_table:      @opts[:join_table],
+            child_key:       "#{@opts[:child_key]}",
+            parent_key:      "#{@opts[:parent_key]}",
+            path:            "#{@opts[:node_prefix]}_path",
+            depth:           "#{@opts[:node_prefix]}_depth",
+            cycle:           "#{@opts[:node_prefix]}_cycle",
+            snapshot_field:  "#{@opts[:snapshot_field]}",
+            is_active_field: "#{@opts[:is_active_field]}"
+          }
+        )
+      end
+
+      def node_field(field)
+        "#{@opts[:model_table]}.#{@opts[:node_prefix]}_#{field}"
+      end
+
+      def snapshot_field?
+        @opts[:snapshot_field].present?
+      end
+
+      def parse_args(*args)
+        opts = args.detect { |x| x.is_a?(Hash) } || {}
+        args.delete(opts) if opts.size > 0
+        opts[:as_of]    = opts[:as_of].respond_to?(:to_date) ? opts[:as_of].to_date : Date.today
+        opts[:depth]    = opts[:depth].to_i
+        opts[:model_id] = args[0].is_a?(ActiveRecord::Base) ? args[0].id : args[0].to_i
+        opts
+      end
+
+    end
+  end
+end

data/lib/snapshot_tree/template.yml

@@ -0,0 +1,121 @@
+root_query: |
+  (
+    SELECT model.* FROM {{model_table}} model
+    {{#if snapshot_field}}
+      LEFT JOIN (
+        SELECT {{child_key}}, {{parent_key}}, {{snapshot_field}}, id,
+          {{#is_active_field}}{{this}}, {{/is_active_field}}
+          RANK() OVER (PARTITION BY {{child_key}} ORDER BY {{snapshot_field}} DESC, id DESC)
+        FROM {{join_table}}
+        WHERE {{snapshot_field}} <= '__snapshot_value__'
+        {{#is_active_field}}AND {{this}}{{/is_active_field}}
+      ) AS tree ON tree.{{child_key}} = model.id AND COALESCE(tree.rank, 1) = 1
+    {{else}}
+      LEFT JOIN {{join_table}} tree ON tree.{{child_key}} = model.id
+    {{/if}}
+    WHERE tree.{{parent_key}} IS NULL
+  ) AS {{model_table}}
+
+leaf_query: |
+  (
+    SELECT model.* FROM {{model_table}} model
+    {{#if snapshot_field}}
+      LEFT JOIN (
+        SELECT {{child_key}}, {{parent_key}}, {{snapshot_field}}, id,
+          {{#is_active_field}}{{this}}, {{/is_active_field}}
+          RANK() OVER (PARTITION BY {{child_key}} ORDER BY {{snapshot_field}} DESC, id DESC)
+        FROM {{join_table}}
+        WHERE {{snapshot_field}} <= '__snapshot_value__'
+        {{#is_active_field}}AND {{this}}{{/is_active_field}}
+      ) AS tree ON tree.{{parent_key}} = model.id AND COALESCE(tree.rank, 1) = 1
+    {{else}}
+      LEFT JOIN {{join_table}} tree ON tree.{{parent_key}} = model.id
+    {{/if}}
+    WHERE tree.{{child_key}} IS NULL
+  ) AS {{model_table}}
+
+descendent_query: |
+  (
+    WITH RECURSIVE tree AS (
+      SELECT
+        alias.{{child_key}}, alias.{{parent_key}},
+        ARRAY[alias.{{parent_key}}] AS {{path}}, 1 AS {{depth}}, false AS {{cycle}}
+      FROM {{join_table}} alias
+        {{#if snapshot_field}}JOIN snapshot ON snapshot.id = alias.id{{/if}}
+      WHERE alias.{{parent_key}} = __model_id__
+      UNION ALL
+      SELECT
+        alias.{{child_key}}, alias.{{parent_key}},
+        tree.{{path}} || alias.{{parent_key}} AS {{path}},
+        tree.{{depth}} + 1 AS {{depth}},
+        alias.{{child_key}} = ANY(tree.{{path}}) AS {{cycle}}
+      FROM tree
+        JOIN {{join_table}} alias ON alias.{{parent_key}} = tree.{{child_key}}
+        {{#if snapshot_field}}JOIN snapshot ON snapshot.id = alias.id{{/if}}
+      WHERE NOT tree.{{cycle}}
+    )
+    ,snapshot AS (
+      SELECT alias.id
+      FROM {{model_table}} model
+      {{#if snapshot_field}}
+        LEFT JOIN (
+          SELECT {{child_key}}, {{parent_key}}, {{snapshot_field}}, id,
+            {{#is_active_field}}{{this}}, {{/is_active_field}}
+            RANK() OVER (PARTITION BY {{child_key}} ORDER BY {{snapshot_field}} DESC, id DESC)
+          FROM {{join_table}}
+          WHERE {{snapshot_field}} <= '__snapshot_value__'
+          {{#is_active_field}}AND {{this}}{{/is_active_field}}
+        ) AS alias ON alias.{{child_key}} = model.id AND COALESCE(rank, 1) = 1
+      {{else}}
+        LEFT JOIN {{join_table}} alias ON alias.{{child_key}} = model.id
+      {{/if}}
+      WHERE alias.{{parent_key}} IS NOT NULL
+    )
+    SELECT model.*, tree.*
+    FROM tree
+    JOIN {{model_table}} model ON model.id = tree.{{child_key}}
+    WHERE NOT tree.{{cycle}}
+  ) AS {{model_table}}
+
+ancestor_query: |
+  (
+    WITH RECURSIVE tree AS (
+      SELECT
+        alias.{{child_key}}, alias.{{parent_key}},
+        ARRAY[alias.{{parent_key}}] AS {{path}}, 1 AS {{depth}}, false AS {{cycle}}
+      FROM {{join_table}} alias
+        {{#if snapshot_field}}JOIN snapshot ON snapshot.id = alias.id{{/if}}
+      WHERE alias.{{child_key}} = __model_id__
+      UNION ALL
+      SELECT
+        alias.{{child_key}}, alias.{{parent_key}},
+        tree.{{path}} || alias.{{parent_key}} AS {{path}},
+        tree.{{depth}} + 1 AS {{depth}},
+        alias.{{parent_key}} = ANY(tree.{{path}}) AS {{cycle}}
+      FROM tree
+        JOIN {{join_table}} alias ON alias.{{child_key}} = tree.{{parent_key}}
+        {{#if snapshot_field}}JOIN snapshot ON snapshot.id = alias.id{{/if}}
+      WHERE NOT tree.{{cycle}}
+    )
+    ,snapshot AS (
+      SELECT alias.id
+      FROM {{model_table}} model
+      {{#if snapshot_field}}
+        LEFT JOIN (
+          SELECT {{child_key}}, {{parent_key}}, {{snapshot_field}}, id,
+            {{#is_active_field}}{{this}}, {{/is_active_field}}
+            RANK() OVER (PARTITION BY {{child_key}} ORDER BY {{snapshot_field}} DESC, id DESC)
+          FROM {{join_table}}
+          WHERE {{snapshot_field}} <= '__snapshot_value__'
+          {{#is_active_field}}AND {{this}}{{/is_active_field}}
+        ) AS alias ON alias.{{child_key}} = model.id AND COALESCE(rank, 1) = 1
+      {{else}}
+        LEFT JOIN {{join_table}} alias ON alias.{{child_key}} = model.id
+      {{/if}}
+      WHERE alias.{{parent_key}} IS NOT NULL
+    )
+    SELECT model.*, tree.*
+    FROM tree
+    JOIN {{model_table}} model ON model.id = tree.{{parent_key}}
+    WHERE NOT tree.{{cycle}}
+  ) AS {{model_table}}

data/lib/snapshot_tree/version.rb

@@ -0,0 +1,3 @@
+module SnapshotTree
+  VERSION = "0.0.1"
+end

data/lib/snapshot_tree.rb

@@ -0,0 +1,8 @@
+require "active_record"
+require 'handlebars'
+
+require "snapshot_tree/version"
+require "snapshot_tree/acts_as_tree"
+
+module SnapshotTree
+end

data/snapshot_tree.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/snapshot_tree/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Szetobo"]
+  gem.email         = ["szetobo@gmail.com"]
+  gem.homepage      = "https://github.com/szetobo/snapshot_tree"
+  gem.summary       = "Mutliple snapshot hierarchical tree implementation of adjacency list using recursive query of Postgresql"
+  gem.description   = "Mutliple snapshot hierarchical tree implementation of adjacency list using recursive query of Postgresql"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "snapshot_tree"
+  gem.require_paths = ["lib"]
+  gem.version       = SnapshotTree::VERSION
+
+  gem.add_dependency "activerecord", ">= 3.0.0"
+  gem.add_dependency "activesupport", ">= 3.0.0"
+  gem.add_dependency "pg", ">= 0.11.0"
+  gem.add_dependency "hbs", "~> 0.1.2"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", "~> 2.6"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "pry"
+end

data/spec/acts_as_tree_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe SnapshotTree do
+
+  describe 'after suite setup' do
+    it 'should have populated nodes and node_trees' do
+      Node.count.should == 15
+      NodeTree.count.should == 37
+    end
+  end
+
+  describe 'when requesting root/leaf nodes' do
+    it 'should return a relation' do
+      Node.root_nodes.should be_a_kind_of ActiveRecord::Relation
+      Node.leaf_nodes.should be_a_kind_of ActiveRecord::Relation
+    end
+
+    it 'should allow scope chaining' do
+      Node.where(name: 'root_1').first.should   == Node.root_nodes.where(name: 'root_1').first
+      Node.where(name: 'node_2_1').first.should == Node.leaf_nodes.where(name: 'node_2_1').first
+    end
+
+    it 'should return all root nodes' do
+      Node.root_nodes.count.should == 3
+      Node.root_nodes(as_of: '1800-01-01').count.should == 15
+    end
+
+    it 'should have empty parent node for root nodes' do
+      Node.root_nodes.all? { |r| r.parent_node.nil? }.should be true
+    end
+
+    it 'should return all leaf nodes' do
+      Node.leaf_nodes.count.should == 8
+      Node.leaf_nodes(as_of: '1800-01-01').count.should == 15
+    end
+
+    it 'should have empty child nodes for leaf nodes' do
+      Node.leaf_nodes.all? { |r| r.child_nodes.size == 0 }.should be true
+    end
+  end
+
+  describe 'when access tree_1' do
+    before(:each) do
+      @parent = Node.root_nodes.first
+    end
+
+    it 'should have 5 descendents and 1 child' do
+      @parent.parent_node.should be nil
+      @parent.descendent_nodes.size.should == 5
+      @parent.child_nodes.size.should == 1
+    end
+
+    it 'should have 1 child for each node except the last node' do
+      nodes = @parent.descendent_nodes.all
+      (nodes.size - 1).times do |i|
+        nodes[i].root_node.should == @parent
+        nodes[i].parent_node.should == (i > 0 ? nodes[i-1] : @parent)
+        nodes[i].child_nodes.size.should == 1
+        nodes[i].child_nodes[0].name.should == nodes[i+1].name
+      end
+      nodes[-1].child_nodes.size.should == 0
+    end
+
+    it 'should be a flat tree before year 2000' do
+      nodes = @parent.descendent_nodes(as_of: '1990-01-01').where("name ~* 'node_1_'").all
+      nodes.all? { |r| r.parent_node(as_of: '1990-01-01') == @parent }.should be true
+      nodes.all? { |r| r.child_nodes(as_of: '1990-01-01').where("name ~* 'node_1_'").size == 0 }.should be true
+    end
+
+    it 'should be all root nodes before year 1900' do
+      nodes = Node.root_nodes(as_of: '1890-01-01').where("name ~* 'root_1|node_1_'").all
+      nodes.size.should == 6
+      nodes.all? { |r| r.parent_node(as_of: '1890-01-01').nil? }.should be true
+    end
+  end
+
+  describe 'when access tree_2' do
+    before(:each) do
+      @parent = Node.root_nodes.where(name: 'root_2').first
+    end
+
+    it 'should have 5 descendents and 5 child' do
+      @parent.parent_node.should be nil
+      @parent.descendent_nodes.size.should == 5
+      @parent.child_nodes.size.should == 5
+    end
+
+    it 'should have no child for each node' do
+      nodes = @parent.descendent_nodes.all
+      nodes.size.times do |i|
+        nodes[i].root_node.should == @parent
+        nodes[i].parent_node.should == @parent
+        nodes[i].child_nodes.size.should == 0
+      end
+    end
+
+    it 'should be all child of root_1 before year 2000' do
+      root_1 = Node.where(name: 'root_1').first
+      nodes = @parent.descendent_nodes(as_of: '1990-01-01').where("name ~* 'node_2_'").all
+      nodes.all? { |r| r.parent_node(as_of: '1990-01-01') == root_1 }.should be true
+      nodes.all? { |r| r.child_nodes(as_of: '1990-01-01').size == 0 }.should be true
+    end
+  end
+
+  describe 'when access tree_3' do
+    before(:each) do
+      @parent = Node.root_nodes.where(name: 'root_3').first
+    end
+
+    it 'should have 2 descendents and 2 child' do
+      @parent.parent_node.should be nil
+      @parent.descendent_nodes.size.should == 2
+      @parent.child_nodes.size.should == 2
+    end
+
+    it 'should have no child for each node' do
+      nodes = @parent.descendent_nodes.all
+      nodes.size.times do |i|
+        nodes[i].root_node.should == @parent
+        nodes[i].parent_node.should == @parent
+        nodes[i].child_nodes.size.should == 0
+      end
+    end
+
+    it 'should be respect the snapshot history' do
+      node = Node.where(name: 'node_3_1').first
+      node.parent_node(as_of:'1901-01-01').name.should == 'node_1_1'
+      node.parent_node(as_of:'1911-01-01').name.should == 'node_1_2'
+      node.parent_node(as_of:'1921-01-01').name.should == 'node_1_3'
+      node.parent_node(as_of:'1931-01-01').name.should == 'node_1_4'
+      node.parent_node(as_of:'1941-01-01').name.should == 'node_1_5'
+      node.parent_node(as_of:'2010-01-01').name.should == 'root_3'
+    end
+
+    it 'should be respect the active status of snapshot history' do
+      node = Node.where(name: 'node_3_2').first
+      node.parent_node(as_of:'1901-01-01').name.should == 'node_1_1'
+      node.parent_node(as_of:'1911-01-01').name.should == 'node_1_1'
+      node.parent_node(as_of:'1921-01-01').name.should == 'node_1_3'
+      node.parent_node(as_of:'1931-01-01').name.should == 'node_1_3'
+      node.parent_node(as_of:'1941-01-01').name.should == 'node_1_5'
+      node.parent_node(as_of:'2010-01-01').name.should == 'root_3'
+    end
+  end
+
+  #
+  # db setup for the whole test suite
+  #
+  before(:all) do
+    if Node.table_exists? && NodeTree.table_exists?
+      NodeTree.delete_all
+      Node.delete_all
+      Node.connection.execute("select setval('nodes_id_seq', 1, false); select setval('node_trees_id_seq', 1, false);")
+    else
+      load(File.dirname(__FILE__) + '/db/schema.rb')
+    end
+
+    # for testing multi-level hierarchy
+    parent1 = Node.create(name: "root_1")
+    node = Node.new(name: "node_1_1")
+    node.parent_tree_nodes.build(parent_id: parent1.id, effective_on: '1900-01-01')
+    node.save!
+    nodes = [node]
+    4.times do |i|
+      node = Node.new(name: "node_1_#{i + 2}")
+      node.parent_tree_nodes.build(parent_id: nodes[i].id, effective_on: '2000-01-01')
+      node.parent_tree_nodes.build(parent_id: parent1.id, effective_on: '1900-01-01')
+      node.save!
+      nodes << node
+    end
+
+    # for testing single-level hierarchy
+    parent2 = Node.create(name: "root_2")
+    5.times do |i|
+      node = Node.new(name: "node_2_#{i + 1}")
+      node.parent_tree_nodes.build(parent_id: parent2.id, effective_on: '2000-01-01')
+      node.parent_tree_nodes.build(parent_id: parent1.id, effective_on: '1900-01-01')
+      node.save!
+    end
+
+    parent3 = Node.create(name: "root_3")
+
+    # testing effective snapshot
+    node = Node.new(name: "node_3_1")
+    node.parent_tree_nodes.build(parent_id: nodes[0].id, effective_on: '1900-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[1].id, effective_on: '1910-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[2].id, effective_on: '1920-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[3].id, effective_on: '1930-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[4].id, effective_on: '1940-01-01')
+    node.parent_tree_nodes.build(parent_id: parent1.id, effective_on: '2000-01-01', created_at: Time.now - 2.hour)
+    node.parent_tree_nodes.build(parent_id: parent2.id, effective_on: '2000-01-01', created_at: Time.now - 1.hour)
+    node.parent_tree_nodes.build(parent_id: parent3.id, effective_on: '2000-01-01')
+    node.save!
+
+    # testing active snapshot
+    node = Node.new(name: "node_3_2")
+    node.parent_tree_nodes.build(parent_id: nodes[0].id, effective_on: '1900-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[1].id, effective_on: '1910-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[2].id, effective_on: '1920-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[3].id, effective_on: '1930-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[4].id, effective_on: '1940-01-01')
+    node.parent_tree_nodes.build(parent_id: nodes[0].id, effective_on: '2000-01-01', created_at: Time.now - 4.hour)
+    node.parent_tree_nodes.build(parent_id: nodes[1].id, effective_on: '2000-01-01', created_at: Time.now - 3.hour)
+    node.parent_tree_nodes.build(parent_id: nodes[2].id, effective_on: '2000-01-01', created_at: Time.now - 2.hour)
+    node.parent_tree_nodes.build(parent_id: parent3.id,  effective_on: '2000-01-01', created_at: Time.now - 1.hour)
+    node.parent_tree_nodes.build(parent_id: parent1.id,  effective_on: '2000-01-01')
+    node.save!
+    NodeTree.where(child_id: node.id, parent_id: nodes[1].id).first.update_attribute(:is_active, false)
+    NodeTree.where(child_id: node.id, parent_id: nodes[3].id).first.update_attribute(:is_active, false)
+    NodeTree.where(child_id: node.id, parent_id: parent1.id).first.update_attribute(:is_active, false)
+  end
+
+end

data/spec/db/database.yml.sample

@@ -0,0 +1,8 @@
+adapter:  postgresql
+encoding: unicode
+database: tree_test
+# username: postgres
+# password: postgres
+pool: 5
+port: 5432
+

data/spec/db/schema.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table "nodes", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "node_trees", :force => true do |t|
+    t.integer  "child_id"
+    t.integer  "parent_id"
+    t.boolean  "is_active"
+    t.date     "effective_on"
+    t.datetime "created_at",   :null => false
+    t.datetime "updated_at",   :null => false
+  end
+
+  add_index "node_trees", ["child_id"], :name => "index_node_trees_on_child_id"
+  add_index "node_trees", ["parent_id"], :name => "index_node_trees_on_parent_id"
+  add_index "node_trees", ["is_active"], :name => "index_node_trees_on_is_active"
+  add_index "node_trees", ["effective_on"], :name => "index_node_trees_on_effective_on"
+end

data/spec/setup.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pry'
+
+require 'snapshot_tree'
+
+ActiveRecord::Base.establish_connection YAML::load(File.open(File.dirname(__FILE__) + '/db/database.yml'))
+
+class Node < ActiveRecord::Base
+  include SnapshotTree::ActsAsTree
+  acts_as_tree
+  validates :name, presence: true
+end
+
+class NodeTree < ActiveRecord::Base
+  belongs_to :node
+  belongs_to :parent, class_name: 'Node'
+  validates :node, :parent, associated: true
+  validates :effective_on, :is_active, presence: true
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'setup'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: snapshot_tree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Szetobo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &13337080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *13337080
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &13335920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *13335920
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &13368200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *13368200
+- !ruby/object:Gem::Dependency
+  name: hbs
+  requirement: &13365500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *13365500
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &13387820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13387820
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13385800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *13385800
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &13382620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13382620
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &13405940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13405940
+description: Mutliple snapshot hierarchical tree implementation of adjacency list
+  using recursive query of Postgresql
+email:
+- szetobo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/snapshot_tree.rb
+- lib/snapshot_tree/acts_as_tree.rb
+- lib/snapshot_tree/template.yml
+- lib/snapshot_tree/version.rb
+- snapshot_tree.gemspec
+- spec/acts_as_tree_spec.rb
+- spec/db/database.yml.sample
+- spec/db/schema.rb
+- spec/setup.rb
+- spec/spec_helper.rb
+homepage: https://github.com/szetobo/snapshot_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3800555106948873925
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3800555106948873925
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Mutliple snapshot hierarchical tree implementation of adjacency list using
+  recursive query of Postgresql
+test_files: []