erichummel-sunspot 1.2.1a

data/lib/sunspot/search/field_facet.rb

@@ -0,0 +1,88 @@
+module Sunspot
+  module Search
+    # 
+    # A FieldFacet is a facet whose rows are all values for a certain field, in
+    # contrast to a QueryFacet, whose rows represent arbitrary queries.
+    #
+    class FieldFacet < QueryFacet
+      def initialize(field, search, options) #:nodoc:
+        super((options[:name] || field.name).to_sym, search, options)
+        @field = field
+      end
+
+      def field_name
+        @field.name
+      end
+
+      # 
+      # Get the rows returned for this facet.
+      #
+      # ==== Options (options)
+      #
+      # :verify::
+      #   Only return rows for which the referenced object exists in the data
+      #   store. This option is ignored unless the field associated with this
+      #   facet is configured with a :references argument.
+      #
+      # ==== Returns
+      #
+      # Array:: Array of FacetRow objects
+      #
+      def rows(options = {})
+        if options[:verify]
+          verified_rows
+        else
+          @rows ||=
+            begin
+              rows = super
+              has_query_facets = !rows.empty?
+              if @search.facet_response['facet_fields']
+                if data = @search.facet_response['facet_fields'][key]
+                  data.each_slice(2) do |value, count|
+                    row = FacetRow.new(@field.cast(value), count, self)
+                    rows << row
+                  end
+                end
+              end
+              sort_rows!(rows) if has_query_facets
+              rows
+            end
+        end
+      end
+
+      # 
+      # If this facet references a model class, populate the rows with instances
+      # of the model class by loading them out of the appropriate adapter.
+      #
+      def populate_instances #:nodoc:
+        if reference = @field.reference
+          values_hash = rows.inject({}) do |hash, row|
+            hash[row.value] = row
+            hash
+          end
+          instances = Adapters::DataAccessor.create(Sunspot::Util.full_const_get(reference)).load_all(
+            values_hash.keys
+          )
+          instances.each do |instance|
+            values_hash[Adapters::InstanceAdapter.adapt(instance).id].instance = instance
+          end
+          true
+        end
+      end
+
+      private
+
+      def verified_rows
+        if @field.reference
+          @verified_rows ||= rows.select { |row| row.instance }
+        else
+          rows
+        end
+      end
+      
+      def key
+        @key ||= (@options[:name] || @field.indexed_name).to_s
+      end
+    end
+  end
+end

data/lib/sunspot/search/highlight.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  module Search
+    # 
+    # A Highlight represents a single highlighted fragment of text from a
+    # document. Depending on the highlighting parameters used for search, there
+    # may be more than one Highlight object for a given field in a given result.
+    #
+    class Highlight
+      HIGHLIGHT_MATCHER = /@@@hl@@@(.*?)@@@endhl@@@/ #:nodoc:
+      
+      #
+      # The name of the field in which the highlight appeared.
+      #
+      attr_reader :field_name
+            
+      def initialize(field_name, highlight) #:nodoc:
+        @field_name = field_name.to_sym
+        @highlight = highlight.to_s.strip
+      end
+      
+      #
+      # Returns the highlighted text with formatting according to the template given in &block.
+      # When no block is given, <em> and </em> are used to surround the highlight.
+      #
+      # ==== Example
+      #
+      #   search.highlights(:body).first.format { |word| "<strong>#{word}</strong>" }
+      #
+      def format(&block)
+        block ||= proc { |word| "<em>#{word}</em>" }
+        @highlight.gsub(HIGHLIGHT_MATCHER) do
+          block.call(Regexp.last_match[1])
+        end
+      end
+      alias_method :formatted, :format
+    end
+  end
+end

data/lib/sunspot/search/hit.rb

