tanker 0.5.6 → 1.0.0

data/Gemfile

@@ -4,7 +4,7 @@ gem 'jeweler'
 gem 'will_paginate', '>= 2.3.15'
 
 group :test do
-  gem 'rspec', '>= 2.0.0.beta.22' 
+  gem 'rspec', '>= 2.5.0' 
 end
 
 

data/README.rdoc

@@ -1,7 +1,5 @@
 = Tanker - IndexTank integration to your favorite orm
 
-*Note:* This gem is still quite alpha but please feel free to send comments
-
 IndexTank is a great search indexing service, this gem tries to make 
 any orm keep in sync with indextank with ease. This gem has a simple 
 but powerful approach to integrating IndexTank to any orm. The gem 
@@ -39,6 +37,7 @@ in the IndexTank Dashboard
     
     class Topic < ActiveRecord::Base
       acts_as_taggable
+      has_many :authors
       
       # just include the Tanker module
       include Tanker
@@ -50,7 +49,32 @@ in the IndexTank Dashboard
       tankit 'my_index' do
         indexes :title
         indexes :content
+        indexes :id
         indexes :tag_list #NOTICE this is an array of Tags! Awesome!
+
+        # you may also dynamically retrieve field data
+        indexes :author_names do
+          authors.map {|author| author.name }
+        end
+
+        # to pass in a list of variables with your document,
+        # supply a hash with the variable integers as keys:
+        variables do
+          {
+            0 => authors.first.id, # these will be available in your queries
+            1 => id                # as doc.var[0] and doc.var[1]
+          }
+        end
+
+        # You may defined some server-side functions that can be
+        # referenced in your queries. They're always referenced by
+        # their integer key:
+        functions do
+          {
+            1 => '-age',
+            2 => 'doc.var[0] - doc.var[1]'
+          }
+        end
       end
       
       # define the callbacks to update or delete the index
@@ -78,10 +102,83 @@ Search Topics
     @topics = Topic.search_tank('blah',  :conditions => {:tag_list => 'tag1'}) # Gets 2 results!
     @topics = Topic.search_tank('blah',  :conditions => {:title => 'Awesome', :tag_list => 'tag1'}) # Gets 1 result!
 
+Search multiple models
+
+    @results = Tanker.search([Topic, Post], 'blah') # Gets any Topic OR Post results that match!
+
+Search with negative conditions
+
+    @topics = Topic.search_tank('keyword',  :conditions => {'tag_list' => 'tag1'}) # Gets 1 result!
+    @topics = Topic.search_tank('keyword',  :conditions => {'-id' => [5,9]}) # Ignores documents with ids of '5' or '9'
+
+Search with query variables
+
+    @topics = Topic.search_tank('keyword',  :variables => {0 => 5.6}) # Makes 5.6 available server-side as q[0]
+
 Paginate Results
 
     <% will_paginate(@topics) %>
 
+== Geospatial Search Example
+
+IndexTank and the Tanker gem support native geographic calculations. All you need is to define two document variables with your latitude and your longitude
+ 
+    class Restaurant < ActiveRecord::Base
+      include Tanker
+
+      tankit 'my_index' do
+        indexes :name
+
+        # You may define lat/lng at any variable number you like, as long
+        # as you refer to them consistently with the same integers
+        variables do
+          {
+            0 => lat
+            1 => lng
+          }
+        end
+
+        functions do
+          {
+            # This function is good for sorting your results. It will
+            # rank relevant, close results higher and irrelevant, distant results lower
+            1 => "relevance / miles(d[0], d[1], q[0], q[1])",
+
+            # This function is useful for limiting the results that your query returns.
+            # It just calculates the distance of each document in miles, which you can use
+            # in your query. Notice that we're using 0 and 1 consistently as 'lat' and 'lng'
+            2 => "miles(d[0], d[1], q[0], q[1])"
+          }
+        end
+      end
+    end
+    
+    # When searching, you need to provide a latitude and longitude in the query so that
+    # these variables are accessible on the server.
+    Restaurant.search("tasty",
+                      :var0 => 47.689948,
+                      :var1 => -122.363684,
+                      # And we'll return all results sorted by distance
+                      :function => 1)
+
+    # Or we can use just function 2 to return results in the default order, while
+    # limiting the total results to just those within 50 miles from our lat/lng:
+    Restaurant.search("tasty",
+                      :var0 => 47.689948,
+                      :var1 => -122.363684,
+                      # the following is a fancy way of saying "return all results where
+                      the result of function 2 is at least anything and less than 50"
+                      :filter_functions => {2 => [['*', 50]]})
+    # And we can combine these two function calls to return only results within 50 miles
+    # and sort them by relevance / distance:
+    Restaurant.search("tasty",
+                      :var0 => 47.689948,
+                      :var1 => -122.363684,
+                      :function => 1,
+                      :filter_functions => {2 => [['*', 50]]})
+
+
+
 == Reindex your data
 
 If you are using rails 3 there are of couple of rake tasks included in your project
