tire-erez 0.5.4

data/lib/tire/search/script_field.rb

@@ -0,0 +1,23 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/script-fields.html
+    # http://www.elasticsearch.org/guide/reference/modules/scripting.html
+
+    class ScriptField
+
+      def initialize(name, options)
+        @hash = { name => options }
+      end
+
+      def to_json(options={})
+        to_hash.to_json
+      end
+
+      def to_hash
+        @hash
+      end
+    end
+
+  end
+end

data/lib/tire/search/sort.rb

@@ -0,0 +1,25 @@
+module Tire
+  module Search
+
+    class Sort
+      def initialize(&block)
+        @value = []
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def by(name, direction=nil)
+        @value << ( direction ? { name => direction } : name )
+        self
+      end
+
+      def to_ary
+        @value
+      end
+
+      def to_json(options={})
+        @value.to_json
+      end
+    end
+
+  end
+end

data/lib/tire/tasks.rb

@@ -0,0 +1,138 @@
+require 'rake'
+require 'benchmark'
+
+namespace :tire do
+
+  full_comment_import = <<-DESC.gsub(/    /, '')
+    Import data from your model using paginate: rake environment tire:import CLASS='MyModel'.
+
+    Pass params for the `paginate` method:
+      $ rake environment tire:import CLASS='Article' PARAMS='{:page => 1}'
+
+    Force rebuilding the index (delete and create):
+      $ rake environment tire:import CLASS='Article' PARAMS='{:page => 1}' FORCE=1
+
+    Set target index name:
+      $ rake environment tire:import CLASS='Article' INDEX='articles-new'
+  DESC
+  desc full_comment_import
+  task :import do |t|
+
+    def elapsed_to_human(elapsed)
+      hour = 60*60
+      day  = hour*24
+
+      case elapsed
+      when 0..59
+        "#{sprintf("%1.2f", elapsed)} seconds"
+      when 60..hour-1
+        "#{(elapsed/60).floor} minutes and #{(elapsed % 60).floor} seconds"
+      when hour..day
+        "#{(elapsed/hour).floor} hours and #{(elapsed/60 % hour).floor} minutes"
+      else
+        "#{(elapsed/hour).round} hours"
+      end
+    end
+
+    if ENV['CLASS'].to_s == ''
+      puts '='*90, 'USAGE', '='*90, full_comment_import, ""
+      exit(1)
+    end
+
+    klass  = eval(ENV['CLASS'].to_s)
+    params = eval(ENV['PARAMS'].to_s) || {}
+
+    params.update :method => 'paginate'
+
+    index = Tire::Index.new( ENV['INDEX'] || klass.tire.index.name )
+
+    if ENV['FORCE']
+      puts "[IMPORT] Deleting index '#{index.name}'"
+      index.delete
+    end
+
+    unless index.exists?
+      mapping = MultiJson.encode(klass.tire.mapping_to_hash, :pretty => Tire::Configuration.pretty)
+      puts "[IMPORT] Creating index '#{index.name}' with mapping:", mapping
+      unless index.create( :mappings => klass.tire.mapping_to_hash, :settings => klass.tire.settings )
+        STDERR.puts "[ERROR] There has been an error when creating the index -- elasticsearch returned:",
+                    index.response
+        exit(1)
+      end
+    end
+
+    STDOUT.sync = true
+    puts "[IMPORT] Starting import for the '#{ENV['CLASS']}' class"
+    tty_cols = 80
+    total    = klass.count rescue nil
+    offset   = (total.to_s.size*2)+8
+    done     = 0
+
+    STDOUT.puts '-'*tty_cols
+    elapsed = Benchmark.realtime do
+
+      # Add Kaminari-powered "paginate" method
+      #
+      if defined?(Kaminari) && klass.respond_to?(:page)
+        klass.instance_eval do
+          def paginate(options = {})
+            page(options[:page]).per(options[:per_page]).to_a
+          end
+        end
+      end unless klass.respond_to?(:paginate)
+
+      # Import the documents
+      #
+      index.import(klass, params) do |documents|
+
+        if total
+          done += documents.to_a.size
+          # I CAN HAZ PROGREZ BAR LIEK HOMEBRU!
+          percent  = ( (done.to_f / total) * 100 ).to_i
+          glyphs   = ( percent * ( (tty_cols-offset).to_f/100 ) ).to_i
+          STDOUT.print( "#" * glyphs )
+          STDOUT.print( "\r"*tty_cols+"#{done}/#{total} | \e[1m#{percent}%\e[0m " )
+        end
+
+        # Don't forget to return the documents collection back!
+        documents
+      end
+    end
+
+    puts "", '='*80, "Import finished in #{elapsed_to_human(elapsed)}"
+  end
+
+  namespace :index do
+
+    full_comment_drop = <<-DESC.gsub(/      /, '')
+      Delete indices passed in the INDEX environment variable; separate multiple indices by comma.
+
+      Pass name of a single index to drop in the INDEX environmnet variable:
+        $ rake environment tire:index:drop INDEX=articles
+
+      Pass names of multiple indices to drop in the INDEX or INDICES environmnet variable:
+        $ rake environment tire:index:drop INDICES=articles-2011-01,articles-2011-02
+
+    DESC
+    desc full_comment_drop
+    task :drop do
+      index_names = (ENV['INDEX'] || ENV['INDICES']).to_s.split(/,\s*/)
+
+      if index_names.empty?
+        puts '='*90, 'USAGE', '='*90, full_comment_drop, ""
+        exit(1)
+      end
+
+      index_names.each do |name|
+        index = Tire::Index.new(name)
+        print "* Deleting index \e[1m#{index.name}\e[0m... "
+        puts  index.delete ? "\e[32mOK\e[0m" : "\e[31mFAILED\e[0m  | #{index.response.body}"
+      end
+
+      puts ""
+
+    end
+
+  end
+
+end

