thinkingtank 0.0.1

data/README

@@ -0,0 +1,67 @@
+ThinkingTank
+=============
+
+ActiveRecord extension that allows to define models that should be indexed 
+in an existing IndexTank index. It supports a very similar syntax to 
+ThinkingSphinx allowing to easily port an existing project.
+
+Every indexable model should include a define_index block in its class 
+definition, see the example for more details. This block supports the indexes
+ method and receives a field name.
+
+Model classes now have a search method that receives one or more string 
+arguments with query strings (according to the query specifications) and 
+supports the :conditions argument as a hash from field name to query string. 
+
+In order for this extension to work you need to define a config/indextank.yml
+in your application with the api_key and index_code (or index_name) settings 
+for each environment (similar to config/database.yml).
+
+Indexed fields in ActiveRecord are prepended an underscore when sent to 
+IndexTank so if you plan to write query strings that use your field names you 
+will have to prepend the underscore to the field names.
+
+In order for the ThinkingTank rake tasks to be available you need to add:
+
+    require 'thinkingtank/tasks'
+    
+to your Rakefile. You can use the following task to reindex your entire database:
+
+    rake indextank:reindex
+
+
+Example
+=======
+
+Sample config/indextank.yml file:
+
+        development:
+          api_key: '<YOUR API KEY>'
+          index_code: '<INDEX CODE>'
+          # instead of index_code you can also use an index_name
+        test:
+          api_key: '<YOUR API KEY>'
+          index_code: '<INDEX CODE>'
+          # instead of index_code you can also use an index_name
+        production:
+          api_key: '<YOUR API KEY>'
+          index_code: '<INDEX CODE>'
+          # instead of index_code you can also use an index_name
+
+Sample model:
+    class Person < ActiveRecord::Base
+        define_index do
+            indexes :name
+            indexes gender
+            indexes age
+        end
+    end
+
+Sample query code:
+    Person.search("john")
+    Person.search("john OR stacey")
+    Person.search("stacey", :conditions => { :age => 25 } )
+    Person.search("james", :conditions => { :age => 25 , :gender => "female" } )
+   
+
+Copyright(c) 2010 Flaptor Inc.

data/lib/indextank.rb

@@ -0,0 +1,150 @@
+require 'net/http'
+require 'uri'
+require 'rubygems'
+require 'json'
+
+BASE_URL = 'http://api.indextank.com/api/v0'
+class IndexTank
+    def initialize(api_key, options={})
+        @api_key = api_key
+        @def_index_code = options[:index_code]
+        @def_index_name = options[:index_name]
+    end
+
+    def create_index(index_name)
+        return api_call("admin/create", "index_code", :index_name => index_name)
+    end
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def delete_index(options={})
+        return api_call("admin/delete", nil, options)
+    end
+
+
+    def list_indexes()
+        return api_call("admin/list", "results")
+    end
+
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def add(doc_id, content, options={})
+        options.merge!(:document_id => doc_id, :document => content.to_json)
+        options[:boosts] = options[:boosts].to_json if options.key?(:boosts)             
+        return api_call("index/add", nil, options)
+    end
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def boost(doc_id, boosts, options={})
+        options.merge!(:document_id => doc_id, :boosts => boosts.to_json)
+        return api_call("index/boost", nil, options)
+    end
+
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def promote(doc_id, query, options={})
+        options.merge!(:document_id => doc_id, :query => query)
+        return api_call("index/promote", nil, options)
+    end
+
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def update(doc_id, content, options={})
+        options.merge!(:document_id => doc_id, :document => content.to_json)
+        return api_call("index/update", nil, options)
+    end
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def delete(doc_id, options={})
+        options.merge!(:document_id => doc_id)
+        return api_call("index/delete", nil, options)
+    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_fields => a comma separated list of field names for which a snippet
+    #                      should be returned. (requires an index that supports snippets)
+    #   :fetch_fields => a comma separated list of field names for which its content
+    #                    should be returned. (requires an index that supports storage)
+    #   :relevance_function => an int with the index of the relevance function to be used
+    #                          for this query 
+    def search(query, options={})
+        options = { :start => 0, :len => 10 }.merge(options)
+        options.merge!(:query => query)
+        return api_call("search/query", "results", options)
+    end
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def add_function(function_index, definition, options={})
+        options.merge!( :function_id => function_index, :definition => definition )
+        return api_call("index/add_function", nil, options)
+    end
+    
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def del_function(function_index, options={})
+        options.merge!( :function_id => function_index )
+        return api_call("index/remove_function", nil, options)
+    end
+    
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def list_functions(options={})
+        return api_call("index/list_functions", "results", options)
+    end
+
+       
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def index_stats(options={})
+        return api_call("index/stats", "results", options)
+    end
+
+
+    # the options argument may contain an :index_code definition to override 
+    # this instance's default index_code  
+    def search_stats(options={})
+        return api_call("search/stats", "results", options)
+    end
+
+    private
+
+    def base_url
+        return ENV['INDEXTANK_BASE_URL'] || BASE_URL
+    end
+
+    def api_call(method, return_key, params={})
+        params = { "api_key" => @api_key }.merge(params)
+        params = { :index_code => @def_index_code }.merge(params) unless @def_index_code.nil?
+        params = { :index_name => @def_index_name }.merge(params) unless @def_index_name.nil?
+        url = base_url + '/' + method
+        req = Net::HTTP::Post.new(url)
+        req.set_form_data(params, ';')
+        res = Net::HTTP.new(URI.parse(base_url).host).start {|http| http.request(req) }
+        if res.is_a? Net::HTTPOK
+            result = JSON.parse(res.body)
+            ok = result['status'] == 'OK'
+            return ok ? [ok, (return_key.nil? ? nil : result[return_key])] : [ok, result['message']]
+        elsif res.is_a? Net::HTTPForbidden
+            return false, "Access forbidden"
+        elsif res.is_a? Net::HTTPClientError
+            return false, "Unknown client error"
+        elsif res.is_a? Net::HTTPServerError
+            puts res.body
+            return false, "Unknown server error"
+        else
+            puts res.body
+            return false, "Unexpected response"
+        end
+    end
+
+end

