websolr-rails 1.4.4 → 2.0.0

data/lib/solr/xml.rb

@@ -1,44 +0,0 @@
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Solr::XML
-end
-
-begin
-  
-  # If we can load rubygems and libxml-ruby...
-  require 'rubygems'
-  require 'xml/libxml'
-  raise "acts_as_solr requires libxml-ruby 0.7 or greater" unless XML::Node.public_instance_methods.include?("attributes")
-
-  # then make a few modifications to XML::Node so it can stand in for REXML::Element
-  class XML::Node
-    # element.add_element(another_element) should work
-    alias_method :add_element, :<<
-
-
-    # element.text = "blah" should work
-    def text=(x)
-      self << x.to_s
-    end
-  end
-  
-  # And use XML::Node for our XML generation
-  Solr::XML::Element = XML::Node
-  
-rescue LoadError => e # If we can't load either rubygems or libxml-ruby
-  puts "Requiring REXML"
-  # Just use REXML.
-  require 'rexml/document'
-  Solr::XML::Element = REXML::Element
-  
-end

data/lib/solr_fixtures.rb

@@ -1,13 +0,0 @@
-module ActsAsSolr
-
-  class SolrFixtures
-    def self.load(table_names)
-      [table_names].flatten.map { |n| n.to_s }.each do |table_name|
-        klass = instance_eval(File.split(table_name.to_s).last.to_s.gsub('_',' ').split(" ").collect{|w| w.capitalize}.to_s.singularize)
-        klass.rebuild_solr_index if klass.respond_to?(:rebuild_solr_index)
-      end
-      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
-    end
-  end
-  
-end

data/lib/tasks/database.rake

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/../solr_fixtures'
-
-namespace :db do
-  namespace :fixtures do
-    desc "Load fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y"
-    task :load => :environment do
-      begin
-        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "*:*"))
-        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
-        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|    
-          ActsAsSolr::SolrFixtures.load(File.basename(fixture_file, '.*'))
-        end 
-        puts "The fixtures loaded have been added to Solr"       
-      rescue
-      end
-    end
-  end
-end

data/lib/tasks/solr.rake

@@ -1,94 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'net/http'
-require 'active_record'
-
-namespace :solr do
-
-  desc 'Starts Solr. Options accepted: RAILS_ENV=your_env, PORT=XX. Defaults to development if none.'
-  task :start do
-    puts "Use: websolr start"
-  end
-  
-  desc 'Stops Solr. Specify the environment by using: RAILS_ENV=your_env. Defaults to development if none.'
-  task :stop do
-    puts "Use: websolr stop"
-  end
-    
-  # this task is by Henrik Nyh
-  # http://henrik.nyh.se/2007/06/rake-task-to-reindex-models-for-acts_as_solr
-  desc %{Reindexes data for all acts_as_solr models. Clears index first to get rid of orphaned records and optimizes index afterwards. RAILS_ENV=your_env to set environment. ONLY=book,person,magazine to only reindex those models; EXCEPT=book,magazine to exclude those models. START_SERVER=true to solr:start before and solr:stop after. BATCH=123 to post/commit in batches of that size: default is 300. CLEAR=false to not clear the index first; OPTIMIZE=false to not optimize the index afterwards.}
-  task :reindex => :environment do
-    require "#{File.dirname(__FILE__)}/../../config/solr_environment.rb"
-
-    includes = env_array_to_constants('ONLY')
-    if includes.empty?
-      includes = Dir.glob("#{RAILS_ROOT}/app/models/*.rb").map { |path| File.basename(path, ".rb").camelize.constantize }
-    end
-    excludes = env_array_to_constants('EXCEPT')
-    includes -= excludes
-    
-    optimize            = env_to_bool('OPTIMIZE',     true)
-    start_server        = env_to_bool('START_SERVER', false)
-    clear_first         = env_to_bool('CLEAR',       true)
-    batch_size          = ENV['BATCH'].to_i.nonzero? || 300
-    debug_output        = env_to_bool("DEBUG", false)
-
-    RAILS_DEFAULT_LOGGER.level = ActiveSupport::BufferedLogger::INFO unless debug_output
-
-    if start_server
-      puts "Starting Solr server..."
-      Rake::Task["solr:start"].invoke 
-    end
-    
-    # Disable solr_optimize
-    module ActsAsSolr::CommonMethods
-      def blank() end
-      alias_method :deferred_solr_optimize, :solr_optimize
-      alias_method :solr_optimize, :blank
-    end
-    
-    models = includes.select { |m| m.respond_to?(:rebuild_solr_index) }    
-    models.each do |model|
-  
-      if clear_first
-        puts "Clearing index for #{model}..."
-        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "#{model.solr_configuration[:type_field]}:#{model}")) 
-        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
-      end
-      
-      puts "Rebuilding index for #{model}..."
-      model.rebuild_solr_index(batch_size)
-
-    end 
-
-    if models.empty?
-      puts "There were no models to reindex."
-    elsif optimize
-      puts "Optimizing..."
-      models.last.deferred_solr_optimize
-    end
-
-    if start_server
-      puts "Shutting down Solr server..."
-      Rake::Task["solr:stop"].invoke 
-    end
-    
-  end
-  
-  def env_array_to_constants(env)
-    env = ENV[env] || ''
-    env.split(/\s*,\s*/).map { |m| m.singularize.camelize.constantize }.uniq
-  end
-  
-  def env_to_bool(env, default)
-    env = ENV[env] || ''
-    case env
-      when /^true$/i then true
-      when /^false$/i then false
-      else default
-    end
-  end
-
-end
-

