tinia 0.0.3

data/lib/tinia/railtie.rb

@@ -0,0 +1,9 @@
+module Tinia
+  class Railtie < Rails::Railtie
+
+    initializer "tinia.activate" do
+      Tinia.activate_active_record!
+    end
+
+  end
+end

data/lib/tinia/search.rb

@@ -0,0 +1,86 @@
+module Tinia
+
+  module Search
+
+    def self.included(klass)
+      klass.send(:extend, ClassMethods)
+      klass.class_eval do 
+        # lambda block for the scope
+        scope_def = lambda{|*ids|
+          {
+            :conditions => [
+              "#{self.table_name}.#{self.primary_key} IN (?)", ids.flatten
+            ]
+          }
+        }
+        named_scope :tinia_scope, scope_def do 
+          include WillPaginateMethods
+        end
+      end
+    end
+
+    # methods of WillPaginate compatibility
+    module WillPaginateMethods
+      
+      attr_accessor :current_page, :per_page, :total_entries
+
+      # calculated offset given the current page and the number
+      # of entries per page
+      def offset
+        (self.current_page - 1) * self.per_page
+      end
+      
+      # total number of pages  
+      def total_pages
+        (self.total_entries.to_f / self.per_page.to_f).ceil
+      end
+
+    end
+
+    module ClassMethods
+      
+      # return a scope with the subset of ids
+      def cloud_search(*args)
+        opts = {
+          :page => 1,
+          :per_page => 20
+        }
+        opts = opts.merge(args.extract_options!)
+        query = args.first
+        
+        response = self.cloud_search_response(args.first, opts)
+        ids = response.hits.collect{|h| h["id"]}
+
+        proxy = self.tinia_scope(ids)
+        proxy.per_page = opts[:per_page]    
+        proxy.current_page = opts[:page] 
+        proxy.total_entries = response.found  
+        proxy
+      end
+
+      protected
+
+      # perform a query to CloudSearch and get a response
+      def cloud_search_response(query, opts)
+        self.cloud_search_connection.search(
+          self.cloud_search_request(query, opts)
+        )
+      end
+
+      # generate a request to CloudSearch
+      def cloud_search_request(query, opts)
+        AWSCloudSearch::SearchRequest.new.tap do |req|
+          if query.nil?
+            req.bq = "type:'#{self.base_class.name}'"
+          else
+            req.bq = "(and '#{query}' type:'#{self.base_class.name}')" 
+          end
+          req.size = opts[:per_page]
+          req.start = (opts[:page] - 1) * opts[:per_page]
+        end
+      end
+
+    end
+  end
+
+end

data/spec/acceptance/aws_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "AWS" do
+
+  before(:all) do
+
+    conn = ActiveRecord::Base.connection
+    conn.create_table(:clients, :force => true) do |t|
+      t.string(:first_name)
+      t.string(:last_name)
+      t.string(:email)
+      t.timestamps
+    end
+
+    Client = Class.new(ActiveRecord::Base) do
+      indexed_with_cloud_search do |config|
+        config.cloud_search_domain = "client-4wwi2n4ghrnro46w2adiw2temy"
+      end
+
+      def cloud_search_data
+        self.attributes
+      end
+
+    end
+
+    Client.create(
+      :first_name => "Dan",
+      :last_name => "Langevin",
+      :email => "test@test.com"
+    )
+  end
+
+  after(:all) do
+    Client.all.each(&:destroy)
+  end
+
+  it "should be able to index and search records" do
+
+    Client.cloud_search_reindex
+    c = Client.cloud_search("Dan Langevin").first
+    c.should be_instance_of(Client)
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'tinia'
+require 'active_record'
+require 'mocha'
+
+require 'ruby-debug'
+Debugger.start
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+ActiveRecord::Base.establish_connection({
+  "adapter" => "sqlite3",
+  "database" => "/tmp/tinia_test.sqlite"
+})
+
+Tinia.activate_active_record!
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/tinia/connection_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Tinia::Connection do
+
+  before(:each) do
+
+    ConnectionMock = Class.new(ActiveRecord::Base) do
+      indexed_with_cloud_search do |config|
+        config.cloud_search_domain = "connection-mock"
+      end
+    end
+
+  end
+  
+  context ".cloud_search_connection" do
+
+    it "should get a namespaced connection" do
+      ConnectionMock.stubs(:cloud_search_domain => "connection-mock")
+      Tinia.expects(:connection).with("connection-mock")
+      ConnectionMock.cloud_search_connection
+    end
+
+  end
+
+  context ".cloud_search_domain" do
+
+    it "should provide a setter and getter" do
+      ConnectionMock.cloud_search_domain = "123"
+      ConnectionMock.cloud_search_domain.should eql "123"
+
+      ConnectionMock2 = Class.new(ConnectionMock)
+      ConnectionMock2.cloud_search_domain.should eql "123"      
+    end
+
+    it "should raise an error if cloud_search_domain is not defined" do
+
+      lambda{
+        ErrorMock = Class.new(ActiveRecord::Base) do
+          indexed_with_cloud_search
+        end
+      }.should raise_error(Tinia::MissingSearchDomain)
+    end
+
+  end
+
+end

