lalala 4.0.0.dev.46

data/vendor/deps/closure_tree/ci/Gemfile.rails-3.1.x

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec :path => '..'
+
+gem 'activerecord', '~> 3.1.0'

data/vendor/deps/closure_tree/ci/Gemfile.rails-3.2.x

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec :path => '..'
+
+gem 'activerecord', '~> 3.2.0'

data/vendor/deps/closure_tree/closure_tree.gemspec

@@ -0,0 +1,31 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "closure_tree/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "closure_tree"
+  gem.version     = ::ClosureTree::VERSION
+  gem.authors     = ["Matthew McEachen"]
+  gem.email       = ["matthew-github@mceachen.org"]
+  gem.homepage    = "http://matthew.mceachen.us/closure_tree"
+
+  gem.summary = %q{Easily and efficiently make your ActiveRecord model support hierarchies}
+  gem.description = %q{Easily and efficiently make your ActiveRecord model support hierarchies}
+
+  gem.files = Dir["lib/**/*"] + ["MIT-LICENSE", "Rakefile", "README.md"]
+  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  gem.add_runtime_dependency 'activerecord', '>= 3.0.0'
+  gem.add_runtime_dependency 'with_advisory_lock', '>= 0.0.6' # <- to prevent duplicate roots
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rails' # FIXME: just for rspec fixture support (!!)
+  gem.add_development_dependency 'rspec-rails' # FIXME: just for rspec fixture support (!!)
+  gem.add_development_dependency 'mysql2'
+  gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'uuidtools'
+  gem.add_development_dependency 'strong_parameters'
+  # TODO: gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+end

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