@@ -0,0 +1,136 @@
+module Sunspot
+  module Search
+    # 
+    # Hit objects represent the raw information returned by Solr for a single
+    # document. As well as the primary key and class name, hit objects give
+    # access to stored field values, keyword relevance score, and keyword
+    # highlighting.
+    #
+    class Hit
+      SPECIAL_KEYS = Set.new(%w(id type score)) #:nodoc:
+
+      # 
+      # Primary key of object associated with this hit, as string.
+      #
+      attr_reader :primary_key
+      # 
+      # Class name of object associated with this hit, as string.
+      #
+      attr_reader :class_name
+      # 
+      # Keyword relevance score associated with this result. Nil if this hit
+      # is not from a keyword search.
+      #
+      attr_reader :score
+      #
+
+      attr_writer :result #:nodoc:
+
+      def initialize(raw_hit, highlights, search) #:nodoc:
+        @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
+        @score = raw_hit['score']
+        @search = search
+        @stored_values = raw_hit
+        @stored_cache = {}
+        @highlights = highlights
+      end
+      
+      #
+      # Returns all highlights for this hit when called without parameters.
+      # When a field_name is provided, returns only the highlight for this field.
+      #
+      def highlights(field_name = nil)
+        if field_name.nil?
+          highlights_cache.values.flatten 
+        else
+          highlights_cache[field_name.to_sym]
+        end || []
+      end
+
+      #
+      # Return the first highlight found for a given field, or nil if there is
+      # none.
+      #
+      def highlight(field_name)
+        highlights(field_name).first
+      end
+
+      # 
+      # Retrieve stored field value. For any attribute field configured with
+      # :stored => true, the Hit object will contain the stored value for
+      # that field. The value of this field will be typecast according to the
+      # type of the field.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>::
+      #   The name of the field for which to retrieve the stored value.
+      # dynamic_field_name<Symbol>::
+      #   If you want to access a stored dynamic field, this should be the
+      #   dynamic component of the field name.
+      #
+      def stored(field_name, dynamic_field_name = nil)
+        field_key =
+          if dynamic_field_name
+            [field_name.to_sym, dynamic_field_name.to_sym]
+          else
+            field_name.to_sym
+          end
+        return @stored_cache[field_key] if @stored_cache.has_key?(field_key)
+        @stored_cache[field_key] = stored_value(field_name, dynamic_field_name)
+      end
+
+      # 
+      # Retrieve the instance associated with this hit. This is lazy-loaded, but
+      # the first time it is called on any hit, all the hits for the search will
+      # load their instances using the adapter's #load_all method.
+      #
+      def result
+        return @result if defined?(@result)
+        @search.populate_hits
+        @result
+      end
+      alias_method :instance, :result
+
+      def inspect #:nodoc:
+        "#<Sunspot::Search::Hit:#{@class_name} #{@primary_key}>"
+      end
+
+      private
+
+      def setup
+        @setup ||= Sunspot::Setup.for(Util.full_const_get(@class_name))
+      end
+
+      def highlights_cache
+        @highlights_cache ||=
+          begin
+            cache = {}
+            if @highlights
+              @highlights.each_pair do |indexed_field_name, highlight_strings|
+                field_name = indexed_field_name.sub(/_[a-z]+$/, '').to_sym
+                cache[field_name] = highlight_strings.map do |highlight_string|
+                  Highlight.new(field_name, highlight_string)
+                end
+              end
+            end
+            cache
+          end
+      end
+
+      def stored_value(field_name, dynamic_field_name)
+        setup.stored_fields(field_name, dynamic_field_name).each do |field|
+          if value = @stored_values[field.indexed_name]
+            case value
+            when Array
+              return value.map { |item| field.cast(item) }
+            else
+              return field.cast(value)
+            end
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/sunspot/search/more_like_this_search.rb

@@ -0,0 +1,31 @@
+module Sunspot
+  # 
+  # This class encapsulates the results of a Solr MoreLikeThis search. It provides access
+  # to search results, total result count, and pagination information.
+  # Instances of MoreLikeThis are returned by the Sunspot.more_like_this and
+  # Sunspot.new_more_like_this methods.
+  #
+  module Search
+    class MoreLikeThisSearch < AbstractSearch
+      def execute
+        if @query.more_like_this.fields.empty?
+          @setup.all_more_like_this_fields.each do |field|
+            @query.more_like_this.add_field(field)
+          end
+        end
+        super
+      end
+
+      def request_handler
+        super || :mlt
+      end
+
+      private
+
+      # override
+      def dsl
+        DSL::MoreLikeThisQuery.new(self, @query, @setup)
+      end
+    end
+  end
+end

