erichummel-sunspot 1.2.1 → 2.0.0.pre.111215

data/VERSION.yml

@@ -1,4 +0,0 @@
---- 
-:minor: 10
-:patch: 8
-:major: 0

data/bin/sunspot-installer

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'sunspot', 'installer')
-
-home = ARGV.select { |arg| arg !~ /^-/ }.last || Dir.pwd
-options = {}
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: sunspot-install [options] [solr-home]"
-  opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
-    options[:verbose] = v
-  end
-  opts.on('-f', '--[no-]force', 'Overwrite schema and solrconfig files with Sunspot default, instead of modifying them (recommended for new Solr installation)') do |f|
-    options[:force] = f
-  end
-end.parse!
-
-Sunspot::Installer.execute(home, options)

data/bin/sunspot-solr

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-begin
-  require 'fileutils'
-  require 'tempfile'
-  require 'tmpdir'
-  require 'optparse'
-  require File.join(File.dirname(__FILE__), '..', 'lib', 'sunspot', 'server')
-rescue LoadError => e
-  if require 'rubygems'
-    retry
-  else
-    raise(e)
-  end
-end
-
-server = Sunspot::Server.new
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: sunspot-solr start [options]"
-
-  opts.on '-p', '--port=PORT', 'Port on which to run Solr (default 8983)' do |p|
-    server.port = p
-  end
-
-  opts.on '-d', '--data-directory=DIRECTORY', 'Solr data directory' do |d|
-    server.solr_data_dir = File.expand_path(d)
-  end
-
-  opts.on '-s', '--solr-home=HOME', 'Solr home directory (should contain conf/ directory)' do |s|
-    server.solr_home = File.expand_path(s)
-  end
-
-  opts.on '-j', '--solr-jar=JAR', 'Solr start jar' do |j|
-    server.solr_jar = File.expand_path(j)
-  end
-
-  opts.on '--pid-dir=PID_DIR', 'Directory for pid files' do |pd|
-    server.pid_dir = File.expand_path(pd)
-  end
-
-  opts.on '-l', '--log-level=LOG_LEVEL', 'Solr logging level' do |l|
-    server.log_level = l
-  end
-
-  opts.on '--log-file=LOG_FILE', 'Path to Solr log file' do |lf|
-    server.log_file = File.expand_path(lf)
-  end
-  
-  opts.on '--max-memory=MEMORY', 'Specify the maximum size of the memory allocation pool' do |mm|
-    server.max_memory = mm
-  end
-  
-  opts.on '--min-memory=MEMORY', 'Specify the initial size of the memory allocation pool' do |mm|
-    server.min_memory = mm
-  end
-end.parse!
-
-begin
-  case ARGV[0]
-  when 'start'
-    server.start
-  when 'run'
-    server.run
-  when 'stop'
-    server.stop
-  when 'restart'
-    server.stop
-    server.start
-  else
-    abort("Usage: sunspot-solr (start|stop|run)")
-  end
-rescue Sunspot::Server::ServerError => e
-  abort(e.message)
-end

data/installer/config/schema.yml

@@ -1,95 +0,0 @@
-types: !omap
-  - text:
-      class: TextField
-      suffix: text
-      omit_norms: false
-      tokenizer: StandardTokenizerFactory
-      filters:
-        - StandardFilterFactory
-        - LowerCaseFilterFactory
-      invariants:
-        multiValued: true
-  - boolean:
-      class: BoolField
-      suffix: b
-      invariants:
-        termVectors: valse
-  - date:
-      class: DateField
-      suffix: d
-      invariants:
-        termVectors: valse
-  - rand:
-      class: RandomSortField
-  - sdouble:
-      class: SortableDoubleField
-      suffix: e
-      invariants:
-        termVectors: valse
-  - sfloat:
-      class: SortableFloatField
-      suffix: f
-      invariants:
-        termVectors: valse
-  - sint:
-      class: SortableIntField
-      suffix: i
-      invariants:
-        termVectors: valse
-  - slong:
-      class: SortableLongField
-      suffix: l
-      invariants:
-        termVectors: valse
-  - string:
-      class: StrField
-      suffix: s
-      invariants:
-        termVectors: valse
-  - tint:
-      class: TrieIntField
-      suffix: it
-      invariants:
-        termVectors: valse
-  - tfloat:
-      class: TrieFloatField
-      suffix: ft
-      invariants:
-        termVectors: valse
-  - tdouble:
-      class: TrieDoubleField
-      suffix: et
-      invariants:
-        termVectors: valse
-  - tdate:
-      class: TrieDateField
-      suffix: dt
-      invariants:
-        termVectors: valse
-fixed: !omap
-  - id:
-      type: string
-      attributes: [stored]
-  - type:
-      type: string
-      attributes: [multiValued]
-  - class_name:
-      type: string
-  - text:
-      type: string
-      attributes: [multiValued]
-  - lat:
-      type: tdouble
-      attributes: [stored]
-  - lng:
-      type: tdouble
-      attributes: [stored]
-  - 'random_*':
-      type: rand
-  - '_local*':
-      type: tdouble
-    
-variants: !omap
-  - multiValued: m
-  - stored: s
-  - termVectors: v

data/lib/sunspot/installer.rb

@@ -1,31 +0,0 @@
-%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

@@ -1,45 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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