xapian_db 0.3.1

data/CHANGELOG

@@ -0,0 +1,15 @@
+*0.1.0* (November 23th, 2010)
+
+* Proof of concept, not really useful for real world usage
+
+*0.2.0* (December 1st, 2010)
+
+* Blueprint configuration extended
+* Adapter for Datamapper
+* Search by attribute names
+* Search with wildcards
+* Document attributes can carry anything that is serializable by YAML
+
+*0.3.0* (December 4st, 2010)
+
+* Rails integration with configuration file (config/xapian_db.yml) and automatic setup

data/examples/basic.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+# This example shows the most basic way to use xapian_db
+# To run the example, please install the xapian_db gem first
+
+require 'rubygems'
+require 'xapian_db'
+
+puts "Setting up the demo..."
+
+# 1: Open an in memory database
+db = XapianDb.create_db
+
+# 2: Define a class which should get indexed; we define a class that
+# could be an ActiveRecord or Datamapper Domain class
+class People
+  
+  attr_accessor :id, :name, :first_name
+  
+  def initialize(data)
+    @id, @name, @first_name = data[:id], data[:name], data[:first_name]
+  end
+  
+end
+
+# 3: Configure the generic adapter with a unique key expression
+XapianDb::Adapters::GenericAdapter.unique_key do
+  "#{self.class}-#{self.id}"
+end
+
+# 4: Define a document blueprint for our class; the blueprint describes
+# the structure of all documents for our class. Attribute values can
+# be accessed later for each retrieved doc. Attributes are indexed
+# by default.
+XapianDb::DocumentBlueprint.setup(People) do |blueprint|
+  blueprint.attribute :name
+  blueprint.attribute :first_name
+end
+
+# 5: Let's create some objects
+person_1 = People.new(:id => 1, :name => "Kogler", :first_name => "Gernot")
+person_2 = People.new(:id => 2, :name => "Frey",   :first_name => "Daniel")
+person_3 = People.new(:id => 3, :name => "Garaio", :first_name => "Thomas")
+
+# 6: Now add them to the database
+blueprint = XapianDb::DocumentBlueprint.blueprint_for(People)
+db.store_doc(blueprint.indexer.build_document_for(person_1))
+db.store_doc(blueprint.indexer.build_document_for(person_2))
+db.store_doc(blueprint.indexer.build_document_for(person_3))
+
+# 7: Now find the gem author ;-)
+puts "Searching for Gernot..."
+results = db.search("Gernot")
+puts "We found #{results.size} documents"
+puts "And the first document looks like this:"
+page = results.paginate(:page => 1)
+doc  = page.first
+puts "name: #{doc.name}"
+puts "first name: #{doc.first_name}"

data/lib/xapian_db/adapters/active_record_adapter.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+# Adapter for ActiveRecord. To use it, simply set it as the
+# default for any DocumentBlueprint or a specific DocumentBlueprint
+
+module XapianDb
+  module Adapters
+     
+     class ActiveRecordAdapter
+
+       class << self
+         
+         # Implement the class helper methods
+         def add_class_helper_methods_to(klass)
+
+           klass.instance_eval do
+             # define the method to retrieve a unique key
+             define_method(:xapian_id) do
+               "#{self.class}-#{self.id}"
+             end
+                          
+           end
+         
+           klass.class_eval do
+             
+             # add the after save logic
+             after_save do
+               XapianDb::Config.writer.index(self)
+             end
+             
+             # add the after destroy logic
+             after_destroy do
+               XapianDb::Config.writer.unindex(self)
+             end
+
+             # Add a method to reindex all models of this class
+             define_singleton_method(:rebuild_xapian_index) do
+               # db = XapianDb::Adapters::ActiveRecordAdapter.database
+               # # First, delete all docs of this class
+               # db.delete_docs_of_class(klass)
+               # obj_count = klass.count
+               # puts "Reindexing #{obj_count} objects..."
+               # pbar = ProgressBar.new("Status", obj_count)
+               # klass.all.each do |obj|
+               #   doc = @@blueprint.indexer.build_document_for(obj)
+               #   db.store_doc(doc)
+               #   pbar.inc
+               # end
+               # db.commit
+               XapianDb::Config.writer.reindex_class(klass)
+             end
+           end
+         
+         end
+       
+         # Implement the document helper methods
+         def add_doc_helper_methods_to(a_module)
+           a_module.instance_eval do
+             # Implement access to the indexed object
+             define_method :indexed_object do
+               return @indexed_object unless @indexed_object.nil? 
+               # retrieve the object id from data
+               klass_name, id = data.split("-")
+               klass = Kernel.const_get(klass_name)
+               @indexed_object = klass.find(id.to_i)
+             end
+           end
+           
+         end
+       
+       end
+     end
+   end
+ end