@@ -93,11 +190,28 @@ the indexes in the Index Tank interface this task creates them for you provided
 you have enough indexes in your account.
 
     rake tanker:reindex
+
+This task pushes any functions you've defined in your tankit() blocks to indextank.com
+
+    rake tanker:functions
     
 This task re-indexes all the your models that have the Tanker module included.
 Usually you will only need a single Index Tank index but if you want to separate
 your indexes please use different index names in the tankit method call in your models
 
+To reindex just one class rather than all the classes in your application just call:
+
+    Model.tanker_reindex
+
+And if you'd like to specify a custom number of records to PUT with each call to indextank.com you may specify it as the first argument:
+
+    Model.tanker_reindex(:batch_size => 1000) # defaults to batch size of 200
+
+Or you can restrict indexing to a subset of records. This is particularly helpful for massive datasets where only a small portion of the records is useful.
+
+    Model.tanker_reindex(:batch_size => 1000, :scope => :not_deleted) # will call Model.not_deleted.all internally
+
+
 == TODO
 * Documentation
 * More fancy stuff (Suggestions?)

data/Rakefile

@@ -9,9 +9,9 @@ begin
     gem.description = %Q{IndexTank is a great search indexing service, this gem tries to make any orm keep in sync with indextank with ease}
     gem.email = "kidpollo@gmail.com"
     gem.homepage = "http://github.com/kidpollo/tanker"
-    gem.authors = ["@kidpollo"]
-    gem.add_development_dependency "rspec", ">= 2.0.0.beta.22"
-    gem.add_dependency 'will_paginate', '>= 2.3.15'
+    gem.authors = ["@kidpollo", "Jack Danger Canty"]
+    #gem.add_development_dependency "rspec", ">= 2.0.0.beta.22"
+    #gem.add_dependency 'will_paginate', '>= 2.3.15'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -21,10 +21,11 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/*_spec.rb'
   test.verbose = true
 end
+task :spec => :test
 
 begin
   require 'rcov/rcovtask'
@@ -39,7 +40,7 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
+#task :test => :check_dependencies
 
 task :default => :test
 

data/VERSION

@@ -1 +1 @@
-0.5.6
+1.0.0

data/lib/indextank_client.rb

@@ -139,6 +139,11 @@ module IndexTank
             return r
         end
 
+        def add_documents(data_array)
+            code, r = PUT "/docs", data_array
+            return r
+        end
+
         def update_variables(docid, variables, options={})
             options.merge!( :docid => docid, :variables => variables )
             code, r = PUT "/docs/variables", options

data/lib/tanker/tasks/tanker.rake

@@ -2,11 +2,46 @@ namespace :tanker do
  
   desc "Reindex all models"
   task :reindex => :environment do
-    puts "reinexing all models"
+    puts "reindexing all models"
     load_models
     Tanker::Utilities.reindex_all_models
   end
   
+  desc "Update IndexTank functions"
+  task :functions => :environment do
+    puts "reindexing all IndexTank functions"
+    load_models
+    indexes = {}
+    Tanker::Utilities.get_model_classes.each do |model|
+      model.tanker_config.functions.each do |idx, definition|
+        indexes[model.tanker_config.index_name] ||= {}
+        indexes[model.tanker_config.index_name][idx] = definition
+      end
+    end
+    if indexes.blank?
+      puts <<-HELP
+No IndexTank functions defined.
+Define your server-side functions inside your model's tankit block like so:
+  tankit 'myindex' do
+    functions do
+      {
+        1 => "-age",
+        2 => "relevance / miles(d[0], d[1], q[0], q[1])"
+      }
+    end
+  end
+HELP
+    else
+      indexes.each do |index_name, functions|
+        index = Tanker.api.get_index(index_name)
+        functions.each do |idx, definition|
+          index.add_function(idx, definition)
+          puts "Index #{index_name.inspect} function: #{idx} => #{definition.inspect}"
+        end
+      end
+    end
+  end
+  
   desc "Clear all Index Tank indexes"
   task :clear_indexes => :environment do
     puts "clearing all indexes"