data/spec/tinia/index_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Tinia::Index do
+
+  before(:all) do
+
+    conn = ActiveRecord::Base.connection
+
+    conn.create_table(:mock_index_classes, :force => true) do |t|
+      t.string(:name)
+      t.timestamps
+    end
+
+    conn.create_table(:mock_index_with_datas, :force => true) do |t|
+      t.string(:name)
+      t.string(:type)
+      t.timestamps
+    end
+
+    MockIndexClass = Class.new(ActiveRecord::Base) do
+      indexed_with_cloud_search do |config|
+        config.cloud_search_domain = "connection-mock"
+      end
+    end
+
+    MockIndexWithData = Class.new(ActiveRecord::Base) do
+      indexed_with_cloud_search do |config|
+        config.cloud_search_domain = "mock-index-with-data"
+      end
+    end
+
+  end
+
+  shared_examples_for "batching" do
+
+    it "should add a document to its batch, flushing each time" do
+
+      doc = AWSCloudSearch::Document.new
+      doc2 = AWSCloudSearch::Document.new
+
+      batcher = AWSCloudSearch::DocumentBatcher.new(stub)
+      batcher.expects(document_method).with(doc)
+      batcher.expects(document_method).with(doc2)
+      batcher.expects(:flush).twice
+
+      MockIndexWithData.stubs(:cloud_search_document_batcher => batcher)
+
+      MockIndexWithData.send(batch_method, doc)
+      MockIndexWithData.send(batch_method, doc2)
+
+    end
+
+    it "should add a document to its batch flushing only at the end
+      when within a cloud_search_batch_documents block" do
+
+
+      doc = AWSCloudSearch::Document.new
+      doc2 = AWSCloudSearch::Document.new
+
+      batcher = AWSCloudSearch::DocumentBatcher.new(stub)
+      batcher.expects(document_method).with(doc)
+      batcher.expects(document_method).with(doc2)
+
+      # exactly one 
+      batcher.expects(:flush).once
+
+      MockIndexWithData.stubs(:cloud_search_document_batcher => batcher)
+
+      MockIndexWithData.cloud_search_batch_documents do
+        MockIndexWithData.send(batch_method, doc)
+        MockIndexWithData.send(batch_method, doc2)
+      end
+
+    end
+  end
+
+  context ".cloud_search_add_document" do
+
+    let(:batch_method) do
+      :cloud_search_add_document
+    end
+
+    let(:document_method) do
+      :add_document
+    end
+
+    it_should_behave_like("batching")
+  end
+
+  context ".cloud_search_delete_document" do
+
+    let(:batch_method) do
+      :cloud_search_delete_document
+    end
+
+    let(:document_method) do
+      :delete_document
+    end
+
+    it_should_behave_like("batching")
+  end
+
+  context ".cloud_search_domain" do
+
+    it "should be an inheritable attribute" do
+      NewKlass = Class.new(MockIndexWithData)
+      NewKlass.cloud_search_domain.should eql(
+        MockIndexWithData.cloud_search_domain
+      )
+    end
+
+  end
+
+
+  context ".cloud_search_reindex" do
+
+    it "should reindex the entire collection" do
+      mock_index_with_data = MockIndexWithData.new
+      mock_index_with_data.expects(:add_to_cloud_search)
+
+      MockIndexWithData.cloud_search_document_batcher.expects(:flush)
+      MockIndexWithData.expects(:find_each)
+        .with(:conditions => ["x = y"])
+        .yields(mock_index_with_data)
+
+      MockIndexWithData.cloud_search_reindex(:conditions => ["x = y"])
+    end
+
+  end
+
+
+  context "#add_to_cloud_search" do
+
+    it "should add a document to CloudSearch" do
+      doc = AWSCloudSearch::Document.new
+
+      mock_index_with_data = MockIndexWithData.new
+      mock_index_with_data.stubs(:cloud_search_document => doc)
+
+      MockIndexWithData.expects(:cloud_search_add_document).with(doc)
+
+      # call add to cloud_search
+      mock_index_with_data.add_to_cloud_search
+    end
+  end
+
+  context "#cloud_search_data" do
+    
+    it "should define an empty cloud_search_data method" do
+      MockIndexClass.new.cloud_search_data.should eql({})
+    end
+
+  end
+
+  context "#cloud_search_document" do
+
+    it "should provide a wrapper for the document that is indexed " do
+
+      t = Time.now
+
+      doc = AWSCloudSearch::Document.new
+      doc.expects(:id=).with(8989)
+      doc.expects(:lang=).with("en")
+      doc.expects(:version=).with(t.to_i)
+      doc.expects(:add_field).with("key", "val")
+      doc.expects(:add_field).with("type", "MockIndexWithData")
+      AWSCloudSearch::Document.stubs(:new => doc)
+
+      mock_index_with_data = MockIndexWithData.new
+      mock_index_with_data.stubs(
+        :cloud_search_data => {:key => "val"},
+        :id => 8989,
+        :updated_at => t.to_i
+      )
+      mock_index_with_data.cloud_search_document.should eql(doc)
+    end
+
+  end
+
+  context "#delete_from_cloud_search" do
+
+    it "should remvoe a document from CloudSearch" do
+      doc = AWSCloudSearch::Document.new
+
+      mock_index_with_data = MockIndexWithData.new
+      mock_index_with_data.stubs(:cloud_search_document => doc)
+
+      MockIndexWithData.expects(:cloud_search_delete_document).with(doc)
+
+      # call add to cloud_search
+      mock_index_with_data.delete_from_cloud_search
+    end
+
+  end
+
+
+end

