acts_as_xapian 0.1.1

data/lib/acts_as_xapian/index.rb

@@ -0,0 +1,45 @@
+module ActsAsXapian
+  class Index
+    @@db_path = nil
+    @@init_values = []
+
+    cattr_reader :config, :db_path, :stemmer
+
+    class <<self
+      ######################################################################
+      # Initialisation
+      def init(classname = nil, options = nil)
+        # store class and options for use later, when we open the db in readable_init
+        @@init_values.push([classname,options]) unless classname.nil?
+      end
+
+      # Reads the config file (if any) and sets up the path to the database we'll be using
+      def prepare_environment
+        return unless @@db_path.nil?
+
+        # barf if we can't figure out the environment
+        environment = (ENV['RAILS_ENV'] || RAILS_ENV)
+        raise "Set RAILS_ENV, so acts_as_xapian can find the right Xapian database" unless environment
+
+        # check for a config file
+        config_file = File.join(RAILS_ROOT, 'config', 'xapian.yml')
+        @@config = File.exists?(config_file) ? YAML.load_file(config_file)[environment] : {}
+        # figure out where the DBs should go
+        if config['base_db_path']
+          db_parent_path = File.join(RAILS_ROOT, config['base_db_path'])
+        else
+          db_parent_path = File.join(RAILS_ROOT, 'db', 'xapiandbs')
+        end
+
+        # make the directory for the xapian databases to go in
+        Dir.mkdir(db_parent_path) unless File.exists?(db_parent_path)
+
+        @@db_path = File.join(db_parent_path, environment)
+
+        # make some things that don't depend on the db
+        # XXX this gets made once for each acts_as_xapian. Oh well.
+        @@stemmer = Xapian::Stem.new('english')
+      end
+    end
+  end
+end

data/lib/acts_as_xapian/query_base.rb