data/lib/tanker/utilities.rb

@@ -6,7 +6,7 @@ module Tanker
       end
 
       def get_available_indexes
-        get_model_classes.map{|model| model.index_name}.uniq.compact
+        get_model_classes.map{|model| model.tanker_config.index_name}.uniq.compact
       end
 
       def clear_all_indexes
@@ -32,10 +32,7 @@ module Tanker
 
       def reindex_all_models
         get_model_classes.each do |klass|
-          puts "Indexing #{klass.to_s} model"
-          klass.all.each do |model_instance|
-            model_instance.update_tank_indexes
-          end
+          klass.tanker_reindex
         end
       end
     end

data/lib/tanker.rb

@@ -1,8 +1,12 @@
-require "rubygems"
-require "bundler"
 
-Bundler.setup :default
+begin
+  require "rubygems"
+  require "bundler"
 
+  Bundler.setup :default
+rescue => e
+  puts "Tanker: #{e.message}"
+end
 require 'indextank_client'
 require 'tanker/configuration'
 require 'tanker/utilities'
@@ -10,7 +14,10 @@ require 'will_paginate/collection'
 
 
 if defined? Rails
-  require 'tanker/railtie'
+  begin
+    require 'tanker/railtie'
+  rescue LoadError
+  end
 end
 
 module Tanker
@@ -33,8 +40,7 @@ module Tanker
       @included_in << klass
       @included_in.uniq!
 
-      klass.instance_variable_set('@tanker_configuration', configuration)
-      klass.instance_variable_set('@tanker_indexes', [])
+      configuration # raises error if not defined
       klass.send :include, InstanceMethods
       klass.extend ClassMethods
 
@@ -42,62 +48,177 @@ module Tanker
         define_method(:per_page) { 10 } unless respond_to?(:per_page)
       end
     end
+
+    def batch_update(records)
+      return false if records.empty?
+      data = records.map do |record|
+        options = record.tanker_index_options
+        options.merge!( :docid => record.it_doc_id, :fields => record.tanker_index_data )
+        options
+      end
+      records.first.class.tanker_index.add_documents(data)
+    end
+
+    def search(models, query, options = {})
+      ids      = []
+      models   = [models].flatten.uniq
+      page     = (options.delete(:page) || 1).to_i
+      per_page = (options.delete(:per_page) || models.first.per_page).to_i
+      index    = models.first.tanker_index
+      query    = query.join(' ') if Array === query
+
+      if (index_names = models.map(&:tanker_config).map(&:index_name).uniq).size > 1
+        raise "You can't search across multiple indexes in one call (#{index_names.inspect})"
+      end
+
+
+      # move conditions into the query body
+      if conditions = options.delete(:conditions)
+        conditions.each do |field, value|
+          value = [value].flatten.compact
+          value.each do |item|
+            query += " #{field}:(#{item})"
+          end
+        end
+      end
+
+      # rephrase filter_functions
+      if filter_functions = options.delete(:filter_functions)
+        filter_functions.each do |function_number, ranges|
+          options[:"filter_function#{function_number}"] = ranges.map{|r|r.join(':')}.join(',')
+        end
+      end
+
+      # rephrase filter_docvars
+      if filter_docvars = options.delete(:filter_docvars)
+        filter_docvars.each do |var_number, ranges|
+          options[:"filter_docvar#{var_number}"] = ranges.map{|r|r.join(':')}.join(',')
+        end
+      end
+
+      query = "__any:(#{query.to_s}) __type:(#{models.map(&:name).join(' OR ')})"
+      options = { :start => per_page * (page - 1), :len => per_page }.merge(options)
+      results = index.search(query, options)
+
+      @entries = WillPaginate::Collection.create(page, per_page) do |pager|
+        # inject the result array into the paginated collection:
+        pager.replace instantiate_results(results)
+
+        unless pager.total_entries
+          # the pager didn't manage to guess the total count, do it manually
+          pager.total_entries = results["matches"]
+        end
+      end
+    end
+
+    protected
+
+      def instantiate_results(index_result)
+        results = index_result['results']
+        return [] if results.empty?
+
+        id_map = results.inject({}) do |acc, result|
+          model, id = result["docid"].split(" ", 2)
+          acc[model] ||= []
+          acc[model] << id.to_i
+          acc
+        end
+
+        if 1 == id_map.size # check for simple case, just one model involved
+          klass = constantize(id_map.keys.first)
+          # eager-load and return just this model's records
+          klass.find(id_map.values.flatten)
+        else # complex case, multiple models involved
+          id_map.each do |klass, ids|
+            # replace the id list with an eager-loaded list of records for this model
+            id_map[klass] = constantize(klass).find(ids)
+          end
+          # return them in order
+          results.map do |result|
+            model, id = result["docid"].split(" ", 2)
+            id_map[model].detect {|record| id.to_i == record.id }
+          end
+        end
+      end
+
+      def constantize(klass_name)
+        Object.const_defined?(klass_name) ?
+                  Object.const_get(klass_name) :
+                  Object.const_missing(klass_name)
+      end
   end
 
   # these are the class methods added when Tanker is included