data/lib/xapian_db/adapters/datamapper_adapter.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+# Adapter for datamapper. To use it, simply set it as the
+# default for any DocumentBlueprint or a specific DocumentBlueprint
+
+module XapianDb
+  module Adapters
+     
+     class DatamapperAdapter
+
+       class << self
+         
+         # Implement the class helper methods
+         def add_class_helper_methods_to(klass)
+
+           klass.instance_eval do
+             # define the method to retrieve a unique key
+             define_method(:xapian_id) do
+               "#{self.class}-#{self.id}"
+             end
+                          
+           end
+         
+           klass.class_eval do
+             
+             # add the after save logic
+             after :save do
+               XapianDb::Config.writer.index(self)
+             end
+             
+             # add the after destroy logic
+             after :destroy do
+               XapianDb::Config.writer.unindex(self)
+             end
+
+             # Add a method to reindex all models of this class
+             define_singleton_method(:rebuild_xapian_index) do
+               XapianDb::Config.writer.reindex_class(self)
+             end
+           end
+         
+         end
+       
+         # Implement the document helper methods
+         def add_doc_helper_methods_to(a_module)
+           a_module.instance_eval do
+             # Implement access to the indexed object
+             define_method :indexed_object do
+               return @indexed_object unless @indexed_object.nil? 
+               # retrieve the object id from data
+               klass_name, id = data.split("-")
+               klass = Kernel.const_get(klass_name)
+               @indexed_object = klass.get(id.to_i)
+             end
+           end
+           
+         end
+       
+       end
+     end
+   end
+ end

data/lib/xapian_db/adapters/generic_adapter.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+# The generic adapter is a universal adapater that can be used for any
+# ruby class. To use the generic adapter (which is the default),
+# configure the expression that generates a unique key from your objects 
+# using the method 'unique_key'.
+module XapianDb
+  module Adapters
+     
+    class GenericAdapter
+
+      class << self
+        
+        # Define the unique key expression
+        def unique_key(&block)
+          @unique_key_block = block
+        end
+        
+        # Implement the class helper methods
+        def add_class_helper_methods_to(klass)
+          raise "Unique key is not configured for generic adapter!" if @unique_key_block.nil?
+          expression = @unique_key_block
+          klass.instance_eval do
+            define_method(:xapian_id) do
+              instance_eval &expression
+            end
+          end
+        end
+        
+        # Implement the document helper methods
+        def add_doc_helper_methods_to(obj)
+          # We have none so far
+        end
+        
+      end
+
+    end
+     
+  end
+   
+end

data/lib/xapian_db/config.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+# Global configuration for XapianDb
+# @author Gernot Kogler
+
+module XapianDb
+  
+  class Config
+
+    # ---------------------------------------------------------------------------------   
+    # Singleton methods
+    # ---------------------------------------------------------------------------------   
+    class << self
+
+      def setup(&block)
+        @config ||= Config.new
+        yield @config if block_given?
+      end
+      
+      # Install delegates for the config instance variables
+      [:database, :adapter, :writer].each do |attr|
+        define_method attr do
+          @config.nil? ? nil : @config.instance_variable_get("@_#{attr}")
+        end
+      end                
+    end  
+
+    # ---------------------------------------------------------------------------------   
+    # DSL methods
+    # ---------------------------------------------------------------------------------   
+    attr_reader :_database, :_adapter, :_writer
+    
+    # Set the database; either pass a path to the file system or
+    # the symbolic name "memory"
+    def database(path)
+      
+      # If the current database is a persistent database, we must release the
+      # database and run the garbage collector to remove the write lock
+      if @_database.is_a?(XapianDb::PersistentDatabase)
+        @_database = nil
+        GC.start
+      end
+      
+      if path.to_sym == :memory
+        @_database = XapianDb.create_db
+      else
+        if File.exist?(path)
+          @_database = XapianDb.open_db :path => path
+        else
+          # Database does not exist; create it
+          @_database = XapianDb.create_db :path => path
+        end
+      end
+    end
+    
+    # Define the adapter to use; the following adapters are available:
+    # - :generic
+    # - :active_record
+    # - :datamapper
+    def adapter(type)
+      # We try to guess the adapter name
+      @_adapter = XapianDb::Adapters.const_get("#{camelize(type.to_s)}Adapter")
+    end
+
+    # Define the writer to use; the following adapters are available:
+    # - :direct
+    # More to come in a future release :-)
+    def writer(type)
+      # We try to guess the writer name
+      @_writer = XapianDb::IndexWriters.const_get("#{camelize(type.to_s)}Writer")
+    end
+    
+    private
+    
+    # TODO: move this to a helper module
+    def camelize(string)
+      string.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
+    end
+    
+  end
+  
+end