@@ -0,0 +1,55 @@
+require 'closure_tree/columns'
+require 'closure_tree/deterministic_ordering'
+require 'closure_tree/model'
+require 'closure_tree/numeric_deterministic_ordering'
+require 'closure_tree/with_advisory_lock'
+
+module ClosureTree
+  module ActsAsTree
+    def acts_as_tree(options = {})
+
+      class_attribute :closure_tree_options
+
+      self.closure_tree_options = {
+        :ct_base_class => self,
+        :parent_column_name => 'parent_id',
+        :dependent => :nullify, # or :destroy or :delete_all -- see the README
+        :name_column => 'name',
+        :with_advisory_lock => true
+      }.merge(options)
+
+      raise IllegalArgumentException, "name_column can't be 'path'" if closure_tree_options[:name_column] == 'path'
+
+      include ClosureTree::Columns
+      extend ClosureTree::Columns
+
+      include ClosureTree::WithAdvisoryLock
+      extend ClosureTree::WithAdvisoryLock
+
+      # Auto-inject the hierarchy table
+      # See https://github.com/patshaughnessy/class_factory/blob/master/lib/class_factory/class_factory.rb
+      class_attribute :hierarchy_class
+      self.hierarchy_class = ct_class.parent.const_set short_hierarchy_class_name, Class.new(ActiveRecord::Base)
+
+      self.hierarchy_class.class_eval <<-RUBY
+        belongs_to :ancestor, :class_name => "#{ct_class.to_s}"
+        belongs_to :descendant, :class_name => "#{ct_class.to_s}"
+        attr_accessible :ancestor, :descendant, :generations
+        def ==(comparison_object)
+          comparison_object.instance_of?(self.class) &&
+          self.attributes == comparison_object.attributes
+        end
+        alias :eql? :==
+      RUBY
+
+      self.hierarchy_class.table_name = hierarchy_table_name
+
+      include ClosureTree::Model
+      unless order_option.nil?
+        include ClosureTree::DeterministicOrdering
+        include ClosureTree::DeterministicNumericOrdering if order_is_numeric
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,123 @@
+module ClosureTree
+
+  # Mixed into both classes and instances to provide easy access to the column names
+  module Columns
+
+    def parent_column_name
+      closure_tree_options[:parent_column_name]
+    end
+
+    def parent_column_sym
+      parent_column_name.to_sym
+    end
+
+    def has_name?
+      ct_class.new.attributes.include? closure_tree_options[:name_column]
+    end
+
+    def name_column
+      closure_tree_options[:name_column]
+    end
+
+    def name_sym
+      name_column.to_sym
+    end
+
+    def hierarchy_table_name
+      # We need to use the table_name, not something like ct_class.to_s.demodulize + "_hierarchies",
+      # because they may have overridden the table name, which is what we want to be consistent with
+      # in order for the schema to make sense.
+      tablename = closure_tree_options[:hierarchy_table_name] ||
+        remove_prefix_and_suffix(ct_table_name).singularize + "_hierarchies"
+
+      ActiveRecord::Base.table_name_prefix + tablename + ActiveRecord::Base.table_name_suffix
+    end
+
+    def hierarchy_class_name
+      closure_tree_options[:hierarchy_class_name] || ct_class.to_s + "Hierarchy"
+    end
+
+
+    #
+    # Returns the constant name of the hierarchy_class
+    #
+    # @return [String] the constant name
+    #
+    # @example
+    #   Namespace::Model.hierarchy_class_name # => "Namespace::ModelHierarchy"
+    #   Namespace::Model.short_hierarchy_class_name # => "ModelHierarchy"
+    def short_hierarchy_class_name
+      hierarchy_class_name.split('::').last
+    end
+
+    def quoted_hierarchy_table_name
+      connection.quote_table_name hierarchy_table_name
+    end
+
+    def quoted_parent_column_name
+      connection.quote_column_name parent_column_name
+    end
+
+    def quoted_name_column
+      connection.quote_column_name name_column
+    end
+
+    def ct_quote(field)
+      connection.quote(field)
+    end
+
+    def order_option
+      closure_tree_options[:order]
+    end
+
+    def with_order_option(options)
+      order_option ? options.merge(:order => order_option) : options
+    end
+
+    def append_order(order_by)
+      order_option ? "#{order_by}, #{order_option}" : order_by
+    end
+
+    def order_is_numeric
+      # The table might not exist yet (in the case of ActiveRecord::Observer use, see issue 32)
+      return false if order_option.nil? || !self.table_exists?
+      c = ct_class.columns_hash[order_option]
+      c && c.type == :integer
+    end
+
+    def ct_class
+      (self.is_a?(Class) ? self : self.class)
+    end
+
+    # This is the "topmost" class. This will only potentially not be ct_class if you are using STI.
+    def ct_base_class
+      ct_class.closure_tree_options[:ct_base_class]
+    end
+
+    def ct_subclass?
+      ct_class != ct_class.base_class
+    end
+
+    def ct_attribute_names
+      @ct_attr_names ||= ct_class.new.attributes.keys - ct_class.protected_attributes.to_a
+    end
+
+    def ct_has_type?
+      ct_attribute_names.include? 'type'
+    end
+
+    def ct_table_name
+      ct_class.table_name
+    end
+
+    def quoted_table_name
+      connection.quote_table_name ct_table_name
+    end
+
+    def remove_prefix_and_suffix(table_name)
+      prefix = Regexp.escape(ActiveRecord::Base.table_name_prefix)
+      suffix = Regexp.escape(ActiveRecord::Base.table_name_suffix)
+      table_name.gsub(/^#{prefix}(.+)#{suffix}$/, "\\1")
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module ClosureTree
+  module DeterministicOrdering
+    extend ActiveSupport::Concern
+
+    module ClassAndInstanceMethods
+      def order_column
+        o = order_option
+        o.split(' ', 2).first if o
+      end
+
+      def require_order_column
+        raise ":order value, '#{order_option}', isn't a column" if order_column.nil?
+      end
+
+      def order_column_sym
+        require_order_column
+        order_column.to_sym
+      end
+
+      def quoted_order_column(include_table_name = true)
+        require_order_column
+        prefix = include_table_name ? "#{quoted_table_name}." : ""
+        "#{prefix}#{connection.quote_column_name(order_column)}"
+      end
+    end
+
+    include ClassAndInstanceMethods
+
+    module ClassMethods
+      include ClassAndInstanceMethods
+    end
+
+    def order_value
+      read_attribute(order_column_sym)
+    end
+
+    def order_value=(new_order_value)
+      write_attribute(order_column_sym, new_order_value)
+    end
+
+    def siblings_before
+      siblings.where(["#{quoted_order_column} < ?", order_value])
+    end
+
+    def siblings_after
+      siblings.where(["#{quoted_order_column} > ?", order_value])
+    end
+  end
+end

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

@@ -0,0 +1,386 @@
+require 'active_support/concern'
+
+module ClosureTree
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      validate :ct_validate
+      before_save :ct_before_save
+      after_save :ct_after_save
+      before_destroy :ct_before_destroy
+
+      belongs_to :parent,
+        :class_name => ct_class.to_s,
+        :foreign_key => parent_column_name
+
+      unless defined?(ActiveModel::ForbiddenAttributesProtection) && ancestors.include?(ActiveModel::ForbiddenAttributesProtection)
+        attr_accessible :parent
+      end
+
+      has_many :children, with_order_option(
+        :class_name => ct_class.to_s,
+        :foreign_key => parent_column_name,
+        :dependent => closure_tree_options[:dependent]
+      )
+
+      has_many :ancestor_hierarchies,
+        :class_name => hierarchy_class_name,
+        :foreign_key => "descendant_id",
+        :order => "#{quoted_hierarchy_table_name}.generations asc"
+
+      has_many :self_and_ancestors,
+        :through => :ancestor_hierarchies,
+        :source => :ancestor,
+        :order => "#{quoted_hierarchy_table_name}.generations asc"
+
+      has_many :descendant_hierarchies,
+        :class_name => hierarchy_class_name,
+        :foreign_key => "ancestor_id",
+        :order => "#{quoted_hierarchy_table_name}.generations asc"
+      # TODO: FIXME: this collection currently ignores sort_order
+      # (because the quoted_table_named would need to be joined in to get to the order column)
+
+      has_many :self_and_descendants,
+        :through => :descendant_hierarchies,
+        :source => :descendant,
+        :order => append_order("#{quoted_hierarchy_table_name}.generations asc")
+    end
+
+    # Returns true if this node has no parents.
+    def root?
+      ct_parent_id.nil?
+    end
+
+    # Returns true if this node has a parent, and is not a root.
+    def child?
+      !parent.nil?
+    end
+
+    # Returns true if this node has no children.
+    def leaf?
+      children.empty?
+    end
+
+    # Returns the farthest ancestor, or self if +root?+
+    def root
+      self_and_ancestors.where(parent_column_name.to_sym => nil).first
+    end
+
+    def leaves
+      self_and_descendants.leaves
+    end
+
+    def depth
+      ancestors.size
+    end
+
+    alias :level :depth
+
+    def ancestors
+      without_self(self_and_ancestors)
+    end
+
+    def ancestor_ids
+      ids_from(ancestors)
+    end
+
+    # Returns an array, root first, of self_and_ancestors' values of the +to_s_column+, which defaults
+    # to the +name_column+.
+    # (so child.ancestry_path == +%w{grandparent parent child}+
+    def ancestry_path(to_s_column = name_column)
+      self_and_ancestors.reverse.collect { |n| n.send to_s_column.to_sym }
+    end
+
+    def child_ids
+      ids_from(children)
+    end
+
+    def descendants
+      without_self(self_and_descendants)
+    end
+
+    def descendant_ids
+      ids_from(descendants)
+    end
+
+    def self_and_siblings
+      s = ct_base_class.where(parent_column_sym => parent)
+      order_option.present? ? s.order(quoted_order_column) : s
+    end
+
+    def siblings
+      without_self(self_and_siblings)
+    end
+
+    def sibling_ids
+      ids_from(siblings)
+    end
+
+    # Alias for appending to the children collection.
+    # You can also add directly to the children collection, if you'd prefer.
+    def add_child(child_node)
+      children << child_node
+      child_node
+    end
+
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+.
+    def find_by_path(path)
+      return self if path.empty?
+      parent_constraint = "#{quoted_parent_column_name} = #{ct_quote(id)}"
+      ct_class.ct_scoped_to_path(path, parent_constraint).first
+    end
+
+    # Find a child node whose +ancestry_path+ minus self.ancestry_path is +path+
+    def find_or_create_by_path(path, attributes = {}, find_before_lock = true)
+      (find_before_lock && find_by_path(path)) || begin
+        ct_with_advisory_lock do
+          subpath = path.is_a?(Enumerable) ? path.dup : [path]
+          child_name = subpath.shift
+          return self unless child_name
+          child = transaction do
+            attrs = {name_sym => child_name}
+            attrs[:type] = self.type if ct_subclass? && ct_has_type?
+            self.children.where(attrs).first || begin
+              child = self.class.new(attributes.merge(attrs))
+              self.children << child
+              child
+            end
+          end
+          child.find_or_create_by_path(subpath, attributes, false)
+        end
+      end
+    end
+
+    def find_all_by_generation(generation_level)
+      s = ct_base_class.joins(<<-SQL)
+        INNER JOIN (
+          SELECT descendant_id
+          FROM #{quoted_hierarchy_table_name}
+          WHERE ancestor_id = #{ct_quote(self.id)}
+          GROUP BY 1
+          HAVING MAX(#{quoted_hierarchy_table_name}.generations) = #{generation_level.to_i}
+        ) AS descendants ON (#{quoted_table_name}.#{ct_base_class.primary_key} = descendants.descendant_id)
+      SQL
+      order_option ? s.order(order_option) : s
+    end
+
+    def hash_tree_scope(limit_depth = nil)
+      scope = self_and_descendants
+      if limit_depth
+        scope.where("#{quoted_hierarchy_table_name}.generations <= #{limit_depth - 1}")
+      else
+        scope
+      end
+    end
+
+    def hash_tree(options = {})
+      self.class.build_hash_tree(hash_tree_scope(options[:limit_depth]))
+    end
+
+    def ct_parent_id
+      read_attribute(parent_column_sym)
+    end
+
+    def ct_validate
+      if changes[parent_column_name] &&
+        parent.present? &&
+        parent.self_and_ancestors.include?(self)
+        errors.add(parent_column_sym, "You cannot add an ancestor as a descendant")
+      end
+    end
+
+    def ct_before_save
+      @was_new_record = new_record?
+      true # don't cancel the save
+    end
+
+    def ct_after_save
+      rebuild! if changes[parent_column_name] || @was_new_record
+      @was_new_record = false # we aren't new anymore.
+      true # don't cancel anything.
+    end
+
+    def rebuild!
+      ct_with_advisory_lock do
+        delete_hierarchy_references unless @was_new_record
+        hierarchy_class.create!(:ancestor => self, :descendant => self, :generations => 0)
+        unless root?
+          sql = <<-SQL
+            INSERT INTO #{quoted_hierarchy_table_name}
+              (ancestor_id, descendant_id, generations)
+            SELECT x.ancestor_id, #{ct_quote(id)}, x.generations + 1
+            FROM #{quoted_hierarchy_table_name} x
+            WHERE x.descendant_id = #{ct_quote(self.ct_parent_id)}
+          SQL
+          connection.execute sql.strip
+        end
+        children.each { |c| c.rebuild! }
+      end
+    end
+
+    def ct_before_destroy
+      delete_hierarchy_references
+      if closure_tree_options[:dependent] == :nullify
+        children.each { |c| c.rebuild! }
+      end
+    end
+
+    def delete_hierarchy_references
+      # The crazy double-wrapped sub-subselect works around MySQL's limitation of subselects on the same table that is being mutated.
+      # It shouldn't affect performance of postgresql.
+      # See http://dev.mysql.com/doc/refman/5.0/en/subquery-errors.html
+      # Also: PostgreSQL doesn't support INNER JOIN on DELETE, so we can't use that.
+      connection.execute <<-SQL
+        DELETE FROM #{quoted_hierarchy_table_name}
+        WHERE descendant_id IN (
+          SELECT DISTINCT descendant_id
+          FROM ( SELECT descendant_id
+            FROM #{quoted_hierarchy_table_name}
+            WHERE ancestor_id = #{ct_quote(id)}
+          ) AS x )
+          OR descendant_id = #{ct_quote(id)}
+      SQL
+    end
+
+    def without_self(scope)
+      scope.where(["#{quoted_table_name}.#{ct_base_class.primary_key} != ?", self])
+    end
+
+    def ids_from(scope)
+      if scope.respond_to? :pluck
+        scope.pluck(:id)
+      else
+        scope.select(:id).collect(&:id)
+      end
+    end
+
+    # TODO: _parent_id will be removed in the next major version
+    alias :_parent_id :ct_parent_id
+
+    module ClassMethods
+      def roots
+        where(parent_column_name => nil)
+      end
+
+      # Returns an arbitrary node that has no parents.
+      def root
+        roots.first
+      end
+
+      # There is no default depth limit. This might be crazy-big, depending
+      # on your tree shape. Hash huge trees at your own peril!
+      def hash_tree(options = {})
+        build_hash_tree(hash_tree_scope(options[:limit_depth]))
+      end
+
+      def leaves
+        s = joins(<<-SQL)
+          INNER JOIN (
+            SELECT ancestor_id
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY 1
+            HAVING MAX(#{quoted_hierarchy_table_name}.generations) = 0
+          ) AS leaves ON (#{quoted_table_name}.#{primary_key} = leaves.ancestor_id)
+        SQL
+        order_option ? s.order(order_option) : s
+      end
+
+      # Rebuilds the hierarchy table based on the parent_id column in the database.
+      # Note that the hierarchy table will be truncated.
+      def rebuild!
+        ct_with_advisory_lock do
+          hierarchy_class.delete_all # not destroy_all -- we just want a simple truncate.
+          roots.each { |n| n.send(:rebuild!) } # roots just uses the parent_id column, so this is safe.
+        end
+        nil
+      end
+
+      def find_all_by_generation(generation_level)
+        s = joins(<<-SQL)
+          INNER JOIN (
+            SELECT #{primary_key} as root_id
+            FROM #{quoted_table_name}
+            WHERE #{quoted_parent_column_name} IS NULL
+          ) AS roots ON (1 = 1)
+          INNER JOIN (
+            SELECT ancestor_id, descendant_id
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY 1, 2
+            HAVING MAX(generations) = #{generation_level.to_i}
+          ) AS descendants ON (
+            #{quoted_table_name}.#{primary_key} = descendants.descendant_id
+            AND roots.root_id = descendants.ancestor_id
+          )
+        SQL
+        order_option ? s.order(order_option) : s
+      end
+
+      # Find the node whose +ancestry_path+ is +path+
+      def find_by_path(path)
+        parent_constraint = "#{quoted_parent_column_name} IS NULL"
+        ct_scoped_to_path(path, parent_constraint).first
+      end
+
+      def ct_scoped_to_path(path, parent_constraint)
+        path = path.is_a?(Enumerable) ? path.dup : [path]
+        scope = scoped.where(name_sym => path.last).readonly(false)
+        path[0..-2].reverse.each_with_index do |ea, idx|
+          subtable = idx == 0 ? quoted_table_name : "p#{idx - 1}"
+          scope = scope.joins(<<-SQL)
+            INNER JOIN #{quoted_table_name} AS p#{idx} ON p#{idx}.id = #{subtable}.#{parent_column_name}
+          SQL
+          scope = scope.where("p#{idx}.#{quoted_name_column} = #{ct_quote(ea)}")
+        end
+        root_table_name = path.size > 1 ? "p#{path.size - 2}" : quoted_table_name
+        scope.where("#{root_table_name}.#{parent_constraint}")
+      end
+
+      # Find or create nodes such that the +ancestry_path+ is +path+
+      def find_or_create_by_path(path, attributes = {})
+        find_by_path(path) || begin
+          subpath = path.dup
+          root_name = subpath.shift
+          ct_with_advisory_lock do
+            # shenanigans because find_or_create can't infer we want the same class as this:
+            # Note that roots will already be constrained to this subclass (in the case of polymorphism):
+            root = roots.where(name_sym => root_name).first
+            root ||= create!(attributes.merge(name_sym => root_name))
+            root.find_or_create_by_path(subpath, attributes)
+          end
+        end
+      end
+
+      def hash_tree_scope(limit_depth = nil)
+        # Deepest generation, within limit, for each descendant
+        # NOTE: Postgres requires HAVING clauses to always contains aggregate functions (!!)
+        generation_depth = <<-SQL
+          INNER JOIN (
+            SELECT descendant_id, MAX(generations) as depth
+            FROM #{quoted_hierarchy_table_name}
+            GROUP BY descendant_id
+            #{limit_depth ? "HAVING MAX(generations) <= #{limit_depth - 1}" : ""}
+          ) AS generation_depth
+            ON #{quoted_table_name}.#{primary_key} = generation_depth.descendant_id
+        SQL
+        scoped.joins(generation_depth).order(append_order("generation_depth.depth"))
+      end
+
+      # Builds nested hash structure using the scope returned from the passed in scope
+      def build_hash_tree(tree_scope)
+        tree = ActiveSupport::OrderedHash.new
+        id_to_hash = {}
+
+        tree_scope.each do |ea|
+          h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
+          if ea.root? || tree.empty? # We're at the top of the tree.
+            tree[ea] = h
+          else
+            id_to_hash[ea.ct_parent_id][ea] = h
+          end
+        end
+        tree
+      end
+    end
+  end
+end