data/lib/tasks/test.rake

@@ -1,7 +0,0 @@
-require 'active_record'
-
-namespace :test do
-  task :migrate do
-    ActiveRecord::Migrator.migrate("test/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-  end
-end

data/lib/websolr_controller.rb

@@ -1,233 +0,0 @@
-require "uri"
-require "rubygems"
-require "restclient"
-require 'rexml/document'
-require "fileutils"
-require "net/http"
-include FileUtils
-
-SOLR_PATH = "#{File.dirname(File.expand_path(__FILE__))}/../solr" unless defined? SOLR_PATH
-SOLR_LOGS_PATH = "#{ENV["PWD"]}/log" unless defined? SOLR_LOGS_PATH
-SOLR_PIDS_PATH = "#{ENV["PWD"]}/tmp/pids" unless defined? SOLR_PIDS_PATH
-SOLR_DATA_PATH = "#{ENV["PWD"]}/solr/#{ENV['RAILS_ENV']}" unless defined? SOLR_DATA_PATH
-SOLR_JVM_OPTIONS = ENV["JAVA_OPTIONS"] || "-Xmx256M"
-
-mkdir_p SOLR_PATH
-mkdir_p SOLR_LOGS_PATH
-mkdir_p SOLR_PIDS_PATH
-mkdir_p SOLR_DATA_PATH
-
-class WebsolrController
-  COMMANDS = %w[add list delete configure local:start local:stop]
-  SOLR_PORT = 8983
-  
-  def initialize(parser)
-    @options = parser.options
-    @command = @options.delete(:command)
-    @parser = parser
-    @user = @options[:user] ||= ENV["WEBSOLR_USER"]
-    @pass = @options[:pass] ||= ENV["WEBSOLR_PWD"]
-    if @user && @pass
-      @base = "http://#{URI::escape @user}:#{URI::escape @pass}@websolr.com"
-    end
-  end
-  
-  def die(s)
-    STDERR.puts s
-    exit(1)
-  end
-  
-  def required_options(hash)
-    hash = hash.dup
-    if hash.delete(:auth) && (!@user || !@pass)
-      die <<-STR
-
-      You need to specify your username and password, either on the command
-      line with the -u and -p flags, or in the WEBSOLR_USER and WEBSOLR_PWD
-      environment variables.
-
-      STR
-    end
-    hash.inject(true) do |memo, (key, flag)|
-      unless @options[key]
-        STDERR.puts "Please use the #{flag} flag to specify the #{key}."
-      end
-      memo && @options[key]
-    end || exit(1)
-  end
-  
-  def url(url)
-    URI.join(@base, url).to_s
-  end
-  
-  def check_local_solr_conditions
-    ENV["RAILS_ENV"] = @options[:rails_env] || ENV["RAILS_ENV"] || "development"
-    begin
-      require "config/environment"
-    rescue LoadError
-      die("I can't find config/environment.rb.  Are we in a rails app?")
-    end
-    
-    unless ENV["WEBSOLR_URL"]
-      ENV["WEBSOLR_URL"] = "http://localhost:8983/solr"
-      puts <<-STR
-      
-      You haven't configured your app.  You might want to do that. I 
-      assume you just want a quick development server, so I'll start 
-      one up for you at http://localhost:8983/solr.
-      
-      You should let Rails know about it by setting the WEBSOLR_URL, i.e:
-      
-      > ./script/server WEBSOLR_URL=http://localhost:8983/solr
-      
-      If you want to set up a full environment, run websolr configure.
-      
-      STR
-      puts "Is this what you want? [yes]"
-      if STDIN.gets.strip =~/^(yes)?$/i
-        puts "Continuing...."
-      else
-        die "Aborted."
-      end
-    end
-    
-    
-    uri = URI.parse(ENV["WEBSOLR_URL"])
-    @port = uri.port
-  rescue URI::InvalidURIError => e
-    die(e.message)
-  end
-  
-  def cmd_local_start
-    check_local_solr_conditions    
-    begin
-      n = Net::HTTP.new('127.0.0.1', @port)
-      n.request_head('/').value 
-      
-    rescue Net::HTTPServerException #responding
-      puts "Port #{@port} in use" and return
-
-    rescue Errno::ECONNREFUSED #not responding
-      Dir.chdir(SOLR_PATH) do
-        pid = fork do
-          exec "java #{SOLR_JVM_OPTIONS} -Dsolr.data.dir=#{SOLR_DATA_PATH} -Djetty.logs=#{SOLR_LOGS_PATH} -Djetty.port=#{@port} -jar start.jar"
-        end
-        sleep(5)
-        File.open("#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid", "w"){ |f| f << pid}
-        puts "#{ENV['RAILS_ENV']} Solr started successfully on #{SOLR_PORT}, pid: #{pid}."
-      end
-    end
-  end
-  
-  def cmd_local_stop
-    ENV["RAILS_ENV"] = @options[:rails_env] || ENV["RAILS_ENV"] || "development"
-    fork do
-      file_path = "#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid"
-      if File.exists?(file_path)
-        File.open(file_path, "r") do |f| 
-          pid = f.readline
-          Process.kill('TERM', pid.to_i)
-        end
-        File.unlink(file_path)
-        Rake::Task["solr:destroy_index"].invoke if ENV['RAILS_ENV'] == 'test'
-        puts "Solr shutdown successfully."
-      else
-        puts "PID file not found at #{file_path}. Either Solr is not running or no PID file was written."
-      end
-    end
-  end
-  
-  def cmd_add
-    required_options :name => "-n", :auth => true
-    doc = post "/slices.xml", {:slice => {:name => name}}
-    puts "#{x doc, '//name'}\t#{x doc, '//base-url'}"
-  end
-  
-  def cmd_delete
-    required_options :name => "-n", :auth => true
-    delete "/slices/#{name}/destroy"
-    puts "done"
-  end
-  
-  def x(doc, path)
-    REXML::XPath.first(doc, path).text 
-  end
-  
-  def cmd_list
-    required_options :auth => true
-    doc = get "/slices.xml"
-    REXML::XPath.each(doc, "//slice") do |node|
-      puts "#{x node, 'name'}\t#{x node, 'base-url'}"
-    end
-  end
-  
-  %w[get post delete put].each do |verb|
-    eval <<-STR
-      def #{verb}(url, params = {})
-        str = RestClient.#{verb} url(url), params
-        return nil if str.strip == ""
-        REXML::Document.new(StringIO.new str)
-      rescue RestClient::RequestFailed => e
-        print_errors REXML::Document.new(StringIO.new e.response.body)
-      end
-    STR
-  end
-    
-  def print_errors(doc)
-    REXML::XPath.each(doc, "//error") do |node|
-      STDERR.puts "Error: #{node.text}"
-    end
-    exit 1
-  end
-  
-  def cmd_configure
-    required_options :name => "-n", :auth => true
-    doc = get "/slices.xml"
-    found = false
-    REXML::XPath.each(doc, "//slice") do |node|
-      if x(node, 'name') == self.name
-        found = true
-        FileUtils.mkdir_p "config/initializers"
-        path = "config/initializers/websolr.rb"
-        puts "Writing #{path}"
-        File.open(path, "w") do |f|
-str = <<-STR
-require 'websolr'
-case RAILS_ENV
-when 'production'
-  ENV['WEBSOLR_URL'] ||= '#{x node, 'base-url'}'
-else
-  ENV['WEBSOLR_URL'] ||= 'http://localhost:8983/solr'
-end
-STR
-          f.puts str
-        end
-        
-        FileUtils.mkdir_p "lib/tasks"
-        path = "lib/tasks/websolr.rake"
-        puts "Writing #{path}"
-        File.open(path, "w") do |f|
-          f.puts "require 'rubygems'\nrequire 'websolr_rails/tasks'"
-        end
-      end
-    end
-    unless found
-      STDERR.puts "Error: Index not found"
-      exit 1
-    end
-  end
-  
-  def start
-    if(COMMANDS.include?(@command))
-      send("cmd_#{@command.gsub(/\W+/, '_')}")
-    else
-      puts @parser
-      exit(1)
-    end
-  end
-  
-  def method_missing(method, *a, &b)
-    return @options[method] if @options[method]
-    super(method, *a, &b)
-  end
-end

data/lib/websolr_option_parser.rb

@@ -1,61 +0,0 @@
-require 'optparse'
-
-class WebsolrOptionParser < OptionParser
-  attr_accessor :options
-  
-  def usage
-"Usage: #{$0} COMMAND [INDEX_NAME] [options] 
-
-    COMMANDs:
-    local:start     - starts the local development server
-    local:stop      - stops the local development server
-
-    add             - creates a new index
-    list            - shows your indexes
-    delete          - deletes an index
-    configure       - adds websolr to your current Rails app
-    
-"
-  end
-  
-  def parse!
-    super
-    self.options[:command] = ARGV[0]
-    self.options[:name] ||= ARGV[1]
-  end
-  
-  def initialize
-    self.options = {}
-    super do |opts|
-      
-      yield opts if block_given?
-  
-      opts.banner = usage
-  
-      opts.on("-u", "--user=USER", "Your Websolr username") do |u|
-        options[:user] = u
-      end
-  
-      opts.on("-p", "--password=PASSWORD", "Your Websolr password") do |p|
-        options[:pass] = p
-      end
-      
-      opts.on("-n", "--name=NAME", "Name of the index") do |p|
-        options[:name] = p
-      end
-      
-      opts.on("-e", "--rails-env=ENV", "RAILS_ENV") do |p|
-        options[:rails_env] = p
-      end
-      
-      opts.on("-i", "--invitation=CODE", "Your invitation code") do |p|
-        options[:invitation_code] = p
-      end
-  
-      opts.on_tail("-h", "--help", "Show this message") do
-        puts opts
-        exit
-      end
-    end
-  end
-end