searchlogic 1.6.6 → 2.1.0

data/test/libs/awesome_nested_set/.autotest

@@ -1,13 +0,0 @@
-Autotest.add_hook :initialize do |at|
-  at.clear_mappings
-
-  at.add_mapping %r%^lib/(.*)\.rb$% do |_, m|
-    at.files_matching %r%^test/#{m[1]}_test.rb$%
-  end
-
-  at.add_mapping(%r%^test/.*\.rb$%) {|filename, _| filename }
-
-  at.add_mapping %r%^test/fixtures/(.*)s.yml% do |_, _|
-    at.files_matching %r%^test/.*\.rb$%
-  end
-end

data/test/libs/awesome_nested_set/compatability.rb

@@ -1,29 +0,0 @@
-# Rails <2.x doesn't define #except
-class Hash #:nodoc:
-  # Returns a new hash without the given keys.
-  def except(*keys)
-    clone.except!(*keys)
-  end unless method_defined?(:except)
-
-  # Replaces the hash without the given keys.
-  def except!(*keys)
-    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-    keys.each { |key| delete(key) }
-    self
-  end unless method_defined?(:except!)
-end
-
-# NamedScope is new to Rails 2.1
-unless defined? ActiveRecord::NamedScope
-  require 'awesome_nested_set/named_scope'
-  ActiveRecord::Base.class_eval do
-    include CollectiveIdea::NamedScope
-  end
-end
-
-# Rails 1.2.x doesn't define #quoted_table_name
-class ActiveRecord::Base  #:nodoc:
-  def self.quoted_table_name
-    self.connection.quote_column_name(self.table_name)
-  end unless methods.include?('quoted_table_name')
-end

data/test/libs/awesome_nested_set/helper.rb

@@ -1,40 +0,0 @@
-module CollectiveIdea #:nodoc:
-  module Acts #:nodoc:
-    module NestedSet #:nodoc:
-      # This module provides some helpers for the model classes using acts_as_nested_set.
-      # It is included by default in all views.
-      #
-      module Helper
-        # Returns options for select.
-        # You can exclude some items from the tree.
-        # You can pass a block receiving an item and returning the string displayed in the select.
-        #
-        # == Params
-        #  * +class_or_item+ - Class name or top level times
-        #  * +mover+ - The item that is being move, used to exlude impossible moves
-        #  * +&block+ - a block that will be used to display: { |item| ... item.name }
-        #
-        # == Usage
-        #
-        #   <%= f.select :parent_id, nested_set_options(Category, @category) {|i|
-        #       "#{'–' * i.level} #{i.name}"
-        #     }) %>
-        #
-        def nested_set_options(class_or_item, mover = nil)
-          class_or_item = class_or_item.roots if class_or_item.is_a?(Class)
-          items = Array(class_or_item)
-          result = []
-          items.each do |root|
-            result += root.self_and_descendants.map do |i|
-              if mover.nil? || mover.new_record? || mover.move_possible?(i)
-                [yield(i), i.id]
-              end
-            end.compact
-          end
-          result
-        end  
-        
-      end
-    end  
-  end
-end

data/test/libs/awesome_nested_set/named_scope.rb