+  # They're kept to a minimum to prevent namespace pollution
   module ClassMethods
 
-    attr_reader :tanker_indexes, :index_name
+    attr_accessor :tanker_config
 
     def tankit(name, &block)
       if block_given?
-        @index_name = name
-        self.instance_exec(&block)
+        self.tanker_config = ModelConfig.new(name, block)
       else
         raise(NoBlockGiven, 'Please provide a block')
       end
     end
 
-    def indexes(field)
-      @tanker_indexes << field
+    def search_tank(query, options = {})
+      Tanker.search([self], query, options)
     end
 
-    def index
-      @index ||= Tanker.api.get_index(self.index_name)
+    def tanker_index
+      tanker_config.index
     end
 
-    def search_tank(query, options = {})
-      ids      = []
-      page     = options.delete(:page) || 1
-      per_page = options.delete(:per_page) || self.per_page
+    def tanker_reindex(options = {})
+      puts "Indexing #{self} model"
 
-      # transform fields in query
-      if options.has_key? :conditions
-        options[:conditions].each do |field,value|
-          query += " #{field}:(#{value})"
-        end
-      end
+      batches = []
+      options[:batch_size] ||= 200
+      records = options[:scope] ? send(options[:scope]).all : all
+      record_size = records.size
 
-      query = "__any:(#{query.to_s}) __type:#{self.name}"
-      options = { :start => per_page * (page - 1), :len => per_page }.merge(options)
-      results = index.search(query, options)
+      records.each_with_index do |model_instance, idx|
+        batch_num = idx / options[:batch_size]
+        (batches[batch_num] ||= []) << model_instance
+      end
 
-      ids = unless results["results"].empty?
-        results["results"].map{|res| res["docid"].split(" ", 2)[1]}
-      else
-        []
+      timer = Time.now
+      batches.each_with_index do |batch, idx|
+        Tanker.batch_update(batch)
+        puts "Indexed #{batch.size} records   #{(idx * options[:batch_size]) + batch.size}/#{record_size}"
       end
+      puts "Indexed #{record_size} #{self} records in #{Time.now - timer} seconds"
+    end
+  end
 
-      @entries = WillPaginate::Collection.create(page, per_page) do |pager|
-        result = self.find(ids)
-        # inject the result array into the paginated collection:
-        pager.replace(result)
+  class ModelConfig
+    attr_reader :index_name
 
-        unless pager.total_entries
-          # the pager didn't manage to guess the total count, do it manually
-          pager.total_entries = results["matches"]
-        end
-      end
+    def initialize(index_name, block)
+      @index_name = index_name
+      @indexes    = []
+      @functions  = {}
+      instance_exec &block
+    end
+
+    def indexes(field = nil, &block)
+      @indexes << [field, block] if field
+      @indexes
+    end
+
+    def variables(&block)
+      @variables = block if block
+      @variables
+    end
+
+    def functions(&block)
+      @functions = block.call if block
+      @functions
+    end
+
+    def index
+      @index ||= Tanker.api.get_index(index_name)
     end
 
   end
@@ -105,28 +226,58 @@ module Tanker
   # these are the instance methods included
   module InstanceMethods
 
+    def tanker_config
+      self.class.tanker_config || raise(NotConfigured, "Please configure Tanker for #{self.class.inspect} with the 'tankit' block")
+    end
+
     def tanker_indexes
