parlement 0.14 → 0.17

data/vendor/plugins/activerecord_text_id_extensions/init.rb

@@ -0,0 +1,2 @@
+require 'active_record/schema_dumper'
+require 'active_record_extensions'

data/vendor/plugins/activerecord_text_id_extensions/lib/active_record_extensions.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+	class SchemaDumper
+		private
+		alias old_table_text_id table
+
+		def table(table, stream)
+			text_id = false
+			@connection.columns(table).each { |c|
+				if c.name == 'id' and c.type.to_s == 'text'
+					text_id = true
+				end
+			}
+
+			old_table_text_id(table, stream)
+
+			if text_id
+				stream.puts "  remove_column :#{table}, :id"
+				stream.puts "  add_column :#{table}, :id, :text, :null => false, :primary_key => true"
+				stream.puts "  execute 'ALTER TABLE #{table} ADD CONSTRAINT #{table}_pkey PRIMARY KEY (id)'"
+				stream.puts
+			end
+		end
+	end
+end

data/vendor/plugins/acts_as_nested_set/README

@@ -0,0 +1,15 @@
+ActsAsNestedSet
+==============
+
+This acts_as extension provides Nested Set functionality.  Nested Set is similiar to Tree, but with the added feature that you can select the children and all of their descendents with a single query.  A good use case for this is a threaded post system, where you want to display every reply to a comment without multiple selects.
+
+
+Example
+=======
+
+  class Product < ActiveRecord::Base
+    acts_as_nested_set
+  end
+
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license  

data/vendor/plugins/acts_as_nested_set/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send :include, ActiveRecord::Acts::NestedSet

data/vendor/plugins/acts_as_nested_set/lib/active_record/acts/nested_set.rb

