websolr-rails 0.0.0 → 1.4.3

data/lib/solr/xml.rb

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

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

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

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

@@ -0,0 +1,7 @@
+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-rails.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/acts_as_solr"

data/lib/websolr.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/acts_as_solr"

data/lib/websolr_controller.rb

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

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