data/lib/xapian_db/database.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+# Singleton class representing a Xapian database.
+# @author Gernot Kogler
+
+module XapianDb
+
+  # Base class for a Xapian database.    
+  class Database
+    attr_reader :reader    
+    
+    # Size of the database (number of docs)
+    def size
+      reader.doccount
+    end
+    
+    # Store a Xapian document
+    def store_doc(doc)
+      # We always replace; Xapian adds the document automatically if
+      # it is not found
+      writer.replace_document("Q#{doc.data}", doc)
+    end
+
+    # Delete a document by a unique term; this method is used by the
+    # orm adapters
+    def delete_doc_with_unique_term(term)
+      writer.delete_document("Q#{term}")
+      true
+    end
+
+    # Delete all docs of a specific class 
+    def delete_docs_of_class(klass)
+      writer.delete_document("C#{klass}")
+      true
+    end
+       
+    # Perform a search
+    def search(expression)
+      @query_parser ||= QueryParser.new(self)
+      query = @query_parser.parse(expression)
+      enquiry = Xapian::Enquire.new(reader)
+      enquiry.query = query
+      Resultset.new(enquiry)
+    end
+           
+  end
+  
+  # In Memory database
+  class InMemoryDatabase < Database
+
+    def initialize
+      @writer ||= Xapian::inmemory_open
+      @reader = @writer
+    end
+    
+    def writer
+      @writer
+    end
+
+    # Commit all pending changes 
+    def commit
+      # Nothing to do for an in memory database
+    end
+    
+  end
+
+  # Persistent database on disk
+  class PersistentDatabase < Database
+        
+    def initialize(options)
+      @path    = options[:path]
+      @db_flag = options[:create] ? Xapian::DB_CREATE_OR_OVERWRITE : Xapian::DB_OPEN
+      if options[:create]
+        # make sure the path exists; Xapian will not create the necessary directories 
+        FileUtils.makedirs @path
+        @writer = Xapian::WritableDatabase.new(@path, @db_flag)
+      end
+      @reader = Xapian::Database.new(@path)
+    end
+    
+    # Get the readable instance of the database
+    def reader
+      # Always reopen the readable database so we get live index data
+      # TODO: make this configurable
+      @reader.reopen
+      @reader
+    end
+    
+    # The writer is instantiated layzily to avoid a permanent write lock on the database
+    def writer
+      @writer ||= Xapian::WritableDatabase.new(@path, @db_flag)
+    end
+   
+    # Commit all pending changes 
+    def commit
+      writer.commit
+      reader.reopen
+    end
+    
+  end
+  
+end