data/lib/tire/utils.rb

@@ -0,0 +1,17 @@
+require 'uri'
+
+module Tire
+  module Utils
+
+    def escape(s)
+      URI.encode_www_form_component(s.to_s)
+    end
+
+    def unescape(s)
+      s = s.to_s.respond_to?(:force_encoding) ? s.to_s.force_encoding(Encoding::UTF_8) : s.to_s
+      URI.decode_www_form_component(s)
+    end
+
+    extend self
+  end
+end

data/lib/tire/version.rb

@@ -0,0 +1,18 @@
+module Tire
+  VERSION   = "0.5.4"
+
+  CHANGELOG =<<-END
+    IMPORTANT CHANGES LATELY:
+
+    * Added the support for the Count API
+    * Escape single quotes in `to_curl` serialization
+    * Added JRuby compatibility
+    * Added proper `as_json` support for `Results::Collection` and `Results::Item` classes
+    * Added extracting the `routing` information in the `Index#store` method
+    * Refactored the `update_index` method for search and persistence integration
+    * Cast collection properties in Model::Persistence as empty Array by default
+    * Allow passing `:index` option to `MyModel.import`
+    * Update to Mocha ~> 0.13
+    * Update to MultiJson ~> 1.3
+  END
+end

data/test/fixtures/articles/1.json

@@ -0,0 +1 @@
+{"title" : "One", "tags" : ["ruby"], "published_on" : "2011-01-01", "words" : 125, "draft" : true}

data/test/fixtures/articles/2.json

@@ -0,0 +1 @@
+{"title" : "Two", "tags" : ["ruby", "python"], "published_on" : "2011-01-02", "words" : 250}

data/test/fixtures/articles/3.json

@@ -0,0 +1 @@
+{"title" : "Three", "tags" : ["java"], "published_on" : "2011-01-02", "words" : 375}

data/test/fixtures/articles/4.json

@@ -0,0 +1 @@
+{"title" : "Four", "tags" : ["erlang"], "published_on" : "2011-01-03", "words" : 250}

data/test/fixtures/articles/5.json

@@ -0,0 +1 @@
+{"title" : "Five", "tags" : ["javascript", "java"], "published_on" : "2011-01-04", "words" : 125}