data/spec/tinia/search_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Tinia::Search do
+
+  before(:all) do
+
+    conn = ActiveRecord::Base.connection
+    conn.create_table(:mock_classes, :force => true) do |t|
+      t.string("name")
+      t.timestamps
+    end
+
+    MockClass = Class.new(ActiveRecord::Base) do
+      indexed_with_cloud_search do |config|
+        config.cloud_search_domain = "mock-class"
+      end
+
+      named_scope :name_like, lambda{|n|
+        {:conditions => ["name LIKE ?", n]}
+      }
+
+    end
+
+  end
+
+  context "#cloud_search" do
+
+    before(:each) do
+      AWSCloudSearch::SearchRequest.stubs(:new => search_request)
+
+      MockClass.cloud_search_connection
+        .expects(:search)
+        .with(search_request)
+        .returns(stub({
+          :hits => [
+            {"id" => 1},
+            {"id" => 2}
+          ],
+          :found => 300,
+          :start => 0
+        }))
+    end
+
+    let(:search_request) do
+      search_request = AWSCloudSearch::SearchRequest.new
+      search_request.expects(:bq=).with("(and 'my query' type:'MockClass')")
+      search_request
+    end
+
+    it "should proxy its search request to cloud_search and return
+      an Arel-like object" do
+
+      proxy = MockClass.cloud_search("my query")
+      proxy.proxy_options[:conditions].should eql(
+        ["mock_classes.id IN (?)", [1, 2]]
+      )
+    end
+
+    it "should be chainable, maintaining its meta_data" do
+      proxy = MockClass.cloud_search("my query").name_like("name")
+      proxy.current_page.should eql(1)
+      proxy.offset.should eql(0)
+    end
+
+    context "#current_page" do
+
+      it "should default to 1" do
+        proxy = MockClass.cloud_search("my query")
+        proxy.current_page.should eql(1)
+      end
+
+      it "should be able to be set" do
+        search_request.expects(:start=).with(80)
+        proxy = MockClass.cloud_search("my query", :page => 5)
+        proxy.current_page.should eql(5)
+      end
+
+    end
+
+    context "#offset" do
+
+      it "should be able to compute its offset" do
+        proxy = MockClass.cloud_search("my query", :page => 5)
+        proxy.offset.should eql(80)
+      end
+
+    end
+
+    context "#per_page" do
+
+      it "should default to 20" do
+        proxy = MockClass.cloud_search("my query")
+        proxy.per_page.should eql(20)
+      end
+
+      it "should be able to be set" do
+        search_request.expects(:size=).with(50)
+        proxy = MockClass.cloud_search("my query", :per_page => 50)
+        proxy.per_page.should eql(50)
+      end
+
+    end
+
+    context "#total_entries" do
+      
+      it "should get it from its search_response" do
+        proxy = MockClass.cloud_search("my query")
+        proxy.total_entries.should eql(300)
+      end
+
+    end
+
+    context "#total_pages" do
+      
+      it "should be the ceiling of its total_entries divided 
+        by per_page" do
+        proxy = MockClass.cloud_search("my query", :per_page => 7)
+        proxy.total_pages.should eql(43)
+      end
+
+    end
+  end
+  
+end