pduey-sunspot 1.2.1.1

data/lib/sunspot/installer.rb

@@ -0,0 +1,31 @@
+%w(task_helper library_installer schema_builder solrconfig_updater).each do |file|
+  require File.join(File.dirname(__FILE__), 'installer', file)
+end
+
+module Sunspot
+  class Installer
+    class <<self
+      def execute(solr_home, options = {})
+        new(solr_home, options).execute
+      end
+
+      private :new
+    end
+
+    def initialize(solr_home, options)
+      @solr_home, @options = solr_home, options
+    end
+
+    def execute
+      SchemaBuilder.execute(
+        File.join(@solr_home, 'conf', 'schema.xml'),
+        @options
+      )
+      SolrconfigUpdater.execute(
+        File.join(@solr_home, 'conf', 'solrconfig.xml'),
+        @options
+      )
+      LibraryInstaller.execute(File.join(@solr_home, 'lib'), @options)
+    end
+  end
+end

data/lib/sunspot/installer/library_installer.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+
+module Sunspot
+  class Installer
+    class LibraryInstaller
+      class <<self
+        def execute(library_path, options)
+          new(library_path, options).execute
+        end
+      end
+
+      def initialize(library_path, options)
+        @library_path = library_path
+        @verbose = !!options[:verbose]
+        @force = !!options[:force]
+      end
+
+      def execute
+        sunspot_library_path = File.join(File.dirname(__FILE__), '..', '..',
+                                         '..', 'solr', 'solr', 'lib')
+        return if File.expand_path(sunspot_library_path) == File.expand_path(@library_path)
+        FileUtils.mkdir_p(@library_path)
+        Dir.glob(File.join(sunspot_library_path, '*.jar')).each do |jar|
+          jar = File.expand_path(jar)
+          dest = File.join(@library_path, File.basename(jar))
+          if File.exist?(dest)
+            if @force
+              say("Removing existing library #{dest}")
+            else
+              next
+            end
+          end
+          say("Copying #{jar} => #{dest}")
+          FileUtils.cp(jar, dest)
+                           end
+      end
+
+      def say(message)
+        if @verbose
+          STDOUT.puts(message)
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/installer/schema_builder.rb

