lalala 4.0.0.dev.136 → 4.0.0.dev.141

data/vendor/deps/closure_tree/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -1,93 +0,0 @@
-# This module is only included if the order column is an integer.
-module ClosureTree
-  module DeterministicNumericOrdering
-    extend ActiveSupport::Concern
-
-    def self_and_descendants_preordered
-      # TODO: raise NotImplementedError if sort_order is not numeric and not null?
-      h = connection.select_one(<<-SQL)
-        SELECT
-          count(*) as total_descendants,
-          max(generations) as max_depth
-        FROM #{quoted_hierarchy_table_name}
-        WHERE ancestor_id = #{ct_quote(self.id)}
-      SQL
-      join_sql = <<-SQL
-        JOIN #{quoted_hierarchy_table_name} anc_hier
-          ON anc_hier.descendant_id = #{quoted_hierarchy_table_name}.descendant_id
-        JOIN #{quoted_table_name} anc
-          ON anc.id = anc_hier.ancestor_id
-        JOIN #{quoted_hierarchy_table_name} depths
-          ON depths.ancestor_id = #{ct_quote(self.id)} AND depths.descendant_id = anc.id
-      SQL
-      node_score = "(1 + anc.#{quoted_order_column(false)}) * " +
-        "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - depths.generations)"
-      order_by = "sum(#{node_score})"
-      self_and_descendants.joins(join_sql).group("#{quoted_table_name}.id").reorder(order_by)
-    end
-
-    module ClassMethods
-      def roots_and_descendants_preordered
-        h = connection.select_one(<<-SQL)
-          SELECT
-            count(*) as total_descendants,
-            max(generations) as max_depth
-          FROM #{quoted_hierarchy_table_name}
-        SQL
-        join_sql = <<-SQL
-          JOIN #{quoted_hierarchy_table_name} anc_hier
-            ON anc_hier.descendant_id = #{quoted_table_name}.id
-          JOIN #{quoted_table_name} anc
-            ON anc.id = anc_hier.ancestor_id
-          JOIN (
-            SELECT descendant_id, max(generations) AS max_depth
-            FROM #{quoted_hierarchy_table_name}
-            GROUP BY 1
-          ) AS depths ON depths.descendant_id = anc.id
-        SQL
-        node_score = "(1 + anc.#{quoted_order_column(false)}) * " +
-          "power(#{h['total_descendants']}, #{h['max_depth'].to_i + 1} - depths.max_depth)"
-        order_by = "sum(#{node_score})"
-        joins(join_sql).group("#{quoted_table_name}.id").reorder(order_by)
-      end
-    end
-
-    def append_sibling(sibling_node, use_update_all = true)
-      add_sibling(sibling_node, use_update_all, true)
-    end
-
-    def prepend_sibling(sibling_node, use_update_all = true)
-      add_sibling(sibling_node, use_update_all, false)
-    end
-
-    def add_sibling(sibling_node, use_update_all = true, add_after = true)
-      fail "can't add self as sibling" if self == sibling_node
-      # issue 40: we need to lock the parent to prevent deadlocks on parallel sibling additions
-      ct_with_advisory_lock do
-        # issue 18: we need to set the order_value explicitly so subsequent orders will work.
-        update_attribute(:order_value, 0) if self.order_value.nil?
-        sibling_node.order_value = self.order_value.to_i + (add_after ? 1 : -1)
-        # We need to incr the before_siblings to make room for sibling_node:
-        if use_update_all
-          col = quoted_order_column(false)
-          # issue 21: we have to use the base class, so STI doesn't get in the way of only updating the child class instances:
-          ct_base_class.update_all(
-            ["#{col} = #{col} #{add_after ? '+' : '-'} 1", "updated_at = now()"],
-            ["#{quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
-              ct_parent_id,
-              sibling_node.order_value])
-        else
-          last_value = sibling_node.order_value.to_i
-          (add_after ? siblings_after : siblings_before.reverse).each do |ea|
-            last_value += (add_after ? 1 : -1)
-            ea.order_value = last_value
-            ea.save!
-          end
-        end
-        sibling_node.parent = self.parent
-        sibling_node.save!
-        sibling_node.reload
-      end
-    end
-  end
-end