data/test/integration/active_model_indexing_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+require File.expand_path('../../models/supermodel_article', __FILE__)
+
+module Tire
+
+  class ActiveModelSearchableIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    class ::ActiveModelArticleWithCustomAsSerialization < ActiveModelArticleWithCallbacks
+      mapping do
+        indexes :title
+        indexes :content
+        indexes :characters,  :as => 'content.length'
+        indexes :readability, :as => proc {
+                                       content.split(/\W/).reject { |t| t.blank? }.size /
+                                       content.split(/\./).size
+                                     }
+      end
+    end
+
+    def setup
+      super
+      ActiveModelArticleWithCustomAsSerialization.index.delete
+    end
+
+    def teardown
+      super
+      ActiveModelArticleWithCustomAsSerialization.index.delete
+    end
+
+    context "ActiveModel serialization" do
+
+      setup do
+        @model = ActiveModelArticleWithCustomAsSerialization.new \
+                   :id      => 1, 
+                   :title   => 'Test article',
+                   :content => 'Lorem Ipsum. Dolor Sit Amet.'
+        @model.update_index
+        @model.index.refresh
+      end
+
+      should "serialize the content length" do
+        m = ActiveModelArticleWithCustomAsSerialization.search('*').first
+        assert_equal 28, m.characters
+        assert_equal 2,  m.readability
+      end
+
+    end
+
+  end
+end

data/test/integration/active_model_searchable_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+require File.expand_path('../../models/supermodel_article', __FILE__)
+
+module Tire
+
+  class ActiveModelSearchableIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    def setup
+      super
+      Redis::Persistence.config.redis = Redis.new db: ENV['REDIS_PERSISTENCE_TEST_DATABASE'] || 14
+      Redis::Persistence.config.redis.flushdb
+      @model = SupermodelArticle.new :title => 'Test'
+    end
+
+    def teardown
+      super
+      SupermodelArticle.all.each { |a| a.destroy }
+    end
+
+    context "ActiveModel integration" do
+
+      setup    do
+        Tire.index('supermodel_articles').delete
+        load File.expand_path('../../models/supermodel_article.rb', __FILE__)
+      end
+      teardown { Tire.index('supermodel_articles').delete }
+
+      should "configure mapping" do
+        assert_equal 'czech', SupermodelArticle.mapping[:title][:analyzer]
+        assert_equal 15,      SupermodelArticle.mapping[:title][:boost]
+
+        assert_equal 'czech', SupermodelArticle.index.mapping['supermodel_article']['properties']['title']['analyzer']
+      end
+
+      should "save document into index on save and find it with score" do
+        a = SupermodelArticle.new :title => 'Test'
+        a.save
+        id = a.id
+
+        # Store document of another type in the index
+        Index.new 'supermodel_articles' do
+          store :type => 'other-thing', :title => 'Title for other thing'
+        end
+
+        a.index.refresh
+
+        # The index should contain 2 documents
+        assert_equal 2, Tire.search('supermodel_articles') { query { all } }.results.size
+
+        results = SupermodelArticle.search 'test'
+
+        # The model should find only 1 document
+        assert_equal 1, results.count
+
+        assert_instance_of Results::Item, results.first
+        assert_equal       'Test', results.first.title
+        assert_not_nil     results.first._score
+        assert_equal       id.to_s, results.first.id.to_s
+      end
+
+      should "remove document from index on destroy" do
+        a = SupermodelArticle.new :title => 'Test'
+        a.save
+        assert_equal 1, SupermodelArticle.all.size
+
+        a.destroy
+        assert_equal 0, SupermodelArticle.all.size
+
+        a.index.refresh
+        results = SupermodelArticle.search 'test'
+        
+        assert_equal 0, results.count
+      end
+
+      should "retrieve sorted documents by IDs returned from search" do
+        SupermodelArticle.create :title => 'foo'
+        SupermodelArticle.create :id => 'abc123', :title => 'bar'
+
+        SupermodelArticle.index.refresh
+        results = SupermodelArticle.search 'foo OR bar^100'
+
+        assert_equal 2, results.count
+
+        assert_equal 'bar',    results.first.title
+        assert_equal 'abc123', results.first.id
+      end
+
+      context "within Rails" do
+
+        setup do
+          module ::Rails; end
+        end
+
+        should "load the underlying model" do
+          a = SupermodelArticle.new :title => 'Test'
+          a.save
+          a.index.refresh
+
+          results = SupermodelArticle.search 'test'
+
+          assert_instance_of Results::Item, results.first
+          assert_instance_of SupermodelArticle, results.first.load
+
+          assert_equal 'Test', results.first.load.title
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record_searchable_test.rb