@@ -0,0 +1,159 @@
+module ActsAsXapian
+  # Base class for Search and Similar below
+  class QueryBase
+    attr_accessor :offset, :limit, :query, :query_models, :runtime, :cached_results
+    @@unlimited = 1000000
+
+    # Return a description of the query
+    def description
+      self.query.description
+    end
+
+    # Returns the mset for the query
+    def matches(reload = false)
+      return @matches unless @matches.nil? || reload
+
+      begin
+        self.runtime += Benchmark::realtime do
+          # If using find_options conditions have Xapian return the entire match set
+          # TODO Revisit. This is extremely inefficient for large indices
+          @matches = @index.enquire.mset(@postpone_limit ? 0 : @offset, @postpone_limit ? @@unlimited : @limit, @check_at_least)
+        end
+        @matches
+      rescue IOError => e
+        if @retried.nil? && /DatabaseModifiedError/.match(e.message.to_s)
+          @retried = true
+          @index.reset_enquire!
+          initialize_enquire
+          retry
+        end
+        raise e
+      end
+    end
+
+    # Estimate total number of results
+    # Note: Unreliable if using find_options with conditions or joins
+    def matches_estimated
+      @matches_estimated || self.matches.matches_estimated
+    end
+
+    # Return query string with spelling correction
+    def spelling_correction
+      correction = @index.query_parser.get_corrected_query_string
+      correction.empty? ? nil : correction
+    end
+
+    # Return array of models found
+    def results
+      # If they've already pulled out the results, just return them.
+      return self.cached_results unless self.cached_results.nil?
+
+      docs = nil
+      self.runtime += Benchmark::realtime do
+        # Pull out all the results
+        docs = self.matches.matches.map {|doc| {:data => doc.document.data, :percent => doc.percent, :weight => doc.weight, :collapse_count => doc.collapse_count} }
+      end
+
+      # Log time taken, excluding database lookups below which will be displayed separately by ActiveRecord
+      ActiveRecord::Base.logger.debug("  Xapian query (%.5fs) #{self.log_description.gsub('%','%%')}" % self.runtime) if ActiveRecord::Base.logger
+
+      # Group the ids by the model they belong to
+      lhash = docs.inject({}) do |s,doc|
+        model_name, id = doc[:data].split('-')
+        (s[model_name] ||= []) << id
+        s
+      end
+
+      if @postpone_limit
+        found = lhash.map do |(class_name, ids)|
+          model = class_name.constantize # constantize is expensive do once
+          model.with_xapian_scope(ids) { model.find(:all, @find_options.merge(:select => "#{model.table_name}.#{model.primary_key}")) }.map {|m| m.xapian_document_term }
+        end.flatten
+
+        self.runtime += Benchmark::realtime do
+          found = found.inject({}) {|s,i| s[i] = true; s } # hash key searching is MUCH faster than an array sequential scan
+          docs.delete_if {|doc| !found.delete(doc[:data]) }
+
+          @matches_estimated = docs.size
+
+          docs = docs[@offset,@limit] || []
+
+          lhash = docs.inject({}) do |s,doc|
+            model_name, id = doc[:data].split('-')
+            (s[model_name] ||= []) << id
+            s
+          end
+        end
+      end
+
+      # for each class, look up the associated ids
+      chash = lhash.inject({}) do |out, (class_name, ids)|
+        model = class_name.constantize # constantize is expensive do once
+        found = model.with_xapian_scope(ids) { model.find(:all, @find_options) }
+        out[class_name] = found.inject({}) {|s,f| s[f.id] = f; s }
+        out
+      end
+
+      # add the model to each doc
+      docs.each do |doc|
+        model_name, id = doc[:data].split('-')
+        doc[:model] = chash[model_name][id.to_i]
+      end
+
+      self.cached_results = docs
+    end
+
+    protected
+
+    def initialize_db(models)
+      self.runtime = 0.0
+
+      @index = ReadableIndex.index_for(models)
+
+      raise "ActsAsXapian::ReadableIndex not initialized" if @index.nil?
+    end
+
+    # Set self.query before calling this
+    def initialize_query(options)
+      self.runtime += Benchmark::realtime do
+        @offset = options[:offset].to_i
+        @limit = (options[:limit] || @@unlimited).to_i
+        @check_at_least = (options[:check_at_least] || 100).to_i
+        @sort_by_prefix = options[:sort_by_prefix]
+        @sort_by_ascending = options[:sort_by_ascending].nil? ? true : options[:sort_by_ascending]
+        @collapse_by_prefix = options[:collapse_by_prefix]
+        @find_options = options[:find_options]
+        @postpone_limit = !(@find_options.blank? || (@find_options[:conditions].blank? && @find_options[:joins].blank?))
+
+        self.cached_results = nil
+      end
+
+      initialize_enquire
+    end
+
+    def initialize_enquire
+      self.runtime += Benchmark::realtime do
+        @index.enquire.query = self.query
+
+        if @sort_by_prefix.nil?
+          @index.enquire.sort_by_relevance!
+        else
+          value = @index.values_by_prefix[@sort_by_prefix]
+          raise "couldn't find prefix '#{@sort_by_prefix}'" if value.nil?
+          # Xapian has inverted the meaning of ascending order to handle relevence sorting
+          # "keys which sort higher by string compare are better"
+          @index.enquire.sort_by_value_then_relevance!(value, !@sort_by_ascending)
+        end
+
+        if @collapse_by_prefix.nil?
+          @index.enquire.collapse_key = Xapian.BAD_VALUENO
+        else
+          value = @index.values_by_prefix[@collapse_by_prefix]
+          raise "couldn't find prefix '#{@collapse_by_prefix}'" if value.nil?
+          @index.enquire.collapse_key = value
+        end
+      end
+      true
+    end
+  end
+end

data/lib/acts_as_xapian/readable_index.rb

