xapit 0.2.7 → 0.3.0

data/features/suggestions.feature

@@ -1,17 +1,23 @@
-Background:
-  Given an empty database at "tmp/xapiandatabase"
+Feature: Suggestions
 
-Scenario: Spelling suggestion
-  Given indexed records named "Zebra, Apple, Bike"
-  When I query for "zerba bike aple"
-  Then I should have "zebra bike apple" as a spelling suggestion
+  Scenario: Spelling suggestion
+    Given an empty database at "tmp/spellingdb"
+    And spelling is enabled
+    And indexed records named "Zebra, Apple, Bike"
+    When I query for "zerba bike aple"
+    Then I should have "zebra bike apple" as a spelling suggestion
 
-Scenario: Match similar words with stemming
-  Given indexed records named "flies, fly, glider"
-  When I query for "flying"
-  Then I should find records named "flies, fly"
+  Scenario: No spelling suggestion
+    Given indexed records named "Zebra, Apple, Bike"
+    When I query for "zerba bike aple"
+    Then I should have "" as a spelling suggestion
 
-Scenario: Find similar records
-  Given indexed records named "Jason John Smith, John Doe, Jason Smith, Jacob Johnson"
-  When I query for similar records for "Jason John Smith"
-  Then I should find records named "Jason Smith, John Doe"
+  Scenario: Find similar records
+    Given indexed records named "Jason John Smith, John Doe, Jason Smith, Jacob Johnson"
+    When I query for similar records for "Jason John Smith"
+    Then I should find records named "Jason Smith, John Doe"
+
+  Scenario: Match similar words with stemming
+    Given indexed records named "flies, fly, glider"
+    When I query for "flying"
+    Then I should find records named "flies, fly"

data/features/support/env.rb

@@ -1,7 +1,14 @@
-require 'cucumber'
-require 'spec'
-require 'active_support'
-require 'fileutils'
+require 'bundler/setup'
 
-require File.dirname(__FILE__) + '/../../lib/xapit'
-require File.dirname(__FILE__) + '/../../spec/xapit_member'
+Bundler.require(:default)
+
+require File.expand_path('../../../spec/support/xapit_member', __FILE__)
+
+Before do
+  Xapit.reset_config
+  Xapit.config[:spelling] = false
+end
+
+at_exit do
+  $server.close if $server
+end

data/features/support/xapit_helpers.rb

@@ -1,16 +1,15 @@
 module XapitHelpers
   def create_records(records,  perform_index = true)
-    Xapit.remove_database
     XapitMember.delete_all
-    XapitMember.xapit do |index|
+    XapitMember.xapit do
       records.first.keys.each do |attribute|
         if block_given?
-          yield(index, attribute)
+          yield(self, attribute)
         else
-          index.text attribute
-          index.field attribute
-          index.facet attribute
-          index.sortable attribute
+          text attribute
+          field attribute
+          facet attribute
+          sortable attribute
         end
       end
     end
@@ -18,9 +17,9 @@ module XapitHelpers
       attributes.each do |key, value|
         attributes[key] = value.split(', ') if value.include? ', '
       end
-      XapitMember.new(attributes.symbolize_keys)
+      member = XapitMember.new(attributes)
+      member.class.xapit_index_builder.add_document(member) if perform_index
     end
-    Xapit.index_all if perform_index
   end
 end
 

data/lib/generators/xapit/install_generator.rb

@@ -0,0 +1,14 @@
+module Xapit
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def self.source_root
+        File.dirname(__FILE__) + "/templates"
+      end
+
+      def copy_files
+        copy_file "xapit.yml", "config/xapit.yml"
+        copy_file "xapit.ru", "xapit.ru"
+      end
+    end
+  end
+end

data/lib/generators/xapit/templates/xapit.ru

@@ -0,0 +1,6 @@
+require "rubygems"
+require "xapit"
+
+Xapit.load_config(File.expand_path('../config/xapit.yml', __FILE__), "production")
+
+run Xapit::Server::App.new

data/lib/generators/xapit/templates/xapit.yml

@@ -0,0 +1,11 @@
+# See https://github.com/ryanb/xapit/wiki/Configuration
+development:
+  database_path: "db/xapit"
+
+test:
+  enabled: false
+  spelling: false
+
+production:
+  database_path: "db/xapit"
+  server: "http://localhost:9292"

data/lib/xapit.rb

@@ -1,71 +1,113 @@
-require 'digest/sha1'
-require 'rubygems'
 require 'xapian'
+require 'digest/sha1'
+require 'rack'
+require 'json'
+require 'net/http'
 
-# Looking for more documentation? A good place to start is Xapit::Membership
 module Xapit