@@ -0,0 +1,210 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # This +acts_as+ extension provides Nested Set functionality.  Nested Set is similiar to Tree, but with
+      # the added feature that you can select the children and all of their descendents with
+      # a single query.  A good use case for this is a threaded post system, where you want
+      # to display every reply to a comment without multiple selects.
+      #
+      # A Google search for "Nested Set" should point you to in the right direction to explain the
+      # database theory.  I figured out a bunch of this from
+      # http://threebit.net/tutorials/nestedset/tutorial1.html
+      #
+      # Instead of picturing a leaf node structure with children pointing back to their parent,
+      # the best way to imagine how this works is to think of the parent entity surrounding all
+      # of its children, and its parent surrounding it, etc.  Assuming that they are lined up
+      # horizontally, we store the left and right boundries in the database.
+      #
+      # Imagine:
+      #   root
+      #     |_ Child 1
+      #       |_ Child 1.1
+      #       |_ Child 1.2
+      #     |_ Child 2
+      #       |_ Child 2.1
+      #       |_ Child 2.2
+      #
+      # If my cirlces in circles description didn't make sense, check out this sweet
+      # ASCII art:
+      #
+      #     ___________________________________________________________________
+      #    |  Root                                                             |
+      #    |    ____________________________    ____________________________   |
+      #    |   |  Child 1                  |   |  Child 2                  |   |
+      #    |   |   __________   _________  |   |   __________   _________  |   |
+      #    |   |  |  C 1.1  |  |  C 1.2 |  |   |  |  C 2.1  |  |  C 2.2 |  |   |
+      #    1   2  3_________4  5________6  7   8  9_________10 11_______12 13  14
+      #    |   |___________________________|   |___________________________|   |
+      #    |___________________________________________________________________| 
+      #
+      # The numbers represent the left and right boundries.  The table then might
+      # look like this:
+      #    ID | PARENT | LEFT | RIGHT | DATA
+      #     1 |      0 |    1 |    14 | root
+      #     2 |      1 |    2 |     7 | Child 1
+      #     3 |      2 |    3 |     4 | Child 1.1
+      #     4 |      2 |    5 |     6 | Child 1.2
+      #     5 |      1 |    8 |    13 | Child 2
+      #     6 |      5 |    9 |    10 | Child 2.1
+      #     7 |      5 |   11 |    12 | Child 2.2
+      #
+      # So, to get all children of an entry, you
+      #     SELECT * WHERE CHILD.LEFT IS BETWEEN PARENT.LEFT AND PARENT.RIGHT
+      #
+      # To get the count, it's <tt>(LEFT - RIGHT + 1)/2</tt>, etc.
+      #
+      # To get the direct parent, it falls back to using the +PARENT_ID+ field.
+      #
+      # There are instance methods for all of these.
+      #
+      # The structure is good if you need to group things together; the downside is that
+      # keeping data integrity is a pain, and both adding and removing an entry
+      # require a full table write.
+      #
+      # This sets up a +before_destroy+ callback to prune the tree correctly if one of its
+      # elements gets deleted.
+      #
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * +parent_column+ - specifies the column name to use for keeping the position integer (default: +parent_id+)
+        # * +left_column+ - column name for left boundry data, default +lft+
+        # * +right_column+ - column name for right boundry data, default +rgt+
+        # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 
+        #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 
+        #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
+        #   Example: <tt>acts_as_nested_set :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
+        def acts_as_nested_set(options = {})
+          configuration = { :parent_column => "parent_id", :left_column => "lft", :right_column => "rgt", :scope => "1 = 1" }
+
+          configuration.update(options) if options.is_a?(Hash)
+
+          configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+          if configuration[:scope].is_a?(Symbol)
+            scope_condition_method = %(
+              def scope_condition
+                if #{configuration[:scope].to_s}.nil?
+                  "#{configuration[:scope].to_s} IS NULL"
+                else
+                  "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+                end
+              end
+            )
+          else
+            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+          end
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::NestedSet::InstanceMethods
+
+            #{scope_condition_method}
+
+            def left_col_name() "#{configuration[:left_column]}" end
+
+            def right_col_name() "#{configuration[:right_column]}" end
+
+            def parent_column() "#{configuration[:parent_column]}" end
+
+          EOV
+        end
+      end
+
+      module InstanceMethods
+        # Returns +true+ is this is a root node.
+        def root?
+          parent_id = self[parent_column]
+          (parent_id == 0 || parent_id.nil?) && (self[left_col_name] == 1) && (self[right_col_name] > self[left_col_name])
+        end
+
+        # Returns +true+ is this is a child node
+        def child?
+          parent_id = self[parent_column]
+          !(parent_id == 0 || parent_id.nil?) && (self[left_col_name] > 1) && (self[right_col_name] > self[left_col_name])
+        end
+
+        # Returns +true+ if we have no idea what this is
+        def unknown?
+          !root? && !child?
+        end
+
+        # Adds a child to this object in the tree.  If this object hasn't been initialized,
+        # it gets set up as a root node.  Otherwise, this method will update all of the
+        # other elements in the tree and shift them to the right, keeping everything
+        # balanced. 
+        def add_child( child )
+          self.reload
+          child.reload
+
+          if child.root?
+            raise "Adding sub-tree isn\'t currently supported"
+          else
+            if ( (self[left_col_name] == nil) || (self[right_col_name] == nil) )
+              # Looks like we're now the root node!  Woo
+              self[left_col_name] = 1
+              self[right_col_name] = 4
+
+              # What do to do about validation?
+              return nil unless self.save
+
+              child[parent_column] = self.id
+              child[left_col_name] = 2
+              child[right_col_name]= 3
+              return child.save
+            else
+              # OK, we need to add and shift everything else to the right
+              child[parent_column] = self.id
+              right_bound = self[right_col_name]
+              child[left_col_name] = right_bound
+              child[right_col_name] = right_bound + 1
+              self[right_col_name] += 2
+              self.class.base_class.transaction {
+                self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} + 2)",  "#{scope_condition} AND #{left_col_name} >= #{right_bound}" )
+                self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} + 2)",  "#{scope_condition} AND #{right_col_name} >= #{right_bound}" )
+                self.save
+                child.save
+              }
+            end
+          end
+        end
+
+        # Returns the number of nested children of this object.
+        def children_count
+          return (self[right_col_name] - self[left_col_name] - 1)/2
+        end
+
+        # Returns a set of itself and all of its nested children
+        def full_set
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
+        end
+
+        # Returns a set of all of its children and nested children
+        def all_children
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
+        end
+
+        # Returns a set of only this entry's immediate children
+        def direct_children
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}", :order => left_col_name)
+        end
+
+        # Prunes a branch off of the tree, shifting all of the elements on the right
+        # back to the left so the counts still work.
+        def before_destroy
+          return if self[right_col_name].nil? || self[left_col_name].nil?
+          dif = self[right_col_name] - self[left_col_name] + 1
+
+          self.class.base_class.transaction {
+            self.class.base_class.delete_all( "#{scope_condition} and #{left_col_name} > #{self[left_col_name]} and #{right_col_name} < #{self[right_col_name]}" )
+            self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} - #{dif})",  "#{scope_condition} AND #{left_col_name} >= #{self[right_col_name]}" )
+            self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} - #{dif} )",  "#{scope_condition} AND #{right_col_name} >= #{self[right_col_name]}" )
+          }
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/acts_as_nested_set/test/nested_set_test.rb