data/lib/xapian_db/document_blueprint.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+# A document blueprint describes the mapping of an object to a Xapian document
+# for a given class.
+# @author Gernot Kogler
+
+module XapianDb
+    
+  class DocumentBlueprint
+
+    # ---------------------------------------------------------------------------------   
+    # Singleton methods
+    # ---------------------------------------------------------------------------------   
+    class << self
+
+      # Configure the blueprint for a class
+      def setup(klass, &block)
+        @blueprints ||= {}
+        blueprint = DocumentBlueprint.new
+        blueprint.indexer = Indexer.new(blueprint)
+        yield blueprint if block_given? # configure the blueprint through the block
+        @blueprints[klass] = blueprint
+        @adapter = blueprint.adapter || XapianDb::Config.adapter || Adapters::GenericAdapter
+        @adapter.add_class_helper_methods_to klass
+        @searchable_prefixes = nil # force rebuild of the searchable prefixes
+      end
+      
+      # Get the blueprint for a class
+      def blueprint_for(klass)
+        @blueprints[klass] if @blueprints
+      end
+
+      # Return an array of all configured text methods in any blueprint
+      def searchable_prefixes
+        return [] unless @blueprints
+        return @searchable_prefixes unless @searchable_prefixes.nil?
+        prefixes = []
+        @blueprints.each do |klass, blueprint|
+          prefixes << blueprint.searchable_prefixes
+        end
+        @searchable_prefixes = prefixes.flatten.compact.uniq
+      end
+            
+    end
+
+    # ---------------------------------------------------------------------------------   
+    # Instance methods
+    # ---------------------------------------------------------------------------------       
+    attr_accessor :indexer
+    
+    # Return an array of all configured text methods in this blueprint
+    def searchable_prefixes
+      @prefixes ||= indexed_methods.map{|method_name, options| method_name}
+    end
+    
+    # Lazily build and return a module that implements accessors for each field
+    def accessors_module
+      return @accessors_module unless @accessors_module.nil?
+      @accessors_module = Module.new
+      
+      @accessors_module.instance_eval do
+        define_method :domain_class do
+          self.values[0].value
+        end
+      end
+      
+      @attributes.each_with_index do |field, index|
+        @accessors_module.instance_eval do
+          define_method field do
+            YAML::load(self.values[index+1].value)
+          end
+        end
+      end
+      # Let the adapter add its document helper methods (if any)
+      adapter = XapianDb::Config.adapter || XapianDb::Adapters::GenericAdapter
+      adapter.add_doc_helper_methods_to(@accessors_module)
+      @accessors_module
+    end
+          
+    # ---------------------------------------------------------------------------------   
+    # Blueprint DSL methods
+    # ---------------------------------------------------------------------------------   
+    attr_reader :adapter, :attributes, :indexed_methods
+        
+    # Construct the blueprint
+    def initialize
+      @attributes = []
+      @indexed_methods = {}
+    end
+    
+    # Set a custom adapter for this blueprint
+    def adapter=(adapter)
+      @adapter = adapter
+    end
+    
+    # Add an attribute to the list
+    # TODO: Make sure the name does not collide with a method name of Xapian::Document since
+    # we generate methods in the documents for all defined fields
+    def attribute(name, options={})
+      opts = {:index => true}.merge(options)
+      @attributes << name
+      self.index(name, opts) if opts[:index]
+    end
+
+    # Add an indexed value to the list
+    def index(name, options={})
+      @indexed_methods[name] = IndexOptions.new(options)
+    end
+
+    # Options for an indexed text
+    class IndexOptions      
+      attr_accessor :weight
+      
+      def initialize(options)
+        @weight = options[:weight] || 1
+      end
+    end
+          
+  end
+  
+end

data/lib/xapian_db/index_writers/direct_writer.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+# This writer writes changes directly to the open database. 
+# Use the direct writer only for single process environments
+# (one single rails app server, e.g. one mongrel).
+# For multi process environemnts you should use a writer that
+# processes index changes through a queue.
+# @author Gernot Kogler
+
+module XapianDb
+  module IndexWriters
+    
+    class DirectWriter
+      
+      class << self
+        
+        # Update an object in the index
+        def index(obj)
+          blueprint = XapianDb::DocumentBlueprint.blueprint_for(obj.class)
+          doc = blueprint.indexer.build_document_for(obj)
+          XapianDb.database.store_doc(doc)
+          XapianDb.database.commit
+        end
+
+        # Remove an object from the index
+        def unindex(obj)
+          XapianDb.database.delete_doc_with_unique_term(obj.xapian_id)
+          XapianDb.database.commit
+        end
+
+        # Reindex all objects of a given class
+        def reindex_class(klass)
+          # First, delete all docs of this class
+          XapianDb.database.delete_docs_of_class(klass)
+          blueprint = XapianDb::DocumentBlueprint.blueprint_for(klass)
+          obj_count = klass.count
+          puts "Reindexing #{obj_count} objects..."
+          pbar = ProgressBar.new("Status", obj_count)
+          klass.all.each do |obj| 
+            doc = blueprint.indexer.build_document_for(obj)
+            XapianDb.database.store_doc(doc)
+            pbar.inc
+          end
+          XapianDb.database.commit
+        end
+        
+      end
+      
+    end 
+    
+  end
+end