@@ -0,0 +1,620 @@
+require 'test_helper'
+
+module Tire
+
+  class ActiveRecordSearchableIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    def setup
+      super
+      ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :active_record_articles do |t|
+          t.string   :title
+          t.datetime :created_at, :default => 'NOW()'
+        end
+        create_table :active_record_comments do |t|
+          t.string     :author
+          t.text       :body
+          t.references :article
+          t.timestamps
+        end
+        create_table :active_record_stats do |t|
+          t.integer    :pageviews
+          t.string     :period
+          t.references :article
+        end
+        create_table :active_record_class_with_tire_methods do |t|
+          t.string     :title
+        end
+        create_table :active_record_class_with_dynamic_index_names do |t|
+          t.string     :title
+        end
+        create_table :active_record_model_with_percolations do |t|
+          t.string   :title
+          t.datetime :created_at, :default => 'NOW()'
+        end
+      end
+    end
+
+    context "ActiveRecord integration" do
+
+      setup do
+        ActiveRecordArticle.delete_all
+        Tire.index('active_record_articles').delete
+
+        load File.expand_path('../../models/active_record_models.rb', __FILE__)
+      end
+
+      teardown do
+        ActiveRecordArticle.delete_all
+        Tire.index('active_record_articles').delete
+      end
+
+      should "configure mapping" do
+         assert_equal 'snowball', ActiveRecordArticle.mapping[:title][:analyzer]
+         assert_equal 10, ActiveRecordArticle.mapping[:title][:boost]
+
+         assert_equal 'snowball', ActiveRecordArticle.index.mapping['active_record_article']['properties']['title']['analyzer']
+      end
+
+      should "save document into index on save and find it" do
+        a = ActiveRecordArticle.new :title => 'Test'
+        a.save!
+        id = a.id
+
+        a.index.refresh
+
+        results = ActiveRecordArticle.search 'test'
+
+        assert       results.any?
+        assert_equal 1, results.count
+
+        assert_instance_of Results::Item, results.first
+        assert_not_nil results.first.id
+        assert_equal   id.to_s, results.first.id.to_s
+        assert         results.first.persisted?, "Record should be persisted"
+        assert_not_nil results.first._score
+        assert_equal   'Test', results.first.title
+      end
+
+      should "remove document from index on destroy" do
+        a = ActiveRecordArticle.new :title => 'Test remove...'
+        a.save!
+        assert_equal 1, ActiveRecordArticle.count
+
+        a.destroy
+        assert_equal 0, ActiveRecordArticle.all.size
+
+        a.index.refresh
+        results = ActiveRecordArticle.search 'test'
+        assert_equal 0, results.count
+      end
+
+      should "return documents with scores" do
+        ActiveRecordArticle.create! :title => 'foo'
+        ActiveRecordArticle.create! :title => 'bar'
+
+        ActiveRecordArticle.index.refresh
+        results = ActiveRecordArticle.search 'foo OR bar^100'
+        assert_equal 2, results.count
+
+        assert_equal 'bar', results.first.title
+      end
+
+      should "raise exception on invalid query" do
+        ActiveRecordArticle.create! :title => 'Test'
+
+        assert_raise Search::SearchRequestFailed do
+          ActiveRecordArticle.search '[x'
+        end
+      end
+
+      context "with eager loading" do
+        setup do
+          ActiveRecordArticle.destroy_all
+          5.times { |n| ActiveRecordArticle.create! :title => "Test #{n+1}" }
+          ActiveRecordArticle.index.refresh
+        end
+
+        should "load records on query search" do
+          results = ActiveRecordArticle.search '"Test 1"', :load => true
+
+          assert       results.any?
+          assert_equal ActiveRecordArticle.find(1), results.first
+        end
+
+        should "load records on block search" do
+          results = ActiveRecordArticle.search :load => true do
+            query { string '"Test 1"' }
+          end
+
+          assert_equal ActiveRecordArticle.find(1), results.first
+        end
+
+        should "load records with options on query search" do
+          assert_equal ActiveRecordArticle.find(['1'], :include => 'comments').first,
+                       ActiveRecordArticle.search('"Test 1"',
+                                                  :load => { :include => 'comments' }).results.first
+        end
+
+        should "return empty collection for nonmatching query" do
+          assert_nothing_raised do
+            results = ActiveRecordArticle.search :load => true do
+              query { string '"Hic Sunt Leones"' }
+            end
+            assert_equal 0, results.size
+            assert ! results.any?
+          end
+        end
+
+        should "iterate results with hits" do
+          results = ActiveRecordArticle.search :load => true do
+            query { string '"Test 1" OR "Test 2"' }
+          end
+          results.each_with_hit do |result, hit|
+            assert_instance_of ActiveRecordArticle, result
+            assert_instance_of Hash, hit
+            assert_match /Test \d/, result.title
+            assert_match /Test \d/, hit['_source']['title']
+            assert hit['_score'] > 0
+          end
+        end
+
+        should "provide access to highlighted fields in hit" do
+          results = ActiveRecordArticle.search :load => true do
+            query { string '"Test 1" OR "Test 2"' }
+            highlight :title
+          end
+          results.each_with_hit do |result, hit|
+            assert_equal 1, hit['highlight']['title'].size
+          end
+        end
+      end
+
+      context "with pagination" do
+        setup do
+          1.upto(9) { |number| ActiveRecordArticle.create :title => "Test#{number}" }
+          ActiveRecordArticle.index.refresh
+        end
+
+        context "and parameter searches" do
+
+          should "find first page with five results" do
+            results = ActiveRecordArticle.search 'test*', :sort => 'title', :per_page => 5, :page => 1
+            assert_equal 5, results.size
+
+            # WillPaginate
+            #
+            assert_equal 2, results.total_pages
+            assert_equal 1, results.current_page
+            assert_equal nil, results.previous_page
+            assert_equal 2, results.next_page
+
+            # Kaminari
+            #
+            assert_equal 5, results.limit_value
+            assert_equal 9, results.total_count
+            assert_equal 2, results.num_pages
+            assert_equal 0, results.offset_value
+
+            assert_equal 'Test1', results.first.title
+          end
+
+          should "find second page with four results" do
+            results = ActiveRecordArticle.search 'test*', :sort => 'title', :per_page => 5, :page => 2
+            assert_equal 4, results.size
+
+            assert_equal 2, results.total_pages
+            assert_equal 2, results.current_page
+            assert_equal 1, results.previous_page
+            assert_equal nil, results.next_page
+
+            #kaminari
+            assert_equal 5, results.limit_value
+            assert_equal 9, results.total_count
+            assert_equal 2, results.num_pages
+            assert_equal 5, results.offset_value
+
+            assert_equal 'Test6', results.first.title
+          end
+
+          should "find not find missing (third) page" do
+            results = ActiveRecordArticle.search 'test*', :sort => 'title', :per_page => 5, :page => 3
+            assert_equal 0, results.size
+
+            assert_equal 2, results.total_pages
+            assert_equal 3, results.current_page
+            assert_equal 2, results.previous_page
+            assert_equal nil, results.next_page
+
+            #kaminari
+            assert_equal 5, results.limit_value
+            assert_equal 9, results.total_count
+            assert_equal 2, results.num_pages
+            assert_equal 10, results.offset_value
+
+            assert_nil results.first
+          end
+
+          context "without an explicit per_page" do
+
+            should "not find a missing (second) page" do
+              results = ActiveRecordArticle.search 'test*', :sort => 'title', :page => 2
+              assert_equal 0, results.size
+
+              # WillPaginate
+              #
+              assert_equal 1, results.total_pages
+              assert_equal 2, results.current_page
+              assert_equal 1, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_nil results.first
+            end
+
+          end
+
+        end
+
+        context "and block searches" do
+          setup { @q = 'test*' }
+
+          context "with page/per_page" do
+
+            should "find first page with five results" do
+              results = ActiveRecordArticle.search :page => 1, :per_page => 5 do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+              end
+              assert_equal 5, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 1, results.current_page
+              assert_equal nil, results.previous_page
+              assert_equal 2, results.next_page
+
+              assert_equal 'Test1', results.first.title
+            end
+
+            should "find second page with four results" do
+              results = ActiveRecordArticle.search :page => 2, :per_page => 5 do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+              end
+              assert_equal 4, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 2, results.current_page
+              assert_equal 1, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_equal 'Test6', results.first.title
+            end
+
+            should "not find a missing (third) page" do
+              results = ActiveRecordArticle.search :page => 3, :per_page => 5 do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+              end
+              assert_equal 0, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 3, results.current_page
+              assert_equal 2, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_nil results.first
+            end
+
+            should "find second page with four loaded models" do
+              results = ActiveRecordArticle.search :load => true, :page => 2, :per_page => 5 do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+              end
+              assert_equal 4, results.size
+              assert results.all? { |r| assert_instance_of ActiveRecordArticle, r }
+              assert_equal 'Test6', results.first.title
+            end
+
+          end
+
+          context "with from/size" do
+
+            should "find first page with five results" do
+              results = ActiveRecordArticle.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 0
+                search.size 5
+              end
+              assert_equal 5, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 1, results.current_page
+              assert_equal nil, results.previous_page
+              assert_equal 2, results.next_page
+
+              assert_equal 'Test1', results.first.title
+            end
+
+            should "find second page with five results" do
+              results = ActiveRecordArticle.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 5
+                search.size 5
+              end
+              assert_equal 4, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 2, results.current_page
+              assert_equal 1, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_equal 'Test6', results.first.title
+            end
+
+            should "not find a missing (third) page" do
+              results = ActiveRecordArticle.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 10
+                search.size 5
+              end
+              assert_equal 0, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 3, results.current_page
+              assert_equal 2, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_nil results.first
+            end
+
+          end
+
+      end
+
+      end
+
+      context "with proxy" do
+
+        should "allow access to Tire instance methods" do
+          a = ActiveRecordClassWithTireMethods.create :title => 'One'
+          assert_equal "THIS IS MY INDEX!", a.index
+          assert_instance_of Tire::Index, a.tire.index
+          assert a.tire.index.exists?, "Index should exist"
+        end
+
+        should "allow access to Tire class methods" do
+          class ::ActiveRecordClassWithTireMethods < ActiveRecord::Base
+            def self.search(*)
+              "THIS IS MY SEARCH!"
+            end
+          end
+
+          ActiveRecordClassWithTireMethods.create :title => 'One'
+          ActiveRecordClassWithTireMethods.tire.index.refresh
+
+          assert_equal "THIS IS MY SEARCH!", ActiveRecordClassWithTireMethods.search
+
+          results = ActiveRecordClassWithTireMethods.tire.search 'one'
+
+          assert_equal 'One', results.first.title
+        end
+
+      end
+
+      context "with dynamic index name" do
+        setup do
+          @a = ActiveRecordClassWithDynamicIndexName.create! :title => 'Test'
+          @a.index.refresh
+        end
+
+        should "search in proper index" do
+          assert_equal 'dynamic_index', ActiveRecordClassWithDynamicIndexName.index.name
+          assert_equal 'dynamic_index', @a.index.name
+
+          results = ActiveRecordClassWithDynamicIndexName.search 'test'
+          assert_equal 'dynamic_index', results.first._index
+        end
+      end
+
+      context "within Rails" do
+
+        setup do
+          module ::Rails; end
+
+          a = ActiveRecordArticle.new :title => 'Test'
+          a.comments.build :author => 'fool', :body => 'Works!'
+          a.stats.build    :pageviews  => 12, :period => '2011-08'
+          a.save!
+          @id = a.id.to_s
+
+          a.index.refresh
+          @item = ActiveRecordArticle.search('test').first
+        end
+
+        should "have access to indexed properties" do
+          assert_equal 'Test', @item.title
+          assert_equal 'fool', @item.comments.first.author
+          assert_equal 12,     @item.stats.first.pageviews
+        end
+
+        should "load the underlying models" do
+          assert_instance_of Results::Item, @item
+          assert_instance_of ActiveRecordArticle, @item.load
+          assert_equal      'Test', @item.load.title
+
+          assert_instance_of Results::Item, @item.comments.first
+          assert_instance_of ActiveRecordComment, @item.comments.first.load
+          assert_equal      'fool', @item.comments.first.load.author
+        end
+
+        should "load the underlying model with options" do
+          ActiveRecordArticle.expects(:find).with(@id, :include => 'comments')
+          @item.load(:include => 'comments')
+        end
+
+      end
+
+      context "with multiple class instances in one index" do
+         setup do
+           ActiveRecord::Schema.define do
+             create_table(:active_record_assets)    { |t| t.string :title, :timestamp }
+             create_table(:active_record_model_one) { |t| t.string :title, :timestamp }
+             create_table(:active_record_model_two) { |t| t.string :title, :timestamp }
+           end
+
+           ActiveRecordModelOne.create :title => 'Title One', timestamp: Time.now.to_i
+           ActiveRecordModelTwo.create :title => 'Title Two', timestamp: Time.now.to_i
+           ActiveRecordModelOne.tire.index.refresh
+           ActiveRecordModelTwo.tire.index.refresh
+
+
+           ActiveRecordVideo.create! :title => 'Title One', timestamp: Time.now.to_i
+           ActiveRecordPhoto.create! :title => 'Title Two', timestamp: Time.now.to_i
+           ActiveRecordAsset.tire.index.refresh
+         end
+
+         teardown do
+           ActiveRecordModelOne.destroy_all
+           ActiveRecordModelTwo.destroy_all
+           ActiveRecordModelOne.tire.index.delete
+           ActiveRecordModelTwo.tire.index.delete
+
+           ActiveRecordAsset.destroy_all
+           ActiveRecordAsset.tire.index.delete
+           ActiveRecordModelOne.destroy_all
+         end
+
+         should "eagerly load instances of multiple classes, from multiple indices" do
+           s = Tire.search ['active_record_model_one', 'active_record_model_two'], :load => true do
+             query { string 'title' }
+             sort  { by :timestamp }
+           end
+
+           # puts s.results[0].inspect
+
+           assert_equal 2, s.results.length
+           assert_instance_of ActiveRecordModelOne, s.results[0]
+           assert_instance_of ActiveRecordModelTwo, s.results[1]
+         end
+
+         should "eagerly load all STI descendant records" do
+           s = Tire.search('active_record_assets', :load => true) do
+             query { string 'title' }
+             sort  { by :timestamp }
+           end
+
+           assert_equal 2, s.results.length
+           assert_instance_of ActiveRecordVideo,  s.results[0]
+           assert_instance_of ActiveRecordPhoto,  s.results[1]
+         end
+      end
+
+      context "with namespaced models" do
+        setup do
+           ActiveRecord::Schema.define { create_table(:active_record_namespace_my_models) { |t| t.string :title, :timestamp } }
+
+           ActiveRecordNamespace::MyModel.create :title => 'Test'
+           ActiveRecordNamespace::MyModel.tire.index.refresh
+        end
+
+        teardown do
+           ActiveRecordNamespace::MyModel.destroy_all
+           ActiveRecordNamespace::MyModel.tire.index.delete
+        end
+
+        should "save document into index on save and find it" do
+          results = ActiveRecordNamespace::MyModel.search 'test'
+
+          assert       results.any?, "No results returned: #{results.inspect}"
+          assert_equal 1, results.count
+
+          assert_instance_of Results::Item, results.first
+        end
+
+        should "eagerly load the records from returned hits" do
+          results = ActiveRecordNamespace::MyModel.search 'test', :load => true
+
+          assert             results.any?, "No results returned: #{results.inspect}"
+          assert_instance_of ActiveRecordNamespace::MyModel, results.first
+          assert_equal       ActiveRecordNamespace::MyModel.find(1), results.first
+        end
+
+      end
+
+      context "multi search" do
+        setup do
+          # Tire.configure { logger STDERR }
+          ActiveRecordArticle.create! :title => 'Test'
+          ActiveRecordArticle.create! :title => 'Pest'
+          ActiveRecordArticle.index.refresh
+        end
+
+        should "return multiple result sets" do
+          results = ActiveRecordArticle.multi_search do
+            search do
+              query { match :title, 'test' }
+            end
+            search search_type: 'count' do
+              query { match :title, 'pest' }
+            end
+            search :articles, index: 'articles-test', type: 'article' do
+              query { all }
+            end
+          end
+
+          assert_equal 3, results.size
+
+          assert_equal 1, results[0].size
+          assert_equal 1, results[0].total
+
+          assert_equal 0, results[1].size
+          assert_equal 1, results[1].total
+
+          assert_equal 5, results[:articles].size
+        end
+
+        should "return model instances with the :load option" do
+          results = ActiveRecordArticle.multi_search do
+            search :items do
+              query { match :title, 'test' }
+            end
+            search :models, :load => true do
+              query { match :title, 'test' }
+            end
+          end
+
+          assert_instance_of Tire::Results::Item, results[:items].first
+          assert_instance_of ActiveRecordArticle, results[:models].first
+        end
+
+      end
+
+      context "percolated search" do
+        setup do
+          ActiveRecordModelWithPercolation.index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return matching queries when percolating" do
+          a = ActiveRecordModelWithPercolation.new :title => 'Warning!'
+          assert_contains a.percolate, 'alert'
+        end
+
+        should "return matching queries when saving" do
+          a = ActiveRecordModelWithPercolation.create! :title => 'Warning!'
+          assert_contains a.tire_matches, 'alert'
+        end
+      end
+
+    end
+
+  end
+
+end