-      self.class.tanker_indexes
+      tanker_config.indexes
+    end
+
+    def tanker_variables
+      tanker_config.variables
     end
 
     # update a create instance from index tank
     def update_tank_indexes
+      tanker_config.index.add_document(
+        it_doc_id, tanker_index_data, tanker_index_options
+      )
+    end
+
+    # delete instance from index tank
+    def delete_tank_indexes
+      tanker_config.index.delete_document(it_doc_id)
+    end
+
+    def tanker_index_data
       data = {}
 
-      tanker_indexes.each do |field|
-        val = self.instance_eval(field.to_s)
-        data[field.to_s] = val.to_s unless val.nil?
+      # attempt to autodetect timestamp
+      if respond_to?(:created_at)
+        data[:timestamp] = created_at.to_i
       end
 
-      data[:__any] = data.values.join " . "
+      tanker_indexes.each do |field, block|
+        val = block ? instance_exec(&block) : send(field)
+        val = val.join(' ') if Array === val
+        data[field.to_sym] = val.to_s unless val.nil?
+      end
+
+      data[:__any] = data.values.sort_by{|v| v.to_s}.join " . "
       data[:__type] = self.class.name
 
-      self.class.index.add_document(it_doc_id, data)
+      data
     end
 
-    # delete instance from index tank
-    def delete_tank_indexes
-      self.class.index.delete_document(it_doc_id)
+    def tanker_index_options
+      options = {}
+
+      if tanker_variables
+        options[:variables] = instance_exec(&tanker_variables)
+      end
+
+      options
     end
 
     # create a unique index based on the model name and unique id
@@ -134,4 +285,4 @@ module Tanker
       self.class.name + ' ' + self.id.to_s
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -16,28 +16,45 @@ class Dummy
 
 end
 
+$frozen_moment = Time.now
+
 class Person
+
+  attr_accessor :name, :last_name
+
+  def initialize(attrs = {})
+    attrs.each {|k,v| self.send "#{k}=", v }
+    self.name ||= 'paco'
+    self.last_name ||= 'viramontes'
+  end
+
   include Tanker
 
   tankit 'people' do
     indexes :name
     indexes :last_name
+    variables do
+      {0 => 1.0,
+       1 => 20.0,
+       2 => 300.0}
+    end
   end
 
-  def id
-    1
+  def created_at
+    $frozen_moment
   end
 
-  def name
-    'paco'
-  end
-
-  def last_name
-    'viramontes'
+  def id
+    1
   end
 end
 
 class Dog
+  attr_accessor :name, :id
+  def initialize(attrs = {})
+    attrs.each {|k,v| self.send "#{k}=", v }
+  end
+
   include Tanker
 
   tankit 'animals' do
@@ -47,6 +64,11 @@ class Dog
 end
 
 class Cat
+  attr_accessor :name, :id
+  def initialize(attrs = {})
+    attrs.each {|k,v| self.send "#{k}=", v }
+  end
+
   include Tanker
 
   tankit 'animals' do

data/spec/tanker_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
 describe Tanker do
 
@@ -33,7 +33,20 @@ describe Tanker do
     end
 
     dummy_instance = Dummy.new
-    dummy_instance.tanker_indexes.include?(:field).should == true
+    dummy_instance.tanker_config.indexes.any? {|field, block| field == :field }.should == true
+  end
+
+  it 'should allow blocks for indexable field data' do
+    Tanker.configuration = {:url => 'http://api.indextank.com'}
+    Dummy.send(:include, Tanker)
+    Dummy.send(:tankit, 'dummy index') do
+      indexes :class_name do
+        self.class.name
+      end
+    end
+
+    dummy_instance = Dummy.new
+    dummy_instance.tanker_config.indexes.any? {|field, block| field == :class_name }.should == true
   end
 
   describe 'tanker instance' do
@@ -42,11 +55,11 @@ describe Tanker do
     end
 
     it 'should create a connexion to index tank' do
-      Person.index.class.should == IndexTank::IndexClient
+      Person.tanker_index.class.should == IndexTank::IndexClient
     end
 