@@ -0,0 +1,117 @@
+module ActsAsXapian
+  class ReadableIndex < Index
+    @@available_indicies = {}
+
+    attr_reader :enquire, :query_parser, :values_by_prefix
+
+    # Takes an array of model classes and returns an index object to be
+    # used for searching across the given models
+    #
+    # Prevents query parser interaction across multiple models unless
+    # performing a multi model search
+    def self.index_for(models)
+      index_key = models.map {|m| m.to_s }.sort.join('---')
+      if @@available_indicies.key?(index_key)
+        index = @@available_indicies[index_key]
+        index.reset_enquire!
+        index
+      else
+        index = self.new(models)
+        @@available_indicies[index_key] = index
+        index
+      end
+    end
+
+    # Opens the db for reading and builds the query parser
+    def initialize(models)
+      raise NoXapianRubyBindingsError.new("Xapian Ruby bindings not installed") unless ActsAsXapian.bindings_available
+      raise "acts_as_xapian hasn't been called in any models" if @@init_values.empty?
+
+      self.class.prepare_environment
+
+      # basic Xapian objects
+      begin
+        @db = Xapian::Database.new(@@db_path)
+        @enquire = Xapian::Enquire.new(@db)
+      rescue IOError
+        raise "Xapian database not opened; have you built it with rake xapian:rebuild_index ?"
+      end
+
+      init_query_parser(models)
+    end
+
+    # Creates a new search session
+    def reset_enquire!
+      @db.reopen # This grabs the latest db updates
+      @enquire = Xapian::Enquire.new(@db)
+    rescue IOError
+      raise "Xapian database not opened; have you built it with rake xapian:rebuild_index ?"
+    end
+
+    protected
+
+    # Make a new query parser
+    def init_query_parser(models)
+      # for queries
+      @query_parser = Xapian::QueryParser.new
+      @query_parser.stemmer = @@stemmer
+      @query_parser.stemming_strategy = Xapian::QueryParser::STEM_SOME
+      @query_parser.database = @db
+      @query_parser.default_op = Xapian::Query::OP_AND
+
+      @terms_by_capital = {}
+      @values_by_number = {}
+      @values_by_prefix = {}
+      @value_ranges_store = []
+
+      models.each do |klass|
+        options = klass.xapian_options
+        # go through the various field types, and tell query parser about them,
+        # and error check them - i.e. check for consistency between models
+        @query_parser.add_boolean_prefix("model", "M")
+        @query_parser.add_boolean_prefix("modelid", "I")
+        (options[:terms] || []).each do |term|
+          raise "Use up to 3 single capital letters for term code" unless term[1].match(/^[A-Z]{1,3}$/)
+          raise "M and I are reserved for use as the model/id term" if term[1] == "M" || term[1] == "I"
+          raise "model and modelid are reserved for use as the model/id prefixes" if term[2] == "model" || term[2] == "modelid"
+          raise "Z is reserved for stemming terms" if term[1] == "Z"
+          raise "Already have code '#{term[1]}' in another model but with different prefix '#{@terms_by_capital[term[1]]}'" if @terms_by_capital.key?(term[1]) && @terms_by_capital[term[1]] != term[2]
+          @terms_by_capital[term[1]] = term[2]
+          @query_parser.add_prefix(term[2], term[1])
+        end
+        values = (options[:values] || [])
+        values = values.select {|i| i[3] == :number } + values.reject {|i| i[3] == :number }
+        values.each do |value|
+          raise "Value index '#{value[1]}' must be an integer, is #{value[1].class}" unless value[1].instance_of?(Fixnum)
+          raise "Already have value index '#{value[1]}' in another model but with different prefix '#{@values_by_number[value[1]]}'" if @values_by_number.key?(value[1]) && @values_by_number[value[1]] != value[2]
+          raise "Already have value prefix '#{value[2]}' in another model but with different index '#{@values_by_prefix[value[2]]}'" if value[3] == :number && @values_by_prefix.key?(value[2]) && @values_by_prefix[value[2]] != value[1]
+
+          # date types are special, mark them so the first model they're seen for
+          if !@values_by_number.key?(value[1])
+            value_range = case value[3]
+            when :date
+              Xapian::DateValueRangeProcessor.new(value[1])
+            when :string
+              Xapian::StringValueRangeProcessor.new(value[1])
+            when :number
+              Xapian::NumberValueRangeProcessor.new(value[1],"#{value[2]}:",true)
+            else
+              raise "Unknown value type '#{value[3]}'"
+            end
+
+            @query_parser.add_valuerangeprocessor(value_range)
+
+            # stop it being garbage collected, as
+            # add_valuerangeprocessor ref is outside Ruby's GC
+            @value_ranges_store.push(value_range)
+          end
+
+          @values_by_number[value[1]] = value[2]
+          @values_by_prefix[value[2]] = value[1]
+        end
+      end
+      
+      @values_by_prefix.freeze # This can be read outside the instance. Make sure it can't be changed there
+    end
+  end
+end

data/lib/acts_as_xapian/search.rb

