acts_as_xapian 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mike Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,148 @@
+=acts_as_xapian_gem / acts_as_xapian
+
+== Introduction
+
+Xapian[http://www.xapian.org] is a full text search engine library which has Ruby bindings. acts_as_xapian adds support for it to Rails. It is an alternative to acts_as_solr, acts_as_ferret, Ultrasphinx, acts_as_indexed, acts_as_searchable or acts_as_tsearch.
+
+acts_as_xapian is deployed in production on these websites.
+* WhatDoTheyKnow[http://www.whatdotheyknow.com] 
+* MindBites[http://www.mindbites.com]
+
+== A Quick Note
+
+This gem was created directly from the acts_as_xapian plugin. There were very few changes, the majority of which were to make the gem handle installation better. If you'd like more information about the original plugin go here[http://www.github.com/frabcus/acts_as_xapian/] or if I've left something crucial out, send me a message via github.
+
+== Installation
+
+Install Xapian with the ruby bindings on your box. For you OSX users, I'd recommend using Homebrew[http://github.com/mxcl/homebrew]
+
+Then install the gem
+ sudo gem install acts_as_xapian
+
+Navigate to your project and generate the required files
+ script/generate acts_as_xapian
+ 
+Migrate your database
+ rake db:migrate
+
+== Usage
+
+Xapian is an offline indexing search library - only one process can have the Xapian database open for writing at once, and others that try meanwhile are unceremoniously kicked out. For this reason, acts_as_xapian does not support immediate writing to the database when your models change.
+
+Instead, there is a ActsAsXapianJob model which stores which models need updating or deleting in the search index. A rake task 'xapian:update_index' then performs the updates since last change. You can run it on a cron job, or similar.
+
+Here's how to add indexing to your Rails app:
+
+Put acts_as_xapian in your models that need search indexing. e.g.
+
+  acts_as_xapian :texts => [:name, :short_name],
+                           :values => [[ :created_at, 0, "created_at", :date ]],
+                           :terms => [[ :variety, 'V', "variety" ]]
+
+Options must include:
+
+* :texts, an array of fields for indexing with full text search. 
+ e.g. :texts => [ :title, :body ]
+
+* :values, things which have a range of values for sorting or collapsing. Specify an array quadruple of [ field, identifier, prefix, type ] where _identifier_ is an arbitary numeric identifier for use in the Xapian database, _prefix_ is the part to use in search queries that goes before the : , and _type_ can be any of :string, :number or :date.
+ e.g. :values => [[ :created_at, 0, "created_at", :date ], [ :size, 1, "size", :string ]]
+
+* :terms, things which come with a prefix (before a ':') in search queries. Specify an array triple of [ field, char, prefix ] where _char_ is an arbitary single upper case char used in the Xapian database, just pick any single uppercase character, but use a different one for each prefix. _prefix_ is the part to use in search queries that goes before the : . For example, if you were making Google and indexing to be able to later do a query like "site:www.whatdotheyknow.com", then the prefix would be "site".
+ e.g. :terms => [ [ :variety, 'V', "variety" ] ]
+        
+A 'field' is a symbol referring to either an attribute or a function which returns the text, date or number to index. Both 'identifier' and 'char' must be the same for the same prefix in different models.
+
+Options may include:
+
+* :eager_load, added as an :include clause when looking up search results in database
+* :if, either an attribute or a function which if returns false means the object isn't indexed
+
+To build the index
+the first time, call: 
+ rake xapian:rebuild_index
+
+It puts the db in the development/test/production directory in your db directory. See the configuration section below if you want to change this.
+
+Then from a cron job or a daemon, or by hand regularly call:
+ 'rake xapian:update_index'
+
+
+== Querying
+
+
+=== Testing indexing
+
+If you just want to test indexing is working, you'll find this rake task useful:
+    rake xapian:query q="moo"
+  
+You have a few more options here:
+* models - the models to query (ex: models="User Company"). Omitting searches all xapian models
+* offset - the offset of the results
+* limit - the limiting number of results
+* sort_by_prefix - sort by the prefix specified in value field of the acts_as_xapian call
+* collapse_by_prefix - collapse the results based on best result for it's prefix
+
+=== Performing a query
+
+To perform a query from code call ActsAsXapian::Search.new. This takes in turn:
+* model_classes - list of models to search, e.g. [PublicBody, InfoRequestEvent]
+* query_string - Google like syntax, see below
+
+And then a hash of options:
+* :offset - Offset of first result (default 0)
+* :limit - Number of results per page
+* :sort_by_prefix - Optionally, prefix of value to sort by, otherwise sort by relevance
+* :sort_by_ascending - Default true (documents with higher values better/earlier), set to false for descending sort
+* :collapse_by_prefix - Optionally, prefix of value to collapse by (i.e. only return most relevant result from group)
+
+Google like query syntax is as described in {Xapian::QueryParser Syntax}[http://www.xapian.org/docs/queryparser.html] Queries can include prefix:value parts, according to what you indexed in the acts_as_xapian part above. You can also say things like model:InfoRequestEvent to constrain by model in more complex ways than the :model parameter, or modelid:InfoRequestEvent-100 to only find one specific object.
+
+Returns an ActsAsXapian::Search object. Useful methods are:
+* description - a techy one, to check how the query has been parsed
+* matches_estimated - a guesstimate at the total number of hits
+* spelling_correction - the corrected query string if there is a correction, otherwise nil
+* words_to_highlight - list of words for you to highlight, perhaps with TextHelper::highlight
+* results - an array of hashes each structured like:
+ {:model > YourModel, :weight => 3.92, :percent => 100%, :collapse_count => 0}
+* :model - your Rails model, this is what you most want!
+* :weight - relevancy measure
+* :percent - the weight as a %, 0 meaning the item did not match the query at all
+* :collapse_count - number of results with the same prefix, if you specified collapse_by_prefix
+
+=== Finding similar models
+
+To find models that are similar to a given set of models call ActsAsXapian::Similar.new. This takes:
+* model_classes - list of model classes to return models from within
+* models - list of models that you want to find related ones to
+
+Returns an ActsAsXapian::Similar object. Has all methods from ActsAsXapian::Search above, except for words_to_highlight. In addition has:
+* important_terms - the terms extracted from the input models, that were used to search for output. You need the results methods to get the similar models.
+
+
+== Configuration
+
+
+If you want to customise the configuration of acts_as_xapian, it will look for a file called 'xapian.yml' under RAILS_ROOT/config. As is familiar from the format of the database.yml file, separate :development, :test and :production sections are expected.
+
+The following options are available:
+* base_db_path - specifies the directory, relative to RAILS_ROOT, in which acts_as_xapian stores its search index databases. Default is the xapiandbs directory within the db directory.
+
+
+== Performance
+
+On development sites, acts_as_xapian automatically logs the time taken to do searches.  The time displayed is for the Xapian parts of the query; the Rails database model lookups will be logged separately by ActiveRecord. Example:
+
+ Xapian query (0.00029s) Search: hello
+
+To enable this, and other performance logging, on a production site, temporarily add this to the end of your config/environment.rb
+
+ ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+
+== Support
+
+Please ask any questions on the {acts_as_xapian Google Group}[http://groups.google.com/group/acts_as_xapian]
+
+The official home page and repository for acts_as_xapian are the {acts_as_xapian github page}[http://github.com/frabcus/acts_as_xapian/wikis]
+
+For more details about anything, see source code in lib/acts_as_xapian/*.rb

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_xapian"
+    gem.summary = %Q{A gem for interacting with the Xapian full text search engine}
+    gem.description = %Q{A gem for interacting with the Xapian full text search engine. Completely based on the acts_as_xapian plugin.}
+    gem.email = "mdnelson30@gmail.com"
+    gem.homepage = "http://github.com/mnelson/acts_as_xapian_gem"
+    gem.authors = ["Mike Nelson"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "active_record"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "acts_as_xapian #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/acts_as_xapian.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_xapian}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mike Nelson"]
+  s.date = %q{2010-03-17}
+  s.description = %q{A gem for interacting with the Xapian full text search engine. Completely based on the acts_as_xapian plugin.}
+  s.email = %q{mdnelson30@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "acts_as_xapian.gemspec",
+     "generators/acts_as_xapian/USAGE",
+     "generators/acts_as_xapian/acts_as_xapian_generator.rb",
+     "generators/acts_as_xapian/templates/migrations/migration.rb",
+     "generators/acts_as_xapian/templates/tasks/xapian.rake",
+     "lib/acts_as_xapian.rb",
+     "lib/acts_as_xapian/base.rb",
+     "lib/acts_as_xapian/core_ext/array.rb",
+     "lib/acts_as_xapian/index.rb",
+     "lib/acts_as_xapian/query_base.rb",
+     "lib/acts_as_xapian/readable_index.rb",
+     "lib/acts_as_xapian/search.rb",
+     "lib/acts_as_xapian/similar.rb",
+     "lib/acts_as_xapian/writeable_index.rb",
+     "spec/acts_as_xapian_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mnelson/acts_as_xapian_gem}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A gem for interacting with the Xapian full text search engine}
+  s.test_files = [
+    "spec/acts_as_xapian_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<active_record>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<active_record>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<active_record>, [">= 0"])
+  end
+end
+

data/generators/acts_as_xapian/USAGE

@@ -0,0 +1 @@
+./script/generate acts_as_xapian

data/generators/acts_as_xapian/acts_as_xapian_generator.rb

@@ -0,0 +1,14 @@
+class ActsAsXapianGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'migrations/migration.rb', 'db/migrate',
+        :migration_file_name => "create_acts_as_xapian"
+      m.file "tasks/xapian.rake", "lib/tasks/xapian.rake"
+    end
+  end
+  
+  protected
+    def banner
+      "Usage: #{$0} acts_as_xapian"
+    end
+end

data/generators/acts_as_xapian/templates/migrations/migration.rb

@@ -0,0 +1,14 @@
+class CreateActsAsXapian < ActiveRecord::Migration
+  def self.up
+    create_table :acts_as_xapian_jobs do |t|
+      t.column :model, :string, :null => false
+      t.column :model_id, :integer, :null => false
+      t.column :action, :string, :null => false
+    end
+    add_index :acts_as_xapian_jobs, [:model, :model_id], :unique => true
+  end
+  def self.down
+    drop_table :acts_as_xapian_jobs
+  end
+end
+

data/generators/acts_as_xapian/templates/tasks/xapian.rake

@@ -0,0 +1,42 @@
+
+namespace :xapian do
+  
+    # Parameters - specify "flush=true" to save changes to the Xapian database
+    # after each model that is updated. This is safer, but slower. Specify
+    # "verbose=true" to print model name as it is run.
+    desc 'Updates Xapian search index with changes to models since last call'
+    task :update_index => :environment do
+        ActsAsXapian::WriteableIndex.update_index(ENV['flush'] ? true : false, ENV['verbose'] ? true : false)
+    end
+
+    desc 'Pulls all the xapian models from either the params or the project itself'
+    task :retrieve_models => :environment do 
+      @models = (ENV['models'] || ENV['m']) && (ENV['models'] || ENV['m']).split(" ").map{|m| m.constantize} || ActiveRecord::Base.send(:subclasses).select{|klazz| klazz.respond_to?(:xapian?)}
+      STDOUT.puts("Found Xapian Models: #{@models.map(&:name).join(', ')}")
+    end
+    # Parameters - specify 'models="PublicBody User"' to say which models
+    # you index with Xapian.
+    # This totally rebuilds the database, so you will want to restart any
+    # web server afterwards to make sure it gets the changes, rather than
+    # still pointing to the old deleted database. Specify "verbose=true" to
+    # print model name as it is run.
+    desc 'Completely rebuilds Xapian search index (must specify all models)'
+    task :rebuild_index => :retrieve_models do
+        ActsAsXapian::WriteableIndex.rebuild_index(@models, ENV['verbose'] ? true : false)
+    end
+
+    # Parameters - are models, query, offset, limit, sort_by_prefix,
+    # collapse_by_prefix
+    desc 'Run a query, return YAML of results'
+    task :query => :retrieve_models do
+        raise "specify q=\"your terms\" as parameter" if (ENV['query'] || ENV['q']).nil?
+        s = ActsAsXapian::Search.new(@models, 
+            (ENV['query'] || ENV['q']),
+            :offset => (ENV['offset'] || 0), :limit => (ENV['limit'] || 10),
+            :sort_by_prefix => (ENV['sort_by_prefix'] || nil), 
+            :collapse_by_prefix => (ENV['collapse_by_prefix'] || nil)
+        )
+        STDOUT.puts(s.results.to_yaml)
+    end
+end
+

data/lib/acts_as_xapian/base.rb

@@ -0,0 +1,215 @@
+# acts_as_xapian/lib/acts_as_xapian.rb:
+# Xapian full text search in Ruby on Rails.
+#
+# Copyright (c) 2008 UK Citizens Online Democracy. All rights reserved.
+# Email: francis@mysociety.org; WWW: http://www.mysociety.org/
+#
+# Documentation
+# =============
+#
+# See ../README.txt foocumentation. Please update that file if you edit
+# code.
+
+# Make it so if Xapian isn't installed, the Rails app doesn't fail completely,
+# just when somebody does a search.
+begin
+  require 'xapian'
+  $acts_as_xapian_bindings_available = true
+rescue LoadError
+  STDERR.puts "acts_as_xapian: No Ruby bindings for Xapian installed"
+  $acts_as_xapian_bindings_available = false
+end
+
+module ActsAsXapian
+  class NoXapianRubyBindingsError < StandardError; end
+
+  # Offline indexing job queue model, create with migration made
+  # using "script/generate acts_as_xapian" as described in ../README.txt
+  class ActsAsXapianJob < ActiveRecord::Base; end
+
+  ######################################################################
+  # Module level variables
+  # XXX must be some kind of cattr_accessor that can do this better
+  def self.bindings_available
+    $acts_as_xapian_bindings_available
+  end
+
+  ######################################################################
+  # Main entry point, add acts_as_xapian to your model.
+
+  module ActsMethods
+    # See top of this file for docs
+    def acts_as_xapian(options)
+      # Give error only on queries if bindings not available
+      return unless ActsAsXapian.bindings_available
+
+      include InstanceMethods
+      extend ClassMethods
+
+      class_eval('def xapian_boost(term_type, term); 1; end') unless self.instance_methods.include?('xapian_boost')
+
+      # extend has_many && has_many_and_belongs_to associations with our ProxyFinder to get scoped results
+      # I've written a small report in the discussion group why this is the proper way of doing this.
+      # see here: XXX - write it you lazy douche bag!
+      self.reflections.each do |association_name, r|
+        # skip if the associated model isn't indexed by acts_as_xapian
+        next unless r.klass.respond_to?(:xapian?) && r.klass.xapian?
+        # skip all associations except ham and habtm
+        next unless [:has_many, :has_many_and_belongs_to_many].include?(r.macro)
+
+        # XXX todo:
+        # extend the associated model xapian options with this term:
+        # [proxy_reflection.primary_key_name.to_sym, <magically find a free capital letter>, proxy_reflection.primary_key_name]
+        # otherways this assumes that the associated & indexed model indexes this kind of term
+
+        # but before you do the above, rewrite the options syntax... wich imho is actually very ugly
+
+        # XXX test this nifty feature on habtm!
+
+        if r.options[:extend].nil?
+          r.options[:extend] = [ProxyFinder]
+        elsif !r.options[:extend].include?(ProxyFinder)
+          r.options[:extend] << ProxyFinder
+        end
+      end
+
+      cattr_accessor :xapian_options
+      self.xapian_options = options
+
+      ActsAsXapian::Index.init(self.class.to_s, options)
+
+      after_save :xapian_mark_needs_index
+      after_destroy :xapian_mark_needs_destroy
+    end
+  end
+
+  module ClassMethods
+    # Model.find_with_xapian("Search Term OR Phrase")
+    # => Array of Records
+    #
+    # this can be used through association proxies /!\ DANGEROUS MAGIC /!\
+    # example:
+    # @document = Document.find(params[:id])
+    # @document_pages = @document.pages.find_with_xapian("Search Term OR Phrase").compact # NOTE THE compact wich removes nil objects from the array
+    #
+    # as seen here: http://pastie.org/270114
+    def find_with_xapian(search_term, options = {})
+      search_with_xapian(search_term, options).results.map {|x| x[:model] }
+    end
+
+    def search_with_xapian(search_term, options = {})
+      ActsAsXapian::Search.new([self], search_term, options)
+    end
+
+    def with_xapian_scope(ids)
+      with_scope(:find => {:conditions => {"#{self.table_name}.#{self.primary_key}" => ids}, :include => self.xapian_options[:eager_load]}) { yield }
+    end
+
+    #this method should return true if the integration of xapian on self is complete
+    def xapian?
+      self.included_modules.include?(InstanceMethods) && self.extended_by.include?(ClassMethods)
+    end
+  end
+
+  ######################################################################
+  # Instance methods that get injected into your model.
+
+  module InstanceMethods
+    # Used internally
+    def xapian_document_term
+      "#{self.class}-#{self.id}"
+    end
+
+    # Extract value of a field from the model
+    def xapian_value(field, type = nil)
+      value = self.respond_to?(field) ? self.send(field) : self[field] # Give preference to method if it exists
+      case type
+      when :date
+        value = value.to_time if value.kind_of?(Date)
+        raise "Only Time or Date types supported by acts_as_xapian for :date fields, got #{value.class}" unless value.kind_of?(Time)
+        value.utc.strftime("%Y%m%d")
+      when :boolean
+        value ? true : false
+      when :number
+        value.nil? ? "" : Xapian::sortable_serialise(value.to_f)
+      else
+        value.to_s
+      end
+    end
+
+    # Store record in the Xapian database
+    def xapian_index
+      # if we have a conditional function for indexing, call it and destory object if failed
+      if self.class.xapian_options.key?(:if) && !xapian_value(self.class.xapian_options[:if], :boolean)
+        self.xapian_destroy
+        return
+      end
+
+      # otherwise (re)write the Xapian record for the object
+      doc = Xapian::Document.new
+      WriteableIndex.term_generator.document = doc
+
+      doc.data = self.xapian_document_term
+
+      doc.add_term("M#{self.class}")
+      doc.add_term("I#{doc.data}")
+      (self.xapian_options[:terms] || []).each do |term|
+        WriteableIndex.term_generator.increase_termpos # stop phrases spanning different text fields
+        WriteableIndex.term_generator.index_text(xapian_value(term[0]), self.xapian_boost(:term, term[0]), term[1])
+      end
+      (self.xapian_options[:values] || []).each {|value| doc.add_value(value[1], xapian_value(value[0], value[3])) }
+      (self.xapian_options[:texts] || []).each do |text|
+        WriteableIndex.term_generator.increase_termpos # stop phrases spanning different text fields
+        WriteableIndex.term_generator.index_text(xapian_value(text), self.xapian_boost(:text, text))
+      end
+
+      WriteableIndex.replace_document("I#{doc.data}", doc)
+    end
+
+    # Delete record from the Xapian database
+    def xapian_destroy
+      WriteableIndex.delete_document("I#{self.xapian_document_term}")
+    end
+
+    # Used to mark changes needed by batch indexer
+    def xapian_mark_needs_index
+      model = self.class.base_class.to_s
+      model_id = self.id
+      return false unless model_id # After save gets called even if save fails
+      ActiveRecord::Base.transaction do
+        found = ActsAsXapianJob.delete_all(["model = ? and model_id = ?", model, model_id])
+        job = ActsAsXapianJob.new
+        job.model = model
+        job.model_id = model_id
+        job.action = 'update'
+        job.save!
+      end
+    end
+
+    def xapian_mark_needs_destroy
+      model = self.class.base_class.to_s
+      model_id = self.id
+      ActiveRecord::Base.transaction do
+        found = ActsAsXapianJob.delete_all(["model = ? and model_id = ?", model, model_id])
+        job = ActsAsXapianJob.new
+        job.model = model
+        job.model_id = model_id
+        job.action = 'destroy'
+        job.save!
+      end
+    end
+  end
+
+  module ProxyFinder
+    def find_with_xapian(search_term, options = {})
+      search_with_xapian(search_term, options).results.map {|x| x[:model] }
+    end
+
+    def search_with_xapian(search_term, options = {})
+      ActsAsXapian::Search.new([proxy_reflection.klass], "#{proxy_reflection.primary_key_name}:#{proxy_owner.id} #{search_term}", options)
+    end
+  end
+end
+
+# Reopen ActiveRecord and include the acts_as_xapian method
+ActiveRecord::Base.extend ActsAsXapian::ActsMethods

data/lib/acts_as_xapian/core_ext/array.rb

@@ -0,0 +1,24 @@
+module ActsAsXapian
+  module ArrayExt
+    # Creates a ActsAsXapian::Similar search passing through the options to the search
+    #
+    # The model classes to search are automatically generated off the classes of the
+    # entries in the array. If you want more control over which models to search,
+    # specify option :models and it will override the default behavior
+    def search_similar(options = {})
+      raise "All entries must be xapian models" unless all? {|i| i.class.respond_to?(:xapian?) && i.class.xapian? }
+      models = options.delete(:models)
+      ActsAsXapian::Similar.new(models || map {|i| i.class }.uniq, self, options)
+    end
+
+    # Runs a ActsAsXapian::Similar search passing back the returned models instead of the
+    # search object. Takes all the same options as search_similar
+    def find_similar(options = {})
+      search_similar(options).results.map {|x| x[:model] }
+    end
+  end
+end
+
+Array.class_eval do
+  include ActsAsXapian::ArrayExt
+end