@@ -0,0 +1,269 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'active_record'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+class Mixin < ActiveRecord::Base
+end
+
+class NestedSet < Mixin
+  acts_as_nested_set :scope => "root_id IS NULL"
+
+  def self.table_name() "mixins" end
+end
+
+class NestedSetWithStringScope < Mixin
+  acts_as_nested_set :scope => 'root_id = #{root_id}'
+
+  def self.table_name() "mixins" end
+end
+
+class NestedSetWithSymbolScope < Mixin
+  acts_as_nested_set :scope => :root
+
+  def self.table_name() "mixins" end
+end
+
+class NestedSetSuperclass < Mixin
+  acts_as_nested_set :scope => :root
+
+  def self.table_name() "mixins" end
+end
+
+class NestedSetSubclass < NestedSetSuperclass
+end
+
+
+class MixinNestedSetTest < Test::Unit::TestCase
+
+  def setup
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :mixins do |t|
+        t.integer :pos, :parent_id, :lft, :rgt, :root_id
+        t.timestamps
+      end
+    end
+
+    (1..10).each { |counter| NestedSet.create! }
+
+    [ [0,  1, 10, NestedSetSuperclass],
+      [11, 2, 5, NestedSetSubclass],
+      [12, 3, 4, NestedSetSuperclass],
+      [11, 6, 9, NestedSetSuperclass],
+      [13, 7, 8, NestedSetSubclass]
+    ].each do |sti|
+      sti[3].create! :parent_id => sti[0], :lft => sti[1], :rgt => sti[2], :root_id => 3100
+    end
+
+    [ [0,  1, 20],
+      [16, 2, 7],
+      [17, 3, 4],
+      [17, 5, 6],
+      [16, 14, 13],
+      [20, 9, 10],
+      [20, 11, 12],
+      [16, 8, 19],
+      [23, 15, 16],
+      [23, 17, 18]
+    ].each do |set|
+      NestedSetWithStringScope.create! :parent_id => set[0], :lft => set[1], :rgt => set[2], :root_id => 42
+    end
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+
+  def test_mixing_in_methods
+    ns = NestedSet.new
+    assert(ns.respond_to?(:all_children))
+    assert_equal(ns.scope_condition, "root_id IS NULL")
+    check_method_mixins ns
+  end
+
+  def test_string_scope
+    ns = NestedSetWithStringScope.new
+    ns.root_id = 1
+    assert_equal(ns.scope_condition, "root_id = 1")
+    ns.root_id = 42
+    assert_equal(ns.scope_condition, "root_id = 42")
+    check_method_mixins ns
+  end
+
+  def test_symbol_scope
+    ns = NestedSetWithSymbolScope.new
+    ns.root_id = 1
+    assert_equal(ns.scope_condition, "root_id = 1")
+    ns.root_id = 42
+    assert_equal(ns.scope_condition, "root_id = 42")
+    check_method_mixins ns
+  end
+
+  def check_method_mixins(obj)
+    [:scope_condition, :left_col_name, :right_col_name, :parent_column, :root?, :add_child,
+    :children_count, :full_set, :all_children, :direct_children].each { |symbol| assert(obj.respond_to?(symbol)) }
+  end
+
+  def set(id)
+    NestedSet.find(id)
+  end
+
+  def test_adding_children
+    assert(set(1).unknown?)
+    assert(set(2).unknown?)
+    set(1).add_child set(2)
+
+    # Did we maintain adding the parent_ids?
+    assert(set(1).root?)
+    assert(set(2).child?)
+    assert(set(2).parent_id == set(1).id)
+
+    # Check boundies
+    assert_equal(set(1).lft, 1)
+    assert_equal(set(2).lft, 2)
+    assert_equal(set(2).rgt, 3)
+    assert_equal(set(1).rgt, 4)
+
+    # Check children cound
+    assert_equal(set(1).children_count, 1)
+
+    set(1).add_child set(3)
+
+    #check boundries
+    assert_equal(set(1).lft, 1)
+    assert_equal(set(2).lft, 2)
+    assert_equal(set(2).rgt, 3)
+    assert_equal(set(3).lft, 4)
+    assert_equal(set(3).rgt, 5)
+    assert_equal(set(1).rgt, 6)
+
+    # How is the count looking?
+    assert_equal(set(1).children_count, 2)
+
+    set(2).add_child set(4)
+
+    # boundries
+    assert_equal(set(1).lft, 1)
+    assert_equal(set(2).lft, 2)
+    assert_equal(set(4).lft, 3)
+    assert_equal(set(4).rgt, 4)
+    assert_equal(set(2).rgt, 5)
+    assert_equal(set(3).lft, 6)
+    assert_equal(set(3).rgt, 7)
+    assert_equal(set(1).rgt, 8)
+
+    # Children count
+    assert_equal(set(1).children_count, 3)
+    assert_equal(set(2).children_count, 1)
+    assert_equal(set(3).children_count, 0)
+    assert_equal(set(4).children_count, 0)
+
+    set(2).add_child set(5)
+    set(4).add_child set(6)
+
+    assert_equal(set(2).children_count, 3)
+
+
+    # Children accessors
+    assert_equal(set(1).full_set.length, 6)
+    assert_equal(set(2).full_set.length, 4)
+    assert_equal(set(4).full_set.length, 2)
+
+    assert_equal(set(1).all_children.length, 5)
+    assert_equal(set(6).all_children.length, 0)
+
+    assert_equal(set(1).direct_children.length, 2)
+
+  end
+
+   def test_snipping_tree
+     big_tree = NestedSetWithStringScope.find(16)
+
+     # Make sure we have the right one
+     assert_equal(3, big_tree.direct_children.length)
+     assert_equal(10, big_tree.full_set.length)
+     assert_equal [17, 23, 20], big_tree.direct_children.map(&:id)
+
+     NestedSetWithStringScope.find(20).destroy
+
+     big_tree = NestedSetWithStringScope.find(16)
+
+     assert_equal(9, big_tree.full_set.length)
+     assert_equal(2, big_tree.direct_children.length)
+
+     assert_equal(1, NestedSetWithStringScope.find(16).lft)
+     assert_equal(2, NestedSetWithStringScope.find(17).lft)
+     assert_equal(3, NestedSetWithStringScope.find(18).lft)
+     assert_equal(4, NestedSetWithStringScope.find(18).rgt)
+     assert_equal(5, NestedSetWithStringScope.find(19).lft)
+     assert_equal(6, NestedSetWithStringScope.find(19).rgt)
+     assert_equal(7, NestedSetWithStringScope.find(17).rgt)
+     assert_equal(8, NestedSetWithStringScope.find(23).lft)
+     assert_equal(15, NestedSetWithStringScope.find(24).lft)
+     assert_equal(16, NestedSetWithStringScope.find(24).rgt)
+     assert_equal(17, NestedSetWithStringScope.find(25).lft)
+     assert_equal(18, NestedSetWithStringScope.find(25).rgt)
+     assert_equal(19, NestedSetWithStringScope.find(23).rgt)
+     assert_equal(20, NestedSetWithStringScope.find(16).rgt)
+   end
+ 
+   def test_deleting_root
+     NestedSetWithStringScope.find(16).destroy
+     assert_equal 15, NestedSetWithStringScope.count
+   end
+
+   def test_common_usage
+     NestedSet.find(1).add_child(NestedSet.find(2))
+     assert_equal(1, NestedSet.find(1).direct_children.length)
+
+     NestedSet.find(2).add_child(NestedSet.find(3))
+     assert_equal(1, NestedSet.find(1).direct_children.length) 
+
+     # Local cache is now out of date!
+     # Problem: the update_alls update all objects up the tree
+     assert_equal(2, NestedSet.find(1).all_children.length)
+
+     assert_equal(1, NestedSet.find(1).lft)
+     assert_equal(2, NestedSet.find(2).lft)
+     assert_equal(3, NestedSet.find(3).lft)
+     assert_equal(4, NestedSet.find(3).rgt)
+     assert_equal(5, NestedSet.find(2).rgt)
+     assert_equal(6, NestedSet.find(1).rgt)
+
+     assert(NestedSet.find(1).root?)
+
+     begin
+       NestedSet.find(4).add_child(NestedSet.find(1))
+       fail
+     rescue
+     end
+
+     assert_equal(2, NestedSet.find(1).all_children.length)
+
+     NestedSet.find(1).add_child NestedSet.find(4)
+
+     assert_equal(3, NestedSet.find(1).all_children.length)
+   end
+ 
+   def test_inheritance
+     parent = NestedSetWithStringScope.find(11)
+     child = NestedSetWithStringScope.find(12)
+     grandchild = NestedSetWithStringScope.find(13)
+     assert_equal 5, parent.full_set.size
+     assert_equal 2, child.full_set.size
+     assert_equal 4, parent.all_children.size
+     assert_equal 1, child.all_children.size
+     assert_equal 2, parent.direct_children.size
+     assert_equal 1, child.direct_children.size
+     child.destroy
+     assert_equal 3, parent.full_set.size
+   end
+ 
+end