@@ -0,0 +1,67 @@
+module ActsAsXapian
+  # Search for a query string, returns an array of hashes in result order.
+  # Each hash contains the actual Rails object in :model, and other detail
+  # about relevancy etc. in other keys.
+  class Search < QueryBase
+    attr_accessor :query_string
+
+    @@parse_query_flags = Xapian::QueryParser::FLAG_BOOLEAN | Xapian::QueryParser::FLAG_PHRASE |
+      Xapian::QueryParser::FLAG_LOVEHATE | Xapian::QueryParser::FLAG_WILDCARD |
+      Xapian::QueryParser::FLAG_SPELLING_CORRECTION
+
+    # Note that model_classes is not only sometimes useful here - it's
+    # essential to make sure the classes have been loaded, and thus
+    # acts_as_xapian called on them, so we know the fields for the query
+    # parser.
+
+    # model_classes - model classes to search within, e.g. [PublicBody,
+    # User]. Can take a single model class, or you can express the model
+    # class names in strings if you like.
+    # query_string - user inputed query string, with syntax much like Google Search
+    #
+    # options include
+    # - :limit - limit the number of records returned
+    # - :offset - start with this record number
+    # - :check_at_least - used for total match estimates. Set higher for greater accuracy at the cost of slower queries. default: 100
+    # - :sort_by_prefix - determines which data field to sort by. default: sort by relevance
+    # - :sort_by_ascending - determines which direction to sort. default: true (ascending sort)
+    # - :collapse_by_prefix - groups the return set by this prefix
+    # - :find_options - These options are passed through to the active record find. Be careful if searching against multiple model classes.
+    def initialize(model_classes, query_string, options = {})
+      # Check parameters, convert to actual array of model classes
+      model_classes = Array(model_classes).map do |model_class|
+        model_class = model_class.constantize if model_class.instance_of?(String)
+        raise "pass in the model class itself, or a string containing its name" unless model_class.instance_of?(Class)
+        model_class
+      end
+
+      # Set things up
+      self.initialize_db(model_classes)
+
+      # Case of a string, searching for a Google-like syntax query
+      self.query_string = query_string
+
+      # Construct query which only finds things from specified models
+      model_query = Xapian::Query.new(Xapian::Query::OP_OR, model_classes.map {|mc| "M#{mc}" })
+      user_query = @index.query_parser.parse_query(self.query_string, @@parse_query_flags)
+      self.query = Xapian::Query.new(Xapian::Query::OP_AND, model_query, user_query)
+
+      # Call base class constructor
+      self.initialize_query(options)
+    end
+
+    # Return just normal words in the query i.e. Not operators, ones in
+    # date ranges or similar. Use this for cheap highlighting with
+    # TextHelper::highlight, and excerpt.
+    def words_to_highlight
+      query_nopunc = self.query_string.gsub(/[^\w:\.\/_]/i, " ").gsub(/\s+/, " ")
+      # Split on ' ' and remove anything with a :, . or / in it or boolean operators
+      query_nopunc.split(" ").reject {|o| o.match(/(:|\.|\/)|^(AND|NOT|OR|XOR)$/) }
+    end
+
+    # Text for lines in log file
+    def log_description
+      "Search: #{self.query_string}"
+    end
+  end
+end

data/lib/acts_as_xapian/similar.rb