@@ -1,140 +0,0 @@
-# Taken from Rails 2.1
-module CollectiveIdea #:nodoc:
-  module NamedScope #:nodoc:
-    # All subclasses of ActiveRecord::Base have two named_scopes:
-    # * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and
-    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly:
-    #
-    #   Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)
-    #
-    # These anonymous scopes tend to be useful when procedurally generating complex queries, where passing
-    # intermediate values (scopes) around as first-class objects is convenient.
-    def self.included(base)
-      base.class_eval do
-        extend ClassMethods
-        named_scope :scoped, lambda { |scope| scope }
-      end
-    end
-
-    module ClassMethods
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
-      end
-
-      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
-      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'}
-      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
-      #   end
-      # 
-      # The above calls to <tt>named_scope</tt> define class methods <tt>Shirt.red</tt> and <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, 
-      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
-      #
-      # Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object
-      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
-      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
-      # as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
-      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.
-      #
-      # These named scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
-      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-      #
-      # All scopes are available as class methods on the ActiveRecord descendent upon which the scopes were defined. But they are also available to
-      # <tt>has_many</tt> associations. If,
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :shirts
-      #   end
-      #
-      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
-      # only shirts.
-      #
-      # Named scopes can also be procedural.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
-      #
-      # Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'} do
-      #       def dom_id
-      #         'red_shirts'
-      #       end
-      #     end
-      #   end
-      #
-      #
-      # For testing complex named scopes, you can examine the scoping options using the
-      # <tt>proxy_options</tt> method on the proxy itself.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      #   expected_options = { :conditions => { :colored => 'red' } }
-      #   assert_equal expected_options, Shirt.colored('red').proxy_options
-      def named_scope(name, options = {}, &block)
-        scopes[name] = lambda do |parent_scope, *args|
-          Scope.new(parent_scope, case options
-            when Hash
-              options
-            when Proc
-              options.call(*args)
-          end, &block)
-        end
-        (class << self; self end).instance_eval do
-          define_method name do |*args|
-            scopes[name].call(self, *args)
-          end
-        end
-      end
-    end
-
-    class Scope
-      attr_reader :proxy_scope, :proxy_options
-      [].methods.each { |m| delegate m, :to => :proxy_found unless m =~ /(^__|^nil\?|^send|class|extend|find|count|sum|average|maximum|minimum|paginate)/ }
-      delegate :scopes, :with_scope, :to => :proxy_scope
-
-      def initialize(proxy_scope, options, &block)
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
-        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
-      end
-
-      def reload
-        load_found; self
-      end
-
-      protected
-      def proxy_found
-        @found || load_found
-      end
-
-      private
-      def method_missing(method, *args, &block)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope :find => proxy_options do
-            proxy_scope.send(method, *args, &block)
-          end
-        end
-      end
-
-      def load_found
-        @found = find(:all)
-      end
-    end
-  end
-end

data/test/libs/rexml_fix.rb

@@ -1,14 +0,0 @@
-module REXML
-  module Formatters
-    class Pretty < Default
-      private
-      def wrap(string, width)
-        # Recursivly wrap string at width.
-        return string if string.length <= width
-        place = string.rindex(/\s+/, width) # Position in string with last ' ' before cutoff
-        return string if place.nil?
-        return string[0,place] + "\n" + wrap(string[place+1..-1], width)
-      end
-    end
-  end
-end

data/test/modifier_tests/day_of_month_test.rb

@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module ConditionsTests
-  class DayOfMonthTest < ActiveSupport::TestCase
-    def test_modifier_names
-      
-    end
-    
-    def test_usage
-      search = User.new_search
-      search.conditions.dom_of_created_at_gt = "1"
-      assert_equal({:conditions => ["(strftime('%d', \"users\".\"created_at\") * 1) > ?", 1], :limit => 25}, search.sanitize)
-      search.all
-    end
-  end
-end

data/test/search_tests/base_test.rb

