sphinxsearchlogic 0.9.1

data/CHANGELOG.rdoc

@@ -0,0 +1,7 @@
+== 0.9.1 released 2009-08-25
+
+* Bumped gem version and add Rails init stuff.
+
+== 0.9.0 released 2009-08-25
+
+* First release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,161 @@
+= Sphinxsearchlogic
+
+Sphinxsearchlogic is for ThinkingSphinx what Searchlogic is for ActiveRecord.. or at least something similar.
+
+== Helpful links
+
+* <b>Github:</b> http://github.com/joost/sphinxsearchlogic
+
+Sphinxsearchlogic is largely based on / using:
+
+* <b>Searchlogic:</b> http://github.com/binarylogic/searchlogic/
+* <b>ThinkingSphinx:</b> http://freelancing-god.github.com/ts/en/
+* <b>Sphinx:</b> http://www.sphinxsearch.com/
+
+If you're not familiar with ThinkingSphinx check {this presentation!}[http://www.slideshare.net/freelancing_god/solving-the-riddle-of-search-using-sphinx-with-rails-1406954]
+
+== Install
+
+First you need Sphinx and ThinkingSphinx. Simply because they rock. Check the ThinkingSphinx pages for this.
+Use the gem in your environment.rb like:
+
+  config.gem "freelancing-god-thinking-sphinx", :lib => 'thinking_sphinx', :version => '1.2.7'
+
+Install as gem from Github (recommended).
+
+  gem sources -a http://gems.github.com (you only have to do this once)
+  sudo gem install joost-sphinxsearchlogic
+  
+Next use it in your environment.rb like:
+
+  config.gem 'joost-sphinxsearchlogic', :lib => 'sphinxsearchlogic'
+
+Install as plugin from Github.
+
+  ./script/plugin install git://github.com/joost/sphinxsearchlogic.git
+
+== Usage
+
+Use Sphinxsearchlogic as you use the Searchlogic search method:
+
+ @search = Movie.sphinxsearchlogic(params[:search])
+ 
+The search params you can pass:
+
+Search:
+
+  :all => 'something'     # search('something') 
+  :name => 'john'         # search(:conditions => {:name => 'john'})
+
+Filters:
+
+  :with_age => 20         # search(:with => {:age => 20})
+  :with_age => [21, 22]   # search(:with => {:age => [21, 22]})
+  :with_age => 20..25     # search(:with => {:age => 20..25})
+                           
+  :without_age => 20      # search(:without => {:age => 20})
+  
+For MVAs you can also use:
+
+  :with_all_tags => [1,2,3] # search(:with_all => {:tags => [1,2,3]})
+
+Thinking Sphinx scopes:
+  :my_scope => true       # my_scope (actually called with my_scope(true))
+  :some_scope => 'sweet'  # some_scope(sweet)
+  
+=== Ordering
+
+Ordering is implemented similar to Searchlogic.
+
+  :order => 'ascend_by_created_at'   # :order => :attribute, 
+  :order => 'descend_by_created_at'  # :order => :attribute, :sort_mode => :desc
+More advanced ordering? Use scopes! Like for {:order => 'rating DESC, votes DESC'} or {:sort_mode => :expr, :sort_by => '@weight * ranking'}
+  :order => 'my_order_scope'
+
+For your views see the order helper below.
+
+=== Pagination
+
+Unsimilar to Searchlogic Sphinxsearchlogic does pagination in the search.
+You can add them as follows since all arguments are merged.
+
+ @search = Movie.sphinxsearchlogic(params[:search], :page => params[:page], :per_page => params[:per_page])
+ 
+If not specified default limits and pagination is used. As pagination is 'Always on' with ThinkingSphinx.
+
+== Examples
+
+=== Your controller
+
+An example controller action:
+
+  class MovieController < ApplicationController
+    def index
+      @search = Movie.sphinxsearchlogic(params[:search], :page => params[:page], :per_page => params[:per_page])
+      @movies = @sphinxsearch.results
+    end
+  end
+
+=== Your search forms
+
+An example view search form:
+
+  <% sphinxsearchlogic_form_for @search do |form| %>
+    <p>
+      <%= form.label :all %>
+      <%= form.text_field :all %>
+    </p>
+    <p>
+      <%= form.check_box :scary_movies, {}, '1', nil %>
+      Only scary movies
+    </p>
+  <% end %>
+
+The first field will send search[:all] params which will fulltext search through your data.
+The second is making use of a ThinkingSphinx scope (http://freelancing-god.github.com/ts/en/scopes.html) so it
+only works if you've defined it in your model.
+
+=== Helpers
+
+You can use a similar order helper as Searchlogic offers. You can order by attributes and fields (only if they
+are specified as sortable in your ThinkingSphinx index).
+
+  <%= order(@search, :by => :title, :as => 'Movie Title')
+  
+When you create two ThinkingSphinx scopes in your model you can even do special exotic ordering.
+
+  sphinx_scope(:ascend_by_rating_and_votes) { 
+      {:order => "rating ASC, votes ASC"}
+    }
+
+  sphinx_scope(:descend_by_rating_and_votes) { 
+      {:order => "rating DESC, votes DESC"}
+    }
+
+You can also use this in the helper:
+
+  <%= order(@search, :by => :rating_and_votes, :as => 'Special ordering')
+
+== TODO
+
+Things that might be in next versions. Please contact me via Github if you've any suggestions or want to
+contribute.
+
+=== Sanitize
+
+Sanitize params so we don't f*ck with ThinkingSphinx.
+
+=== Facets
+
+Easy facets (http://freelancing-god.github.com/ts/en/facets.html) support.
+
+=== Defaults
+
+On the Model you want to search specify the defaults for the search. Eg. on the Movie model:
+
+ sphinxsearchlogic_default_order = 'descend_by_weight'
+ sphinxsearchlogic_protected = :order, :per_page, :age, :name, :match_mode
+ sphinxsearchlogic_max_per_page = 100
+ sphinxsearchlogic_match_mode = :any
+ 
+Copyright (c) 2009 Joost Hietbrink, released under the MIT license

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 9
+:patch: 1

data/init.rb

@@ -0,0 +1,7 @@
+require 'sphinxsearchlogic'
+ActiveRecord::Base.extend(Sphinxsearchlogic::Search::Implementation)
+
+if defined?(ActionController)
+  require "rails_helpers"
+  ActionController::Base.helper(Sphinxsearchlogic::RailsHelpers)
+end

data/lib/rails_helpers.rb

@@ -0,0 +1,45 @@
+module Sphinxsearchlogic
+  module RailsHelpers
+
+    # Creates a form with a :search scope. Use to create search form in your views.
+    def sphinxsearchlogic_form_for(*args, &block)
+      if search_obj = args.find { |arg| arg.is_a?(Sphinxsearchlogic::Search) }
+        options = args.extract_options!
+        options[:html] ||= {}
+        options[:html][:method] ||= :get
+        options[:url] ||= url_for
+        args.unshift(:search) if args.first == search_obj
+        args << options
+      end
+      form_for(*args, &block)
+    end
+
+    # Similar to the Searchlogic order helper.
+    def order(search, options = {}, html_options = {})
+      options[:params_scope] ||= :search
+      options[:as] ||= options[:by].to_s.humanize
+      options[:ascend_scope] ||= "ascend_by_#{options[:by]}"
+      options[:descend_scope] ||= "descend_by_#{options[:by]}"
+      ascending = search.order.to_s == options[:ascend_scope]
+      new_scope = ascending ? options[:descend_scope] : options[:ascend_scope]
+      selected = [options[:ascend_scope], options[:descend_scope]].include?(search.order.to_s)
+      if selected
+        css_classes = html_options[:class] ? html_options[:class].split(" ") : []
+        if ascending
+          options[:as] = "&#9650;&nbsp;#{options[:as]}"
+          css_classes << "ascending"
+        else
+          options[:as] = "&#9660;&nbsp;#{options[:as]}"
+          css_classes << "descending"
+        end
+        html_options[:class] = css_classes.join(" ")
+      end
+      params = controller.params.clone
+      params[options[:params_scope]] ||= {}
+      params[options[:params_scope]].merge!(:order => new_scope)
+      url_options = {:controller => params[:controller], :action => params[:action], options[:params_scope] => params[options[:params_scope]]}
+      link_to(options[:as], url_options, html_options)
+    end
+
+  end
+end

data/lib/sphinxsearchlogic.rb

@@ -0,0 +1,322 @@
+# Sphinxsearchlogic
+#
+# A adapted version of the Searchlogic::Search class to attach to an ActiveRecord::Base#sphinxsearchlogic
+# method.
+module Sphinxsearchlogic
+  class Search
+    module Implementation
+      # Use like:
+      #  Movie.sphinxsearchlogic(params[:search], :page => params[:page], :per_page => [:per_page])
+      def sphinxsearchlogic(conditions = {}, pagination = {})
+        conditions ||= {} # params[:search] might be nil
+        conditions.merge!(pagination)
+        # Merge array of hashes, but doesn't work if Hash value is an Array.
+        # conditions = Hash[*args.collect {|h| h.to_a}.flatten]
+        Search.new(self, scope(:find), conditions)
+      end
+    end
+
+    # Is an invalid condition is used this error will be raised. Ex:
+    #
+    #   User.search(:unkown => true)
+    #
+    # Where unknown is not a valid named scope for the User model.
+    class UnknownConditionError < StandardError
+      def initialize(condition)
+        msg = "The #{condition} is not a valid condition. You may only use conditions that map to a thinking sphinx named scope or attribute."
+        super(msg)
+      end
+    end
+
+    # class OutofboundsError < StandardError
+    #   def initialize(page, per_page)
+    #     msg = "The page #{page} is out of bounds. Using per_page #{per_page}."
+    #     super(msg)
+    #   end
+    # end
+
+    # Accessors that define this Search object.
+    attr_accessor :klass, :current_scope, :with, :without, :with_all, :params, :conditions, :scopes, :all
+    undef :id if respond_to?(:id)
+
+    module Pagination
+      attr_writer :page, :per_page, :max_matches
+
+      def default_per_page
+        default_per_page = 20
+        default_per_page = klass.per_page if klass.respond_to?(:per_page)
+        default_per_page
+      end
+
+      # Returns a set max_matches or 1000.
+      def max_matches
+        @max_matches || 1000
+      end
+
+      # Returns the last page we have in this search based on the max_matches.
+      # So we don't get a Riddle error for an offset that is too high.
+      def last_page
+        (max_matches.to_f / per_page).ceil
+      end
+
+      def offset
+        (page-1)*per_page
+      end
+
+      def page
+        page = (@page || 1).to_i
+        page = 1 if page < 1 # Fixes pages like -1 and 0.
+        # Fix riddle error.. we always return the last page? Think should be handled by application!
+        # However this isn't yet the case for pages > total_results.
+        # raise OutofboundsError.new(page, per_page) if page > last_page
+        page = last_page if page > last_page
+        page
+      end
+
+      # Returns 20 by default (ThinkingSphinx/Riddle default)
+      def per_page
+        per_page = (@per_page || default_per_page).to_i
+        per_page = default_per_page if per_page < 1 # Fixes per_page like -1 and 0.
+        per_page
+      end
+
+      def pagination_options
+        options = {}
+        options[:page] = page
+        options[:per_page] = per_page
+        options
+      end
+
+    end
+    include Pagination
+
+    module Ordering
+      
+      attr_reader :order, :order_direction, :order_attribute
+
+      # Sets the order. If the order is incorrect this won't be set. Similar to pagination the
+      # defaults will be used.
+      def order=(order)
+        @order = order
+        return if order.blank?
+        if is_sphinx_scope?(order) # We first check for scopes since they might be named ascend_by_scopename.
+          scopes[order.to_sym] = true
+        elsif order.to_s =~ /^(ascend|descend)_by_(\w+)$/
+          @order_direction = ($1 == 'ascend') ? :asc : :desc
+          if is_sphinx_attribute?($2)
+            @order_attribute = $2.to_sym
+          elsif [:weight, :relevance, :rank, :id, :random, :geodist].include?($2.to_sym)
+            @order_attribute = "@#{$2} #{@order_direction}"
+          end
+        end
+      end
+
+      def ordering_options
+        if order_attribute.blank?
+          {}
+        elsif order_attribute.is_a?(Symbol)
+          {
+            :order => order_attribute,
+            :sort_mode => order_direction
+          }
+        else
+          {:order => order_attribute}
+        end
+      end
+
+    end
+    include Ordering
+
+    # Creates a new search object for the given class. Ex:
+    #
+    #   Searchlogic::Search.new(User, {}, {:username_like => "bjohnson"})
+    def initialize(klass, current_scope, params = {})
+      @with = {}
+      @without = {}
+      @with_all = {}
+      @conditions = {}
+      @scopes = {}
+
+      self.klass = klass
+      raise "No Sphinx indexes found on #{klass.to_s}!" unless has_sphinx_index?
+      self.current_scope = current_scope
+      self.params = params if params.is_a?(Hash)
+    end
+
+    # Accepts a hash of conditions.
+    def params=(values)
+      values.each do |param, value|
+        value.delete_if { |v| v.blank? } if value.is_a?(Array)
+        next if value.blank?
+        send("#{param}=", value)
+      end
+    end
+
+    # Returns actual search results.
+    #  Movie.sphinxsearchlogic.results
+    def results
+      Rails.logger.debug("Sphinxsearchlogic: #{klass.to_s}.search('#{all}', #{search_options.inspect})")
+      if scopes.empty?
+        klass.search(all, search_options)
+      else
+        cloned_scopes = scopes.clone # Clone scopes since we're deleting form the hash.
+        # Get the first scope and call all others on this one..
+        first_scope = cloned_scopes.keys.first
+        first_args = cloned_scopes.delete(first_scope)
+        result = klass.send(first_scope, first_args)
+        # Call remaining scopes on this scope.
+        cloned_scopes.each do |scope, args|
+          result = result.send(scope, args)
+        end
+        result.search(all, search_options)
+      end
+    end
+
+  # private
+
+    # Handles (in order):
+    # * with / without / with_all conditions (Filters)
+    # * field conditions (Regular searches)
+    # * scope conditions
+    def method_missing(name, *args, &block)
+      name = name.to_s
+      if name =~ /^(\w+)=$/ # If we have a setter
+        name = $1
+        if name =~ /^with(out|_all)?_(\w+)$/
+          attribute_name = $2.to_sym
+          if is_sphinx_attribute?(attribute_name)
+            # Put in with / without / with_all depending on what the regexp matched.
+            if $1 == 'out'
+              without[attribute_name] = type_cast(args.first, cast_type(attribute_name))
+            elsif $1 == '_all'
+              with_all[attribute_name] = type_cast(args.first, cast_type(attribute_name))
+            else
+              with[attribute_name] = type_cast(args.first, cast_type(attribute_name))
+            end
+          else
+            raise UnknownConditionError.new(attribute_name)
+          end
+        elsif is_sphinx_field?(name)
+          conditions[name.to_sym] = args.first
+        elsif is_sphinx_scope?(name)
+          scopes[name.to_sym] = args.first
+        else
+          # If we have an unknown setter..
+          # raise UnknownConditionError.new(attribute_name)
+          super
+        end
+      else
+        if name =~ /^with(out|_all)?_(\w+)$/
+          attribute_name = $2.to_sym
+          if is_sphinx_attribute?(attribute_name)
+            # Put in with / without / with_all depending on what the regexp matched.
+            if $1 == 'out'
+              without[attribute_name]
+            elsif $1 == '_all'
+              with_all[attribute_name]
+            else
+              with[attribute_name]
+            end
+          else
+            raise UnknownConditionError.new(attribute_name)
+          end
+        elsif is_sphinx_field?(name)
+          conditions[name.to_sym]
+        elsif is_sphinx_scope?(name)
+          scopes[name.to_sym]
+        else
+          # If we have something else than a setter..
+          # raise UnknownConditionError.new(attribute_name)
+          super
+        end
+      end
+    end
+
+    # Returns a hash for the ThinkingSphinx search method. Eg.
+    #  {
+    #    :with => {:year => 2001}
+    #  }
+    def attribute_filter_options
+      options = {}
+      options[:with] = with unless with.blank?
+      options[:without] = without unless without.blank?
+      options[:with_all] = with_all unless with_all.blank? # See http://www.mailinglistarchive.com/thinking-sphinx@googlegroups.com/msg00351.html
+      options
+    end
+    
+    # Returns a hash for the ThinkingSphinx search method. Eg.
+    #  {
+    #    :conditions => {:name => 'John'}
+    #  }
+    def search_options
+      options = {}
+      options[:conditions] = conditions unless conditions.blank?
+      options.merge(attribute_filter_options).merge(ordering_options).merge(pagination_options)
+    end
+
+    # # cleanup_hash removes empty and nil stuff from params hashes.
+    # def cleanup_hash(hash)
+    #   hash.collect do |condition, value|
+    #     value.delete_if { |v| v.blank? } if value.is_a?(Array)
+    #     value unless value.blank?
+    #   end.compact
+    # end
+
+    # Returns the ThinkingSphinx index for the klass we search on.
+    def sphinx_index
+      klass.sphinx_indexes.first
+    end
+
+    # Returns true if the class of this Search has a Sphinx index.
+    def has_sphinx_index?
+      sphinx_index.is_a?(ThinkingSphinx::Index)
+    rescue
+      false
+    end
+
+    # Returns particular ThinkingSphinx::Attribute.
+    def sphinx_attribute(attribute_name)
+      sphinx_index.attributes.find do |index_attribute|
+        index_attribute.public? && index_attribute.unique_name.to_s =~ /^#{attribute_name}(_sort)?$/ # Also check for :sortable attributes (they are given prefix _sort)
+      end
+    end
+
+    # Returns true if the class of this search has a public attribute with this name (or name_sort if field is :sortable).
+    def is_sphinx_attribute?(attribute_name)
+      !!sphinx_attribute(attribute_name)
+    end
+
+    # Returns true if the class of this search has a public field with this name.
+    def is_sphinx_field?(field_name)
+      !sphinx_index.fields.find do |index_field|
+        index_field.public? && (index_field.unique_name.to_s == field_name.to_s)
+      end.nil?
+    end
+
+    # Returns true if class of this search has a sphinx scope with this name.
+    def is_sphinx_scope?(scope_name)
+      klass.sphinx_scopes.include?(scope_name.to_sym)
+    end
+
+    # Returns the type we should type_cast a ThinkingSphinx::Attribute to, eg. :integer.
+    def cast_type(name)
+      sphinx_attribute(name).type
+    end
+
+    # type_cast method of Searchlogic plugin
+    def type_cast(value, type)
+      case value
+      when Array
+        value.collect { |v| type_cast(v, type) }
+      else
+        # Let's leverage ActiveRecord's type casting, so that casting is consistent
+        # with the other models.
+        column_for_type_cast = ::ActiveRecord::ConnectionAdapters::Column.new("", nil)
+        column_for_type_cast.instance_variable_set(:@type, type)
+        value = column_for_type_cast.type_cast(value)
+        Time.zone && value.is_a?(Time) ? value.in_time_zone : value
+      end
+    end
+
+  end
+end

data/rails/init.rb

@@ -0,0 +1,7 @@
+require 'sphinxsearchlogic'
+ActiveRecord::Base.extend(Sphinxsearchlogic::Search::Implementation)
+
+if defined?(ActionController)
+  require "rails_helpers"
+  ActionController::Base.helper(Sphinxsearchlogic::RailsHelpers)
+end

data/test/sphinxsearchlogic_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+# Define classes to test on..
+class Book < ActiveRecord::Base
+
+  establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+  define_index do
+    indexes title, :sortable => true
+    indexes description
+    has :production_year
+  end
+
+  sphinx_scope(:millenium) do
+    {:with => {:production_year => 2000..9999}}
+  end
+
+end
+
+class SphinxsearchlogicTest < ActiveSupport::TestCase
+
+  def setup
+  end
+
+# General
+
+  test 'book model should have sphinx index' do
+    assert Book.sphinxsearchlogic.send(:has_sphinx_index?)
+  end
+
+# Attribute Filters
+
+  test 'valid with params' do
+    search = Book.sphinxsearchlogic(:with_production_year => '2006')
+    assert_equal({:production_year => '2006'}, search.with)
+  end
+
+  test 'invalid with params' do
+    assert_raise Sphinxsearchlogic::Search::UnknownConditionError do
+      search = Book.sphinxsearchlogic(:with_non_existing_stuff => '2006')
+    end
+  end
+
+  test 'valid without params' do
+    search = Book.sphinxsearchlogic(:without_production_year => '2006')
+    assert_equal({:production_year => '2006'}, search.without)
+  end
+
+  test 'invalid without params' do
+    assert_raise Sphinxsearchlogic::Search::UnknownConditionError do
+      search = Book.sphinxsearchlogic(:without_non_existing_stuff => '2006')
+    end
+  end
+
+# Regular field and scope searches
+
+  test 'empty search' do
+    search = Book.sphinxsearchlogic()
+    assert_equal({}, search.search_options)
+  end
+
+  test 'search on all' do
+    search = Book.sphinxsearchlogic(:all => 'test')
+    assert_equal('test', search.all)
+  end
+
+  test 'search on field' do
+    search = Book.sphinxsearchlogic(:title => 'test')
+    assert_equal('test', search.title)
+    assert_equal({:conditions => {:title => 'test'}}, search.search_options)
+  end
+
+  test 'scope search' do
+    search = Book.sphinxsearchlogic(:millenium => true)
+    assert_equal(true, search.millenium)
+  end
+
+# Ordering
+
+  test 'invalid ordering by non existing scope' do
+    search = Book.sphinxsearchlogic(:order => 'non_existing_scope')
+    assert_equal({}, search.ordering_options)
+  end
+
+  test 'invalid ordering by non sortable field' do
+    search = Book.sphinxsearchlogic(:order => 'ascend_by_description')
+    assert_equal({}, search.ordering_options)
+  end
+
+  test 'ascend ordering by sortable field' do
+    search = Book.sphinxsearchlogic(:order => 'ascend_by_title')
+    assert_equal({:order => :title, :sort_mode => :asc}, search.ordering_options)
+  end
+
+  test 'descend ordering by sortable field' do
+    search = Book.sphinxsearchlogic(:order => 'descend_by_title')
+    assert_equal({:order => :title, :sort_mode => :desc}, search.ordering_options)
+  end
+
+  test 'ascend ordering by attribute' do
+    search = Book.sphinxsearchlogic(:order => 'ascend_by_production_year')
+    assert_equal({:order => :production_year, :sort_mode => :asc}, search.ordering_options)
+  end
+
+  test 'descend ordering by @relevance' do
+    search = Book.sphinxsearchlogic(:order => 'descend_by_relevance')
+    assert_equal({:order => '@relevance desc'}, search.ordering_options)
+  end
+
+# Pagination
+
+  test 'pagination' do
+    search = Book.sphinxsearchlogic(:per_page => '123', :page => '12')
+    assert_equal(12, search.page)
+    assert_equal(123, search.per_page)
+    # We also check if the search_options are correctly set..
+    assert_equal(12, search.search_options[:page])
+    assert_equal(123, search.search_options[:per_page])
+  end
+
+  test 'invalid pagination' do
+    search = Book.sphinxsearchlogic(:per_page => 'asdasd', :page => 'as')
+    assert_equal(1, search.page)
+    assert_equal(10, search.per_page)
+
+    search = Book.sphinxsearchlogic(:per_page => '0', :page => '0')
+    assert_equal(1, search.page)
+    assert_equal(10, search.per_page)
+
+    search = Book.sphinxsearchlogic(:per_page => '-123', :page => '-12')
+    assert_equal(1, search.page)
+    assert_equal(10, search.per_page)
+  end
+
+  test 'no pagination' do
+    search = Book.sphinxsearchlogic(:per_page => '', :page => '')
+    assert_equal(nil, search.page)
+    assert_equal(nil, search.per_page)
+  end
+
+# Other methods
+
+  test 'attribute finding' do
+    assert Book.sphinxsearchlogic.is_sphinx_attribute?('title') # sortable so attribute
+    assert !Book.sphinxsearchlogic.is_sphinx_attribute?('notitle') # not existing
+    assert !Book.sphinxsearchlogic.is_sphinx_attribute?('description') # attribute
+  end
+
+  test 'field finding' do
+    assert Book.sphinxsearchlogic.is_sphinx_field?('title') # but also field
+    assert Book.sphinxsearchlogic.is_sphinx_field?('description')
+    assert !Book.sphinxsearchlogic.is_sphinx_field?('production_year')
+  end
+
+  test 'scope finding' do
+    assert Book.sphinxsearchlogic.is_sphinx_scope?('millenium')
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+
+# Create some test db stuff..
+require 'activerecord'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+ActiveRecord::Base.configurations = true
+
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :books do |t|
+    t.string :title
+    t.string :description
+    t.integer :production_year
+    t.timestamps
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: sphinxsearchlogic
+version: !ruby/object:Gem::Version 
+  version: 0.9.1
+platform: ruby
+authors: 
+- Joost Hietbrink
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: Searchlogic provides common named scopes and object based searching for ActiveRecord.
+email: joost@joopp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+- CHANGELOG.rdoc
+files: 
+- CHANGELOG.rdoc
+- MIT-LICENSE
+- README.rdoc
+- VERSION.yml
+- init.rb
+- lib/sphinxsearchlogic.rb
+- lib/rails_helpers.rb
+- rails/init.rb
+- test/sphinxsearchlogic_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/joost/sphinxsearchlogic
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sphinxsearchlogic
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Sphinxsearchlogic is for ThinkingSphinx what Searchlogic is for ActiveRecord.. or at least something similar.
+test_files: 
+- test/sphinxsearchlogic_test.rb
+- test/test_helper.rb