@@ -0,0 +1,61 @@
+module ActsAsXapian
+  # Search for models which contain theimportant terms taken from a specified
+  # list of models. i.e. Use to find documents similar to one (or more)
+  # documents, or use to refine searches.
+  class Similar < QueryBase
+    attr_accessor :query_models
+    attr_accessor :important_terms
+
+    # model_classes - model classes to search within, e.g. [PublicBody, User]
+    # query_models - list of models you want to find things similar to
+    def initialize(model_classes, query_models, options = {})
+      self.initialize_db(model_classes)
+
+      self.runtime += Benchmark::realtime do
+        # Case of an array, searching for models similar to those models in the array
+        self.query_models = query_models
+
+        # Find the documents by their unique term
+        input_models_query = Xapian::Query.new(Xapian::Query::OP_OR, query_models.map {|m| "I#{m.xapian_document_term}" })
+        begin
+          @index.enquire.query = input_models_query
+
+          # Get set of relevant terms for those documents
+          selection = Xapian::RSet.new()
+          @index.enquire.mset(0, 100, 100).matches.each {|m| selection.add_document(m.docid) } # XXX so this whole method will only work with 100 docs
+
+          # Bit weird that the function to make esets is part of the enquire
+          # object. This explains what exactly it does, which is to exclude
+          # terms in the existing query.
+          # http://thread.gmane.org/gmane.comp.search.xapian.general/3673/focus=3681
+          #
+          # Do main search for them
+          self.important_terms = @index.enquire.eset(40, selection).terms.map {|e| e.name }
+        rescue IOError => e
+          if @retried.nil? && /DatabaseModifiedError/.match(e.message.to_s)
+            @retried = true
+            @index.reset_enquire!
+            retry
+          end
+          raise e
+        end
+
+        similar_query = Xapian::Query.new(Xapian::Query::OP_OR, self.important_terms)
+        # Exclude original
+        combined_query = Xapian::Query.new(Xapian::Query::OP_AND_NOT, similar_query, input_models_query)
+
+        # Restrain to model classes
+        model_query = Xapian::Query.new(Xapian::Query::OP_OR, model_classes.map {|mc| "M#{mc}" })
+        self.query = Xapian::Query.new(Xapian::Query::OP_AND, model_query, combined_query)
+      end
+
+      # Call base class constructor
+      self.initialize_query(options)
+    end
+
+    # Text for lines in log file
+    def log_description
+      "Similar: #{self.query_models}"
+    end
+  end
+end

data/lib/acts_as_xapian/writeable_index.rb