data/vendor/deps/closure_tree/lib/closure_tree/version.rb

@@ -1,3 +0,0 @@
-module ClosureTree
-  VERSION = "3.10.0" unless defined?(::ClosureTree::VERSION)
-end

data/vendor/deps/closure_tree/lib/closure_tree/with_advisory_lock.rb

@@ -1,18 +0,0 @@
-require 'with_advisory_lock'
-
-module ClosureTree
-  module WithAdvisoryLock
-    def ct_with_advisory_lock(&block)
-      if closure_tree_options[:with_advisory_lock]
-        with_advisory_lock("closure_tree") do
-          transaction do
-            yield
-          end
-        end
-      else
-        yield
-      end
-    end
-  end
-end
-

data/vendor/deps/closure_tree/lib/closure_tree.rb

@@ -1,8 +0,0 @@
-require 'active_support'
-require 'active_record'
-
-ActiveSupport.on_load :active_record do
-  require 'closure_tree/acts_as_tree'
-
-  ActiveRecord::Base.send :extend, ClosureTree::ActsAsTree
-end

data/vendor/deps/closure_tree/spec/cuisine_type_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-def assert_lineage(e, m)
-  m.parent.should == e
-  m.self_and_ancestors.should == [m, e]
-
-  # make sure reloading doesn't affect the self_and_ancestors:
-  m.reload
-  m.self_and_ancestors.should == [m, e]
-end
-
-describe CuisineType do
-  it "finds self and parents when children << is used" do
-    e = CuisineType.new(:name => "e")
-    m = CuisineType.new(:name => "m")
-    e.children << m
-    e.save
-    assert_lineage(e, m)
-  end
-
-  it "finds self and parents properly if the constructor is used" do
-    e = CuisineType.create(:name => "e")
-    m = CuisineType.create(:name => "m", :parent => e)
-    assert_lineage(e, m)
-  end
-
-  it "sets the table_name of the hierarchy class properly" do
-    CuisineTypeHierarchy.table_name.should == ActiveRecord::Base.table_name_prefix + "cuisine_type_hierarchies" + ActiveRecord::Base.table_name_suffix
-  end
-end

data/vendor/deps/closure_tree/spec/db/database.yml

@@ -1,19 +0,0 @@
-sqlite:
-  adapter: <%= "jdbc" if defined? JRUBY_VERSION %>sqlite3
-  database: spec/sqlite3.db
-  pool: 50
-  timeout: 5000
-
-postgresql:
-  adapter: postgresql
-  username: postgres
-  database: closure_tree_test
-  min_messages: ERROR
-  pool: 50
-
-mysql:
-  adapter: mysql2
-  host: localhost
-  username: root
-  database: closure_tree_test
-  pool: 50

data/vendor/deps/closure_tree/spec/db/schema.rb