data/lib/xapian_db/indexer.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+# The indexer creates a Xapian::Document from a configured object
+# @author Gernot Kogler
+
+module XapianDb
+  
+  class Indexer
+    
+    def initialize(document_blueprint)
+      @document_blueprint = document_blueprint
+    end
+    
+    # Build the doc for an object. The object must respond to 'xapian_id'.
+    # The configured adapter should implement this method.
+    def build_document_for(obj)
+      @obj = obj
+      @blueprint = DocumentBlueprint.blueprint_for(@obj.class)
+      @xapian_doc = Xapian::Document.new
+      @xapian_doc.data = @obj.xapian_id
+      store_fields
+      index_text
+      @xapian_doc
+    end
+    
+    private
+    
+    # Store all configured fields
+    def store_fields
+
+      # We store the class name of the object at position 0
+      @xapian_doc.add_value(0, @obj.class.name)
+      
+      pos = 1
+      @blueprint.attributes.each do |attribute, options|
+        value = @obj.send(attribute)
+        @xapian_doc.add_value(pos, value.to_yaml)
+        pos += 1
+      end
+    end
+    
+    # Index all configured text methods
+    def index_text
+      term_generator = Xapian::TermGenerator.new()
+      term_generator.document = @xapian_doc
+      # TODO: make this configurable globally and per document 
+      # (retrieve the language from the object, if configured)
+      stemmer = Xapian::Stem.new("english")
+      term_generator.stemmer = stemmer
+      # TODO: Configure and enable these features
+      # tg.stopper = stopper if stopper
+      # tg.stemmer = stemmer
+      # tg.set_flags Xapian::TermGenerator::FLAG_SPELLING if db.spelling
+
+      # Always index the class and the primary key
+      @xapian_doc.add_term("C#{@obj.class}")
+      @xapian_doc.add_term("Q#{@obj.xapian_id}")
+      
+      @blueprint.indexed_methods.each do |method, options|
+        value = @obj.send(method)
+        unless value.nil?
+          values = value.is_a?(Array) ? value : [value]
+          values.each do |value|
+            # Add value with field name
+            term_generator.index_text(value.to_s.downcase, options.weight, "X#{method.upcase}")
+            # Add value without field name
+            term_generator.index_text(value.to_s.downcase)
+          end
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/xapian_db/query_parser.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+# Parse a query expression and convert it to Xapian Query arguments
+# @author Gernot Kogler
+
+module XapianDb
+  
+  class QueryParser
+    
+    def initialize(database)
+      @db = database
+      
+      # Set the parser options
+      @query_flags = 0
+      @query_flags |= Xapian::QueryParser::FLAG_WILDCARD # enable wildcards
+      @query_flags |= Xapian::QueryParser::FLAG_BOOLEAN
+      @query_flags |= Xapian::QueryParser::FLAG_BOOLEAN_ANY_CASE
+    end
+    
+    def parse(expression)
+      parser            = Xapian::QueryParser.new
+      parser.database   = @db.reader
+      parser.default_op = Xapian::Query::OP_AND # Could be made configurable
+      # TODO: Setup stopper, stemmer, defaults and fields
+      
+      # Add the searchable prefixes to allow searches by field 
+      # (like "name:Kogler")
+      XapianDb::DocumentBlueprint.searchable_prefixes.each{|prefix| parser.add_prefix(prefix.to_s.downcase, "X#{prefix.to_s.upcase}") }
+      parser.parse_query(expression, @query_flags)
+    end
+    
+  end
+  
+end

data/lib/xapian_db/railtie.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# Configuration for a rails app
+# @author Gernot Kogler
+
+require 'xapian_db'
+require 'rails'
+
+module XapianDb
+  class Railtie < ::Rails::Railtie
+
+    config.before_configuration do
+
+      # Read the database configuration file if there is one
+      config_file_path = "#{Rails.root}/config/xapian_db.yml"
+      if File.exist?(config_file_path)
+        db_config = YAML::load_file config_file_path
+        env_config = db_config[Rails.env]
+        database_path = env_config["database"] || ":memory:"
+        adapter       = env_config["adapter"]  || :active_record
+        writer        = env_config["writer"]   || :direct
+      else
+        # No config file, set the defaults
+        Rails.env == "test" ? database_path = ":memory:" : database_path = "db/xapian_db/#{Rails.env}"
+        adapter = :active_record
+        writer  = :direct
+      end
+      
+      # Do the configuration
+      XapianDb::Config.setup do |config|
+        if database_path == ":memory:"
+          config.database :memory
+        else
+          config.database database_path
+        end
+        config.adapter adapter.to_sym  
+        config.writer writer.to_sym
+      end
+      
+    end
+    
+  end
+end