-  # Index all membership classes with xapit defined. Delegates to Xapit::IndexBlueprint.
-  # You will likely want to call Xapit.remove_database before this.
-  def self.index_all(*args, &block)
-    IndexBlueprint.index_all(*args, &block)
-  end
-  
-  # Used to perform a search on all indexed models. The returned collection can
-  # contain instances of different classes which were indexed.
-  # 
-  #   # perform a simple full text search
-  #   @records = Xapit.search("phone")
-  # 
-  # See Xapit::Membership for details on search options.
-  def self.search(*args)
-    Collection.new(nil, *args)
-  end
-  
-  # Setup configuration options. The following options are supported.
-  # 
-  # <tt>:database_path</tt>:     Where the database is stored.
-  # <tt>:stemming</tt>:          The language to use for stemming, defaults to "english".
-  # <tt>:spelling</tt>:          True or false to enable/disable spelling, defaults to true.
-  # <tt>:indexer</tt>:           Class to handle the indexing, defaults to SimpleIndexer.
-  # <tt>:query_parser</tt>:      Class to handle the parsing, defaults to ClassicQueryParser.
-  # <tt>:breadcrumb_facets</tt>: Use breadcrumb mode for applied facets. See Collection#applied_facet_options for details.
-  #
-  def self.setup(*args)
-    Config.setup(*args)
-  end
-  
-  # Removes the configured database file and clears the stored one in memory.
-  def self.remove_database
-    Config.remove_database
-  end
-  
-  def self.serialize_value(value)
-    if value.kind_of?(Date)
-      Xapian.sortable_serialise(value.to_time.to_i)
-    elsif value.kind_of?(Time)
-      Xapian.sortable_serialise(value.to_i)
-    elsif value.kind_of?(Numeric) || value.to_s =~ /^[0-9]+$/
-      Xapian.sortable_serialise(value.to_f)
-    else
-      value.to_s.downcase
+  # A general Xapit exception
+  class Error < StandardError; end
+
+  # Raised when accessing the database when Xapit is disabled
+  class Disabled < Error; end
+
+  class << self
+    attr_reader :config
+
+    def reset_config
+      @database = nil
+      @config = {
+        :enabled => true,
+        :spelling => true,
+        :stemming => "english"
+      }
+    end
+
+    def reload
+      reset_config
+      @config.merge!(@loaded_config) if @loaded_config
+    end
+
+    def database
+      raise Disabled, "Unable to access Xapit database because it is disabled in configuration." unless Xapit.config[:enabled]
+      if config[:server]
+        @database ||= Xapit::Client::RemoteDatabase.new(config[:server])
+      else
+        @database ||= Xapit::Server::Database.new(config[:database_path])
+      end
+    end
+
+    def load_config(filename, environment)
+      @loaded_config = symbolize_keys(YAML.load_file(filename)[environment.to_s])
+      raise ArgumentError, "The #{environment} environment does not exist in #{filename}" if @loaded_config.nil?
+      @config.merge!(@loaded_config)
+    end
+
+    def value_index(type, attribute)
+      Zlib.crc32(["xapit", type, attribute].join) % 99999999 # TODO: Figure out the true max of a xapian value index
+    end
+
+    def facet_identifier(attribute, value)
+      Digest::SHA1.hexdigest(["xapit", attribute, value].join)[0..6]
+    end
+
+    def search(*args)
+      Xapit::Client::Collection.new.not_in_classes("FacetOption").search(*args)
+    end
+
+    def serialize_value(value)
+      if value.kind_of?(Time)
+        Xapian.sortable_serialise(value.to_i)
+      elsif value.kind_of?(Numeric) || value.to_s =~ /^[0-9]+$/
+        Xapian.sortable_serialise(value.to_f)
+      else
+        value.to_s.downcase
+      end
+    end
+
+    def enable
+      config[:enabled] = true
+    end
+
+    def index(*models)
+      models.each do |model|
+        model.xapit_model_adapter.index_all
+      end
+    end
+
+    # from http://snippets.dzone.com/posts/show/11121
+    # could use some refactoring
+    def symbolize_keys(arg)
+      case arg
+      when Array
+        arg.map { |elem| symbolize_keys(elem) }
+      when Hash
+        Hash[
+          arg.map { |key, value|
+            k = key.is_a?(String) ? key.to_sym : key
+            v = symbolize_keys(value)
+            [k,v]
+          }]
+      else
+        arg
+      end
     end
   end
+
+  reset_config
 end
 