data/lib/sunspot/search/query_facet.rb

@@ -0,0 +1,67 @@
+module Sunspot
+  module Search
+    class QueryFacet
+      RequestedFacet = Struct.new(:label, :boolean_phrase) #:nodoc:
+
+      attr_reader :name
+
+      def initialize(name, search, options) #:nodoc:
+        @name, @search, @options = name, search, options
+        @requested_facets = []
+      end
+
+      def rows(options = {})
+        @rows ||=
+          begin
+            data = @search.facet_response['facet_queries']
+            rows = []
+            minimum_count =
+              case
+              when @options[:minimum_count] then @options[:minimum_count]
+              when @options[:zeros] then 0
+              else 1
+              end
+            @requested_facets.each do |requested_facet|
+              count = data[requested_facet.boolean_phrase] || 0
+              if count >= minimum_count
+                rows << FacetRow.new(requested_facet.label, count, self)
+              end
+            end
+            sort_rows!(rows)
+          end
+      end
+
+      def add_row(label, boolean_phrase) #:nodoc:
+        @requested_facets << RequestedFacet.new(label, boolean_phrase)
+      end
+
+      private
+
+      def sort_rows!(rows)
+        case @options[:sort] || (:count if limit)
+        when :count
+          rows.sort! { |lrow, rrow| rrow.count <=> lrow.count }
+        when :index
+          rows.sort! do |lrow, rrow|
+            if lrow.respond_to?(:<=>)
+              lrow.value <=> rrow.value
+            elsif lrow.respond_to?(:first) && rrow.respond_to?(:first) && lrow.first.respond_to?(:<=>)
+              lrow.first.value <=> rrow.first.value
+            else
+              lrow.value.to_s <=> rrow.value.to_s
+            end
+          end
+        end
+        if limit
+          rows.replace(rows.first(limit))
+        end
+        rows
+      end
+
+      def limit
+        return @limit if defined?(@limit)
+        @limit = (@options[:limit].to_i if @options[:limit].to_i > 0)
+      end
+    end
+  end
+end

data/lib/sunspot/search/standard_search.rb

@@ -0,0 +1,21 @@
+module Sunspot
+  module Search
+    # 
+    # This class encapsulates the results of a Solr search. It provides access
+    # to search results, total result count, facets, and pagination information.
+    # Instances of Search are returned by the Sunspot.search and
+    # Sunspot.new_search methods.
+    #
+    class StandardSearch < AbstractSearch
+      def request_handler
+        super || :select
+      end
+  
+      private
+  
+      def dsl
+        DSL::Search.new(self, @setup)
+      end
+    end
+  end
+end

data/lib/sunspot/search.rb

@@ -0,0 +1,9 @@
+%w(abstract_search standard_search more_like_this_search query_facet field_facet
+   date_facet facet_row hit highlight).each do |file|
+  require File.join(File.dirname(__FILE__), 'search', file)
+end
+
+module Sunspot
+  module Search
+  end
+end

data/lib/sunspot/server.rb