@@ -0,0 +1,152 @@
+module ActsAsXapian
+  class WriteableIndex < Index
+    @@writable_db = nil
+    @@writable_suffix = nil
+
+    cattr_reader :term_generator
+
+    class << self
+      def delete_document(*args)
+        @@writable_db.delete_document(*args)
+      end
+
+      def replace_document(*args)
+        @@writable_db.replace_document(*args)
+      end
+
+      def writable_init(suffix = "")
+        raise NoXapianRubyBindingsError.new("Xapian Ruby bindings not installed") unless ActsAsXapian.bindings_available
+        raise "acts_as_xapian hasn't been called in any models" if @@init_values.empty?
+
+        # if DB is not nil, then we're already initialised, so don't do it again
+        return unless @@writable_db.nil?
+
+        prepare_environment
+
+        new_path = @@db_path + suffix
+        raise "writable_suffix/suffix inconsistency" if @@writable_suffix && @@writable_suffix != suffix
+
+        # for indexing
+        @@writable_db = Xapian::WritableDatabase.new(new_path, Xapian::DB_CREATE_OR_OPEN)
+        @@term_generator = Xapian::TermGenerator.new()
+        @@term_generator.set_flags(Xapian::TermGenerator::FLAG_SPELLING, 0)
+        @@term_generator.database = @@writable_db
+        @@term_generator.stemmer = @@stemmer
+        @@writable_suffix = suffix
+      end
+
+      ######################################################################
+      # Index
+
+      # Update index with any changes needed, call this offline. Only call it
+      # from a script that exits - otherwise Xapian's writable database won't
+      # flush your changes. Specifying flush will reduce performance, but
+      # make sure that each index update is definitely saved to disk before
+      # logging in the database that it has been.
+      def update_index(flush = false, verbose = false)
+        # puts "start of self.update_index" if verbose
+
+        # Before calling writable_init we have to make sure every model class has been initialized.
+        # i.e. has had its class code loaded, so acts_as_xapian has been called inside it, and
+        # we have the info from acts_as_xapian.
+        model_classes = ActsAsXapianJob.find(:all, :select => 'model', :group => 'model').map {|a| a.model.constantize }
+        # If there are no models in the queue, then nothing to do
+        return if model_classes.empty?
+
+        self.writable_init
+
+        ids_to_refresh = ActsAsXapianJob.find(:all, :select => 'id').map { |i| i.id }
+        ids_to_refresh.each do |id|
+          begin
+            ActsAsXapianJob.transaction do
+              job = ActsAsXapianJob.find(id, :lock =>true)
+              puts "ActsAsXapian::WriteableIndex.update_index #{job.action} #{job.model} #{job.model_id.to_s}" if verbose
+              begin
+                case job.action
+                when 'update'
+                  # XXX Index functions may reference other models, so we could eager load here too?
+                  model = job.model.constantize.find(job.model_id) # :include => cls.constantize.xapian_options[:include]
+                  model.xapian_index
+                when 'destroy'
+                  # Make dummy model with right id, just for destruction
+                  model = job.model.constantize.new
+                  model.id = job.model_id
+                  model.xapian_destroy
+                else
+                  raise "unknown ActsAsXapianJob action '#{job.action}'"
+                end
+              rescue ActiveRecord::RecordNotFound => e
+                job.action = 'destroy'
+                retry
+              end
+              job.destroy
+
+              @@writable_db.flush if flush
+            end
+          rescue => detail
+            # print any error, and carry on so other things are indexed
+            # XXX If item is later deleted, this should give up, and it
+            # won't. It will keep trying (assuming update_index called from
+            # regular cron job) and mayhap cause trouble.
+            STDERR.puts("#{detail.backtrace.join("\n")}\nFAILED ActsAsXapian::WriteableIndex.update_index job #{id} #{$!}")
+          end
+        end
+      end
+
+      # You must specify *all* the models here, this totally rebuilds the Xapian database.
+      # You'll want any readers to reopen the database after this.
+      def rebuild_index(model_classes, verbose = false)
+        raise "when rebuilding all, please call as first and only thing done in process / task" unless @@writable_db.nil?
+
+        prepare_environment
+
+        # Delete any existing .new database, and open a new one
+        new_path = "#{self.db_path}.new"
+        if File.exist?(new_path)
+          raise "found existing #{new_path} which is not Xapian flint database, please delete for me" unless File.exist?(File.join(new_path, "iamflint"))
+          FileUtils.rm_r(new_path)
+        end
+        self.writable_init(".new")
+
+        # Index everything
+
+        most_recent_job = ActsAsXapianJob.find(:first, :order => 'id DESC')
+        batch_size = 1000
+        model_classes.each do |model_class|
+          all_ids = model_class.find(:all, :select => model_class.primary_key, :order => model_class.primary_key).map {|i| i.id }
+          all_ids.each_slice(batch_size) do |ids|
+            puts "ActsAsXapian::WriteableIndex: New batch. Including ids #{ids.first} to #{ids.last}" if verbose
+            models = model_class.find(:all, :conditions => {model_class.primary_key => ids})
+            models.each do |model|
+              puts "ActsAsXapian::WriteableIndex.rebuild_index #{model_class} #{model.id}" if verbose
+              model.xapian_index
+            end
+          end
+        end
+
+        @@writable_db.flush
+
+        # Rename into place
+        old_path = self.db_path
+        temp_path = "#{old_path}.tmp"
+        if File.exist?(temp_path)
+          raise "temporary database found #{temp_path} which is not Xapian flint database, please delete for me" unless File.exist?(File.join(temp_path, "iamflint"))
+          FileUtils.rm_r(temp_path)
+        end
+        FileUtils.mv(old_path, temp_path) if File.exist?(old_path)
+        FileUtils.mv(new_path, old_path)
+
+        # Delete old database
+        if File.exist?(temp_path)
+          raise "old database now at #{temp_path} is not Xapian flint database, please delete for me" unless File.exist?(File.join(temp_path, "iamflint"))
+          FileUtils.rm_r(temp_path)
+        end
+
+        ActsAsXapianJob.delete_all ['id <= ?', most_recent_job.id] if most_recent_job
+
+        # You'll want to restart your FastCGI or Mongrel processes after this,
+        # so they get the new db
+      end
+    end
+  end
+end

data/lib/acts_as_xapian.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'acts_as_xapian', 'base'     )
+require File.join(File.dirname(__FILE__), 'acts_as_xapian', 'query_base'     )
+require File.join(File.dirname(__FILE__), 'acts_as_xapian', 'search'         )
+require File.join(File.dirname(__FILE__), 'acts_as_xapian', 'similar'        )
+require File.join(File.dirname(__FILE__), 'acts_as_xapian', 'core_ext/array' )

data/spec/acts_as_xapian_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ActsAsXapian" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'acts_as_xapian'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end