refinerycms 0.9.0

data/vendor/plugins/acts_as_indexed/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Douglas Shearer
+
+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.

data/vendor/plugins/acts_as_indexed/README.rdoc

@@ -0,0 +1,114 @@
+= acts_as_indexed
+
+If you find this plugin useful, please consider a donation to show your support!
+
+http://www.paypal.com/cgi-bin/webscr?cmd=_send-money
+  
+Paypal address: mailto:dougal.s@gmail.com
+  
+
+== Instructions
+
+This plugin allows boolean-queried fulltext search to be added to any Rails app
+with no dependencies and minimal setup.
+
+
+== Resources
+
+=== Install
+  ./script/plugin install git://github.com/dougal/acts_as_indexed.git
+
+If you don't have git installed, you can download the plugin from the GitHub page (http://github.com/dougal/acts_as_indexed) and unpack it into the +vendor/plugins+ directory of your rails app. 
+
+== Usage
+
+
+=== Setup
+
+Add +acts_as_indexed+ to the top of any models you want to index, along with a
+list of the fields you wish to be indexed.
+
+	class Post < ActiveRecord::Base
+	  acts_as_indexed :fields => [:title, :body]
+  
+	  ...
+	end
+
+The fields are not limited to model fields, but can be any instance method of
+the current model.
+
+	class User < ActiveRecord::Base
+	  acts_as_indexed :fields => [:address, :fullname]
+
+		def fullname
+			return self.firstname + ' ' + self.lastname
+		end
+
+	  ...
+	end
+	
+Acts_as_indexed automatically filters out query words shorter than 3 characters, for
+performance sake. This value can be changed by passing +min_word_size+ along
+with the fields. NOTE: The index files must be rebuilt by deleting the 'index'
+directory in your app's root directory.
+
+	class Post < ActiveRecord::Base
+	  acts_as_indexed :fields => [:title, :body], :min_word_size => 5
+
+	  ...
+	end
+
+
+=== Searching
+
+To search, call the +find_with_index+ method on your model, passing a query as 
+the first argument. The optional +ids_only+ parameter, when set to true, will
+return only the IDs of any matching records.
+
+	# Returns array of Post objects.
+	my_search_results = Post.find_with_index('my search query')
+	
+	# Pass any of the ActiveRecord find options to the search.
+	my_search_results = Post.find_with_index('my search query',{:limit => 10}) # return the first 10 matches.
+	
+	# Returns array of IDs.
+	my_search_results = Post.find_with_index('my search query',{},{:ids_only => true}) # =>  [12,19,33...
+	
+	
+=== Query Options
+
+The following query operators are supported:
+
+AND:: This is the default option. 'cat dog' will find records matching 'cat' AND 'dog'.
+NOT:: 'cat -dog' will find records matching 'cat' AND NOT 'dog'
+INCLUDE:: 'cat +me' will find records matching 'cat' and 'me', even if 'me' is smaller than the +min_word_size+
+"":: Quoted terms are matched as phrases. '"cat dog"' will find records matching the whole phrase. Quoted terms can be preceded by the NOT operator; 'cat -"big dog"' etc. Quoted terms can include words shorter than the +min_word_size+.
+
+=== Pagination
+
+Pagination is supported via the +paginate_search+ method whose first argument is the search query, followed all the standard will_paginate arguments.
+
+  @images = Image.paginate_search 'girl', :page => 1, :per_page => 5
+
+== RDoc Documentation
+
+To generate the RDoc documentation, run the <tt>rake rdoc</tt> task in the acts_as_indexed 
+plugin folder. Then point your browser at <tt>/vendor/plugins/acts_as_indexed/rdoc/index.html</tt>.
+
+Alternatively, you can view the rdoc documentation online[http://douglasfshearer.com/rdoc/acts_as_indexed/].
+
+== Problems, Comments, Suggestions?
+
+All of the above are most welcome. mailto:dougal.s@gmail.com
+
+
+== Credits
+
+Douglas F Shearer - http:douglasfshearer.com
+
+
+== Future Releases
+
+Future releases will be looking to add the following features:
+* Optional html scrubbing during indexing.
+* Ranking affected by field weightings.

data/vendor/plugins/acts_as_indexed/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_indexed plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_indexed plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsIndexed'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :rcov do
+  desc "Generate a coverage report in coverage/"
+  task :gen do
+    sh "rcov --output coverage test/*_test.rb"
+  end
+
+  desc "Remove generated coverage files."
+  task :clobber do
+    sh "rm -rdf coverage"
+  end
+end

data/vendor/plugins/acts_as_indexed/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/acts_as_indexed'
+require File.dirname(__FILE__) + '/lib/will_paginate_search'

data/vendor/plugins/acts_as_indexed/lib/acts_as_indexed.rb

@@ -0,0 +1,224 @@
+# ActsAsIndexed
+# Copyright (c) 2007 Douglas F Shearer.
+# http://douglasfshearer.com
+# Distributed under the MIT license as included with this plugin.
+
+require 'active_record'
+
+require File.dirname(__FILE__) + '/search_index'
+require File.dirname(__FILE__) + '/search_atom'
+
+module Foo #:nodoc:
+  module Acts #:nodoc:
+    module Indexed #:nodoc:
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Declares a class as searchable.
+        #
+        # ====options:
+        # fields:: Names of fields to include in the index. Symbols pointing to
+        #          instance methods of your model may also be given here.
+        # index_file_depth:: Tuning value for the index partitioning. Larger
+        #                    values result in quicker searches, but slower
+        #                    indexing. Default is 3.
+        # min_word_size:: Sets the minimum length for a word in a query. Words
+        #                 shorter than this value are ignored in searches
+        #                 unless preceded by the '+' operator. Default is 3.
+        # index_file:: Sets the location for the index. By default this is 
+        #              RAILS_ROOT/index. Specify as an array. Heroku, for
+        #              example would use RAILS_ROOT/tmp/index, which would be
+        #              set as [RAILS_ROOT,'tmp','index]
+
+        def acts_as_indexed(options = {})
+          class_eval do
+            extend Foo::Acts::Indexed::SingletonMethods
+          end
+          include Foo::Acts::Indexed::InstanceMethods
+
+          after_create  :add_to_index
+          before_update  :update_index
+          after_destroy :remove_from_index
+
+          cattr_accessor :aai_config
+
+          # default config
+          self.aai_config = { 
+            :index_file => [RAILS_ROOT,'index'],
+            :index_file_depth => 3,
+            :min_word_size => 3,
+            :fields => []
+          }
+
+          aai_config[:index_file] += [RAILS_ENV,name]
+
+          aai_config.merge!(options)
+
+          raise(ArgumentError, 'no fields specified') unless aai_config.include?(:fields)
+          raise(ArgumentError, 'index_file_depth cannot be less than one (1)') if aai_config[:index_file_depth].to_i < 1
+        end
+
+        # Adds the passed +record+ to the index. Index is built if it does not already exist. Clears the query cache.
+
+        def index_add(record)
+          build_index if !File.exists?(File.join(aai_config[:index_file]))
+          index = SearchIndex.new(aai_config[:index_file], aai_config[:index_file_depth], aai_config[:fields], aai_config[:min_word_size])
+          index.add_record(record)
+          index.save
+          @query_cache = {}
+          true
+        end
+
+        # Removes the passed +record+ from the index. Clears the query cache.
+
+        def index_remove(record)
+          index = SearchIndex.new(aai_config[:index_file], aai_config[:index_file_depth], aai_config[:fields], aai_config[:min_word_size])
+          # record won't be in index if it doesn't exist. Just return true.
+          return true if !index.exists?
+          index.remove_record(record)
+          index.save
+          @query_cache = {}
+          true
+        end
+        
+        # Updates the index.
+        # 1. Removes the previous version of the record from the index
+        # 2. Adds the new version to the index.
+        
+        def index_update(record)
+          build_index if !File.exists?(File.join(aai_config[:index_file]))
+          index = SearchIndex.new(aai_config[:index_file], aai_config[:index_file_depth], aai_config[:fields], aai_config[:min_word_size])
+          #index.remove_record(find(record.id))
+          #index.add_record(record)
+          index.update_record(record,find(record.id))
+          index.save
+          @query_cache = {}
+          true
+        end
+
+        # Finds instances matching the terms passed in +query+. Terms are ANDed by
+        # default. Returns an array of model instances or, if +ids_only+ is
+        # true, an array of integer IDs.
+        #
+        # Keeps a cache of matched IDs for the current session to speed up
+        # multiple identical searches.
+        #
+        # ====find_options
+        # Same as ActiveRecord#find options hash. An :order key will override
+        # the relevance ranking 
+        #
+        # ====options
+        # ids_only:: Method returns an array of integer IDs when set to true.
+        # no_query_cache:: Turns off the query cache when set to true. Useful for testing.
+
+        def search_index(query, find_options={}, options={})
+          # Clear the query cache off  if the key is set.
+          @query_cache = {}  if (options.has_key?('no_query_cache') || options[:no_query_cache])
+          if !@query_cache || !@query_cache[query]
+            logger.debug('Query not in cache, running search.')
+            build_index if !File.exists?(File.join(aai_config[:index_file]))
+            index = SearchIndex.new(aai_config[:index_file], aai_config[:index_file_depth], aai_config[:fields], aai_config[:min_word_size])
+            @query_cache = {} if !@query_cache
+            @query_cache[query] = index.search(query)
+          else
+            logger.debug('Query held in cache.')
+          end
+          return @query_cache[query].sort.reverse.map(&:first) if (options.has_key?(:ids_only) && options[:ids_only]) || @query_cache[query].empty?
+          
+          # slice up the results by offset and limit
+          offset = find_options[:offset] || 0
+          limit = find_options.include?(:limit) ? find_options[:limit] : @query_cache[query].size
+          part_query = @query_cache[query].sort.reverse.slice(offset,limit).map(&:first)
+          
+          # Set these to nil as we are dealing with the pagination by setting
+          # exactly what records we want.
+          find_options[:offset] = nil
+          find_options[:limit] = nil
+          
+          with_scope :find => find_options do
+            # Doing the find like this eliminates the possibility of errors occuring
+            # on either missing records (out-of-sync) or an empty results array.
+            records = find(:all, :conditions => [ "#{class_name.tableize}.id IN (?)", part_query])
+            
+            if find_options.include?(:order)
+             records # Just return the records without ranking them.
+           else
+             # Results come back in random order from SQL, so order again.
+             ranked_records = {}
+             records.each do |r|
+               ranked_records[r] = @query_cache[query][r.id]
+             end
+          
+             ranked_records.to_a.sort_by{|a| a.last }.reverse.map(&:first)
+           end
+          end
+          
+        end
+
+        private
+
+        # Builds an index from scratch for the current model class.
+        def build_index
+          increment = 500
+          offset = 0
+          while (records = find(:all, :limit => increment, :offset => offset)).size > 0
+            #p "offset is #{offset}, increment is #{increment}"
+            index = SearchIndex.new(aai_config[:index_file], aai_config[:index_file_depth], aai_config[:fields], aai_config[:min_word_size])
+            offset += increment
+            index.add_records(records)
+            index.save
+          end
+        end
+
+      end
+
+      # Adds model class singleton methods.
+      module SingletonMethods
+
+        # Finds instances matching the terms passed in +query+.
+        #
+        # See Foo::Acts::Indexed::ClassMethods#search_index.
+        def find_with_index(query='', find_options = {}, options = {})
+          search_index(query, find_options, options)
+        end
+
+      end
+
+      # Adds model class instance methods.
+      # Methods are called automatically by ActiveRecord on +save+, +destroy+,
+      # and +update+ of model instances.
+      module InstanceMethods
+
+        # Adds the current model instance to index.
+        # Called by ActiveRecord on +save+.
+        def add_to_index
+          self.class.index_add(self)
+        end
+
+        # Removes the current model instance to index.
+        # Called by ActiveRecord on +destroy+.
+        def remove_from_index
+          self.class.index_remove(self)
+        end
+
+        # Updates current model instance index.
+        # Called by ActiveRecord on +update+.
+        def update_index
+          self.class.index_update(self)
+        end
+      end
+
+    end
+  end
+end
+
+# reopen ActiveRecord and include all the above to make
+# them available to all our models if they want it
+
+ActiveRecord::Base.class_eval do
+  include Foo::Acts::Indexed
+end

data/vendor/plugins/acts_as_indexed/lib/search_atom.rb

@@ -0,0 +1,107 @@
+# ActsAsIndexed
+# Copyright (c) 2007 Douglas F Shearer.
+# http://douglasfshearer.com
+# Distributed under the MIT license as included with this plugin.
+
+module Foo #:nodoc:
+  module Acts #:nodoc:
+    module Indexed #:nodoc:
+      class SearchAtom
+
+        # Contains a hash of records.
+        # { 'record_id' => [pos1, pos2, pos] }
+        #--
+        # Weighting:
+        # http://www.perlmonks.com/index.pl?node_id=27509
+        # W(T, D) = tf(T, D) * log ( DN / df(T))
+        # weighting = frequency_in_this_record * log (total_number_of_records / number_of_matching_records)
+        
+        def initialize
+          @records = {}
+        end
+
+        # Returns true if the given record is present.
+        def include_record?(record_id)
+          @records.include?(record_id)
+        end
+
+        # Adds +record_id+ to the stored records.
+        def add_record(record_id)
+          @records[record_id] = [] if !include_record?(record_id)
+        end
+
+        # Adds +pos+ to the array of positions for +record_id+.
+        def add_position(record_id, pos)
+          add_record(record_id)
+          @records[record_id] << pos
+        end
+
+        # Returns all record IDs stored in this Atom.
+        def record_ids
+          @records.keys
+        end
+
+        # Returns an array of positions for +record_id+ stored in this Atom.
+        def positions(record_id)
+          return @records[records] if include_record?(record_id)
+          nil
+        end
+
+        # Removes +record_id+ from this Atom.
+        def remove_record(record_id)
+          @records.delete(record_id)
+        end
+
+        # Returns at atom containing the records and positions of +self+ preceded by +former+
+        # "former latter" or "big dog" where "big" is the former and "dog" is the latter.
+        def preceded_by(former)
+          matches = SearchAtom.new
+          latter = {}
+          former.record_ids.each do |rid|
+            latter[rid] = @records[rid] if @records[rid]
+          end
+          # Iterate over each record in latter.
+          latter.each do |record_id,pos|
+
+            # Iterate over each position.
+            pos.each do |p|
+              # Check if previous position is in former.
+              if former.include_position?(record_id,p-1)
+                matches.add_record(record_id) if !matches.include_record?(record_id)
+                matches.add_position(record_id,p)
+              end
+            end
+            
+          end  
+          return matches
+        end
+
+        # Returns a hash of record_ids and weightings for each record in the
+        # atom.
+        def weightings(records_size)
+          out = {}
+          @records.each do |r_id, pos|
+            
+            # Fixes a bug when the records_size is zero. i.e. The only record
+            # contaning the word has been deleted.
+            if records_size < 1
+              out[r_id] = 0.0
+              next
+            end
+            
+            # weighting = frequency * log (records.size / records_with_atom)
+            out[r_id] = pos.size * Math.log(records_size / @records.size)
+          end
+          out
+        end
+
+        protected
+      
+        def include_position?(record_id,pos)
+          @records[record_id].include?(pos)
+        end
+
+      end
+    end
+  end
+end