index-tanked 0.6.0 → 0.7.0

data/Rakefile

@@ -13,10 +13,22 @@ task :default => :test
 require 'rdoc/task'
 
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "foo #{version}"
+  rdoc.title = "index-tanked"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
+end

data/lib/index-tanked.rb

@@ -8,7 +8,7 @@ module IndexTanked
   end
 end
 
-require 'indextank'
+require 'index-tanked/indextank/indextank'
 require 'will_paginate/collection'
 require 'active_record'
 

data/lib/index-tanked/active_record_defaults/queue/worker.rb

@@ -65,7 +65,7 @@ module IndexTanked
             begin
               this_batch = partitioned_documents[companion_key]
               Queue::Document.index_tanked(companion_key).index.batch_insert(this_batch)
-            rescue IndexTank::InvalidArgument => e
+            rescue IndexTanked::IndexTank::InvalidArgument => e
               bad_document_number = e.message.scan(/in document #(\d+) of \d+/).flatten.first
               bad_document_number = bad_document_number && (bad_document_number.to_i - 1)
               if bad_document_number

data/lib/index-tanked/class_companion.rb

@@ -36,7 +36,7 @@ module IndexTanked
 
     def api_client
       return nil if @index_tank_url.nil?
-      @api_client ||= (IndexTank::Client.new @index_tank_url)
+      @api_client ||= (IndexTanked::IndexTank::Client.new @index_tank_url)
     end
 
     def get_value_from(instance, method)

data/lib/index-tanked/indextank/client.rb

@@ -0,0 +1,55 @@
+require 'index-tanked/indextank/index'
+require 'uri'
+
+module IndexTanked
+  module IndexTank
+    class Client
+      attr_reader :uri
+
+      def initialize(api_url)
+        @uri = api_url
+        @conn = IndexTanked::IndexTank.setup_connection(api_url) do |faraday|
+          faraday.use ClientResponseMiddleware
+        end
+      end
+
+      def indexes(name = nil)
+        if name.nil?
+          list_indexes
+        else
+          get_index(name)
+        end
+      end
+
+      private
+      def list_indexes
+        indexes = Hash.new
+
+        @conn.get("/v1/indexes").body.each do |name, metadata|
+          indexes[name] = Index.new("#{@uri}/v1/indexes/#{name}", metadata)
+        end
+
+        indexes
+      end
+
+      def get_index(name)
+        Index.new("#{@uri}/v1/indexes/#{name}")
+      end
+    end
+
+    class ClientResponseMiddleware < FaradayMiddleware::ResponseMiddleware
+      def process_response(env)
+        case env[:status]
+        when 200
+          nil # this is the expected return code
+        when 204
+          nil # this is the expected return code for empty responses
+        when 401
+          raise InvalidApiKey
+        else
+          raise UnexpectedHTTPException, env[:body]
+        end
+      end
+    end
+  end
+end

data/lib/index-tanked/indextank/document.rb

@@ -0,0 +1,89 @@
+require 'yajl/json_gem'
+require 'faraday'
+
+module IndexTanked
+  module IndexTank
+    class Document
+      attr_reader :docid
+
+      # :docid => a String or Symbol, that is no longer than 1024 bytes when UTF-8 encoded
+      def initialize(document_url, docid)
+        raise InvalidArgument , "docid too long. max is 1024 bytes and got #{String(docid).bytesize}" unless String(docid).bytesize <= 1024
+        @docid = docid
+        @conn = IndexTanked::IndexTank.setup_connection(document_url) do |faraday|
+          faraday.use DocumentResponseMiddleware
+        end
+      end
+
+      # the options argument may contain a :variables key
+      # with a Hash from variable numbers to their float values
+      # this variables can be used in the scoring functions
+      # when sorting a search
+      def add(fields, options = {})
+        options.merge!(:docid => self.docid, :fields => fields)
+
+        resp = @conn.put do |req|
+          req.url ""
+          req.body = options.to_json
+        end
+
+        resp.status
+      end
+
+      def delete(options = {})
+        options.merge!(:docid => self.docid)
+        resp = @conn.delete do |req|
+          req.url ""
+          req.body = options.to_json
+        end
+
+        resp.status 
+      end
+
+      def update_variables(variables, options = {})
+        options.merge!(:docid => self.docid, :variables => variables)
+        resp = @conn.put do |req|
+          req.url "variables"
+          req.body = options.to_json
+        end
+
+        resp.status
+      end
+
+      # updates the categories of a given document
+      # the categories argument should be a Hash from string
+      # to string defining the value for each category defined
+      # by this document.
+      def update_categories(categories, options = {} )
+        options.merge!(:docid => self.docid, :categories => categories)
+        resp = @conn.put do |req|
+          req.url "categories"
+          req.body = options.to_json
+        end
+
+        resp.status 
+      end
+    end
+
+    class DocumentResponseMiddleware < FaradayMiddleware::ResponseMiddleware
+      def process_response(env)
+        case env[:status]
+        when 200
+          nil # this is the expected code
+        when 204
+          nil # this is another expected code, for empty responses
+        when 401
+          raise InvalidApiKey
+        when 409
+          raise IndexInitializing
+        when 404
+          raise NonExistentIndex
+        when 400
+          raise InvalidArgument, env[:body]
+        else
+          raise UnexpectedHTTPException, env[:body]
+        end
+      end
+    end
+  end
+end

data/lib/index-tanked/indextank/exceptions.rb

@@ -0,0 +1,13 @@
+module IndexTanked
+  module IndexTank
+    class IndexAlreadyExists < StandardError; end
+    class NonExistentIndex < StandardError; end
+    class TooManyIndexes < StandardError; end
+    class MissingFunctionDefinition < StandardError; end
+    class InvalidApiKey < StandardError; end
+    class InvalidQuery < StandardError; end
+    class IndexInitializing < StandardError; end
+    class InvalidArgument < StandardError; end
+    class UnexpectedHTTPException < StandardError; end
+  end
+end

data/lib/index-tanked/indextank/function.rb

@@ -0,0 +1,46 @@
+require 'yajl/json_gem'
+
+module IndexTanked
+  module IndexTank
+    class Function
+      attr_reader :uri, :index, :definition
+
+      def initialize(function_url, index, definition)
+        @uri        = "#{function_url}/#{index}"
+        @index      = index
+        @definition = definition
+        @conn = IndexTanked::IndexTank.setup_connection(@uri) do |faraday|
+          # Function and Document have the same Response statuses
+          faraday.use IndexTanked::IndexTank::DocumentResponseMiddleware
+        end
+      end
+
+      def add(options = {})
+        raise MissingFunctionDefinition unless self.definition
+
+        options.merge!(:definition => self.definition)
+        response = @conn.put do |req|
+          req.url ''
+          req.body = options.to_json
+        end
+
+        true
+      end
+
+      def delete(options = {})
+        resp = @conn.delete do |req|
+          req.url ''
+          req.body = options.to_json
+        end
+
+        true
+      end
+
+      def ==(other)
+        self.uri == other.uri and
+          self.index == other.index
+          self.definition == other.definition
+      end
+    end
+  end
+end

data/lib/index-tanked/indextank/index.rb

@@ -0,0 +1,341 @@
+require 'index-tanked/indextank/exceptions'
+require 'index-tanked/indextank/document'
+require 'index-tanked/indextank/function'
+require 'yajl/json_gem'
+
+module IndexTanked
+  module IndexTank
+    class Index
+      def initialize(index_url, metadata = nil)
+        @uri      = index_url
+        @conn     = IndexTanked::IndexTank.setup_connection(index_url)
+        @metadata = metadata
+      end
+
+      def add( options = {} )
+
+        if self.exists?
+          raise IndexAlreadyExists
+        end
+
+        response = @conn.put do |req|
+          req.url ""
+          req.body = options.to_json unless options.length == 0
+        end
+        case response.status
+        when 201
+          true
+        when 409
+          raise TooManyIndexes
+        when 401 
+          raise InvalidApiKey 
+        end
+      end
+
+      def update( options )
+
+        if not self.exists?
+          raise NonExistentIndex
+        end
+      
+        response = @conn.put do |req|
+          req.url ""
+          req.body = options.to_json
+        end
+        case response.status
+        when 204
+          true
+        when 401 
+          raise InvalidApiKey 
+        end
+      end
+
+      def refresh
+        response = @conn.get('')
+        if response.status == 200
+          @metadata = response.body
+        end
+
+        response
+      end
+
+      def delete
+        response = @conn.delete('')
+        case response.status
+        when 204
+          raise NonExistentIndex
+        end
+      end
+
+      def running?
+        refresh
+        @metadata['started']
+      end
+
+      def method_missing(sym, *args, &block)
+        refresh if @metadata.nil?
+        @metadata[sym.to_s]
+      end
+
+      def exists?
+        refresh.status != 404
+      end
+
+      def public_search_enabled?
+        refresh
+        @metadata['public_search']
+      end
+
+      def batch_insert(documents)
+        resp = @conn.put do |req|
+          req.url "docs"
+          req.body = documents.to_json
+        end
+        case resp.status
+        when 200
+          resp.body
+        when 401
+          raise InvalidApiKey
+        when 409
+          raise IndexInitializing
+        when 404
+          raise NonExistentIndex
+        when 400
+          raise InvalidArgument, resp.body
+        else
+          raise UnexpectedHTTPException, resp.body
+        end
+      end
+
+      def bulk_delete(docids)
+        data = []
+        docids.each do |docid|
+          data << {'docid' => docid}
+        end
+        resp = @conn.delete do |req|
+          req.url "docs"
+          req.body = data.to_json
+        end
+        case resp.status
+        when 200
+          resp.body
+        when 401
+          raise InvalidApiKey
+        when 409
+          raise IndexInitializing
+        when 404
+          raise NonExistentIndex
+        when 400
+          raise InvalidArgument, resp.body
+        else
+          raise UnexpectedHTTPException, resp.body
+        end
+      end
+
+      # the options argument may contain an :index_code definition to override 
+      # this instance's default index_code
+      # it can also contain any of the following:
+      #   :start => an int with the number of results to skip
+      #   :len => an int with the number of results to return
+      #   :snippet => a comma separated list of field names for which a snippet
+      #               should be returned. (requires an index that supports snippets)
+      #   :fetch => a comma separated list of field names for which its content
+      #             should be returned. (requires an index that supports storage)
+      #   :function => an int with the index of the scoring function to be used
+      #                for this query
+      #   :variables => a hash int => float, with variables that can be later
+      #                 used in scoring :function
+      #   :category_filters => a hash to filter the query based on document categories. Keys represent category names.
+      #                       see http://indextank.com/documentation/ruby-client#faceting
+      #
+      #                       Example:
+      #                         category_filters => {:size => "big", :price => "expensive"}
+      #                         means that only documents that have "big" as size category and "expensive" as price category
+      #                         will match the query
+      #   :docvar_filters =>  a hash with int keys and Array values to filter the query based on document variables.
+      #                       see http://indextank.com/documentation/ruby-client#range_queries
+      #
+      #                       Example: 
+      #                           docvar_filters = { 1 => [ [2, 3], [5, nil] ]} 
+      #                           means that only documents with document variable number 1 between 2 and 3 or bigger than 5
+      #                           will match the query.
+      #   :function_filters => a hash with int keys and Array values to filter the query based on scoring functions.
+      #                       see http://indextank.com/documentation/ruby-client#range_queries
+      #
+      #                       Example: 
+      #                           function_filters = { 3 => [ [nil, 2], [5, 7], [8,14] ]} 
+      #                           means that only documents whose score calculated by scoring function 3 is lower than 2,
+      #                           between 5 and 7 or between 8 and 14 will match the query.
+      def search(query, options = {})
+        options = {:start => 0, :len => 10 }.merge(options).merge(:q => query)
+        if options[:variables]
+          options[:variables].each_pair { |k, v| options.merge!( :"var#{k}" => v ) }
+          options.delete :variables
+        end
+
+        if options[:docvar_filters]
+          # go from { 3 => [ [1, 3], [5, nil] ]} to filter_docvar3 => 1:3,5:*
+          options[:docvar_filters].each_pair { |k, v| 
+                                                rng = v.map { |val|
+                                                  raise ArgumentError, "using a range with bound count != 2"  unless val.length == 2
+                                                  "#{val[0] || '*'}:#{val[1] || '*'}"
+                                                }.join ","
+                                                options.merge!( :"filter_docvar#{k}" => rng ) 
+                                             }
+          options.delete :docvar_filters
+        end
+
+        if options[:function_filters]
+          # go from { 2 => [ [1 , 3],[5,8] ]} to filter_function2 => 1:3,5:8
+          options[:function_filters].each_pair { |k, v| 
+                                                rng = v.map { |val|
+                                                  raise ArgumentError, "using a range with bound count != 2"  unless val.length == 2
+                                                  "#{val[0] || '*'}:#{val[1] || '*'}"
+                                                }.join ","
+                                                options.merge!( :"filter_function#{k}" => rng ) 
+                                             }
+          options.delete :function_filters
+        end
+
+        if options[:category_filters]
+          options[:category_filters] = options[:category_filters].to_json
+        end
+
+        response = @conn.get do |req|
+          req.url 'search', options
+        end  
+        case response.status
+        when 400
+          raise InvalidQuery
+        when 404
+          raise NonExistentIndex
+        when 409
+          raise IndexInitializing
+        end
+
+        response.body
+      end
+
+      # the options argument may contain an :index_code definition to override 
+      # this instance's default index_code
+      # it can also contain any of the following:
+      #   :start => an int with the number of results to skip
+      #   :function => an int with the index of the scoring function to be used
+      #                for this query
+      #   :variables => a hash int => float, with variables that can be later
+      #                 used in scoring :function
+      #   :category_filters => a hash to filter the query based on document categories. Keys represent category names.
+      #                       see http://indextank.com/documentation/ruby-client#faceting
+      #
+      #                       Example:
+      #                         category_filters => {:size => "big", :price => "expensive"}
+      #                         means that only documents that have "big" as size category and "expensive" as price category
+      #                         will match the query
+      #   :docvar_filters =>  a hash with int keys and Array values to filter the query based on document variables.
+      #                       see http://indextank.com/documentation/ruby-client#range_queries
+      #
+      #                       Example: 
+      #                           docvar_filters = { 1 => [ [2, 3], [5, nil] ]} 
+      #                           means that only documents with document variable number 1 between 2 and 3 or bigger than 5
+      #                           will match the query.
+      #   :function_filters => a hash with int keys and Array values to filter the query based on scoring functions.
+      #                       see http://indextank.com/documentation/ruby-client#range_queries
+      #
+      #                       Example: 
+      #                           function_filters = { 3 => [ [nil, 2], [5, 7], [8,14] ]} 
+      #                           means that only documents whose score calculated by scoring function 3 is lower than 2,
+      #                           between 5 and 7 or between 8 and 14 will match the query.
+      def delete_by_search(query, options = {})
+        options = {:start => 0}.merge(options).merge(:q => query)
+        if options[:variables]
+          options[:variables].each_pair { |k, v| options.merge!( :"var#{k}" => v ) }
+          options.delete :variables
+        end
+
+        if options[:docvar_filters]
+          # go from { 3 => [ [1, 3], [5, nil] ]} to filter_docvar3 => 1:3,5:*
+          options[:docvar_filters].each_pair { |k, v| 
+                                                rng = v.map { |val|
+                                                  raise ArgumentError, "using a range with bound count != 2"  unless val.length == 2
+                                                  "#{val[0] || '*'}:#{val[1] || '*'}"
+                                                }.join ","
+                                                options.merge!( :"filter_docvar#{k}" => rng ) 
+                                             }
+          options.delete :docvar_filters
+        end
+
+        if options[:function_filters]
+          # go from { 2 => [ [1 , 3],[5,8] ]} to filter_function2 => 1:3,5:8
+          options[:function_filters].each_pair { |k, v| 
+                                                rng = v.map { |val|
+                                                  raise ArgumentError, "using a range with bound count != 2"  unless val.length == 2
+                                                  "#{val[0] || '*'}:#{val[1] || '*'}"
+                                                }.join ","
+                                                options.merge!( :"filter_function#{k}" => rng ) 
+                                             }
+          options.delete :function_filters
+        end
+
+        if options[:category_filters]
+          options[:category_filters] = options[:category_filters].to_json
+        end
+
+        response = @conn.delete do |req|
+          req.url 'search', options
+        end  
+        case response.status
+        when 400
+          raise InvalidQuery
+        when 404
+          raise NonExistentIndex
+        when 409
+          raise IndexInitializing
+        end
+
+        response.body
+      end
+
+      def suggest(query, options = {})
+        options.merge!({:query => query})
+        @conn.get do |req|
+          req.url 'autocomplete', options
+        end.body
+      end
+
+      # the options argument may contain an :index_code definition to override 
+      # this instance's default index_code  
+      def promote(docid, query, options={})
+        options.merge!( :docid => docid, :query => query )
+        resp = @conn.put do |req|
+          req.url 'promote'
+          req.body = options.to_json
+        end
+      
+        case resp.status
+        when 409
+          raise IndexInitializing
+        when 404
+          raise NonExistentIndex
+        when 400
+          raise InvalidArgument, resp.body
+        end
+      end
+
+      # creates a new document, identified by :docid
+      # :docid => a String or Symbol, with bytesize no longer than 1024 bytes
+      def document(docid)
+        Document.new("#{@uri}/docs", docid)
+      end
+
+      def functions(index = -1, formula = nil)
+        if index == -1
+          @conn.get("functions").body.sort.collect do |index, formula|
+            Function.new("#{@uri}/functions", index, formula)
+          end
+        else
+          Function.new("#{@uri}/functions", index, formula)
+        end
+      end
+    end
+  end
+end

data/lib/index-tanked/indextank/indextank.rb

@@ -0,0 +1,24 @@
+require 'faraday_middleware'
+require 'faraday_middleware/response_middleware'
+require 'uri'
+
+require 'index-tanked/indextank/client'
+
+module IndexTanked
+  module IndexTank
+    VERSION = "1.0.12"
+
+    def self.setup_connection(url)
+      ## in Faraday 0.8 or above:
+      @conn = Faraday.new(url) do |conn|
+        conn.response :json
+        yield conn if block_given?
+        conn.adapter Faraday.default_adapter
+      end
+      @uri = URI.parse(url)
+      @conn.basic_auth @uri.user,@uri.password
+      @conn.headers['User-Agent'] = "IndexTanked::IndexTank-Ruby/#{VERSION}"
+      @conn
+    end
+  end
+end

data/lib/index-tanked/search_result.rb

@@ -46,7 +46,7 @@ module IndexTanked
       @results ||= WillPaginate::Collection.create(@page, @per_page) do |pager|
         begin
           raise SearchingDisabledError, "index tank search is disabled in configuration" unless IndexTanked::Configuration.search_available?
-          raise IndexTanked::SearchError, "No or invalid index has been provided" unless @index.is_a? IndexTank::Index
+          raise IndexTanked::SearchError, "No or invalid index has been provided" unless @index.is_a? IndexTanked::IndexTank::Index
           raise IndexTanked::SearchError, "No query provided" if @query.nil?
           search_timeout = if IndexTanked::Configuration.search_timeout.is_a?(Proc)
             IndexTanked::Configuration.search_timeout.call

data/lib/index-tanked/version.rb

@@ -1,3 +1,3 @@
 module IndexTanked
-  GEM_VERSION = '0.6.0'
+  GEM_VERSION = '0.7.0'
 end

metadata

@@ -1,67 +1,69 @@
 --- !ruby/object:Gem::Specification 
 name: index-tanked
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Adam Kittelson
 - Brandon Arbini
+- Nathan Sutton
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-11-20 00:00:00 Z
+date: 2013-02-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: indextank
+  name: will_paginate
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 5
         segments: 
-        - 1
-        - 0
-        - 12
-        version: 1.0.12
+        - 2
+        - 3
+        version: "2.3"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: will_paginate
+  name: faraday_middleware
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 59
         segments: 
-        - 3
         - 0
-        version: "3.0"
+        - 9
+        - 0
+        version: 0.9.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: yajl-ruby
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 19
         segments: 
-        - 3
-        - 2
-        version: "3.2"
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -70,14 +72,12 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 33
+        hash: 3
         segments: 
-        - 2
-        - 10
-        - 3
-        version: 2.10.3
+        - 0
+        version: "0"
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -86,14 +86,12 @@ dependencies:
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 3
         segments: 
         - 0
-        - 9
-        - 8
-        version: 0.9.8
+        version: "0"
   type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
@@ -111,9 +109,23 @@ dependencies:
   type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: sqlite3
+  name: activerecord
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        version: "3"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -123,11 +135,54 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id007
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id011
 description: Provides methods for indexing objects to Index Tank. Extra convenience methods included for Active Record objects.
 email: 
 - adam@zencoder.com
 - brandon@zencoder.com
+- nate@zencoder.com
 executables: []
 
 extensions: []
@@ -149,6 +204,12 @@ files:
 - lib/index-tanked/class_methods.rb
 - lib/index-tanked/configuration.rb
 - lib/index-tanked/index_tanked.rb
+- lib/index-tanked/indextank/client.rb
+- lib/index-tanked/indextank/document.rb
+- lib/index-tanked/indextank/exceptions.rb
+- lib/index-tanked/indextank/function.rb
+- lib/index-tanked/indextank/index.rb
+- lib/index-tanked/indextank/indextank.rb
 - lib/index-tanked/instance_companion.rb
 - lib/index-tanked/instance_methods.rb
 - lib/index-tanked/search_result.rb