websolr-rails 1.4.4 → 2.0.0

data/CHANGELOG

@@ -1,8 +0,0 @@
-1.4.2
-  - Made connection errors a unique exception.
-1.4.1
-	- Changed start to local:start, stop to local:stop
-	- Removed dependency on remote environment
-1.4.0
-	- Added CHANGELOG
-	- Added local development server

data/TESTING_THE_PLUGIN

@@ -1,25 +0,0 @@
-acts_as_solr comes with a quick and fast unit test suite, and with a longer-running
-functional test suite, the latter testing the actual integration with Solr.
-
-The unit test suite is written using Shoulda, so make sure you have a recent version
-installed.
-
-Running `rake test` or just `rake` will run both test suites. Use `rake test:unit` to
-just run the unit test suite.
- 
-== How to run functional tests for this plugin:
-To run the acts_as_solr's plugin tests run the following steps:
-
-- create a MySQL database called "actsassolr_test" (if you want to use MySQL)
-
-- create a new Rails project, if needed (the plugin can only be tested from within a Rails project); move/checkout acts_as_solr into its vendor/plugins/, as usual
-
-- copy vendor/plugins/acts_as_solr/config/solr.yml to config/ (the Rails config folder)
-
-- rake solr:start RAILS_ENV=test
-
-- rake test:functional (Accepts the following arguments: DB=sqlite|mysql and MYSQL_USER=user)
-
-== Troubleshooting:
-If for some reason the tests don't run and you get MySQL errors, make sure you edit the MYSQL_USER entry under
-config/environment.rb. It's recommended to create or use a MySQL user with no password.

data/bin/websolr

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + "/../lib/websolr_option_parser"
-require File.dirname(__FILE__) + "/../lib/websolr_controller"
-
-PWD = File.expand_path(".")
-
-parser = WebsolrOptionParser.new
-parser.parse!
-controller = WebsolrController.new(parser)
-controller.start

data/config/solr.yml

@@ -1,15 +0,0 @@
-# Config file for the acts_as_solr plugin.
-#
-# If you change the host or port number here, make sure you update 
-# them in your Solr config file
-
-development:
-  url: http://127.0.0.1:8982/solr
-  
-production:
-  url: http://127.0.0.1:8983/solr
-  jvm_options: -server -d64 -Xmx1024M -Xms64M
-
-test:
-  url: http://127.0.0.1:8981/solr
-

data/config/solr_environment.rb

@@ -1,22 +0,0 @@
-# ENV['RAILS_ENV']  = (ENV['RAILS_ENV'] || 'development').dup
-# # RAILS_ROOT isn't defined yet, so figure it out.
-# rails_root_dir = "."
-# SOLR_PATH = "#{File.dirname(File.expand_path(__FILE__))}/../solr" unless defined? SOLR_PATH
-# 
-# SOLR_LOGS_PATH = "#{rails_root_dir}/log" unless defined? SOLR_LOGS_PATH
-# SOLR_PIDS_PATH = "#{rails_root_dir}/tmp/pids" unless defined? SOLR_PIDS_PATH
-# SOLR_DATA_PATH = "#{rails_root_dir}/solr/#{ENV['RAILS_ENV']}" unless defined? SOLR_DATA_PATH
-# 
-# unless defined? SOLR_PORT
-#   config = YAML::load_file(rails_root_dir+'/config/solr.yml')
-#   
-#   SOLR_PORT = ENV['PORT'] || URI.parse(config[ENV['RAILS_ENV']]['url']).port
-# end
-# 
-# SOLR_JVM_OPTIONS = config[ENV['RAILS_ENV']]['jvm_options'] unless defined? SOLR_JVM_OPTIONS
-# 
-# if ENV['RAILS_ENV'] == 'test'
-#   DB = (ENV['DB'] ? ENV['DB'] : 'mysql') unless defined?(DB)
-#   MYSQL_USER = (ENV['MYSQL_USER'].nil? ? 'root' : ENV['MYSQL_USER']) unless defined? MYSQL_USER
-#   require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'test', 'db', 'connections', DB, 'connection.rb')
-# end