@@ -1,109 +0,0 @@
-# encoding: UTF-8
-class ActiveRecord::ConnectionAdapters::AbstractAdapter
-  def force_add_index(table_name, columns, options = {})
-    begin
-      remove_index!(table_name, options[:name])
-    rescue ActiveRecord::StatementInvalid, ArgumentError
-    end
-    add_index table_name, columns, options
-  end
-end
-
-ActiveRecord::Schema.define(:version => 0) do
-
-  create_table "tags", :force => true do |t|
-    t.string "name"
-    t.string "title"
-    t.integer "parent_id"
-    t.integer "sort_order"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
-
-  create_table "tag_hierarchies", :id => false, :force => true do |t|
-    t.integer "ancestor_id", :null => false
-    t.integer "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-
-  create_table "tags_uuid", :id => false, :force => true do |t|
-    t.string "id", :unique => true
-    t.string "name"
-    t.string "title"
-    t.string "parent_id"
-    t.integer "sort_order"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
-
-  create_table "tag_hierarchies_uuid", :id => false, :force => true do |t|
-    t.string "ancestor_id", :null => false
-    t.string "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-
-  create_table "destroyed_tags", :force => true do |t|
-    t.string "name"
-  end
-
-  force_add_index "tag_hierarchies", [:ancestor_id, :descendant_id], :unique => true, :name => "tag_anc_desc_idx"
-  force_add_index "tag_hierarchies", [:descendant_id], :name => "tag_desc_idx"
-
-  create_table "users", :force => true do |t|
-    t.string "email"
-    t.integer "referrer_id"
-    t.datetime "created_at"
-    t.datetime "updated_at"
-  end
-
-  create_table "contracts", :force => true do |t|
-    t.integer "user_id", :null => false
-  end
-
-  create_table "referral_hierarchies", :id => false, :force => true do |t|
-    t.integer "ancestor_id", :null => false
-    t.integer "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-
-  force_add_index "referral_hierarchies", [:ancestor_id, :descendant_id], :unique => true, :name => "ref_anc_desc_idx"
-  force_add_index "referral_hierarchies", [:descendant_id], :name => "ref_desc_idx"
-
-  create_table "labels", :force => true do |t|
-    t.string "name"
-    t.string "type"
-    t.integer "sort_order"
-    t.integer "mother_id"
-  end
-
-  create_table "label_hierarchies", :id => false, :force => true do |t|
-    t.integer "ancestor_id", :null => false
-    t.integer "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-
-  force_add_index "label_hierarchies", [:ancestor_id, :descendant_id], :unique => true, :name => "lh_anc_desc_idx"
-  force_add_index "label_hierarchies", [:descendant_id], :name => "lh_desc_idx"
-
-  create_table "cuisine_types", :force => true do |t|
-    t.string "name"
-    t.integer "parent_id"
-  end
-
-  create_table "cuisine_type_hierarchies", :id => false, :force => true do |t|
-    t.integer "ancestor_id", :null => false
-    t.integer "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-
-  create_table "namespace_types", :force => true do |t|
-    t.string "name"
-    t.integer "parent_id"
-  end
-
-  create_table "namespace_type_hierarchies", :id => false, :force => true do |t|
-    t.integer "ancestor_id", :null => false
-    t.integer "descendant_id", :null => false
-    t.integer "generations", :null => false
-  end
-end

data/vendor/deps/closure_tree/spec/fixtures/labels.yml

@@ -1,55 +0,0 @@
-a1:
-  name: a1
-  sort_order: 1
-
-b1:
-  name: b1
-  parent: a1
-  sort_order: 1
-
-b2:
-  name: b2
-  parent: a1
-  sort_order: 2
-
-# Note that the names are not alphabetically ordered:
-c16:
-  name: c1-six
-  parent: b1
-  sort_order: 6
-
-c17:
-  name: c1-seven
-  parent: b1
-  sort_order: 7
-
-c18:
-  name: c1-eight
-  parent: b1
-  sort_order: 8
-
-c19:
-  name: c1-nine
-  parent: b1
-  sort_order: 9
-
-c2:
-  name: c2
-  parent: b2
-  sort_order: 1
-
-d2:
-  name: d2
-  parent: c2
-  sort_order: 1
-
-e2:
-  name: e2
-  parent: d2
-  sort_order: 1
-
-f3:
-  name: f3
-
-f4:
-  name: f4

data/vendor/deps/closure_tree/spec/fixtures/tags.yml