-require File.dirname(__FILE__) + '/xapit/membership'
-require File.dirname(__FILE__) + '/xapit/index_blueprint'
-require File.dirname(__FILE__) + '/xapit/collection'
-require File.dirname(__FILE__) + '/xapit/config'
-require File.dirname(__FILE__) + '/xapit/facet_blueprint'
-require File.dirname(__FILE__) + '/xapit/facet'
-require File.dirname(__FILE__) + '/xapit/facet_option'
-require File.dirname(__FILE__) + '/xapit/query'
-require File.dirname(__FILE__) + '/xapit/query_parsers/abstract_query_parser'
-require File.dirname(__FILE__) + '/xapit/query_parsers/simple_query_parser'
-require File.dirname(__FILE__) + '/xapit/query_parsers/classic_query_parser'
-require File.dirname(__FILE__) + '/xapit/indexers/abstract_indexer'
-require File.dirname(__FILE__) + '/xapit/indexers/simple_indexer'
-require File.dirname(__FILE__) + '/xapit/indexers/classic_indexer'
-require File.dirname(__FILE__) + '/xapit/adapters/abstract_adapter'
-require File.dirname(__FILE__) + '/xapit/adapters/active_record_adapter'
-require File.dirname(__FILE__) + '/xapit/adapters/data_mapper_adapter'
+require 'xapit/server/database'
+require 'xapit/server/query'
+require 'xapit/server/indexer'
+require 'xapit/server/app'
+require 'xapit/client/membership'
+require 'xapit/client/index_builder'
+require 'xapit/client/collection'
+require 'xapit/client/facet'
+require 'xapit/client/facet_option'
+require 'xapit/client/remote_database'
+require 'xapit/client/railtie' if defined? Rails
+require 'xapit/client/model_adapters/abstract_model_adapter'
+require 'xapit/client/model_adapters/default_model_adapter'
+require 'xapit/client/model_adapters/active_record_adapter'

data/lib/xapit/client/collection.rb

@@ -0,0 +1,150 @@
+module Xapit
+  module Client
+    class Collection
+      DEFAULT_PER_PAGE = 20
+
+      attr_reader :clauses
+
+      def initialize(clauses = [])
+        @clauses = clauses
+      end
+
+      def in_classes(*classes)
+        scope(:in_classes, classes)
+      end
+
+      def not_in_classes(*classes)
+        scope(:not_in_classes, classes)
+      end
+
+      def search(phrase = nil)
+        if phrase && !phrase.empty?
+          scope(:search, phrase)
+        else
+          self
+        end
+      end
+
+      def where(conditions)
+        scope(:where, where_conditions(conditions))
+      end
+
+      def not_where(conditions)
+        scope(:not_where, where_conditions(conditions))
+      end
+
+      def or_where(conditions)
+        scope(:or_where, where_conditions(conditions))
+      end
+
+      def order(column, direction = :asc)
+        scope(:order, [column, direction])
+      end
+
+      def page(page_num)
+        scope(:page, page_num)
+      end
+
+      def per(per_page)
+        scope(:per_page, per_page)
+      end
+
+      def similar_to(member)
+        scope(:similar_to, member.class.xapit_index_builder.document_data(member))
+      end
+
+      def with_facets(facets)
+        facets.to_s.length.zero? ? self : scope(:with_facets, facets.split("-"))
+      end
+
+      def include_facets(*facets)
+        facets.empty? ? self : scope(:include_facets, facets)
+      end
+
+      def records
+        @records ||= query[:records].map { |record| Kernel.const_get(record[:class]).find(record[:id]) }
+      end
+
+      def total_entries
+        query[:total].to_i
+      end
+
+      def current_page
+        (clause_value(:page) || 1).to_i
+      end
+
+      def limit_value
+        (clause_value(:per_page) || DEFAULT_PER_PAGE).to_i
+      end
+
+      def num_pages
+        (total_entries.to_f / limit_value).ceil
+      end
+      alias_method :total_pages, :num_pages
+
+      def applied_facet_options
+        query[:applied_facet_options].map do |option|
+          FacetOption.new(option[:name], {:value => option[:value]}, applied_facet_identifiers)
+        end
+      end
+
+      def applied_facet_identifiers
+        query[:applied_facet_options].map { |option| option[:id] }
+      end
+
+      def facets
+        @facets ||= fetch_facets.select { |f| f.options.size > 0 }
+      end
+
+      def spelling_suggestion
+        @spelling_suggestion ||= Xapit.database.spelling_suggestion(@clauses)
+      end
+
+      def respond_to?(method, include_private = false)
+        Array.method_defined?(method) || super
+      end
+
+      private
+
+      def where_conditions(conditions)
+        conditions.keys.each do |key|
+          if conditions[key].kind_of? Range
+            conditions[key] = {:from => conditions[key].begin, :to => conditions[key].end}
+          end
+        end
+        conditions
+      end
+
+      def fetch_facets
+        applied_facets = applied_facet_options.map(&:identifier)
+        query[:facets].map { |attribute, options| Facet.new(attribute, filter_facet_options(options), applied_facets) }
+      end
+
+      def filter_facet_options(options)
+        options.select do |option|
+          option[:count].to_i < total_entries
+        end
+      end
+
+      def clause_value(key)
+        clauses.map { |clause| clause[key] }.compact.first
+      end
+
+      def query
+        @query ||= Xapit.database.query(@clauses)
+      end
+
+      def scope(type, args)
+        Collection.new(@clauses + [{type => args}])
+      end
+
+      def method_missing(method, *args, &block)
+        if Array.method_defined?(method)
+          records.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end