data/generate_rdoc.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-rm -rf /tmp/websolr-rails*
-git clone git@github.com:onemorecloud/websolr-rails.git /tmp/websolr-rails
-rdoc --op /tmp/websolr-rails-rdoc --main README.rdoc README.rdoc lib
-cd /tmp/websolr-rails
-git checkout origin/gh-pages
-git checkout -b gh-pages
-rm -rf /tmp/websolr-rails/*
-mv /tmp/websolr-rails-rdoc/* .
-git add .
-git add -u
-git commit -m "updating rdoc"
-git push origin gh-pages                                                

data/lib/acts_as_solr.rb

@@ -1,65 +0,0 @@
-# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-require 'active_record'
-require 'rexml/document'
-require 'net/http'
-require 'yaml'
-
-require File.dirname(__FILE__) + '/solr'
-require File.dirname(__FILE__) + '/acts_methods'
-require File.dirname(__FILE__) + '/class_methods'
-require File.dirname(__FILE__) + '/instance_methods'
-require File.dirname(__FILE__) + '/common_methods'
-require File.dirname(__FILE__) + '/deprecation'
-require File.dirname(__FILE__) + '/search_results'
-require File.dirname(__FILE__) + '/lazy_document'
-require File.dirname(__FILE__) + '/will_paginate_support'
-
-module ActsAsSolr
-  class ConnectionError < RuntimeError; end
-  
-  class Post    
-    def self.execute(request)
-      begin
-        # if File.exists?(RAILS_ROOT+'/config/solr.yml')
-        #   config = YAML::load_file(RAILS_ROOT+'/config/solr.yml')
-        #   url = config[RAILS_ENV]['url']
-        #   # for backwards compatibility
-        #   url ||= "http://#{config[RAILS_ENV]['host']}:#{config[RAILS_ENV]['port']}/#{config[RAILS_ENV]['servlet_path']}"
-        # else
-        #   url = 'http://localhost:8982/solr'
-        # end
-        unless url = ENV["WEBSOLR_URL"]
-          raise "WEBSOLR_URL was not defined.  Have you run websolr configure?"
-        end
-        connection = Solr::Connection.new(url)
-        return connection.send(request)
-      rescue 
-        raise ActsAsSolr::ConnectionError, "Couldn't connect to the Solr server at #{url}. #{$!}"
-        false
-      end
-    end
-  end
-  
-end
-
-# reopen ActiveRecord and include the acts_as_solr method
-ActiveRecord::Base.extend ActsAsSolr::ActsMethods

data/lib/acts_methods.rb

@@ -1,281 +0,0 @@
-module ActsAsSolr #:nodoc:
-  
-  module ActsMethods
-    
-    # declares a class as solr-searchable
-    # 
-    # ==== options:
-    # fields:: This option can be used to specify only the fields you'd
-    #          like to index. If not given, all the attributes from the 
-    #          class will be indexed. You can also use this option to 
-    #          include methods that should be indexed as fields
-    # 
-    #           class Movie < ActiveRecord::Base
-    #             acts_as_solr :fields => [:name, :description, :current_time]
-    #             def current_time
-    #               Time.now.to_s
-    #             end
-    #           end
-    #          
-    #          Each field passed can also be a hash with the value being a field type
-    # 
-    #           class Electronic < ActiveRecord::Base
-    #             acts_as_solr :fields => [{:price => :range_float}]
-    #             def current_time
-    #               Time.now
-    #             end
-    #           end
-    # 
-    #          The field types accepted are:
-    # 
-    #          :float:: Index the field value as a float (ie.: 12.87)
-    #          :integer:: Index the field value as an integer (ie.: 31)
-    #          :boolean:: Index the field value as a boolean (ie.: true/false)
-    #          :date:: Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)
-    #          :string:: Index the field value as a text string, not applying the same indexing
-    #                    filters as a regular text field
-    #          :range_integer:: Index the field value for integer range queries (ie.:[5 TO 20])
-    #          :range_float:: Index the field value for float range queries (ie.:[14.56 TO 19.99])
-    # 
-    #          Setting the field type preserves its original type when indexed
-    # 
-    #          The field may also be passed with a hash value containing options
-    #
-    #          class Author < ActiveRecord::Base
-    #            acts_as_solr :fields => [{:full_name => {:type => :text, :as => :name}}]
-    #            def full_name
-    #              self.first_name + ' ' + self.last_name
-    #            end
-    #          end
-    #
-    #          The options accepted are:
-    #
-    #          :type:: Index the field using the specified type
-    #          :as:: Index the field using the specified field name
-    #
-    # additional_fields:: This option takes fields to be include in the index
-    #                     in addition to those derived from the database. You
-    #                     can also use this option to include custom fields 
-    #                     derived from methods you define. This option will be
-    #                     ignored if the :fields option is given. It also accepts
-    #                     the same field types as the option above
-    # 
-    #                      class Movie < ActiveRecord::Base
-    #                       acts_as_solr :additional_fields => [:current_time]
-    #                       def current_time
-    #                         Time.now.to_s
-    #                       end
-    #                      end
-    # 
-    # exclude_fields:: This option taks an array of fields that should be ignored from indexing:
-    # 
-    #                    class User < ActiveRecord::Base
-    #                      acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
-    #                    end
-    # 
-    # include:: This option can be used for association indexing, which 
-    #           means you can include any :has_one, :has_many, :belongs_to 
-    #           and :has_and_belongs_to_many association to be indexed:
-    # 
-    #            class Category < ActiveRecord::Base
-    #              has_many :books
-    #              acts_as_solr :include => [:books]
-    #            end
-    # 
-    #           Each association may also be specified as a hash with an option hash as a value
-    #
-    #           class Book < ActiveRecord::Base
-    #             belongs_to :author
-    #             has_many :distribution_companies
-    #             has_many :copyright_dates
-    #             has_many :media_types
-    #             acts_as_solr(
-    #               :fields => [:name, :description],
-    #               :include => [
-    #                 {:author => {:using => :fullname, :as => :name}},
-    #                 {:media_types => {:using => lambda{|media| type_lookup(media.id)}}}
-    #                 {:distribution_companies => {:as => :distributor, :multivalued => true}},
-    #                 {:copyright_dates => {:as => :copyright, :type => :date}}
-    #               ]
-    #             ]
-    #
-    #           The options accepted are:
-    #
-    #           :type:: Index the associated objects using the specified type
-    #           :as:: Index the associated objects using the specified field name
-    #           :using:: Index the associated objects using the value returned by the specified method or proc.  If a method
-    #                    symbol is supplied, it will be sent to each object to look up the value to index; if a proc is
-    #                    supplied, it will be called once for each object with the object as the only argument
-    #           :multivalued:: Index the associated objects using one field for each object rather than joining them
-    #                          all into a single field
-    #
-    # facets:: This option can be used to specify the fields you'd like to
-    #          index as facet fields
-    # 
-    #           class Electronic < ActiveRecord::Base
-    #             acts_as_solr :facets => [:category, :manufacturer]  
-    #           end
-    # 
-    # boost:: You can pass a boost (float) value that will be used to boost the document and/or a field. To specify a more
-    #         boost for the document, you can either pass a block or a symbol. The block will be called with the record
-    #         as an argument, a symbol will result in the according method being called:
-    # 
-    #           class Electronic < ActiveRecord::Base
-    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 10.0
-    #           end
-    # 
-    #           class Electronic < ActiveRecord::Base
-    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => proc {|record| record.id + 120*37}
-    #           end
-    #
-    #           class Electronic < ActiveRecord::Base
-    #             acts_as_solr :fields => [{:price => {:boost => :price_rating}}], :boost => 10.0
-    #           end
-    #
-    # if:: Only indexes the record if the condition evaluated is true. The argument has to be 
-    #      either a symbol, string (to be eval'ed), proc/method, or class implementing a static 
-    #      validation method. It behaves the same way as ActiveRecord's :if option.
-    # 
-    #        class Electronic < ActiveRecord::Base
-    #          acts_as_solr :if => proc{|record| record.is_active?}
-    #        end
-    # 
-    # offline:: Assumes that your using an outside mechanism to explicitly trigger indexing records, e.g. you only
-    #           want to update your index through some asynchronous mechanism. Will accept either a boolean or a block
-    #           that will be evaluated before actually contacting the index for saving or destroying a document. Defaults
-    #           to false. It doesn't refer to the mechanism of an offline index in general, but just to get a centralized point
-    #           where you can control indexing. Note: This is only enabled for saving records. acts_as_solr doesn't always like
-    #           it, if you have a different number of results coming from the database and the index. This might be rectified in
-    #           another patch to support lazy loading.
-    #
-    #             class Electronic < ActiveRecord::Base
-    #               acts_as_solr :offline => proc {|record| record.automatic_indexing_disabled?}
-    #             end
-    #
-    # auto_commit:: The commit command will be sent to Solr only if its value is set to true:
-    # 
-    #                 class Author < ActiveRecord::Base
-    #                   acts_as_solr :auto_commit => false
-    #                 end
-    # 
-    def acts_as_solr(options={}, solr_options={})
-      
-      extend ClassMethods
-      include InstanceMethods
-      include CommonMethods
-      include ParserMethods
-      
-      cattr_accessor :configuration
-      cattr_accessor :solr_configuration
-      
-      self.configuration = { 
-        :fields => nil,
-        :additional_fields => nil,
-        :exclude_fields => [],
-        :auto_commit => true,
-        :include => nil,
-        :facets => nil,
-        :boost => nil,
-        :if => "true",
-        :offline => false
-      }  
-      self.solr_configuration = {
-        :type_field => "type_s",
-        :primary_key_field => "pk_i",
-        :default_boost => 1.0
-      }
-      
-      configuration.update(options) if options.is_a?(Hash)
-      solr_configuration.update(solr_options) if solr_options.is_a?(Hash)
-      Deprecation.validate_index(configuration)
-      
-      configuration[:solr_fields] = {}
-      configuration[:solr_includes] = {}
-      
-      after_save    :solr_save
-      after_destroy :solr_destroy
-
-      if configuration[:fields].respond_to?(:each)
-        process_fields(configuration[:fields])
-      else
-        process_fields(self.new.attributes.keys.map { |k| k.to_sym })
-        process_fields(configuration[:additional_fields])
-      end
-
-      if configuration[:include].respond_to?(:each)
-        process_includes(configuration[:include])
-      end
-      
-      alias_method_chain :method_missing, :solr_magic
-    end
-    
-    private
-    def get_field_value(field)
-      field_name, options = determine_field_name_and_options(field)
-      configuration[:solr_fields][field_name] = options
-      
-      define_method("#{field_name}_for_solr".to_sym) do
-        begin
-          value = self[field_name] || self.instance_variable_get("@#{field_name.to_s}".to_sym) || self.send(field_name.to_sym)
-          case options[:type] 
-            # format dates properly; return nil for nil dates 
-            when :date
-              value ? (value.respond_to?(:utc) ? value.utc : value).strftime("%Y-%m-%dT%H:%M:%SZ") : nil 
-            else value
-          end
-        rescue
-          puts $!
-          logger.debug "There was a problem getting the value for the field '#{field_name}': #{$!}"
-          value = ''
-        end
-      end
-    end
-    
-    def process_fields(raw_field)
-      if raw_field.respond_to?(:each)
-        raw_field.each do |field|
-          next if configuration[:exclude_fields].include?(field)
-          get_field_value(field)
-        end                
-      end
-    end
-    
-    def process_includes(includes)
-      if includes.respond_to?(:each)
-        includes.each do |assoc|
-          field_name, options = determine_field_name_and_options(assoc)
-          configuration[:solr_includes][field_name] = options
-        end
-      end
-    end
-
-    def determine_field_name_and_options(field)
-      if field.is_a?(Hash)
-        name = field.keys.first
-        options = field.values.first
-        if options.is_a?(Hash)
-          [name, {:type => type_for_field(field)}.merge(options)]
-        else
-          [name, {:type => options}]
-        end
-      else
-        [field, {:type => type_for_field(field)}]
-      end
-    end
-    
-    def type_for_field(field)
-      if configuration[:facets] && configuration[:facets].include?(field)
-        :facet
-      elsif column = columns_hash[field.to_s]
-        case column.type
-        when :string then :text
-        when :datetime then :date
-        when :time then :date
-        else column.type
-        end
-      else
-        :text
-      end
-    end
-  end
-end