data/lib/xapian_db/resultset.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+# The resultset holds a Xapian::Query object and allows paged access
+# to the found documents.
+# author Gernot Kogler
+
+module XapianDb
+  
+  class Resultset
+    
+    attr_reader :size
+    
+    # Constructor
+    # @param [Xapian::Enquire] a Xapian query result
+    def initialize(enquiry)
+      @enquiry = enquiry
+      # By passing 0 as the max parameter to the mset method,
+      # we only get statistics about the query, no results
+      @size = enquiry.mset(0, 0).matches_estimated
+    end
+
+    # Paginate the result
+    def paginate(opts={})
+      options = {:page => 1, :per_page => 10}.merge(opts)
+      offset = (options[:page] - 1) * options[:per_page]
+      return [] if offset > @size
+      build_page(offset, options[:per_page])
+    end
+    
+    private
+    
+    # Build a page of Xapian documents
+    def build_page(offset, count)
+      docs = []
+      result_window = @enquiry.mset(offset, count)
+      result_window.matches.each do |match|
+        docs << decorate(match.document)
+      end
+      docs
+    end
+    
+    # Decorate a Xapian document with field accessors
+    def decorate(document)
+      klass_name = document.values[0].value
+      blueprint  = XapianDb::DocumentBlueprint.blueprint_for(Kernel.const_get(klass_name))
+      document.extend blueprint.accessors_module
+    end
+              
+  end
+  
+end

data/lib/xapian_db.rb

@@ -0,0 +1,57 @@
+require 'digest/sha1'
+require 'rubygems'
+require 'xapian'
+require 'yaml'
+require 'progressbar'
+
+module XapianDb
+
+  # Configure XapianDb
+  def self.setup(&block)
+    XapianDb::Config.setup(&block)
+  end
+  
+  # Create a database. Overwrites an existing database on disk, if
+  # option :in_memory is set to false.
+  def self.create_db(options = {})
+    if options[:path] 
+      PersistentDatabase.new(:path => options[:path], :create => true) 
+    else
+      InMemoryDatabase.new
+    end
+  end
+
+  # Open a database.
+  def self.open_db(options = {})
+    if options[:path] 
+      PersistentDatabase.new(:path => options[:path], :create => false) 
+    else
+      InMemoryDatabase.new
+    end
+  end
+  
+  # Access he configured database
+  def self.database
+    XapianDb::Config.database
+  end
+  
+  # Query the database
+  def self.search(expression)
+    XapianDb::Config.database.search(expression)
+  end
+  
+end
+
+require File.dirname(__FILE__) + '/xapian_db/config'
+require File.dirname(__FILE__) + '/xapian_db/adapters/generic_adapter'
+require File.dirname(__FILE__) + '/xapian_db/adapters/datamapper_adapter'
+require File.dirname(__FILE__) + '/xapian_db/adapters/active_record_adapter'
+require File.dirname(__FILE__) + '/xapian_db/index_writers/direct_writer'
+require File.dirname(__FILE__) + '/xapian_db/database'
+require File.dirname(__FILE__) + '/xapian_db/document_blueprint'
+require File.dirname(__FILE__) + '/xapian_db/indexer'
+require File.dirname(__FILE__) + '/xapian_db/query_parser'
+require File.dirname(__FILE__) + '/xapian_db/resultset'
+
+# Configure XapianDB if we are in a Rails app
+require File.dirname(__FILE__) + '/xapian_db/railtie' if defined?(Rails)

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: xapian_db
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
+platform: ruby
+authors: 
+- Gernot kogler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: progressbar
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 0
+        version: 0.9.0
+  type: :runtime
+  version_requirements: *id001
+description: Ruby library to use a Xapian db as a key/value store with high performance fulltext search
+email: gernot.kogler (at) garaio (dot) com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+files: 
+- CHANGELOG
+- lib/xapian_db.rb
+- lib/xapian_db/railtie.rb
+- lib/xapian_db/config.rb
+- lib/xapian_db/index_writers/direct_writer.rb
+- lib/xapian_db/database.rb
+- lib/xapian_db/document_blueprint.rb
+- lib/xapian_db/indexer.rb
+- lib/xapian_db/adapters/generic_adapter.rb
+- lib/xapian_db/adapters/datamapper_adapter.rb
+- lib/xapian_db/adapters/active_record_adapter.rb
+- lib/xapian_db/query_parser.rb
+- lib/xapian_db/resultset.rb
+- examples/basic.rb
+has_rdoc: true
+homepage: https://github.com/garaio/xapian_db
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Xapian-DB
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby library to use a Xapian db as a key/value store with high performance fulltext search
+test_files: []
+