@@ -0,0 +1,219 @@
+require 'yaml'
+require 'rexml/rexml'
+require 'rexml/document'
+require 'fileutils'
+
+module Sunspot
+  class Installer
+    # 
+    # This class modifies an existing Solr schema.xml file to work with Sunspot.
+    # It makes the minimum necessary changes to the schema, adding fields and
+    # types only when they don't already exist. It also comments all fields and
+    # types that Sunspot needs, whether or not they were preexisting, so that
+    # users can modify the resulting schema without unwittingly breaking it.
+    #
+    class SchemaBuilder
+      include TaskHelper
+
+      CONFIG_PATH = File.join(
+        File.dirname(__FILE__), '..', '..', '..', 'installer', 'config', 'schema.yml'
+      )
+
+      class <<self
+        def execute(schema_path, options = {})
+          new(schema_path, options).execute
+        end
+        
+        private :new
+      end
+
+      def initialize(schema_path, options = {})
+        @schema_path = schema_path
+        @config = File.open(CONFIG_PATH) { |f| YAML.load(f) }
+        @verbose = !!options[:verbose]
+        @force = !!options[:force]
+      end
+
+      def execute
+        if @force
+          FileUtils.mkdir_p(File.dirname(@schema_path))
+          source_path = File.join(File.dirname(__FILE__), '..', '..', '..', 'solr', 'solr', 'conf', 'schema.xml')
+          FileUtils.cp(source_path, @schema_path)
+          say("Copied default schema.xml to #{@schema_path}")
+        else
+          @document = File.open(@schema_path) do |f|
+            Nokogiri::XML(
+              f, nil, nil,
+              Nokogiri::XML::ParseOptions::DEFAULT_XML |
+              Nokogiri::XML::ParseOptions::NOBLANKS
+            )
+          end
+          @root = @document.root
+          @added_types = Set[]
+          add_fixed_fields
+          add_dynamic_fields
+          set_misc_settings
+          original_path = "#{@schema_path}.orig"
+          FileUtils.cp(@schema_path, original_path)
+          say("Saved backup of original to #{original_path}")
+          File.open(@schema_path, 'w') do |file|
+            @document.write_xml_to(file, :indent => 2)
+          end
+          say("Wrote schema to #{@schema_path}")
+        end
+      end
+
+      private
+
+      def add_fixed_fields
+        @config['fixed'].each do |name, options|
+          maybe_add_field(name, options['type'], :indexed, *Array(options['attributes']))
+        end
+      end
+
+      def add_dynamic_fields
+        @config['types'].each do |type, options|
+          if suffix = options['suffix']
+            variant_combinations(options).each do |variants|
+              variants_suffix = variants.map { |variant| variant[1] || '' }.join
+              maybe_add_field("*_#{suffix}#{variants_suffix}", type, *variants.map { |variant| variant[0] })
+            end
+          end
+        end
+      end
+
+      def maybe_add_field(name, type, *flags)
+        node_name = name =~ /\*/ ? 'dynamicField' : 'field'
+        if field_node = fields_node.xpath(%Q(#{node_name}[@name="#{name}"])).first
+          say("Using existing #{node_name} #{name.inspect}")
+          add_comment(field_node)
+          return
+        end
+        maybe_add_type(type)
+        say("Adding field #{name.inspect}")
+        attributes = {
+          'name' => name,
+          'type' => type,
+          'indexed' => 'true',
+          'stored' => 'false',
+          'multiValued' => 'false'
+        }
+        flags.each do |flag|
+          attributes[flag.to_s] = 'true'
+        end
+        field_node = add_element(fields_node, node_name, attributes)
+        add_comment(field_node)
+      end
+
+      def maybe_add_type(type)
+        unless @added_types.include?(type)
+          @added_types << type
+          if type_node = types_node.xpath(%Q(fieldType[@name="#{type}"])).first ||
+             types_node.xpath(%Q(fieldtype[@name="#{type}"])).first
+            say("Using existing type #{type.inspect}")
+            add_comment(type_node)
+            return
+          end
+          say("Adding type #{type.inspect}")
+          type_config = @config['types'][type]
+          type_node = add_element(
+            types_node,
+            'fieldType',
+            'name' => type,
+            'class' => to_solr_class(type_config['class']),
+            'omitNorms' => type_config['omit_norms'].nil? ? 'true' : type_config['omit_norms'].to_s
+          )
+          if type_config['tokenizer']
+            add_analyzer(type_node, type_config)
+          end
+          add_comment(type_node)
+        end
+      end
+
+      def add_analyzer(node, config)
+        analyzer_node = add_element(node, 'analyzer')
+        add_element(
+          analyzer_node,
+          'tokenizer',
+          'class' => to_solr_class(config['tokenizer'])
+        )
+        Array(config['filters']).each do |filter|
+          add_element(analyzer_node, 'filter', 'class' => to_solr_class(filter))
+        end
+      end
+
+      def set_misc_settings
+        if @root.xpath('uniqueKey[normalize-space()="id"]').any?
+          say('Unique key already set')
+        else
+          say("Creating unique key node")
+          add_element(@root, 'uniqueKey').content = 'id'
+        end
+        say('Setting default operator to AND')
+        solr_query_parser_node = @root.xpath('solrQueryParser').first ||
+                                 add_element(@root, 'solrQueryParser')
+        solr_query_parser_node['defaultOperator'] = 'AND'
+      end
+
+      def add_comment(node)
+        comment_message = " *** This #{node.name} is used by Sunspot! *** "
+        unless (comment = previous_non_text_sibling(node)) && comment.comment? && comment.content =~ /Sunspot/
+          node.add_previous_sibling(Nokogiri::XML::Comment.new(@document, comment_message))
+        end
+      end
+
+      def types_node
+        @types_node ||= @root.xpath('/schema/types').first
+      end
+
+      def fields_node
+        @fields_node ||= @root.xpath('/schema/fields').first
+      end
+
+      def to_solr_class(class_name)
+        if class_name =~ /\./
+          class_name
+        else
+          "solr.#{class_name}"
+        end
+      end
+
+      def previous_non_text_sibling(node)
+        if previous_sibling = node.previous_sibling
+          if previous_sibling.node_type == :text
+            previous_non_text_sibling(previous_sibling)
+          else
+            previous_sibling
+          end
+        end
+      end
+
+      #
+      # All of the possible combinations of variants
+      #
+      def variant_combinations(type_options)
+        invariants = type_options['invariants'] || {}
+        combinations = []
+        variants = @config['variants'].reject { |name, suffix| invariants.has_key?(name) }
+        0.upto(2 ** variants.length - 1) do |b|
+          combinations << combination = []
+          variants.each_with_index do |variant, i|
+            combination << variant if b & 1<<i > 0
+          end
+          invariants.each do |name, value|
+            if value
+              combination << [name]
+            end
+          end
+        end
+        combinations
+      end
+
+      def say(message)
+        if @verbose
+          STDOUT.puts(message)
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/installer/solrconfig_updater.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'fileutils'
+require 'nokogiri'
+
+module Sunspot
+  class Installer
+    class SolrconfigUpdater
+      include TaskHelper
+
+      CONFIG_FILES = %w(solrconfig.xml elevate.xml spellings.txt stopwords.txt synonyms.txt) 
+
+      class <<self
+        def execute(solrconfig_path, options = {})
+          new(solrconfig_path, options).execute
+        end
+      end
+
+      def initialize(solrconfig_path, options)
+        @force = !!options[:force]
+        unless @force || File.exist?(solrconfig_path)
+          abort("#{File.expand_path(@solrconfig_path)} doesn't exist." +
+                " Are you sure you're pointing to a SOLR_HOME?")
+        end
+        @solrconfig_path = solrconfig_path
+        @verbose = !!options[:verbose]
+      end
+
+      def execute
+        if @force
+          config_dir = File.dirname(@solrconfig_path)
+          FileUtils.mkdir_p(config_dir)
+          CONFIG_FILES.each do |file|
+            source_path =
+              File.join(File.dirname(__FILE__), '..', '..', '..', 'solr', 'solr', 'conf', file)
+            FileUtils.cp(source_path, config_dir)
+            say("Copied default #{file} to #{config_dir}")
+          end
+        else
+          @document = File.open(@solrconfig_path) do |f|
+            Nokogiri::XML(
+              f, nil, nil, 
+              Nokogiri::XML::ParseOptions::DEFAULT_XML |
+              Nokogiri::XML::ParseOptions::NOBLANKS
+            )
+          end
+          @root = @document.root
+          maybe_add_more_like_this_handler
+          original_path = "#{@solrconfig_path}.orig"
+          FileUtils.cp(@solrconfig_path, original_path)
+          say("Saved backup of original to #{original_path}")
+          File.open(@solrconfig_path, 'w') do |file|
+            @document.write_to(
+              file,
+              :indent => 2
+            )
+          end
+          say("Wrote solrconfig to #{@solrconfig_path}")
+        end
+      end
+
+      private
+
+      def maybe_add_more_like_this_handler
+        unless @root.xpath('requestHandler[@name="/mlt"]').first
+          mlt_node = add_element(
+            @root, 'requestHandler',
+            :name => '/mlt', :class => 'solr.MoreLikeThisHandler'
+          )
+          defaults_node = add_element(mlt_node, 'lst', :name => 'defaults')
+          add_element(defaults_node, 'str', :name => 'mlt.mintf').content = '1'
+          add_element(defaults_node, 'str', :name => 'mlt.mindf').content = '2'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/installer/task_helper.rb

@@ -0,0 +1,18 @@
+module Sunspot
+  class Installer
+    module TaskHelper
+      def say(message)
+        if @verbose
+          STDOUT.puts(message)
+        end
+      end
+
+      def add_element(node, name, attributes = {})
+        new_node = Nokogiri::XML::Node.new(name, @document)
+        attributes.each_pair { |name, value| new_node[name.to_s] = value }
+        node << new_node 
+        new_node
+      end
+    end
+  end
+end

data/lib/sunspot/java.rb

@@ -0,0 +1,8 @@
+module Sunspot
+  module Java
+    def self.installed?
+      `java -version &> /dev/null`
+      $?.success?
+    end
+  end
+end

data/lib/sunspot/query.rb

@@ -0,0 +1,11 @@
+%w(filter abstract_field_facet connective boost_query date_field_facet dismax
+   field_facet highlighting pagination restriction common_query
+   standard_query more_like_this more_like_this_query geo query_facet scope
+   sort sort_composite text_field_boost function_query
+   composite_fulltext).each do |file|
+  require(File.join(File.dirname(__FILE__), 'query', file))
+end
+module Sunspot
+  module Query #:nodoc:all
+  end
+end

data/lib/sunspot/query/abstract_field_facet.rb

@@ -0,0 +1,52 @@
+module Sunspot
+  module Query
+    class AbstractFieldFacet
+      include RSolr::Char
+
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      def to_params
+        params = {
+          :facet => 'true',
+        }
+        case @options[:sort]
+        when :count
+          params[qualified_param('sort')] = 'true'
+        when :index
+          params[qualified_param('sort')] = 'false'
+        when nil
+        else
+          raise(
+            ArgumentError,
+            "#{@options[:sort].inspect} is not an allowed value for :sort. Allowed options are :count and :index"
+          )
+        end
+        if @options[:limit]
+          params[qualified_param('limit')] = @options[:limit].to_i
+        end
+        if @options[:prefix]
+          params[qualified_param('prefix')] = escape(@options[:prefix].to_s)
+        end
+        params[qualified_param('mincount')] = 
+          case
+          when @options[:minimum_count] then @options[:minimum_count].to_i
+          when @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      def qualified_param(param)
+        :"f.#{key}.facet.#{param}"
+      end
+      
+      def key
+        @key ||= @options[:name] || @field.indexed_name
+      end
+    end
+  end
+end