ssickles-tire 0.4.2 → 0.4.2.7

data/lib/tire/rubyext/hash.rb

@@ -1,8 +0,0 @@
-class Hash
-
-  def to_json(options=nil)
-    MultiJson.encode(self)
-  end unless respond_to?(:to_json)
-
-  alias_method :to_indexed_json, :to_json
-end

data/lib/tire/rubyext/ruby_1_8.rb

@@ -1,54 +0,0 @@
-# Stolen from ruby core's uri/common.rb, with modifications to support 1.8.x
-#
-# https://github.com/ruby/ruby/blob/trunk/lib/uri/common.rb
-#
-#
-
-module URI
-  TBLENCWWWCOMP_ = {} # :nodoc:
-  256.times do |i|
-    TBLENCWWWCOMP_[i.chr] = '%%%02X' % i
-  end
-  TBLENCWWWCOMP_[' '] = '+'
-  TBLENCWWWCOMP_.freeze
-  TBLDECWWWCOMP_ = {} # :nodoc:
-  256.times do |i|
-    h, l = i>>4, i&15
-    TBLDECWWWCOMP_['%%%X%X' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%x%X' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%X%x' % [h, l]] = i.chr
-    TBLDECWWWCOMP_['%%%x%x' % [h, l]] = i.chr
-  end
-  TBLDECWWWCOMP_['+'] = ' '
-  TBLDECWWWCOMP_.freeze
-
-  # Encode given +s+ to URL-encoded form data.
-  #
-  # This method doesn't convert *, -, ., 0-9, A-Z, _, a-z, but does convert SP
-  # (ASCII space) to + and converts others to %XX.
-  #
-  # This is an implementation of
-  # http://www.w3.org/TR/html5/forms.html#url-encoded-form-data
-  #
-  # See URI.decode_www_form_component, URI.encode_www_form
-  def self.encode_www_form_component(s)
-    str = s.to_s
-    if RUBY_VERSION < "1.9" && $KCODE =~ /u/i
-      str.gsub(/([^ a-zA-Z0-9_.-]+)/) do
-        '%' + $1.unpack('H2' * Rack::Utils.bytesize($1)).join('%').upcase
-      end.tr(' ', '+')
-    else
-      str.gsub(/[^*\-.0-9A-Z_a-z]/) {|m| TBLENCWWWCOMP_[m]}
-    end
-  end
-
-  # Decode given +str+ of URL-encoded form data.
-  #
-  # This decods + to SP.
-  #
-  # See URI.encode_www_form_component, URI.decode_www_form
-  def self.decode_www_form_component(str, enc=nil)
-    raise ArgumentError, "invalid %-encoding (#{str})" unless /\A(?:%[0-9a-fA-F]{2}|[^%])*\z/ =~ str
-    str.gsub(/\+|%[0-9a-fA-F]{2}/) {|m| TBLDECWWWCOMP_[m]}
-  end
-end

data/lib/tire/rubyext/symbol.rb

@@ -1,11 +0,0 @@
-# ActiveModel::Serialization Ruby < 1.9.x compatibility
-
-class Symbol
-  def <=> other
-    self.to_s <=> other.to_s
-  end unless method_defined?(:'<=>')
-
-  def capitalize
-    to_s.capitalize
-  end unless method_defined?(:capitalize)
-end

data/lib/tire/utils.rb

@@ -1,17 +0,0 @@
-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/test/integration/active_model_indexing_test.rb

@@ -1,51 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,446 +0,0 @@
-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
-      end
-    end
-
-    context "ActiveRecord integration" do
-
-      setup do
-        ActiveRecordArticle.destroy_all
-        Tire.index('active_record_articles').delete
-
-        load File.expand_path('../../models/active_record_models.rb', __FILE__)
-      end
-
-      teardown do
-        ActiveRecordArticle.destroy_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 "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
-      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
-      
-      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 next page with five 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 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
-      
-        end
-      
-        context "and block searches" do
-          setup { @q = 'test*' }
-      
-          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 next 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 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
-      
-      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
-    end
-
-  end
-
-end