refinerycms 0.9.5.13 → 0.9.5.14

data/vendor/plugins/acts_as_indexed/lib/search_index.rb

@@ -104,7 +104,7 @@ module Foo #:nodoc:
           positive_quoted = run_quoted_queries(queries[:positive_quoted])
           negative = run_queries(queries[:negative])
           negative_quoted = run_quoted_queries(queries[:negative_quoted])
-          
+
           if !queries[:positive].empty? && !queries[:positive_quoted].empty?
             p = positive.delete_if{ |r_id,w| !positive_quoted.include?(r_id) }
             pq = positive_quoted.delete_if{ |r_id,w| !positive.include?(r_id) }
@@ -114,7 +114,7 @@ module Foo #:nodoc:
           else
             results = positive_quoted
           end
-          
+
           negative_results = (negative.keys + negative_quoted.keys)
           results.delete_if { |r_id, w| negative_results.include?(r_id) }
           #p results
@@ -189,7 +189,7 @@ module Foo #:nodoc:
           end
           @prefix_cache[prefix]
         end
-        
+
         # Allows compatibility with 1.8.6 which has no ord method.
         def encode_character(char)
           if @@has_ord ||= char.respond_to?(:ord)
@@ -236,7 +236,7 @@ module Foo #:nodoc:
           atoms.uniq.each do |atom|
             interim_results = {}
             if include_atom?(atom)
-              
+
               interim_results = @atoms[atom].weightings(@records_size)
             end
             if results.empty?
@@ -269,7 +269,7 @@ module Foo #:nodoc:
               matches = @atoms[atom_name].preceded_by(matches)
             end
             #results += matches.record_ids
-            
+
             interim_results = matches.weightings(@records_size)
             if results.empty?
               results = interim_results
@@ -281,7 +281,7 @@ module Foo #:nodoc:
               #p results.class
               results = rr
             end
-            
+
           end
           return results
         end
@@ -326,4 +326,4 @@ module Foo #:nodoc:
       end
     end
   end
-end
+end

data/vendor/plugins/acts_as_indexed/lib/will_paginate_search.rb

@@ -12,7 +12,7 @@ module WillPaginate
       def paginate_search(query, options)
 
         page, per_page, total_entries = wp_parse_options(options)
-        
+
         total_entries ||= find_with_index(query,{},{:ids_only => true}).size
 
         returning WillPaginate::Collection.new(page, per_page, total_entries) do |pager|

data/vendor/plugins/acts_as_indexed/test/abstract_unit.rb

@@ -24,24 +24,24 @@ class ActiveSupport::TestCase #:nodoc:
   self.fixture_path = File.dirname(__FILE__) + '/fixtures/'
   self.use_transactional_fixtures = true
   self.use_instantiated_fixtures  = false
-  
+
   def destroy_index
     FileUtils::rm_rf(index_loc) if File.exists?(index_loc)
     assert !File.exists?(index_loc)
     true
   end
-  
+
   def build_index
     # Makes a query to invoke the index build.
     assert_equal [], Post.find_with_index('badger')
     assert File.exists?(index_loc)
     true
   end
-  
+
   protected
-  
+
   def index_loc
     File.join(RAILS_ROOT,'index')
   end
-  
+
 end

data/vendor/plugins/acts_as_indexed/test/acts_as_indexed_test.rb

@@ -89,7 +89,7 @@ class ActsAsIndexedTest < ActiveSupport::TestCase
 
   end
 
-  # When a atom already in a record is duplicated, it removes 
+  # When a atom already in a record is duplicated, it removes
   # all records with that same atom from the index.
   def test_update_record_bug
     assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
@@ -98,5 +98,5 @@ class ActsAsIndexedTest < ActiveSupport::TestCase
     assert_equal 2, Post.find_with_index('crane',{},{:ids_only => true}).size
     assert_equal 2, Post.find_with_index('ship',{},{:ids_only => true}).size
   end
-  
+
 end

data/vendor/plugins/acts_as_tree/lib/active_record/acts/tree.rb

@@ -1,141 +1,141 @@
 module ActiveRecord