-    it 'should be able to perform a seach query' do
-      Person.index.should_receive(:search).and_return(
+    it 'should be able to perform a seach query directly on the model' do
+      Person.tanker_index.should_receive(:search).and_return(
         {
           "matches" => 1,
           "results" => [{
@@ -69,18 +82,129 @@ describe Tanker do
       collection.current_page.should == 1
     end
 
+    it 'should be able to use multi-value query phrases' do
+      Person.tanker_index.should_receive(:search).with(
+        "__any:(hey! location_id:(1) location_id:(2)) __type:(Person)",
+        {:start => 0, :len => 10}
+      ).and_return({'results' => [], 'matches' => 0})
+
+      collection = Person.search_tank('hey!', :conditions => {:location_id => [1,2]})
+    end
+
+    it 'should be able to use filter_functions' do
+      Person.tanker_index.should_receive(:search).with(
+        "__any:(hey!) __type:(Person)",
+        { :start => 0,
+          :len => 10,
+          :filter_function2 => "0:10,20:40"
+        }
+      ).and_return({'results' => [], 'matches' => 0})
+
+      collection = Person.search_tank('hey!',
+                                      :filter_functions => {
+                                        2 => [[0,10], [20,40]]
+                                      })
+    end
+    it 'should be able to use filter_docvars' do
+      Person.tanker_index.should_receive(:search).with(
+        "__any:(hey!) __type:(Person)",
+        { :start => 0,
+          :len => 10,
+          :filter_docvar3 => "*:7,80:100"
+        }
+      ).and_return({'results' => [], 'matches' => 0})
+
+      collection = Person.search_tank('hey!',
+                                      :filter_docvars => {
+                                        3 => [['*',7], [80,100]]
+                                      })
+    end
+
+    it 'should be able to perform a seach query over several models' do
+      index = Tanker.api.get_index('animals')
+      Dog.should_receive(:tanker_index).and_return(index)
+      index.should_receive(:search).and_return(
+        {
+          "matches" => 2,
+          "results" => [{
+            "docid" => 'Dog 7',
+            "name"  => 'fido'
+          },
+          {
+            "docid" => 'Cat 9',
+            "name"  => 'fluffy'
+          }],
+          "search_time" => 1
+        }
+      )
+
+      Dog.should_receive(:find).and_return(
+        [Dog.new(:name => 'fido', :id => 7)]
+      )
+      Cat.should_receive(:find).and_return(
+        [Cat.new(:name => 'fluffy', :id => 9)]
+      )
+
+      collection = Tanker.search([Dog, Cat], 'hey!')
+      collection.class.should == WillPaginate::Collection
+      collection.total_entries.should == 2
+      collection.total_pages.should == 1
+      collection.per_page.should == 10
+      collection.current_page.should == 1
+    end
+
     it 'should be able to update the index' do
-      person = Person.new
+      person = Person.new(:name => 'Name', :last_name => 'Last Name')
 
-      Person.index.should_receive(:add_document)
+      Person.tanker_index.should_receive(:add_document).with(
+        Person.new.it_doc_id,
+        {
+          :__any     => "#{$frozen_moment.to_i} . Last Name . Name",
+          :__type    => 'Person',
+          :name      => 'Name',
+          :last_name => 'Last Name',
+          :timestamp => $frozen_moment.to_i
+        },
+        {
+          :variables => {
+            0 => 1.0,
+            1 => 20.0,
+            2 => 300.0
+          }
+        }
+      )
 
       person.update_tank_indexes
     end
 
-    it 'should be able to delete de document from the index' do
+    it 'should be able to batch update the index' do
+      person = Person.new(:name => 'Name', :last_name => 'Last Name')
+
+      Person.tanker_index.should_receive(:add_documents).with(
+        [ {
+            :docid => Person.new.it_doc_id,
+            :fields => {
+              :__any     => "#{$frozen_moment.to_i} . Last Name . Name",
+              :__type    => 'Person',
+              :name      => 'Name',
+              :last_name => 'Last Name',
+              :timestamp => $frozen_moment.to_i
+            },
+            :variables => {
+              0 => 1.0,
+              1 => 20.0,
+              2 => 300.0
+            }
+        } ]
+      )
+
+      Tanker.batch_update([person])
+    end
+
+    it 'should be able to delete the document from the index' do
       person = Person.new
 
-      Person.index.should_receive(:delete_document)
+      Person.tanker_index.should_receive(:delete_document)
 
       person.delete_tank_indexes
     end

data/spec/utilities_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
 class Dummy
   include Tanker

data/tanker.gemspec

@@ -1,65 +1,62 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{tanker}
-  s.version = "0.5.6"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["@kidpollo"]
-  s.date = %q{2011-02-02}
+  s.authors = ["@kidpollo", "Jack Danger Canty"]
+  s.date = %q{2011-04-02}
   s.description = %q{IndexTank is a great search indexing service, this gem tries to make any orm keep in sync with indextank with ease}
   s.email = %q{kidpollo@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc"
   ]
   s.files = [
     ".document",
-     ".gitignore",
-     "Gemfile",
-     "Gemfile.lock",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "autotest/discover.rb",
-     "lib/indextank_client.rb",
-     "lib/tanker.rb",
-     "lib/tanker/configuration.rb",
-     "lib/tanker/railtie.rb",
-     "lib/tanker/tasks/tanker.rake",
-     "lib/tanker/utilities.rb",
-     "spec/spec_helper.rb",
-     "spec/tanker_spec.rb",
-     "spec/utilities_spec.rb",
-     "tanker.gemspec"
+    "Gemfile",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "autotest/discover.rb",
+    "lib/indextank_client.rb",
+    "lib/tanker.rb",
+    "lib/tanker/configuration.rb",
+    "lib/tanker/railtie.rb",
+    "lib/tanker/tasks/tanker.rake",
+    "lib/tanker/utilities.rb",
+    "spec/spec_helper.rb",
+    "spec/tanker_spec.rb",
+    "spec/utilities_spec.rb",
+    "tanker.gemspec"
   ]
   s.homepage = %q{http://github.com/kidpollo/tanker}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{1.7.1}
   s.summary = %q{IndexTank integration to your favorite orm}
   s.test_files = [
     "spec/spec_helper.rb",
-     "spec/tanker_spec.rb",
-     "spec/utilities_spec.rb"
+    "spec/tanker_spec.rb",
+    "spec/utilities_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
       s.add_runtime_dependency(%q<will_paginate>, [">= 2.3.15"])
     else
-      s.add_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<will_paginate>, [">= 2.3.15"])
     end
   else
-    s.add_dependency(%q<rspec>, [">= 2.0.0.beta.22"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<will_paginate>, [">= 2.3.15"])
   end
 end

metadata

@@ -1,56 +1,39 @@
 --- !ruby/object:Gem::Specification 
 name: tanker
 version: !ruby/object:Gem::Version 
-  hash: 7
   prerelease: 
-  segments: 
-  - 0
-  - 5
-  - 6
-  version: 0.5.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - "@kidpollo"
+- Jack Danger Canty
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-02 00:00:00 -08:00
-default_executable: 
+date: 2011-04-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
+  name: jeweler
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 62196431
-        segments: 
-        - 2
-        - 0
-        - 0
-        - beta
-        - 22
-        version: 2.0.0.beta.22
-  type: :development
+        version: "0"
+  type: :runtime
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: will_paginate
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 29
-        segments: 
-        - 2
-        - 3
-        - 15
         version: 2.3.15
   type: :runtime
+  prerelease: false
   version_requirements: *id002
 description: IndexTank is a great search indexing service, this gem tries to make any orm keep in sync with indextank with ease
 email: kidpollo@gmail.com
@@ -63,9 +46,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -81,13 +62,12 @@ files:
 - spec/tanker_spec.rb
 - spec/utilities_spec.rb
 - tanker.gemspec
-has_rdoc: true
 homepage: http://github.com/kidpollo/tanker
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -95,23 +75,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.7.1
 signing_key: 
 specification_version: 3
 summary: IndexTank integration to your favorite orm

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/Gemfile.lock

@@ -1,32 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.1.2)
-    gemcutter (0.6.1)
-    git (1.2.5)
-    jeweler (1.4.0)
-      gemcutter (>= 0.1.0)
-      git (>= 1.2.5)
-      rubyforge (>= 2.0.0)
-    json_pure (1.4.6)
-    rspec (2.0.0.beta.22)
-      rspec-core (= 2.0.0.beta.22)
-      rspec-expectations (= 2.0.0.beta.22)
-      rspec-mocks (= 2.0.0.beta.22)
-    rspec-core (2.0.0.beta.22)
-    rspec-expectations (2.0.0.beta.22)
-      diff-lcs (>= 1.1.2)
-    rspec-mocks (2.0.0.beta.22)
-      rspec-core (= 2.0.0.beta.22)
-      rspec-expectations (= 2.0.0.beta.22)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
-    will_paginate (2.3.15)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  jeweler
-  rspec (>= 2.0.0.beta.22)
-  will_paginate (>= 2.3.15)