@@ -1,98 +0,0 @@
-# Read about fixtures at http://api.rubyonrails.org/classes/Fixtures.html
-
-grandparent:
-  name: grandparent
-  title: Nonnie
-
-parent:
-  name: parent
-  parent: grandparent
-  title: Mom
-
-child:
-  name: child
-  parent: parent
-  title: Kid
-
-people:
-  name: people
-
-# people has no children
-
-events:
-  name: events
-
-# events has only one child
-
-birthday:
-  name: birthday
-  parent: events
-
-places:
-  name: places
-
-# places has many children, with many depths
-
-home:
-  name: home
-  parent: places
-
-indoor:
-  name: indoor
-  parent: places
-
-outdoor:
-  name: outdoor
-  parent: places
-
-museum:
-  name: museum
-  parent: places
-
-united_states:
-  name: united_states
-  parent: places
-
-california:
-  name: california
-  parent: united_states
-
-san_francisco:
-  name: san_francisco
-  parent: california
-
-
-# Move and deletion test tree
-
-a1:
-  name: a1
-
-b1:
-  name: b1
-  parent: a1
-
-b2:
-  name: b2
-  parent: a1
-
-c1a:
-  name: c1a
-  parent: b1
-  sort_order: 2
-
-c1b:
-  name: c1b
-  parent: b1
-  sort_order: 1
-
-c2:
-  name: c2
-  parent: b2
-
-d2:
-  name: d2
-  parent: c2
-
-e2:
-  name: e2
-  parent: d2

data/vendor/deps/closure_tree/spec/hash_tree_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-describe Tag do
-
-  before :each do
-    @b = Tag.find_or_create_by_path %w(a b)
-    @a = @b.parent
-    @b2 = Tag.find_or_create_by_path %w(a b2)
-    @d1 = @b.find_or_create_by_path %w(c1 d1)
-    @c1 = @d1.parent
-    @d2 = @b.find_or_create_by_path %w(c2 d2)
-    @c2 = @d2.parent
-    @full_tree = {@a => {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}, @b2 => {}}}
-  end
-
-  context "#hash_tree" do
-    it "returns {} for depth 0" do
-      Tag.hash_tree(:limit_depth => 0).should == {}
-    end
-    it "limit_depth 1" do
-      Tag.hash_tree(:limit_depth => 1).should == {@a => {}}
-    end
-    it "limit_depth 2" do
-      Tag.hash_tree(:limit_depth => 2).should == {@a => {@b => {}, @b2 => {}}}
-    end
-    it "limit_depth 3" do
-      Tag.hash_tree(:limit_depth => 3).should == {@a => {@b => {@c1 => {}, @c2 => {}}, @b2 => {}}}
-    end
-    it "limit_depth 4" do
-      Tag.hash_tree(:limit_depth => 4).should == @full_tree
-    end
-    it "no limit holdum" do
-      Tag.hash_tree.should == @full_tree
-    end
-  end
-
-  def assert_no_dupes(scope)
-    # the named scope is complicated enough that an incorrect join could result in unnecessarily
-    # duplicated rows:
-    a = scope.collect { |ea| ea.id }
-    a.should == a.uniq
-  end
-
-  context "#hash_tree_scope" do
-    it "no dupes for any depth" do
-      (0..5).each do |ea|
-        assert_no_dupes(Tag.hash_tree_scope(ea))
-      end
-    end
-    it "no limit holdum" do
-      assert_no_dupes(Tag.hash_tree_scope)
-    end
-  end
-
-  context ".hash_tree_scope" do
-    it "no dupes for any depth" do
-      (0..5).each do |ea|
-        assert_no_dupes(@a.hash_tree_scope(ea))
-      end
-    end
-    it "no limit holdum" do
-      assert_no_dupes(@a.hash_tree_scope)
-    end
-  end
-
-  context ".hash_tree" do
-    before :each do
-    end
-    it "returns {} for depth 0" do
-      @b.hash_tree(:limit_depth => 0).should == {}
-    end
-    it "limit_depth 1" do
-      @b.hash_tree(:limit_depth => 1).should == {@b => {}}
-    end
-    it "limit_depth 2" do
-      @b.hash_tree(:limit_depth => 2).should == {@b => {@c1 => {}, @c2 => {}}}
-    end
-    it "limit_depth 3" do
-      @b.hash_tree(:limit_depth => 3).should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
-    end
-    it "no limit holdum from subsubroot" do
-      @c1.hash_tree.should == {@c1 => {@d1 => {}}}
-    end
-    it "no limit holdum from subroot" do
-      @b.hash_tree.should == {@b => {@c1 => {@d1 => {}}, @c2 => {@d2 => {}}}}
-    end
-    it "no limit holdum from root" do
-      @a.hash_tree.should == @full_tree
-    end
-  end
-end