data/lib/thinkingtank/init.rb

@@ -0,0 +1,105 @@
+require 'indextank'
+
+module ThinkingTank
+    class Builder
+        def initialize(model, &block)
+            @index_fields = []
+            self.instance_eval &block
+        end
+        def indexes(*args)
+            options = args.extract_options!
+            args.each do |field|
+                @index_fields << field
+            end
+        end
+        def index_fields
+            return @index_fields
+        end
+        def method_missing(method)
+            return method
+        end
+    end
+    class Configuration
+        include Singleton
+        attr_accessor :app_root, :client
+        def initialize
+            self.app_root = RAILS_ROOT if defined?(RAILS_ROOT)
+            self.app_root = Merb.root  if defined?(Merb)
+            self.app_root ||= Dir.pwd
+
+            path = "#{app_root}/config/indextank.yml"
+            return unless File.exists?(path)
+
+            conf = YAML::load(ERB.new(IO.read(path)).result)[environment]
+            self.client = IndexTank.new(conf['api_key'], :index_code => conf['index_code'], :index_name => conf['index_name'])
+        end
+        def environment
+            if defined?(Merb)
+                Merb.environment
+            elsif defined?(RAILS_ENV)
+                RAILS_ENV
+            else
+                ENV['RAILS_ENV'] || 'development'
+            end
+        end
+    end
+    
+    module IndexMethods
+        def update_index
+            it = ThinkingTank::Configuration.instance.client
+            docid = self.class.name + ' ' + self.id.to_s
+            data = {}
+            self.class.thinkingtank_builder.index_fields.each do |field|
+                val = self.instance_eval(field.to_s)
+                data["_" + field.to_s] = val.to_s unless val.nil?
+            end
+            data[:text] = data.values.join " . "
+            data[:type] = self.class.name
+            it.add(docid, data)
+        end
+    end
+
+end
+
+class << ActiveRecord::Base
+    @indexable = false
+    def search(*args)
+        options = args.extract_options!
+        query = args.join(' ')
+        if options.has_key? :conditions
+            options[:conditions].each do |field,value|
+                field = "_#{field}" # underscore prepended to ActiveRecord fields
+                query += " #{field}:(#{value})"
+            end
+        end
+        # TODO : add relevance functions
+
+        it = IndexTankPlugin::Configuration.instance.client
+        models = []
+        ok, res = it.search("#{query.to_s} type:#{self.name}")
+        if ok
+            res['docs'].each do |doc|
+                type, docid = doc['docid'].split(" ", 2)
+                models << self.find(id=docid)
+            end
+        end
+        return models
+    end
+
+    def define_index(name = nil, &block)
+        include ThinkingTank::IndexMethods
+        @thinkingtank_builder = ThinkingTank::Builder.new self, &block
+        @indexable = true
+        after_save :update_index
+    end
+
+    def is_indexable?
+        return @indexable
+    end
+
+    def thinkingtank_builder
+        return @thinkingtank_builder
+    end
+end
+
+

data/lib/thinkingtank/tasks.rb

@@ -0,0 +1,52 @@
+require 'erb'
+require 'active_record'
+
+def load_models
+    app_root = ThinkingTank::Configuration.instance.app_root
+    dirs = ["#{app_root}/app/models/"] + Dir.glob("#{app_root}/vendor/plugins/*/app/models/")
+    
+    dirs.each do |base|
+        Dir["#{base}**/*.rb"].each do |file|
+            model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
+
+            next if model_name.nil?
+            next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
+                model.name == model_name
+            }
+
+            begin
+                model_name.camelize.constantize
+            rescue LoadError
+                model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry
+            rescue NameError
+                next
+            rescue StandardError
+                STDERR.puts "Warning: Error loading #{file}"
+            end
+        end
+    end
+end
+
+def reindex_models
+    Object.subclasses_of(ActiveRecord::Base).each do |klass|
+        reindex klass if klass.is_indexable?
+    end
+end
+
+def reindex(klass)
+    klass.find(:all).each do |obj|
+        puts "re-indexing #{obj.class.name}:#{obj.id}"
+        obj.update_index
+    end
+end
+
+namespace :indextank do
+    task :reindex => :environment do
+        load_models
+        reindex_models
+    end
+end
+
+namespace :it do
+    task :reindex => "indextank:reindex"
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+# Include hook code here
+require 'active_record'
+require 'thinkingtank'
+

data/tasks/rails.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '/tasks')

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: thinkingtank
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Flaptor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: ActiveRecord extension that allows to define models that should be indexed in an existing IndexTank index. It supports a very similar syntax to ThinkingSphinx allowing to easily port an existing project.
+email: indextank@flaptor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rails/init.rb
+- lib/indextank.rb
+- lib/thinkingtank/init.rb
+- README
+- tasks/rails.rake
+- lib/thinkingtank/tasks.rb
+has_rdoc: false
+homepage: http://indextank.com/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Thinking-Sphinx-like Indextank plugin.
+test_files: []
+