-	module Acts
-		module Tree
-			def self.included(base)
-				base.extend(ClassMethods)
-			end
-
-			# Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
-			# association. This requires that you have a foreign key column, which by default is called +parent_id+.
-			#
-			#	 class Category < ActiveRecord::Base
-			#		 acts_as_tree :order => "name"
-			#	 end
-			#
-			#	 Example:
-			#	 root
-			#		\_ child1
-			#				 \_ subchild1
-			#				 \_ subchild2
-			#
-			#	 root			= Category.create("name" => "root")
-			#	 child1		= root.children.create("name" => "child1")
-			#	 subchild1 = child1.children.create("name" => "subchild1")
-			#
-			#	 root.parent	 # => nil
-			#	 child1.parent # => root
-			#	 root.children # => [child1]
-			#	 root.children.first.children.first # => subchild1
-			#
-			# In addition to the parent and children associations, the following instance methods are added to the class
-			# after calling <tt>acts_as_tree</tt>:
-			# * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
-			# * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
-			# * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
-			# * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
-			# * <tt>descendants</tt> - Returns a flat list of the descendants of the current node (<tt>[child1, subchild1, subchild2]</tt> when called on <tt>root</tt>)
-			module ClassMethods
-				# Configuration options are:
-				#
-				# * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
-				# * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
-				# * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
-				# * <tt>include</tt> - ability to add eager loading to tree finds by specifying associations to include. 'children' association eager loaded by default. Disable by supplying :include => nil or :include => []
-				def acts_as_tree(options = {})
-					configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil, :include => [:children] }
-					configuration.update(options) if options.is_a?(Hash) # to avoid something nasty happening check for Hash here.
-					configuration.update({:include => []}) if configuration[:include].nil? # if calling class really doesn't want to eager load its children.
-
-					belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache], :include => configuration[:include]
-					has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :delete_all, :include => configuration[:include]
-
-					class_eval <<-EOV
-						include ActiveRecord::Acts::Tree::InstanceMethods
-
-						def self.roots
-							find :all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
-						end
-
-						def self.root
-							find :first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
-						end
-						
-						def self.childless
-							nodes = []
-
-							find(:all, :include => configuration[:include]).each do |node|
-								nodes << node if node.children.empty?
-							end
-
-							nodes
-						end
-					EOV
-				end
-			end
-
-			module InstanceMethods
-				# Returns list of ancestors, starting from parent until root.
-				#
-				#	 subchild1.ancestors # => [child1, root]
-				def ancestors
-					node, nodes = self, []
-					nodes << node = node.parent until node.parent.nil? and return nodes
-				end
-
-				# Returns the root node of the tree.
-				def root
-					node = self
-					node = node.parent until node.parent.nil? and return node
-				end
-
-				# Returns all siblings of the current node.
-				#
-				#	 subchild1.siblings # => [subchild2]
-				def siblings
-					self_and_siblings - [self]
-				end
-
-				# Returns all siblings and a reference to the current node.
-				#
-				#	 subchild1.self_and_siblings # => [subchild1, subchild2]
-				def self_and_siblings
-					parent ? parent.children : self.class.roots
-				end
-
-				# Returns a flat list of the descendants of the current node.
-				#
-				#	 root.descendants # => [child1, subchild1, subchild2]
-				def descendants(node=self)
-					nodes = []
-					nodes << node unless node == self
-					
-					node.children.each do |child|
-						nodes += descendants(child)
-					end
-						
-					nodes.compact
-				end
-				
-				def chain
-					[self.ancestors, self, self.descendants].flatten
-				end
-				
-				# Returns a flat list of all of the children under the current node
-				# which don't have any children belonging to them (childless)
-				# 
-				#	 node.childess # => [subchild1, subchild2]
-				def childless
-					nodes = []
-					
-					unless self.children.empty?
-						nodes << self.children.collect { |child| child.childless }
-					else
-						nodes << self
-					end
-					
-					nodes.flatten.compact
-				end
-			end
-		end
-	end
-end
+  module Acts
+    module Tree
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+      # association. This requires that you have a foreign key column, which by default is called +parent_id+.
+      #
+      #   class Category < ActiveRecord::Base
+      #     acts_as_tree :order => "name"
+      #   end
+      #
+      #   Example:
+      #   root
+      #    \_ child1
+      #         \_ subchild1
+      #         \_ subchild2
+      #
+      #   root      = Category.create("name" => "root")
+      #   child1    = root.children.create("name" => "child1")
+      #   subchild1 = child1.children.create("name" => "subchild1")
+      #
+      #   root.parent   # => nil
+      #   child1.parent # => root
+      #   root.children # => [child1]
+      #   root.children.first.children.first # => subchild1
+      #
+      # In addition to the parent and children associations, the following instance methods are added to the class
+      # after calling <tt>acts_as_tree</tt>:
+      # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
+      # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
+      # * <tt>descendants</tt> - Returns a flat list of the descendants of the current node (<tt>[child1, subchild1, subchild2]</tt> when called on <tt>root</tt>)
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
+        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+        # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
+        # * <tt>include</tt> - ability to add eager loading to tree finds by specifying associations to include. 'children' association eager loaded by default. Disable by supplying :include => nil or :include => []
+        def acts_as_tree(options = {})
+          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil, :include => [:children] }
+          configuration.update(options) if options.is_a?(Hash) # to avoid something nasty happening check for Hash here.
+          configuration.update({:include => []}) if configuration[:include].nil? # if calling class really doesn't want to eager load its children.
+
+          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache], :include => configuration[:include]
+          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :delete_all, :include => configuration[:include]
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::Tree::InstanceMethods
+
+            def self.roots
+              find :all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
+            end
+
+            def self.root
+              find :first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}, :include => %W{#{configuration[:include].join(' ')}}
+            end
+
+            def self.childless
+              nodes = []
+
+              find(:all, :include => configuration[:include]).each do |node|
+                nodes << node if node.children.empty?
+              end
+
+              nodes
+            end
+          EOV
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node, nodes = self, []
+          nodes << node = node.parent until node.parent.nil? and return nodes
+        end
+
+        # Returns the root node of the tree.
+        def root
+          node = self
+          node = node.parent until node.parent.nil? and return node
+        end
+
+        # Returns all siblings of the current node.
+        #
+        #   subchild1.siblings # => [subchild2]
+        def siblings
+          self_and_siblings - [self]
+        end
+
+        # Returns all siblings and a reference to the current node.
+        #
+        #   subchild1.self_and_siblings # => [subchild1, subchild2]
+        def self_and_siblings
+          parent ? parent.children : self.class.roots
+        end
+
+        # Returns a flat list of the descendants of the current node.
+        #
+        #   root.descendants # => [child1, subchild1, subchild2]
+        def descendants(node=self)
+          nodes = []
+          nodes << node unless node == self
+
+          node.children.each do |child|
+            nodes += descendants(child)
+          end
+
+          nodes.compact
+        end
+
+        def chain
+          [self.ancestors, self, self.descendants].flatten
+        end
+
+        # Returns a flat list of all of the children under the current node
+        # which don't have any children belonging to them (childless)
+        #
+        #   node.childess # => [subchild1, subchild2]
+        def childless
+          nodes = []
+
+          unless self.children.empty?
+            nodes << self.children.collect { |child| child.childless }
+          else
+            nodes << self
+          end
+
+          nodes.flatten.compact
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/acts_as_tree/test/acts_as_tree_test.rb

@@ -43,7 +43,7 @@ end
 class Mixin < ActiveRecord::Base
 end
 
-class TreeMixin < Mixin 
+class TreeMixin < Mixin
   acts_as_tree :foreign_key => "parent_id", :order => "id"
 end
 
@@ -57,7 +57,7 @@ class RecursivelyCascadedTreeMixin < Mixin
 end
 
 class TreeTest < Test::Unit::TestCase
-  
+
   def setup
     setup_db
     @root1 = TreeMixin.create!
@@ -146,12 +146,12 @@ class TreeTest < Test::Unit::TestCase
     assert_equal [@root_child1, @root_child2], @root_child2.self_and_siblings
     assert_equal [@root1, @root2, @root3], @root2.self_and_siblings
     assert_equal [@root1, @root2, @root3], @root3.self_and_siblings
-  end           
+  end
 end
 
 class TreeTestWithEagerLoading < Test::Unit::TestCase
-  
-  def setup 
+
+  def setup
     teardown_db
     setup_db
     @root1 = TreeMixin.create!
@@ -160,9 +160,9 @@ class TreeTestWithEagerLoading < Test::Unit::TestCase
     @root_child2 = TreeMixin.create! :parent_id => @root1.id
     @root2 = TreeMixin.create!
     @root3 = TreeMixin.create!
-    
+
     @rc1 = RecursivelyCascadedTreeMixin.create!
-    @rc2 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc1.id 
+    @rc2 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc1.id
     @rc3 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc2.id
     @rc4 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc3.id
   end
@@ -170,36 +170,36 @@ class TreeTestWithEagerLoading < Test::Unit::TestCase
   def teardown
     teardown_db
   end
-    
+
   def test_eager_association_loading
     roots = TreeMixin.find(:all, :include => :children, :conditions => "mixins.parent_id IS NULL", :order => "mixins.id")
-    assert_equal [@root1, @root2, @root3], roots                     
+    assert_equal [@root1, @root2, @root3], roots
     assert_no_queries do
       assert_equal 2, roots[0].children.size
       assert_equal 0, roots[1].children.size
       assert_equal 0, roots[2].children.size
-    end   
+    end
   end
-  
+
   def test_eager_association_loading_with_recursive_cascading_three_levels_has_many
     root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :children => { :children => :children } }, :order => 'mixins.id')
     assert_equal @rc4, assert_no_queries { root_node.children.first.children.first.children.first }
   end
-  
+
   def test_eager_association_loading_with_recursive_cascading_three_levels_has_one
     root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :first_child => { :first_child => :first_child } }, :order => 'mixins.id')
     assert_equal @rc4, assert_no_queries { root_node.first_child.first_child.first_child }
   end
-  
+
   def test_eager_association_loading_with_recursive_cascading_three_levels_belongs_to
     leaf_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :parent => { :parent => :parent } }, :order => 'mixins.id DESC')
     assert_equal @rc1, assert_no_queries { leaf_node.parent.parent.parent }
-  end 
+  end
 end
 
 class TreeTestWithoutOrder < Test::Unit::TestCase
-  
-  def setup                               
+
+  def setup
     setup_db
     @root1 = TreeMixinWithoutOrder.create!
     @root2 = TreeMixinWithoutOrder.create!
@@ -212,8 +212,8 @@ class TreeTestWithoutOrder < Test::Unit::TestCase
   def test_root
     assert [@root1, @root2].include?(TreeMixinWithoutOrder.root)
   end
-  
+
   def test_roots
     assert_equal [], [@root1, @root2] - TreeMixinWithoutOrder.roots
   end
-end 
+end