@@ -0,0 +1,152 @@
+require 'escape'
+require 'set'
+require 'tempfile'
+
+module Sunspot
+  class Server #:nodoc:
+    # Raised if #stop is called but the server is not running
+    ServerError = Class.new(RuntimeError)
+    AlreadyRunningError = Class.new(ServerError)
+    NotRunningError = Class.new(ServerError)
+
+    # Name of the sunspot executable (shell script)
+    SOLR_START_JAR = File.expand_path(
+      File.join(File.dirname(__FILE__), '..', '..', 'solr', 'start.jar')
+    )
+
+    LOG_LEVELS = Set['SEVERE', 'WARNING', 'INFO', 'CONFIG', 'FINE', 'FINER', 'FINEST']
+
+    attr_accessor :min_memory, :max_memory, :port, :solr_data_dir, :solr_home, :log_file
+    attr_writer :pid_dir, :pid_file, :log_level, :solr_data_dir, :solr_home, :solr_jar
+
+    #
+    # Start the sunspot-solr server. Bootstrap solr_home first,
+    # if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def start
+      if File.exist?(pid_path)
+        existing_pid = IO.read(pid_path).to_i
+        begin
+          Process.kill(0, existing_pid)
+          raise(AlreadyRunningError, "Server is already running with PID #{existing_pid}")
+        rescue Errno::ESRCH
+          STDERR.puts("Removing stale PID file at #{pid_path}")
+          FileUtils.rm(pid_path)
+        end
+      end
+      fork do
+        pid = fork do
+          Process.setsid
+          STDIN.reopen('/dev/null')
+          STDOUT.reopen('/dev/null', 'a')
+          STDERR.reopen(STDOUT)
+          run
+        end
+        FileUtils.mkdir_p(pid_dir)
+        File.open(pid_path, 'w') do |file|
+          file << pid
+        end
+      end
+    end
+
+    # 
+    # Run the sunspot-solr server in the foreground. Boostrap
+    # solr_home first, if neccessary.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def run
+      command = ['java']
+      command << "-Xms#{min_memory}" if min_memory
+      command << "-Xmx#{max_memory}" if max_memory
+      command << "-Djetty.port=#{port}" if port
+      command << "-Dsolr.data.dir=#{solr_data_dir}" if solr_data_dir && !multicore
+      command << "-Dsolr.solr.home=#{solr_home}" if solr_home
+      command << "-Djava.util.logging.config.file=#{logging_config_path}" if logging_config_path
+      command << '-jar' << File.basename(solr_jar)
+      FileUtils.cd(File.dirname(solr_jar)) do
+        exec(Escape.shell_command(command))
+      end
+    end
+
+    # 
+    # Stop the sunspot-solr server.
+    #
+    # ==== Returns
+    #
+    # Boolean:: success
+    #
+    def stop
+      if File.exist?(pid_path)
+        pid = IO.read(pid_path).to_i
+        begin
+          Process.kill('TERM', pid)
+        rescue Errno::ESRCH
+          raise NotRunningError, "Process with PID #{pid} is no longer running"
+        ensure
+          FileUtils.rm(pid_path)
+        end
+      else
+        raise NotRunningError, "No PID file at #{pid_path}"
+      end
+    end
+
+    def log_level=(level)
+      unless LOG_LEVELS.include?(level.to_s.upcase)
+        raise(ArgumentError, "#{level} is not a valid log level: Use one of #{LOG_LEVELS.to_a.join(',')}")
+      end
+      @log_level = level.to_s.upcase
+    end
+
+    def log_level
+      @log_level || 'WARNING'
+    end
+
+    def pid_path
+      File.join(pid_dir, pid_file)
+    end
+
+    def pid_file
+      @pid_file || 'sunspot-solr.pid'
+    end
+
+    def pid_dir
+      File.expand_path(@pid_dir || FileUtils.pwd)
+    end
+
+    def solr_data_dir
+      File.expand_path(@solr_data_dir || Dir.tmpdir)
+    end
+
+    def solr_home
+      File.expand_path(@solr_home || File.join(File.dirname(solr_jar), 'solr'))
+    end
+
+    def solr_jar
+      @solr_jar || SOLR_START_JAR
+    end
+
+    private
+
+    def logging_config_path
+      return @logging_config_path if defined?(@logging_config_path)
+      @logging_config_path =
+        if log_file
+          logging_config = Tempfile.new('logging.properties')
+          logging_config.puts("handlers = java.util.logging.FileHandler")
+          logging_config.puts("java.util.logging.FileHandler.level = #{log_level.to_s.upcase}")
+          logging_config.puts("java.util.logging.FileHandler.pattern = #{log_file}")
+          logging_config.puts("java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter")
+          logging_config.flush
+          logging_config.close
+          logging_config.path
+        end
+    end
+  end
+end