@@ -1,241 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module SearchTests
-  class BaseTest < ActiveSupport::TestCase
-    def test_needed
-      assert Searchlogic::Search::Base.needed?(Account, :page => 2, :conditions => {:name => "Ben"})
-      assert !Searchlogic::Search::Base.needed?(Account, :conditions => {:name => "Ben"})
-      assert Searchlogic::Search::Base.needed?(Account, :limit => 2, :conditions => {:name_contains => "Ben"})
-      assert !Searchlogic::Search::Base.needed?(Account, :limit => 2)
-      assert Searchlogic::Search::Base.needed?(Account, :per_page => 2)
-    end
-
-    def test_initialize
-      assert_nothing_raised { Account.new_search }
-      search = Account.new_search!(:conditions => {:name_like => "binary"}, :page => 2, :limit => 10, :readonly => true)
-      assert_equal Account, search.klass
-      assert_equal "binary", search.conditions.name_like
-      assert_equal 2, search.page
-      assert_equal 10, search.limit
-      assert_equal true, search.readonly
-    end
-  
-    def test_acting_as_filter
-      search = Account.new_search
-      search.acting_as_filter = true
-      assert search.acting_as_filter?
-      search.acting_as_filter = false
-      assert !search.acting_as_filter?
-    end
-
-    def test_setting_first_level_options
-      search = Account.new_search!(:include => :users, :joins => :users, :offset => 5, :limit => 20, :order => "name ASC", :select => "name", :readonly => true, :group => "name", :from => "accounts", :lock => true)
-      assert_equal :users, search.include
-      assert_equal :users, search.joins
-      assert_equal 5, search.offset
-      assert_equal 20, search.limit
-      assert_equal "name ASC", search.order
-      assert_equal "name", search.select
-      assert_equal true, search.readonly
-      assert_equal "name", search.group
-      assert_equal "accounts", search.from
-      assert_equal true, search.lock
-    
-      search = Account.new_search(:per_page => nil)
-  
-      search.include = :users
-      assert_equal :users, search.include
-    
-      # treat it like SQL, just like AR
-      search.joins = "users"
-      assert_equal "users", search.joins
-  
-      search.page = 5
-      assert_equal 1, search.page
-      assert_nil search.offset
-  
-      search.limit = 20
-      assert_equal search.limit, 20
-      assert_equal search.per_page, 20
-      assert_equal search.page, 5
-      assert_equal search.offset, 80
-      search.limit = nil
-      assert_nil search.limit
-      assert_nil search.per_page
-      assert_equal 1, search.page
-      assert_nil search.offset
-  
-      search.offset = 50
-      assert_equal 50, search.offset
-      assert_equal 1, search.page
-      search.limit = 50
-      assert_equal 2, search.page
-      search.offset = nil
-      assert_nil search.offset
-      assert_equal 1, search.page
-  
-      search.per_page = 2
-      assert_equal 2, search.per_page
-      assert_equal 2, search.limit
-      search.offset = 50
-      assert_equal 26, search.page
-      assert_equal 50, search.offset
-  
-      search.order = "name ASC"
-      assert_equal search.order, "name ASC"
-  
-      search.select = "name"
-      assert_equal search.select, "name"
-  
-      search.readonly = true
-      assert_equal search.readonly, true
-  
-      search.group = "name"
-      assert_equal search.group, "name"
-  
-      search.from = "accounts"
-      assert_equal search.from, "accounts"
-  
-      search.lock = true
-      assert_equal search.lock, true
-    end
-
-    def test_joins
-      search = Account.new_search
-      assert_nil search.joins
-      search.conditions.name_contains = "Binary"
-      assert_nil search.joins
-      search.conditions.users.first_name_contains = "Ben"
-      assert_equal(:users, search.joins)
-      search.conditions.users.orders.id_gt = 2
-      assert_equal({:users => :orders}, search.joins)
-      search.conditions.users.reset_orders!
-      assert_equal(:users, search.joins)
-      search.conditions.users.orders.id_gt = 2
-      search.conditions.reset_users!
-      assert_nil search.joins
-    end
-
-    def test_limit
-      search = Account.new_search
-      search.limit = 10
-      assert_equal 10, search.limit
-      search.page = 2
-      assert_equal 10, search.offset
-      search.limit = 25
-      assert_equal 25, search.offset
-      assert_equal 2, search.page
-      search.page = 5
-      assert_equal 5, search.page
-      assert_equal 25, search.limit
-      search.limit = 3
-      assert_equal 12, search.offset
-    end
-
-    def test_options
-    end
-
-    def test_sanitize
-      search = Account.new_search
-      search.per_page = 2
-      search.conditions.name_like = "Binary"
-      search.conditions.users.id_greater_than = 2
-      search.page = 3
-      search.readonly = true
-      assert_equal({:select => "DISTINCT \"accounts\".*", :joins => :users, :offset => 4, :readonly => true, :conditions => ["\"accounts\".\"name\" LIKE ? AND \"users\".\"id\" > ?", "%Binary%", 2], :limit => 2 }, search.sanitize)
-    end
-
-    def test_scope
-      search = Account.new_search!
-      search.conditions = "some sql"
-      conditions = search.conditions
-      assert_equal "some sql", search.conditions.conditions
-      search.conditions = nil
-      assert_equal({}, search.conditions.conditions)
-      search.conditions = "some sql"
-      assert_equal "some sql", search.conditions.conditions
-      search.conditions = "some sql"
-      assert_equal "some sql", search.conditions.conditions
-    end
-
-    def test_searching
-      binary_logic = accounts(:binary_logic)
-      neco = accounts(:neco)
-      binary_fun = accounts(:binary_fun)
-      
-      search = Account.new_search
-      search.conditions.name_like = "Binary"
-      assert_equal [binary_logic, binary_fun], search.all
-      assert_equal [binary_logic, binary_fun], search.find(:all)
-      assert_equal binary_logic, search.first
-      assert_equal binary_logic, search.find(:first)
-  
-      search.per_page = 20
-      search.page = 2
-  
-      assert_equal [], search.all
-      assert_equal [], search.find(:all)
-      assert_nil search.first
-      assert_nil search.find(:first)
-      
-      search.per_page = 0
-      search.page = nil
-      search.conditions.users.first_name_contains = "Ben"
-      search.conditions.users.orders.description_keywords = "products, &*ap#ple $%^&*"
-      assert_equal [binary_logic], search.all
-      assert_equal [binary_logic], search.find(:all)
-      assert_equal binary_logic, search.first
-      assert_equal binary_logic, search.find(:first)
-    
-      search = Account.new_search
-      search.select = "id, name"
-      assert_equal Account.all, search.all
-    
-      search = Account.scope1.new_search!(:conditions => {:users => {:first_name_starts_with => "Ben"}})
-      assert_equal [binary_logic], search.all
-      search2 = search.dup
-      assert_equal [binary_logic], search2.all
-    end
-
-    def test_calculations
-      binary_logic = accounts(:binary_logic)
-      binary_fun = accounts(:binary_fun)
-      bens_order = orders(:bens_order)
-      
-      search = Account.new_search
-      search.conditions.name_like = "Binary"
-      assert_equal (binary_logic.id + binary_fun.id) / 2.0, search.average('id')
-      assert_equal (binary_logic.id + binary_fun.id) / 2.0, search.calculate(:avg, 'id')
-      assert_equal binary_fun.id, search.calculate(:max, 'id')
-      assert_equal 2, search.count
-      assert_equal binary_fun.id, search.maximum('id')
-      assert_equal binary_logic.id, search.minimum('id')
-      assert_equal binary_logic.id + binary_fun.id, search.sum('id')
-    
-      search.readonly = true
-      assert_equal binary_logic.id + binary_fun.id, search.sum('id')
-    
-      search = Account.new_search(:conditions => {:users => {:orders => {:id_gt => bens_order.id}}})
-      assert_equal 1, search.count
-
-      search = Order.new_search(:conditions => {:user => {:account => {:id_gt => binary_logic.id}}})
-      assert_equal 1, search.count
-    
-      search = UserGroup.new_search(:conditions => {:users => {:orders => {:id_gt => bens_order.id}}})
-      assert_equal 1, search.count
-    end
-  
-    def test_inspect
-      search = Account.new_search
-      assert_nothing_raised { search.inspect }
-    end
-  
-    def test_sti
-    
-    end
-    
-    def test_include_in_relationships
-      
-    end
-  end
-end