ferret-0.11.8.6/ 0000755 0000041 0000041 00000000000 12476264460 013277 5 ustar www-data www-data ferret-0.11.8.6/Rakefile 0000755 0000041 0000041 00000032563 12476264460 014760 0 ustar www-data www-data require 'rake'
require 'rake/clean'
require 'rubygems/package_task'
require 'rdoc/task'
require 'rake/testtask'
$:. << 'lib'
require 'ferret/version'
def say(msg='')
STDERR.puts msg
end
def prompt(msg)
STDERR.print "#{msg} [Yna]: "
while true
case STDIN.gets.chomp!
when /^(y(es)?)?$/i then return true
when /^no?$/i then return false
when /^a(bort)?$/i then fail('aborted')
else
STDERR.print "Sorry, I don't understand. Please type y, n or a: "
end
end
end
windows = (RUBY_PLATFORM =~ /win32|cygwin/) rescue nil
SUDO = windows ? "" : "sudo "
task :default => 'test:unit'
#task :default => :build do
# sh "ruby test/unit/index/tc_index.rb"
#end
BZLIB_SRC = FileList["../c/lib/bzlib/*.h"] +
FileList["../c/lib/bzlib/*.c"].map do |fn|
fn.gsub(%r{/([^/]*.c)}, '/BZ_\1')
end
##############################################################################
# Building
##############################################################################
task :build => 'build:compile'
namespace :build do
EXT = "ferret_ext.so"
# Note: libstemmer.[h] is necessary so that the file isn't included when it
# doesn't exist. It needs to have one regular expression element.
EXT_SRC = FileList["../c/src/*.[ch]", "../c/include/*.h",
"../c/lib/bzlib/*.[ch]",
"../c/lib/libstemmer_c/src_c/*.[ch]",
"../c/lib/libstemmer_c/runtime/*.[ch]",
"../c/lib/libstemmer_c/libstemmer/*.[ch]",
"../c/lib/libstemmer_c/include/libstemmer.[h]"]
EXT_SRC.exclude('../c/**/ind.[ch]',
'../c/**/symbol.[ch]',
'../c/include/threading.h',
'../c/include/scanner.h',
'../c/include/internal.h',
'../c/src/lang.c',
'../c/include/lang.h')
EXT_SRC_MAP = {}
EXT_SRC_DEST = EXT_SRC.map do |fn|
ext_fn = File.join("ext", File.basename(fn))
if fn =~ /.c$/ and fn =~ /(bzlib|stemmer)/
prefix = $1.upcase
ext_fn.gsub!(/ext\//, "ext/#{prefix}_")
end
EXT_SRC_MAP[fn] = ext_fn
end
SRC = FileList["ext/*.[ch]", EXT_SRC_DEST, 'ext/internal.h'].uniq
CLEAN.include ['**/*.o', '**/*.obj', '.config', 'ext/cferret.c']
CLOBBER.include ['doc/api', 'ext/*.so', 'ext/Makefile',
'ext/internal.h', EXT_SRC_DEST]
# The following block creates file tasks for all of the c files. They
# belong in the ../c directory in source the working copy and they need
# to be linked to in the ext directory
EXT_SRC.each do |fn|
dest_fn = EXT_SRC_MAP[fn]
# prepend lib files to avoid conflicts
file dest_fn => fn do |t|
ln_sf File.expand_path(fn), File.expand_path(dest_fn)
if fn =~ /stemmer/
# flatten the directory structure for lib_stemmer
open(dest_fn) do |in_f|
open(dest_fn + ".out", "w") do |out_f|
in_f.each do |line|
out_f.write(line.sub(/(#include ["<])[.a-z_\/]*\//, '\1'))
end
end
end
mv dest_fn + ".out", dest_fn
end
end
end if File.exists?("../c")
file 'ext/internal.h' => '../c/include/internal.h' do
File.open('ext/internal.h', 'w') do |f|
File.readlines('../c/include/internal.h').each do |l|
next if l =~ /ALLOC/ and l !~ /ZERO|MP_/
f.puts(l)
end
end
end
desc "Build the extension (ferret_ext.so). You'll need a C compiler and Make."
task :compile => ["ext/#{EXT}"] + SRC
file "ext/#{EXT}" => "ext/Makefile" do
cd "ext"
if windows and ENV['make'].nil?
begin
sh "nmake"
rescue Exception => e
path = ':\Program Files\Microsoft Visual Studio\VC98\Bin\VCVARS32.BAT'
if File.exists? "f#{path}"
sh "f#{path}"
elsif File.exists? "c#{path}"
sh "c#{path}"
else
say
say "***************************************************************"
say "You need to have Visual C++ 6 to build Ferret on Windows."
say "If you have it installed, you may need to run;"
say ' C:\Program Files\Microsoft Visual Studio\VC98\Bin\VCVARS32.BAT'
say "***************************************************************"
say
raise e
end
sh "nmake"
end
else
sh "make"
end
cd ".."
end
file "ext/Makefile" => SRC do
cd "ext"
ruby "extconf.rb"
cd ".."
end
end
##############################################################################
# Testing
##############################################################################
task :test => 'test:units'
namespace :test do
desc "Run tests with Valgrind"
task :valgrind do
sh "valgrind --suppressions=ferret_valgrind.supp " +
"--leak-check=yes --show-reachable=yes " +
"-v ruby test/unit/index/tc_index_reader.rb"
end
desc "Run all tests"
task :all => [ :units ]
desc "run unit tests in test/unit"
Rake::TestTask.new("units" => :build) do |t|
t.libs << "test/unit"
t.pattern = 'test/unit/t[cs]_*.rb'
t.verbose = true
end
task :unit => :units
desc "run tests using locally installed gem"
Rake::TestTask.new("installed") do |t|
t.libs << "test/unit"
t.ruby_opts << '-rtest/test_installed'
t.pattern = 'test/unit/t[cs]_*.rb'
t.verbose = true
end
end
##############################################################################
# Documentation
##############################################################################
desc "Generate API documentation"
task :doc => 'doc:rdoc'
namespace :doc do
# if allison = Gem.cache.find_name('allison').last
# allison_template = File.join(allison.full_gem_path, 'lib/allison.rb')
# end
desc "Generate documentation for the application"
$rd = Rake::RDocTask.new do |rdoc|
rdoc.rdoc_dir = 'doc/api'
rdoc.title = "Ferret Search Library Documentation"
rdoc.options << '--line-numbers'
rdoc.options << '--inline-source'
rdoc.options << '--charset=utf-8'
# rdoc.template = allison_template if allison_template
rdoc.rdoc_files.include('README')
rdoc.rdoc_files.include('TODO')
rdoc.rdoc_files.include('TUTORIAL')
rdoc.rdoc_files.include('MIT-LICENSE')
rdoc.rdoc_files.include('lib/**/*.rb')
rdoc.rdoc_files.include('ext/r_*.c')
rdoc.rdoc_files.include('ext/ferret.c')
end
desc "Look for TODO and FIXME tags in the code"
task :todo do
FileList['**/*.rb', 'ext/*.[ch]'].egrep /[#*].*(FIXME|TODO|TBD)/i
end
end
##############################################################################
# Packaging and Installing
##############################################################################
PKG_FILES = FileList[
'setup.rb',
'[-A-Z]*',
'lib/**/*.rb',
'lib/**/*.rhtml',
'lib/**/*.css',
'lib/**/*.js',
'test/**/*.rb',
'test/**/wordfile',
'rake_utils/**/*.rb',
'Rakefile',
SRC
]
spec = Gem::Specification.new do |s|
#### Basic information.
s.name = 'ferret'
s.version = Ferret::VERSION
s.summary = "Ruby indexing library."
s.description = "Ferret is a super fast, highly configurable search library."
#### Dependencies and requirements.
s.add_development_dependency('rake')
s.files = PKG_FILES.to_a
s.extensions << "ext/extconf.rb"
s.require_path = 'lib'
s.bindir = 'bin'
s.executables = ['ferret-browser']
s.default_executable = 'ferret-browser'
#### Author and project details.
s.author = "David Balmain"
s.email = "dbalmain@gmail.com"
#s.homepage = "http://ferret.davebalmain.com/trac"
s.homepage = "http://github.com/jkraemer/ferret"
s.rubyforge_project = "ferret"
s.has_rdoc = true
s.extra_rdoc_files = $rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
s.rdoc_options <<
'--title' << 'Ferret -- Ruby Search Library' <<
'--main' << 'README' << '--line-numbers' <<
'TUTORIAL' << 'TODO'
key_file = File.expand_path('~/.gem/gem-private_key.pem')
key_file = nil unless File.exists?(key_file)
cert_file = File.expand_path('~/.gem/gem-public_cert.pem')
cert_file = nil unless File.exists?(cert_file)
if key_file and cert_file
s.signing_key = key_file
s.cert_chain = cert_file
end
if windows
s.files = PKG_FILES.to_a + ["ext/#{EXT}"]
s.extensions.clear
s.platform = Gem::Platform::WIN32
else
s.platform = Gem::Platform::RUBY
end
end
package_task = Gem::PackageTask.new(spec) do |pkg|
unless windows
pkg.need_zip = true
pkg.need_tar = true
end
end
desc "Run :gem and install the resulting gem"
task :install => :gem do
sh "#{SUDO}gem install pkg/ferret-#{Ferret::VERSION}.gem --no-rdoc --no-ri -l"
end
desc "Run :clobber and uninstall the .gem"
task :uninstall => :clobber do
sh "#{SUDO}gem uninstall ferret"
end
desc "Same as :install but you must be rootgem"
task :root_install => :gem do
sh "gem install pkg/ferret-#{Ferret::VERSION}.gem --no-rdoc --no-ri -l"
end
desc "Same as :uninstall but you must be root"
task :root_uninstall => :clobber do
sh "gem uninstall ferret"
end
def list_changes_since_last_release
tag_listing = `svn list svn://davebalmain.com/ferret/tags`
last_tag = tag_listing.split("\n").last
log = `svn log --stop-on-copy svn://davebalmain.com/ferret/tags/#{last_tag}`
first_log = log.split(/-------+/)[-2]
last_revision = /^r(\d+)\s+\|/.match(first_log)[1]
`svn log .. -rHEAD:#{last_revision}`
end
desc "List changes since last release"
task :changes do
puts list_changes_since_last_release
end
if ENV['FERRET_DEV']
##############################################################################
# Releasing
##############################################################################
desc "Generate and upload a new release"
task :release => 'release:release'
namespace :release do
task :release => [:status_check, 'test:all', :package, :tag] do
say
say "**************************************************************"
say "* Release #{Ferret::VERSION} Complete."
say "* Packages ready to upload."
say "**************************************************************"
say
reversion("lib/ferret/version.rb")
end
# Validate that everything is ready to go for a release.
task :status_check do
# Are all source files checked in?
unless `svn -q --ignore-externals status` =~ /^$/
fail "'svn -q status' is not clean ... do you have unchecked-in files?"
end
say "No outstanding checkins found ... OK"
end
def reversion(fn)
new_version = nil
begin
print "Ferret is currently at #{Ferret::VERSION}. What version now? "
new_version = STDIN.gets.chomp!
end until prompt("Change to version #{new_version}?")
if ENV['RELTEST']
say "Would change the version in lib/ferret/version.rb from"
say " #{Ferret::VERSION} => #{new_version}"
say "and then commit the changes with the command"
say " svn ci -m \"Updated to version #{new_version}\" " +
"lib/ferret/version.rb"
else
open(fn) do |ferret_in|
open(fn + ".new", "w") do |ferret_out|
ferret_in.each do |line|
if line =~ /^ VERSION\s*=\s*/
ferret_out.puts " VERSION = '#{new_version}'"
else
ferret_out.puts line
end
end
end
end
mv fn + ".new", fn
sh %{svn ci -m "Updated to version #{new_version}" lib/ferret/version.rb}
end
end
# Tag all the SVN files with the latest release number
task :tag => :status_check do
reltag = "REL-#{Ferret::VERSION}"
say "Tagging SVN with [#{reltag}]"
if ENV['RELTEST']
say "Release Task Testing, skipping SVN tagging. Would do;"
say %{svn copy -m "creating release #{reltag}" svn://www.davebalmain.com/ferret/trunk svn://www.davebalmain.com/ferret/tags/#{reltag}}
else
sh %{svn copy -m "creating release #{reltag}" svn://www.davebalmain.com/ferret/trunk svn://www.davebalmain.com/ferret/tags/#{reltag}}
end
end
end
##############################################################################
# Publishing
##############################################################################
namespace :publish do
PUBLISH_PROMPT = <<-EOF
Make sure you updated RELEASE_NOTES and RELEASE_CHANGES and that the
package exists. Are you sure you want to continue?
EOF
desc "Publish gem on rubyforge for download. Will only do the linux version"
task :release do
exit unless prompt(PUBLISH_PROMPT)
require 'rubyforge'
require 'rake/contrib/rubyforgepublisher'
version = Ferret::VERSION
packages = %w(gem tgz zip).map {|ext| "pkg/ferret-#{version}.#{ext}"}
rubyforge = RubyForge.new
rubyforge.login
rubyforge.add_release('ferret', 'ferret',
"ferret-#{version}", *packages)
end
desc "Publish the documentation"
task :docs => 'doc:rdoc' do
sh %{rsync -rzv --delete -e 'ssh -p 8900' doc/api/ davebalmain.com:/var/www/ferret/api}
end
desc "Publish the documentation and release"
task :all => [:doc, :release]
end
end
#
# In case I ever need to add another racc parser, here's how
#
# # Make Parsers ---------------------------------------------------------------
#
# RACC_SRC = FileList["lib/**/*.y"]
#
# task :parsers => RACC_OUT
# rule(/\.tab\.rb$/ => [proc {|tn| tn.sub(/\.tab\.rb$/, '.y')}]) do |t|
# sh "racc #{t.source}"
# end
ferret-0.11.8.6/CHANGELOG 0000644 0000041 0000041 00000002241 12476264460 014510 0 ustar www-data www-data Thu Mar 08 00:18:44 +0100 2012
* Ruby 1.9 compatibility
* This release is basically the same as the now obsolete jk-ferret 0.11.8.3
Fri Oct 20 22:25:37 JST 2006
* Added Filter#bits method to built-in Filters.
* Added MappingFilter < TokenFilter that can be used to map strings to other
strings during analysis. A possible use of this is it to Filter utf-8
characters to ascii characters.
Fri Oct 13 09:18:31 JST 2006
* Changed documentation to state truthfully that FULL_ENGLISH_STOP_WORDS is
being used by default in StandardAnalyzer and StopwordFilter.
* Removed 'will', 's' and 't' from ENGLISH_STOP_WORDS so that all words in
ENGLISH_STOP_WORDS can be found in FULL_ENGLISH_STOP_WORDS, that is
ENGLISH_STOP_WORDS is a subset of FULL_ENGLISH_STOP_WORDS.
Thu Oct 12 23:04:19 JST 2006
* Fixed adding SortField to Sort object in Ruby. Garbage collection wasn't
working.
* Can now set :sort => SortField#new
Tue Oct 10 14:42:17 JST 2006
* Fixed MultiTermDocEnum bug introduced in version 0.10.10 during
performance enhancements.
* Added Filter#bits(index_reader) method to C implemented filters so that
they can be used in Ruby.
ferret-0.11.8.6/bin/ 0000755 0000041 0000041 00000000000 12476264460 014047 5 ustar www-data www-data ferret-0.11.8.6/bin/ferret-browser 0000755 0000041 0000041 00000003737 12476264460 016757 0 ustar www-data www-data #!/usr/bin/env ruby
$: << File.expand_path(File.join(File.basename(__FILE__), '../lib'))
require 'ferret'
require 'ferret/browser'
require 'optparse'
require 'ostruct'
SERVER_OPTIONS = ['webrick']
conf = OpenStruct.new(:host => '0.0.0.0', :port => 3301)
opts = OptionParser.new do |opts|
opts.banner = "Usage: #{File.basename($0)} /path/to/index"
opts.separator ""
opts.separator "Specific Options:"
opts.on("-h", "--host HOSTNAME",
"Host for web server to bind to (default is all IPs)") { |host| conf.host = host }
opts.on("-p", "--port NUM",
"Port for web server (defaults to #{conf.port})") { |port| conf.port = port }
opts.on("-s", "--server NAME",
"Server to force (#{SERVER_OPTIONS.join(', ')}).") { |s| conf.server = s.to_sym }
opts.separator ""
opts.separator "Common options:"
opts.on_tail("-?", "--help", "Show this message") do
puts opts
exit
end
opts.on_tail("-v", "--version", "Show version") do
puts Ferret::VERSION
exit
end
end
opts.parse! ARGV
if ARGV.length != 1
puts opts
exit
end
@path = ARGV[0]
# Load the Ferret index
begin
@reader = Ferret::Index::IndexReader.new(@path)
rescue Ferret::FileNotFoundError => e
puts "\033[31mCannot start Ferret. No index exists at \"\033[m" +
"\033[33m#{@path}\033[m\033[31m\".\033[m"
exit
rescue Exception => e
puts "\033[31mCannot start Ferret.\n\033[m\033[33m#{e.to_s}\031[m"
exit
end
unless conf.server
conf.server = :webrick
end
case conf.server.to_s
when 'webrick'
require 'webrick/httpserver'
require 'ferret/browser/webrick'
# Mount the root
s = WEBrick::HTTPServer.new(:BindAddress => conf.host, :Port => conf.port)
s.mount "/s", WEBrick::HTTPServlet::FileHandler, Ferret::Browser::Controller::STATIC_DIR, true
s.mount "/", WEBrick::FerretBrowserHandler, @reader, @path
# Server up
trap(:INT) do
s.shutdown
end
s.start
else
raise "server #{conf.server} not known. Must be one of [#{SERVER_OPTIONS.join(', ')}]"
end
ferret-0.11.8.6/MIT-LICENSE 0000644 0000041 0000041 00000002046 12476264460 014735 0 ustar www-data www-data Copyright (c) 2005-2006 David Balmain
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.
ferret-0.11.8.6/README 0000644 0000041 0000041 00000006034 12476264460 014162 0 ustar www-data www-data = Ferret
Ferret is a Ruby search library inspired by the Apache Lucene search engine for
Java (http://jakarta.apache.org/lucene/). In the same way as Lucene, it is not
a standalone application, but a library you can use to index documents and
search for things in them later.
== Requirements
* Ruby 1.8
* C compiler to build the extension. Tested with gcc, VC6
* make (or nmake on windows)
== Installation
$ sudo gem install ferret
If you don't have rubygems installed you can still install Ferret. Just
download one of the zipped up versions of Ferret, unzip it and change into the
unzipped directory. Then run the following set of commands;
$ ruby setup.rb config
$ ruby setup.rb setup
$ sudo ruby setup.rb install
== Usage
You can read the TUTORIAL which you'll find in the same directory as this
README. You can also check the following modules for more specific
documentation.
* Ferret::Analysis: for more information on how the data is processed when it
is tokenized. There are a number of things you can do with your data such as
adding stop lists or perhaps a porter stemmer. There are also a number of
analyzers already available and it is almost trivial to create a new one
with a simple regular expression.
* Ferret::Search: for more information on querying the index. There are a
number of already available queries and it's unlikely you'll need to create
your own. You may however want to take advantage of the sorting or filtering
abilities of Ferret to present your data the best way you see fit.
* Ferret::Document: to find out how to create documents. This part of Ferret
is relatively straightforward. If you know how Strings, Hashes and Arrays work
Ferret then you'll be able to create Documents.
* Ferret::QueryParser: if you want to find out more about what you can do with
Ferret's Query Parser, this is the place to look. The query parser is one
area that could use a bit of work so please send your suggestions.
* Ferret::Index: for more advanced access to the index you'll probably want to
use the Ferret::Index::IndexWriter and Ferret::Index::IndexReader. This is
the place to look for more information on them.
* Ferret::Store: This is the module used to access the actual index storage
and won't be of much interest to most people.
=== Performance
We are unaware of any alternatives that can out-perform Ferret while still
matching it in features.
== Contact
For bug reports and patches I have set up Trac here;
http://ferret.davebalmain.com/trac
Queries, discussion etc should be addressed to the mailing lists here;
http://rubyforge.org/projects/ferret/
Alternatively you could create a new page for discussion on the Ferret wiki;
http://ferret.davebalmain.com/trac
Of course, since Ferret was ported from Apache Lucene, most of what you can
do with Lucene you can also do with Ferret.
== Authors
[David Balmain] Port to Ruby
[The Apache Software Foundation (Doug Cutting and friends)] Original Apache Lucene
== License
Ferret is available under an MIT-style license.
:include: MIT-LICENSE
ferret-0.11.8.6/RELEASE_CHANGES 0000644 0000041 0000041 00000015145 12476264460 015440 0 ustar www-data www-data (in /home/dave/w/ferret/ruby)
------------------------------------------------------------------------
r830 | dbalmain | 2008-03-01 14:10:47 +1100 (Sat, 01 Mar 2008) | 1 line
A few more updates to the build system
------------------------------------------------------------------------
r829 | dbalmain | 2008-03-01 13:55:16 +1100 (Sat, 01 Mar 2008) | 1 line
A few more updates to the build system
------------------------------------------------------------------------
r828 | dbalmain | 2008-02-29 10:48:33 +1100 (Fri, 29 Feb 2008) | 1 line
Moved largefile test to a new long_running test directory so that tests can be run more easily
------------------------------------------------------------------------
r826 | dbalmain | 2008-02-29 10:09:48 +1100 (Fri, 29 Feb 2008) | 1 line
Updated references to ferret/version.rb. Updated Rakefile to allow release task testing
------------------------------------------------------------------------
r825 | dbalmain | 2008-02-29 10:02:27 +1100 (Fri, 29 Feb 2008) | 1 line
Updated Rakefile to clean it up (added namespaces).
------------------------------------------------------------------------
r824 | dbalmain | 2008-02-29 10:01:08 +1100 (Fri, 29 Feb 2008) | 1 line
Updated :filter_proc so that custom PostFilter extensions can be built and applied to searches. See ruby/examples/c_extensions/age_filter
------------------------------------------------------------------------
r823 | dbalmain | 2008-02-26 18:44:39 +1100 (Tue, 26 Feb 2008) | 1 line
Fixed ticket #277. This will also help with the correct highlighting of matching urls in queries
------------------------------------------------------------------------
r822 | dbalmain | 2008-02-22 12:46:48 +1100 (Fri, 22 Feb 2008) | 1 line
Updated to latest posh.h => http://poshlib.hookatooka.com/poshlib/
------------------------------------------------------------------------
r821 | dbalmain | 2008-02-22 09:05:25 +1100 (Fri, 22 Feb 2008) | 1 line
Added ruby bindings to MultiMapper for testing in Ruby
------------------------------------------------------------------------
r820 | dbalmain | 2008-02-09 14:30:55 +1100 (Sat, 09 Feb 2008) | 1 line
Updated svn:ignore properties to handle new stemmer files
------------------------------------------------------------------------
r819 | dbalmain | 2008-02-09 14:27:46 +1100 (Sat, 09 Feb 2008) | 9 lines
Fixed Ticket #337. StemFilter.new now works with 'English', :english or
'EnGlIsH' and 'UTF_8' or 'utf-8' etc.
Also, good news for Norwegians, Romanians, Turks and Finns. We now have 3 new
stemmers for Norwegian, Romanian and Turkish and 2 new stop-word lists for
Finnish and Hungarian. Please try them out and let me know if there are any
problems.
------------------------------------------------------------------------
r818 | dbalmain | 2008-02-09 13:20:37 +1100 (Sat, 09 Feb 2008) | 1 line
Removed old version of stemmer. Making way for new version. This will break build temporarily
------------------------------------------------------------------------
r817 | dbalmain | 2008-02-09 11:55:02 +1100 (Sat, 09 Feb 2008) | 1 line
Added a very useful group_by example.
------------------------------------------------------------------------
r816 | dbalmain | 2008-02-09 09:26:20 +1100 (Sat, 09 Feb 2008) | 1 line
Updated documentation for :filter_proc to indicate that you can return a Float to be used to modify the score.
------------------------------------------------------------------------
r815 | dbalmain | 2008-02-09 00:27:58 +1100 (Sat, 09 Feb 2008) | 1 line
Made TypedRangeQuery the default range query when used from Ferret::Index::Index
------------------------------------------------------------------------
r814 | dbalmain | 2008-02-08 23:16:55 +1100 (Fri, 08 Feb 2008) | 1 line
Made the TypedRangeQuery optional in the query parser
------------------------------------------------------------------------
r813 | dbalmain | 2008-02-08 23:12:13 +1100 (Fri, 08 Feb 2008) | 1 line
Added TypedRangeQuery and TypedRangeFilter to the ruby bindings
------------------------------------------------------------------------
r812 | dbalmain | 2008-02-08 22:19:31 +1100 (Fri, 08 Feb 2008) | 1 line
Added TypedRangeQuery so that you can do range queries with unpadded numbers
------------------------------------------------------------------------
r811 | dbalmain | 2008-02-08 16:22:06 +1100 (Fri, 08 Feb 2008) | 3 lines
Whoops, quick fix. Had unnecessarily nested locks.
------------------------------------------------------------------------
r810 | dbalmain | 2008-02-08 16:17:33 +1100 (Fri, 08 Feb 2008) | 1 line
Added patch for Ticket #340 which adds batch updating and deleting. Made significant modifications from the patch.
------------------------------------------------------------------------
r809 | dbalmain | 2008-02-08 13:49:07 +1100 (Fri, 08 Feb 2008) | 18 lines
Added score filter. This enables you to filter the results and modify the score
to change the sort order.
For example to modify the scoring so that a document with todays date gets
twice the score factor as a document 50 days ago and four times the score
factor of a document 100 days ago (ie a half life of 50 days) you would do
this;
fifty_day_half_life_filter = lambda do |doc, score, searcher|
days = (Date.today() - Date.parse(searcher[doc][:date])).to_i
1.0 / (2.0 ** (days.to_f / 50.0))
end
top_docs = @searcher.search(q, :filter_proc => fifty_day_half_life_filter)
------------------------------------------------------------------------
r808 | dbalmain | 2008-01-11 07:14:01 +1100 (Fri, 11 Jan 2008) | 1 line
Changed unsigned long longs to f_u64 type to fix ticket #336
------------------------------------------------------------------------
r807 | dbalmain | 2008-01-11 07:12:40 +1100 (Fri, 11 Jan 2008) | 1 line
Changed unsigned long longs to f_u64 type to fix ticket #336
------------------------------------------------------------------------
r806 | dbalmain | 2008-01-11 07:01:00 +1100 (Fri, 11 Jan 2008) | 1 line
Minor comment correction
------------------------------------------------------------------------
r805 | dbalmain | 2007-12-12 10:28:23 +1100 (Wed, 12 Dec 2007) | 1 line
Fixed Ticket #332. Added spaces so that code parses correctly.
------------------------------------------------------------------------
r804 | dbalmain | 2007-12-03 11:20:34 +1100 (Mon, 03 Dec 2007) | 1 line
Added test for ticket #324
------------------------------------------------------------------------
r803 | dbalmain | 2007-12-03 11:12:55 +1100 (Mon, 03 Dec 2007) | 1 line
Fixed Ferret::Index::Index#query_update for ticket #324. Was only updating a maximum of 10 records.
------------------------------------------------------------------------
ferret-0.11.8.6/lib/ 0000755 0000041 0000041 00000000000 12476264460 014045 5 ustar www-data www-data ferret-0.11.8.6/lib/ferret.rb 0000644 0000041 0000041 00000002504 12476264460 015662 0 ustar www-data www-data #--
# Copyright (c) 2005 David Balmain
#
# 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.
#++
# :include: ../TUTORIAL
$: << File.expand_path(File.join(File.dirname(__FILE__), "../ext"))
require 'ferret_ext'
require 'ferret/version'
require 'ferret/document'
require 'ferret/index'
require 'ferret/field_infos'
require 'ferret/field_symbol'
ferret-0.11.8.6/lib/ferret/ 0000755 0000041 0000041 00000000000 12476264460 015334 5 ustar www-data www-data ferret-0.11.8.6/lib/ferret/index.rb 0000644 0000041 0000041 00000111500 12476264460 016766 0 ustar www-data www-data require 'monitor'
module Ferret::Index
# This is a simplified interface to the index. See the TUTORIAL for more
# information on how to use this class.
class Index
include MonitorMixin
include Ferret::Store
include Ferret::Search
attr_reader :options
# If you create an Index without any options, it'll simply create an index
# in memory. But this class is highly configurable and every option that
# you can supply to IndexWriter and QueryParser, you can also set here.
# Please look at the options for the constructors to these classes.
#
# === Options
#
# See;
#
# * QueryParser
# * IndexWriter
#
# default_input_field:: Default: "id". This specifies the default field
# that will be used when you add a simple string
# to the index using #add_document or <<.
# id_field:: Default: "id". This field is as the field to
# search when doing searches on a term. For
# example, if you do a lookup by term "cat", ie
# index["cat"], this will be the field that is
# searched.
# key:: Default: nil. Expert: This should only be used
# if you really know what you are doing. Basically
# you can set a field or an array of fields to be
# the key for the index. So if you add a document
# with a same key as an existing document, the
# existing document will be replaced by the new
# object. Using a multiple field key will slow
# down indexing so it should not be done if
# performance is a concern. A single field key (or
# id) should be find however. Also, you must make
# sure that your key/keys are either untokenized
# or that they are not broken up by the analyzer.
# auto_flush:: Default: false. Set this option to true if you
# want the index automatically flushed every time
# you do a write (includes delete) to the index.
# This is useful if you have multiple processes
# accessing the index and you don't want lock
# errors. Setting :auto_flush to true has a huge
# performance impact so don't use it if you are
# concerned about performance. In that case you
# should think about setting up a DRb indexing
# service.
# lock_retry_time:: Default: 2 seconds. This parameter specifies how
# long to wait before retrying to obtain the
# commit lock when detecting if the IndexReader is
# at the latest version.
# close_dir:: Default: false. If you explicitly pass a
# Directory object to this class and you want
# Index to close it when it is closed itself then
# set this to true.
# use_typed_range_query:: Default: true. Use TypedRangeQuery instead of
# the standard RangeQuery when parsing
# range queries. This is useful if you have number
# fields which you want to perform range queries
# on. You won't need to pad or normalize the data
# in the field in anyway to get correct results.
# However, performance will be a lot slower for
# large indexes, hence the default.
#
# == Examples
#
# index = Index::Index.new(:analyzer => WhiteSpaceAnalyzer.new())
#
# index = Index::Index.new(:path => '/path/to/index',
# :create_if_missing => false,
# :auto_flush => true)
#
# index = Index::Index.new(:dir => directory,
# :default_slop => 2,
# :handle_parse_errors => false)
#
# You can also pass a block if you like. The index will be yielded and
# closed at the index of the box. For example;
#
# Ferret::I.new() do |index|
# # do stuff with index. Most of your actions will be cached.
# end
def initialize(options = {}, &block)
super()
if options[:key]
@key = options[:key]
if @key.is_a?(Array)
@key.flatten.map {|k| k.to_s.intern}
end
else
@key = nil
end
if (fi = options[:field_infos]).is_a?(String)
options[:field_infos] = FieldInfos.load(fi)
end
@close_dir = options[:close_dir]
if options[:dir].is_a?(String)
options[:path] = options[:dir]
end
if options[:path]
@close_dir = true
begin
@dir = FSDirectory.new(options[:path], options[:create])
rescue IOError => io
@dir = FSDirectory.new(options[:path],
options[:create_if_missing] != false)
end
elsif options[:dir]
@dir = options[:dir]
else
options[:create] = true # this should always be true for a new RAMDir
@close_dir = true
@dir = RAMDirectory.new
end
@dir.extend(MonitorMixin) unless @dir.kind_of? MonitorMixin
options[:dir] = @dir
options[:lock_retry_time]||= 2
@options = options
if (!@dir.exists?("segments")) || options[:create]
IndexWriter.new(options).close
end
options[:analyzer]||= Ferret::Analysis::StandardAnalyzer.new
if options[:use_typed_range_query].nil?
options[:use_typed_range_query] = true
end
@searcher = nil
@writer = nil
@reader = nil
@options.delete(:create) # only create the first time if at all
@auto_flush = @options[:auto_flush] || false
if (@options[:id_field].nil? and @key.is_a?(Symbol))
@id_field = @key
else
@id_field = @options[:id_field] || :id
end
@default_field = (@options[:default_field]||= :*)
@default_input_field = options[:default_input_field] || @id_field
if @default_input_field.respond_to?(:intern)
@default_input_field = @default_input_field.intern
end
@open = true
@qp = nil
if block
yield self
self.close
end
end
# Returns an array of strings with the matches highlighted. The +query+ can
# either a query String or a Ferret::Search::Query object. The doc_id is
# the id of the document you want to highlight (usually returned by the
# search methods). There are also a number of options you can pass;
#
# === Options
#
# field:: Default: @options[:default_field]. The default_field
# is the field that is usually highlighted but you can
# specify which field you want to highlight here. If
# you want to highlight multiple fields then you will
# need to call this method multiple times.
# excerpt_length:: Default: 150. Length of excerpt to show. Highlighted
# terms will be in the centre of the excerpt. Set to
# :all to highlight the entire field.
# num_excerpts:: Default: 2. Number of excerpts to return.
# pre_tag:: Default: "". Tag to place to the left of the
# match. You'll probably want to change this to a
# "" tag with a class. Try "\033[36m" for use in
# a terminal.
# post_tag:: Default: "". This tag should close the
# +:pre_tag+. Try tag "\033[m" in the terminal.
# ellipsis:: Default: "...". This is the string that is appended
# at the beginning and end of excerpts (unless the
# excerpt hits the start or end of the field.
# Alternatively you may want to use the HTML entity
# … or the UTF-8 string "\342\200\246".
def highlight(query, doc_id, options = {})
@dir.synchronize do
ensure_searcher_open()
@searcher.highlight(do_process_query(query),
doc_id,
options[:field]||@options[:default_field],
options)
end
end
# Closes this index by closing its associated reader and writer objects.
def close
@dir.synchronize do
if not @open
raise(StandardError, "tried to close an already closed directory")
end
@searcher.close() if @searcher
@reader.close() if @reader
@writer.close() if @writer
@dir.close() if @close_dir
@open = false
end
end
# Get the reader for this index.
# NOTE:: This will close the writer from this index.
def reader
ensure_reader_open()
return @reader
end
# Get the searcher for this index.
# NOTE:: This will close the writer from this index.
def searcher
ensure_searcher_open()
return @searcher
end
# Get the writer for this index.
# NOTE:: This will close the reader from this index.
def writer
ensure_writer_open()
return @writer
end
# Adds a document to this index, using the provided analyzer instead of
# the local analyzer if provided. If the document contains more than
# IndexWriter::MAX_FIELD_LENGTH terms for a given field, the remainder are
# discarded.
#
# There are three ways to add a document to the index.
# To add a document you can simply add a string or an array of strings.
# This will store all the strings in the "" (ie empty string) field
# (unless you specify the default_field when you create the index).
#
# index << "This is a new document to be indexed"
# index << ["And here", "is another", "new document", "to be indexed"]
#
# But these are pretty simple documents. If this is all you want to index
# you could probably just use SimpleSearch. So let's give our documents
# some fields;
#
# index << {:title => "Programming Ruby", :content => "blah blah blah"}
# index << {:title => "Programming Ruby", :content => "yada yada yada"}
#
# Or if you are indexing data stored in a database, you'll probably want
# to store the id;
#
# index << {:id => row.id, :title => row.title, :date => row.date}
#
# See FieldInfos for more information on how to set field properties.
def add_document(doc, analyzer = nil)
@dir.synchronize do
ensure_writer_open()
if doc.is_a?(String) or doc.is_a?(Array)
doc = {@default_input_field => doc}
end
# delete existing documents with the same key
if @key
if @key.is_a?(Array)
query = @key.inject(BooleanQuery.new()) do |bq, field|
bq.add_query(TermQuery.new(field, doc[field].to_s), :must)
bq
end
query_delete(query)
else
id = doc[@key].to_s
if id
@writer.delete(@key, id)
end
end
end
ensure_writer_open()
if analyzer
old_analyzer = @writer.analyzer
@writer.analyzer = analyzer
@writer.add_document(doc)
@writer.analyzer = old_analyzer
else
@writer.add_document(doc)
end
flush() if @auto_flush
end
end
alias :<< :add_document
# Run a query through the Searcher on the index. A TopDocs object is
# returned with the relevant results. The +query+ is a built in Query
# object or a query string that can be parsed by the Ferret::QueryParser.
# Here are the options;
#
# === Options
#
# offset:: Default: 0. The offset of the start of the section of the
# result-set to return. This is used for paging through
# results. Let's say you have a page size of 10. If you
# don't find the result you want among the first 10 results
# then set +:offset+ to 10 and look at the next 10 results,
# then 20 and so on.
# limit:: Default: 10. This is the number of results you want
# returned, also called the page size. Set +:limit+ to
# +:all+ to return all results
# sort:: A Sort object or sort string describing how the field
# should be sorted. A sort string is made up of field names
# which cannot contain spaces and the word "DESC" if you
# want the field reversed, all separated by commas. For
# example; "rating DESC, author, title". Note that Ferret
# will try to determine a field's type by looking at the
# first term in the index and seeing if it can be parsed as
# an integer or a float. Keep this in mind as you may need
# to specify a fields type to sort it correctly. For more
# on this, see the documentation for SortField
# filter:: a Filter object to filter the search results with
# filter_proc:: a filter Proc is a Proc which takes the doc_id, the score
# and the Searcher object as its parameters and returns a
# Boolean value specifying whether the result should be
# included in the result set.
def search(query, options = {})
@dir.synchronize do
return do_search(query, options)
end
end
# Run a query through the Searcher on the index. A TopDocs object is
# returned with the relevant results. The +query+ is a Query object or a
# query string that can be validly parsed by the Ferret::QueryParser. The
# Searcher#search_each method yields the internal document id (used to
# reference documents in the Searcher object like this;
# +searcher[doc_id]+) and the search score for that document. It is
# possible for the score to be greater than 1.0 for some queries and
# taking boosts into account. This method will also normalize scores to
# the range 0.0..1.0 when the max-score is greater than 1.0. Here are the
# options;
#
# === Options
#
# offset:: Default: 0. The offset of the start of the section of the
# result-set to return. This is used for paging through
# results. Let's say you have a page size of 10. If you
# don't find the result you want among the first 10 results
# then set +:offset+ to 10 and look at the next 10 results,
# then 20 and so on.
# limit:: Default: 10. This is the number of results you want
# returned, also called the page size. Set +:limit+ to
# +:all+ to return all results
# sort:: A Sort object or sort string describing how the field
# should be sorted. A sort string is made up of field names
# which cannot contain spaces and the word "DESC" if you
# want the field reversed, all separated by commas. For
# example; "rating DESC, author, title". Note that Ferret
# will try to determine a field's type by looking at the
# first term in the index and seeing if it can be parsed as
# an integer or a float. Keep this in mind as you may need
# to specify a fields type to sort it correctly. For more
# on this, see the documentation for SortField
# filter:: a Filter object to filter the search results with
# filter_proc:: a filter Proc is a Proc which takes the doc_id, the score
# and the Searcher object as its parameters and returns a
# Boolean value specifying whether the result should be
# included in the result set.
#
# returns:: The total number of hits.
#
# === Example
# eg.
# index.search_each(query, options = {}) do |doc, score|
# puts "hit document number #{doc} with a score of #{score}"
# end
#
def search_each(query, options = {}) # :yield: doc, score
@dir.synchronize do
ensure_searcher_open()
query = do_process_query(query)
@searcher.search_each(query, options) do |doc, score|
yield doc, score
end
end
end
# Run a query through the Searcher on the index, ignoring scoring and
# starting at +:start_doc+ and stopping when +:limit+ matches have been
# found. It returns an array of the matching document numbers.
#
# There is a big performance advange when using this search method on a
# very large index when there are potentially thousands of matching
# documents and you only want say 50 of them. The other search methods need
# to look at every single match to decide which one has the highest score.
# This search method just needs to find +:limit+ number of matches before
# it returns.
#
# === Options
#
# start_doc:: Default: 0. The start document to start the search from.
# NOTE very carefully that this is not the same as the
# +:offset+ parameter used in the other search methods
# which refers to the offset in the result-set. This is the
# document to start the scan from. So if you scanning
# through the index in increments of 50 documents at a time
# you need to use the last matched doc in the previous
# search to start your next search. See the example below.
# limit:: Default: 50. This is the number of results you want
# returned, also called the page size. Set +:limit+ to
# +:all+ to return all results.
# TODO: add option to return loaded documents instead
#
# === Options
#
# start_doc = 0
# begin
# results = @searcher.scan(query, :start_doc => start_doc)
# yield results # or do something with them
# start_doc = results.last
# # start_doc will be nil now if results is empty, ie no more matches
# end while start_doc
def scan(query, options = {})
@dir.synchronize do
ensure_searcher_open()
query = do_process_query(query)
@searcher.scan(query, options)
end
end
# Retrieves a document/documents from the index. The method for retrieval
# depends on the type of the argument passed.
#
# If +arg+ is an Integer then return the document based on the internal
# document number.
#
# If +arg+ is a Range, then return the documents within the range based on
# internal document number.
#
# If +arg+ is a String then search for the first document with +arg+ in
# the +id+ field. The +id+ field is either :id or whatever you set
# +:id_field+ parameter to when you create the Index object.
def doc(*arg)
@dir.synchronize do
id = arg[0]
if id.kind_of?(String) or id.kind_of?(Symbol)
ensure_reader_open()
term_doc_enum = @reader.term_docs_for(@id_field, id.to_s)
return term_doc_enum.next? ? @reader[term_doc_enum.doc] : nil
else
ensure_reader_open(false)
return @reader[*arg]
end
end
end
alias :[] :doc
# Retrieves the term_vector for a document. The document can be referenced
# by either a string id to match the id field or an integer corresponding
# to Ferret's document number.
#
# See Ferret::Index::IndexReader#term_vector
def term_vector(id, field)
@dir.synchronize do
ensure_reader_open()
if id.kind_of?(String) or id.kind_of?(Symbol)
term_doc_enum = @reader.term_docs_for(@id_field, id.to_s)
if term_doc_enum.next?
id = term_doc_enum.doc
else
return nil
end
end
return @reader.term_vector(id, field)
end
end
# iterate through all documents in the index. This method preloads the
# documents so you don't need to call #load on the document to load all the
# fields.
def each
@dir.synchronize do
ensure_reader_open
(0...@reader.max_doc).each do |i|
yield @reader[i].load unless @reader.deleted?(i)
end
end
end
# Deletes a document/documents from the index. The method for determining
# the document to delete depends on the type of the argument passed.
#
# If +arg+ is an Integer then delete the document based on the internal
# document number. Will raise an error if the document does not exist.
#
# If +arg+ is a String then search for the documents with +arg+ in the
# +id+ field. The +id+ field is either :id or whatever you set +:id_field+
# parameter to when you create the Index object. Will fail quietly if the
# no document exists.
#
# If +arg+ is a Hash or an Array then a batch delete will be performed.
# If +arg+ is an Array then it will be considered an array of +id+'s. If
# it is a Hash, then its keys will be used instead as the Array of
# document +id+'s. If the +id+ is an Integer then it is considered a
# Ferret document number and the corresponding document will be deleted.
# If the +id+ is a String or a Symbol then the +id+ will be considered a
# term and the documents that contain that term in the +:id_field+ will be
# deleted.
def delete(arg)
@dir.synchronize do
if arg.is_a?(String) or arg.is_a?(Symbol)
ensure_writer_open()
@writer.delete(@id_field, arg.to_s)
elsif arg.is_a?(Integer)
ensure_reader_open()
cnt = @reader.delete(arg)
elsif arg.is_a?(Hash) or arg.is_a?(Array)
batch_delete(arg)
else
raise ArgumentError, "Cannot delete for arg of type #{arg.class}"
end
flush() if @auto_flush
end
return self
end
# Delete all documents returned by the query.
#
# query:: The query to find documents you wish to delete. Can either be a
# string (in which case it is parsed by the standard query parser)
# or an actual query object.
def query_delete(query)
@dir.synchronize do
ensure_writer_open()
ensure_searcher_open()
query = do_process_query(query)
@searcher.search_each(query, :limit => :all) do |doc, score|
@reader.delete(doc)
end
flush() if @auto_flush
end
end
# Returns true if document +n+ has been deleted
def deleted?(n)
@dir.synchronize do
ensure_reader_open()
return @reader.deleted?(n)
end
end
# Update the document referenced by the document number +id+ if +id+ is an
# integer or all of the documents which have the term +id+ if +id+ is a
# term..
# For batch update of set of documents, for performance reasons, see batch_update
#
# id:: The number of the document to update. Can also be a string
# representing the value in the +id+ field. Also consider using
# the :key attribute.
# new_doc:: The document to replace the old document with
def update(id, new_doc)
@dir.synchronize do
ensure_writer_open()
delete(id)
if id.is_a?(String) or id.is_a?(Symbol)
@writer.commit
else
ensure_writer_open()
end
@writer << new_doc
flush() if @auto_flush
end
end
# Batch updates the documents in an index. You can pass either a Hash or
# an Array.
#
# === Array (recommended)
#
# If you pass an Array then each value needs to be a Document or a Hash
# and each of those documents must have an +:id_field+ which will be used
# to delete the old document that this document is replacing.
#
# === Hash
#
# If you pass a Hash then the keys of the Hash will be considered the
# +id+'s and the values will be the new documents to replace the old ones
# with.If the +id+ is an Integer then it is considered a Ferret document
# number and the corresponding document will be deleted. If the +id+ is a
# String or a Symbol then the +id+ will be considered a term and the
# documents that contain that term in the +:id_field+ will be deleted.
#
# Note: No error will be raised if the document does not currently
# exist. A new document will simply be created.
#
# == Examples
#
# # will replace the documents with the +id+'s id:133 and id:254
# @index.batch_update({
# '133' => {:id => '133', :content => 'yada yada yada'},
# '253' => {:id => '253', :content => 'bla bla bal'}
# })
#
# # will replace the documents with the Ferret Document numbers 2 and 92
# @index.batch_update({
# 2 => {:id => '133', :content => 'yada yada yada'},
# 92 => {:id => '253', :content => 'bla bla bal'}
# })
#
# # will replace the documents with the +id+'s id:133 and id:254
# # this is recommended as it guarantees no duplicate keys
# @index.batch_update([
# {:id => '133', :content => 'yada yada yada'},
# {:id => '253', :content => 'bla bla bal'}
# ])
#
# docs:: A Hash of id/document pairs. The set of documents to be updated
def batch_update(docs)
@dir.synchronize do
ids = values = nil
case docs
when Array
ids = docs.collect{|doc| doc[@id_field].to_s}
if ids.include?(nil)
raise ArgumentError, "all documents must have an #{@id_field} "
"field when doing a batch update"
end
when Hash
ids = docs.keys
docs = docs.values
else
raise ArgumentError, "must pass Hash or Array, not #{docs.class}"
end
batch_delete(ids)
ensure_writer_open()
docs.each {|new_doc| @writer << new_doc }
flush()
end
end
# Update all the documents returned by the query.
#
# query:: The query to find documents you wish to update. Can either be
# a string (in which case it is parsed by the standard query
# parser) or an actual query object.
# new_val:: The values we are updating. This can be a string in which case
# the default field is updated, or it can be a hash, in which
# case, all fields in the hash are merged into the old hash.
# That is, the old fields are replaced by values in the new hash
# if they exist.
#
# === Example
#
# index << {:id => "26", :title => "Babylon", :artist => "David Grey"}
# index << {:id => "29", :title => "My Oh My", :artist => "David Grey"}
#
# # correct
# index.query_update('artist:"David Grey"', {:artist => "David Gray"})
#
# index["26"]
# #=> {:id => "26", :title => "Babylon", :artist => "David Gray"}
# index["28"]
# #=> {:id => "28", :title => "My Oh My", :artist => "David Gray"}
#
def query_update(query, new_val)
@dir.synchronize do
ensure_writer_open()
ensure_searcher_open()
docs_to_add = []
query = do_process_query(query)
@searcher.search_each(query, :limit => :all) do |id, score|
document = @searcher[id].load
if new_val.is_a?(Hash)
document.merge!(new_val)
else new_val.is_a?(String) or new_val.is_a?(Symbol)
document[@default_input_field] = new_val.to_s
end
docs_to_add << document
@reader.delete(id)
end
ensure_writer_open()
docs_to_add.each {|doc| @writer << doc }
flush() if @auto_flush
end
end
# Returns true if any documents have been deleted since the index was last
# flushed.
def has_deletions?()
@dir.synchronize do
ensure_reader_open()
return @reader.has_deletions?
end
end
# Flushes all writes to the index. This will not optimize the index but it
# will make sure that all writes are written to it.
#
# NOTE: this is not necessary if you are only using this class. All writes
# will automatically flush when you perform an operation that reads the
# index.
def flush()
@dir.synchronize do
if @reader
if @searcher
@searcher.close
@searcher = nil
end
@reader.commit
elsif @writer
@writer.close
@writer = nil
end
end
end
alias :commit :flush
# optimizes the index. This should only be called when the index will no
# longer be updated very often, but will be read a lot.
def optimize()
@dir.synchronize do
ensure_writer_open()
@writer.optimize()
@writer.close()
@writer = nil
end
end
# returns the number of documents in the index
def size()
@dir.synchronize do
ensure_reader_open()
return @reader.num_docs()
end
end
# Merges all segments from an index or an array of indexes into this
# index. You can pass a single Index::Index, Index::Reader,
# Store::Directory or an array of any single one of these.
#
# This may be used to parallelize batch indexing. A large document
# collection can be broken into sub-collections. Each sub-collection can
# be indexed in parallel, on a different thread, process or machine and
# perhaps all in memory. The complete index can then be created by
# merging sub-collection indexes with this method.
#
# After this completes, the index is optimized.
def add_indexes(indexes)
@dir.synchronize do
ensure_writer_open()
indexes = [indexes].flatten # make sure we have an array
return if indexes.size == 0 # nothing to do
if indexes[0].is_a?(Index)
indexes.delete(self) # don't merge with self
indexes = indexes.map {|index| index.reader }
elsif indexes[0].is_a?(Ferret::Store::Directory)
indexes.delete(@dir) # don't merge with self
indexes = indexes.map {|dir| IndexReader.new(dir) }
elsif indexes[0].is_a?(IndexReader)
indexes.delete(@reader) # don't merge with self
else
raise ArgumentError, "Unknown index type when trying to merge indexes"
end
ensure_writer_open
@writer.add_readers(indexes)
end
end
# This is a simple utility method for saving an in memory or RAM index to
# the file system. The same thing can be achieved by using the
# Index::Index#add_indexes method and you will have more options when
# creating the new index, however this is a simple way to turn a RAM index
# into a file system index.
#
# directory:: This can either be a Store::Directory object or a String
# representing the path to the directory where you would
# like to store the index.
#
# create:: True if you'd like to create the directory if it doesn't
# exist or copy over an existing directory. False if you'd
# like to merge with the existing directory. This defaults to
# false.
def persist(directory, create = true)
synchronize do
close_all()
old_dir = @dir
if directory.is_a?(String)
@dir = FSDirectory.new(directory, create)
elsif directory.is_a?(Ferret::Store::Directory)
@dir = directory
end
@dir.extend(MonitorMixin) unless @dir.kind_of? MonitorMixin
@options[:dir] = @dir
@options[:create_if_missing] = true
add_indexes([old_dir])
end
end
def to_s
buf = ""
(0...(size)).each do |i|
buf << self[i].to_s + "\n" if not deleted?(i)
end
buf
end
# Returns an Explanation that describes how +doc+ scored against
# +query+.
#
# This is intended to be used in developing Similarity implementations,
# and, for good performance, should not be displayed with every hit.
# Computing an explanation is as expensive as executing the query over the
# entire index.
def explain(query, doc)
@dir.synchronize do
ensure_searcher_open()
query = do_process_query(query)
return @searcher.explain(query, doc)
end
end
# Turn a query string into a Query object with the Index's QueryParser
def process_query(query)
@dir.synchronize do
ensure_searcher_open()
return do_process_query(query)
end
end
# Returns the field_infos object so that you can add new fields to the
# index.
def field_infos
@dir.synchronize do
ensure_writer_open()
return @writer.field_infos
end
end
protected
def ensure_writer_open()
raise "tried to use a closed index" if not @open
return if @writer
if @reader
@searcher.close if @searcher
@reader.close
@reader = nil
@searcher = nil
end
@writer = IndexWriter.new(@options)
end
# returns the new reader if one is opened
def ensure_reader_open(get_latest = true)
raise "tried to use a closed index" if not @open
if @reader
if get_latest
latest = false
begin
latest = @reader.latest?
rescue Lock::LockError => le
sleep(@options[:lock_retry_time]) # sleep for 2 seconds and try again
latest = @reader.latest?
end
if not latest
@searcher.close if @searcher
@reader.close
return @reader = IndexReader.new(@dir)
end
end
else
if @writer
@writer.close
@writer = nil
end
return @reader = IndexReader.new(@dir)
end
return false
end
def ensure_searcher_open()
raise "tried to use a closed index" if not @open
if ensure_reader_open() or not @searcher
@searcher = Searcher.new(@reader)
end
end
private
def do_process_query(query)
if query.is_a?(String)
if @qp.nil?
@qp = Ferret::QueryParser.new(@options)
end
# we need to set this every time, in case a new field has been added
@qp.fields =
@reader.fields unless options[:all_fields] || options[:fields]
@qp.tokenized_fields =
@reader.tokenized_fields unless options[:tokenized_fields]
query = @qp.parse(query)
end
return query
end
def do_search(query, options)
ensure_searcher_open()
query = do_process_query(query)
return @searcher.search(query, options)
end
def close_all()
@dir.synchronize do
@searcher.close if @searcher
@reader.close if @reader
@writer.close if @writer
@reader = nil
@searcher = nil
@writer = nil
end
end
# If +docs+ is a Hash or an Array then a batch delete will be performed.
# If +docs+ is an Array then it will be considered an array of +id+'s. If
# it is a Hash, then its keys will be used instead as the Array of
# document +id+'s. If the +id+ is an Integers then it is considered a
# Ferret document number and the corresponding document will be deleted.
# If the +id+ is a String or a Symbol then the +id+ will be considered a
# term and the documents that contain that term in the +:id_field+ will
# be deleted.
#
# docs:: An Array of docs to be deleted, or a Hash (in which case the keys
# are used)
def batch_delete(docs)
docs = docs.keys if docs.is_a?(Hash)
raise ArgumentError, "must pass Array or Hash" unless docs.is_a? Array
ids = []
terms = []
docs.each do |doc|
case doc
when String then terms << doc
when Symbol then terms << doc.to_s
when Integer then ids << doc
else
raise ArgumentError, "Cannot delete for arg of type #{id.class}"
end
end
if ids.size > 0
ensure_reader_open
ids.each {|id| @reader.delete(id)}
end
if terms.size > 0
ensure_writer_open()
@writer.delete(@id_field, terms)
end
return self
end
end
end
module Ferret
I = Index::Index
end
ferret-0.11.8.6/lib/ferret/number_tools.rb 0000644 0000041 0000041 00000012604 12476264460 020374 0 ustar www-data www-data require 'date'
require 'time'
class Float
# Return true if the float is within +precision+ of the other value +o+. This
# is used to accommodate for floating point errors.
#
# o:: value to compare with
# precision:: the precision to use in the comparison.
# return:: true if the match is within +precision+
def =~(o, precision = 0.0000000001)
return (1 - self/o).abs < precision
end
end
# Provides support for converting integers to Strings, and back again. The
# strings are structured so that lexicographic sorting order is preserved.
#
# That is, if integer1 is less than integer2 for any two integers integer1 and
# integer2, then integer1.to_s_lex is lexicographically less than
# integer2.to_s_lex. (Similarly for "greater than" and "equals".)
#
# This class handles numbers between - 10 ** 10,000 and 10 ** 10,000
# which should cover all practical numbers. If you need bigger numbers,
# increase Integer::LEN_STR_SIZE.
class Integer
# LEN_SIZE of 4 should handle most numbers that can practically be held in
# memory.
LEN_STR_SIZE = 4
NEG_LEN_MASK = 10 ** LEN_STR_SIZE
LEN_STR_TEMPLATE = "%0#{LEN_STR_SIZE}d"
# Convert the number to a lexicographically sortable string. This string will
# use printable characters only but will not be human readable.
def to_s_lex
if (self >= 0)
num_str = self.to_s
len_str = LEN_STR_TEMPLATE % num_str.size
return len_str + num_str
else
num = self * -1
num_str = num.to_s
num_len = num_str.size
len_str = LEN_STR_TEMPLATE % (NEG_LEN_MASK - num_len)
num = (10 ** num_str.size) - num
return "-#{len_str}%0#{num_len}d" % num
end
end
# Convert the number to a lexicographically sortable string by padding with
# 0s. You should make sure that you set the width to a number large enough to
# accommodate all possible values. Also note that this method will not work
# with negative numbers. That is negative numbers will sort in the opposite
# direction as positive numbers. If you have very large numbers or a mix of
# positive and negative numbers you should use the Integer#to_s_lex method
#
# width:: number of characters in the string returned. Default is 10. So
# 123.to_s_pad(5) => 00123 and -123.to_s_pad(5) => -0123
# return:: padding string representation of the number.
def to_s_pad(width = 10)
"%#{width}d" % self
end
end
class Date
# Convert the Date to a lexicographically sortable string with the required
# precision. The format used is %Y%m%d
#
# precision:: the precision required in the string version of the date. The
# options are :year, :month and :day
# return:: a lexicographically sortable string representing the date
def to_s_lex(precision = :day)
self.strftime(Time::LEX_FORMAT[precision])
end
end
class DateTime
# Convert the DateTime to a lexicographically sortable string with the
# required precision. The format used is %Y%m%d %H:%M:%S.
#
# precision:: the precision required in the string version of the date. The
# options are :year, :month, :day, :hour, :minute and :second
# return:: a lexicographically sortable string representing the date
def to_s_lex(precision = :day)
self.strftime(Time::LEX_FORMAT[precision])
end
end
class Time
LEX_FORMAT = {
:year => "%Y",
:month => "%Y-%m",
:day => "%Y-%m-%d",
:hour => "%Y-%m-%d %H",
:minute => "%Y-%m-%d %H:%M",
:second => "%Y-%m-%d %H:%M:%S",
:millisecond => "%Y-%m-%d %H:%M:%S"
}
# Convert the Time to a lexicographically sortable string with the required
# precision. The format used is %Y%m%d %H:%M:%S.
#
# precision:: the precision required in the string version of the time. The
# options are :year, :month, :day, :hour, :minute and :second
# return:: a lexicographically sortable string representing the date
def to_s_lex(precision = :day)
self.strftime(LEX_FORMAT[precision])
end
end
class String
# Convert a string to an integer. This method will only work on strings that
# were previously created with Integer#to_s_lex, otherwise the result will be
# unpredictable.
def to_i_lex
if (self[0] == ?-)
return self[(Integer::LEN_STR_SIZE + 1)..-1].to_i -
10 ** (self.size - Integer::LEN_STR_SIZE - 1)
else
return self[Integer::LEN_STR_SIZE..-1].to_i
end
end
# Convert a string to a Time. This method will only work on strings that
# match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
def to_time_lex
vals = []
self.gsub(/(?:^|[- :])(\d+)/) {vals << $1.to_i; $&}
Time.mktime(*vals)
end
# Convert a string to a Date. This method will only work on strings that
# match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
def to_date_lex
return Date.strptime(self + "-02-01", "%Y-%m-%d")
end
# Convert a string to a DateTime. This method will only work on strings that
# match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
def to_date_time_lex
return DateTime.strptime(self + "-01-01", "%Y-%m-%d %H:%M:%S")
end
private
def get_lex_format(len)
case len
when 0.. 3 then ""
when 4.. 5 then "%Y"
when 6.. 7 then "%Y%m"
when 8.. 9 then "%Y%m%d"
when 10..11 then "%Y%m%d%H"
when 12..13 then "%Y%m%d%H%M"
else "%Y%m%d%H%M%S"
end
end
end
ferret-0.11.8.6/lib/ferret/browser.rb 0000644 0000041 0000041 00000015557 12476264460 017361 0 ustar www-data www-data require 'erb'
module Ferret::Browser
class Delegator
def initialize(reader, path)
@reader, @path = reader, path
end
def run(env)
controller, action, args = :home, :index, nil
query_string = env['QUERY_STRING']||''
params = parse_query_string(query_string)
req_path = env['PATH_INFO'].gsub(/\/+/, '/')
case req_path
when '/'
# nothing to do
when /^\/?([-a-zA-Z]+)\/?$/
controller = $1
when /^\/?([-a-zA-Z]+)\/([-a-zA-Z]+)\/?(.*)?$/
controller = $1
action = $2
args = $3
else
controller = :error
args = req_path
end
controller_vars = {
:params => params,
:req_path => req_path,
:query_string => query_string,
}
delegate(controller, action, args, controller_vars)
end
private
def delegate(controller, action, args, controller_vars)
begin
controller = to_const(controller, 'Controller').
new(@reader, @path, controller_vars)
controller.send(action, args)
rescue Exception => e
puts e.to_s
controller_vars[:params][:error] = e
ErrorController.new(@reader, @path, controller_vars).index
end
end
def to_const(str, suffix='')
Ferret::Browser.const_get(str.to_s.split('-').
map {|w| w.capitalize}.join('') + suffix)
end
# from _why's camping
def unescape_uri(s)
s.tr('+', ' ').gsub(/%([\da-f]{2})/in){[$1].pack('H*')}
end
def parse_query_string(query_string, delim = '&;')
m = proc {|_,o,n| o.update(n, &m) rescue ([*o] << n)}
(query_string||'').split(/[#{delim}] */n).
inject({}) { |hash, param| key, val = unescape_uri(param).split('=',2)
hash.update(key.split(/[\]\[]+/).reverse.
inject(val) { |x,i| Hash[i,x] }, &m)
}
end
end
module ViewHelper
# truncates the string at the first space after +len+ characters
def truncate(str, len = 80)
if str and str.length > len and (add = str[len..-1].index(' '))
str = str[0, len + add] + '…'
end
str
end
def tick_or_cross(t)
""
end
end
class Controller
include ViewHelper
APP_DIR = File.expand_path(File.join(File.dirname(__FILE__), "browser/"))
STATIC_DIR = File.expand_path(File.join(APP_DIR, "s/"))
def initialize(reader, path, vars)
@reader = reader
@path = path
vars.each_pair {|key, val| instance_eval("@#{key} = val")}
@controller_path = pathify(self.class.to_s.gsub(/.*:/, ''))
end
def method_missing(meth_id, *args)
render(:action => meth_id)
end
protected
def load_page(page)
File.read(File.join(APP_DIR, page))
end
def render(options = {})
options = {
:controller => @controller_path,
:action => :index,
:status => 200,
:content_type => 'text/html',
:env => nil,
:layout => 'views/layout.rhtml',
}.update(options)
path = "views/#{options[:controller]}/#{options[:action]}.rhtml"
content = ERB.new(load_page(path)).result(lambda{})
if options[:layout]
content = ERB.new(load_page(options[:layout])).result(lambda{})
end
return options[:status], options[:content_type], content
end
# takes an optional block to set optional attributes in the links
def paginate(idx, max, url, &b)
return '' if max == 0
url = url.gsub(%r{^/?(.*?)/?$}, '\1')
b ||= lambda{}
link = lambda {|*args|
i, title, text = args
"#{text||i}"
}
res = '
'
if (idx > 0)
res << link.call(idx - 1, "Go to previous page", "« Previous")
else
res << "« Previous"
end
if idx < 10
idx.times {|i| res << link.call(i)}
else
(0..2).each {|i| res << link.call(i)}
res << ' … '
((idx-4)...idx).each {|i| res << link.call(i)}
end
res << link.call(idx, 'Current Page')
if idx > (max - 10)
((idx+1)...max).each {|i| res << link.call(i)}
else
((idx+1)..(idx+4)).each {|i| res << link.call(i)}
res << ' … '
((max-3)...max).each {|i| res << link.call(i)}
end
if (idx < (max - 1))
res << link.call(idx + 1, "Go to next page", "Next »")
else
res << "Next »"
end
res << '
'
end
private
def pathify(str)
str.gsub(/Controller$/, '').gsub(/([a-z])([A-Z])/) {"#{$1}-#{$2}"}.downcase
end
end
class ErrorController < Controller
def index
render(:status => 404)
end
end
class HomeController < Controller
end
class DocumentController < Controller
def list(page = 0)
@page = (page||0).to_i
@page_size = @params[:page_size]||10
@first = @page * @page_size
@last = [@reader.max_doc, (@page + 1) * @page_size].min
render(:action => :list)
end
alias :index :list
def show(doc_id)
doc_id = @params['doc_id']||doc_id||'0'
if doc_id !~ /^\d+$/
raise ArgumentError.new("invalid document number '#{doc_id}'")
end
@doc_id = doc_id.to_i
@doc = @reader[@doc_id].load unless @reader.deleted?(@doc_id)
render(:action => :show)
end
private
def choose_document(doc_id='')
<<-EOF
EOF
end
def paginate_docs
paginate(@doc_id, @reader.max_doc, '/document/show/') {|i|
'deleted' if @reader.deleted?(i)
}
end
end
class TermController < Controller
def show(field)
if field and field.length > 0
@field = field.to_sym
@terms = @reader.terms(@field).to_json(:fast)
end
render(:action => :index)
end
def termdocs(args)
args = args.split('/')
@field = args.shift.intern
@term = args.join('/')
render(:action => :termdocs,
:content_type => 'text/plain',
:layout => false)
end
end
class TermVectorController < Controller
end
class HelpController < Controller
end
end
ferret-0.11.8.6/lib/ferret/field_infos.rb 0000644 0000041 0000041 00000002002 12476264460 020134 0 ustar www-data www-data require 'yaml'
module Ferret::Index
class FieldInfos
# Load FieldInfos from a YAML file. The YAML file should look something like
# this:
# default:
# store: :yes
# index: :yes
# term_vector: :no
#
# fields:
# id:
# index: :untokenized
# term_vector: :no
#
# title:
# boost: 20.0
# term_vector: :no
#
# content:
# term_vector: :with_positions_offsets
#
def self.load(yaml_str)
info = YAML.load(yaml_str)
convert_strings_to_symbols(info)
fis = FieldInfos.new(info[:default])
fields = info[:fields]
fields.keys.each {|key| fis.add_field(key, fields[key])} if fields
fis
end
private
def self.convert_strings_to_symbols(hash)
hash.keys.each do |key|
convert_strings_to_symbols(hash[key]) if hash[key].is_a?(Hash)
if key.is_a?(String)
hash[key.intern] = hash[key]
hash.delete(key)
end
end
end
end
end
ferret-0.11.8.6/lib/ferret/document.rb 0000644 0000041 0000041 00000010347 12476264460 017504 0 ustar www-data www-data module Ferret
# Instead of using documents to add data to an index you can use Hashes and
# Arrays. The only real benefits of using a Document over a Hash are pretty
# printing and the boost attribute. You can add the boost attribute to
# Hashes and arrays using the BoostMixin. For example;
#
# class Hash
# include BoostMixin
# end
#
# class Array
# include BoostMixin
# end
#
# class String
# include BoostMixin
# end
module BoostMixin
attr_accessor :boost
end
# Documents are the unit of indexing and search.
#
# A Document is a set of fields. Each field has a name and an array of
# textual values. If you are coming from a Lucene background you should note
# that Fields don't have any properties except for the boost property. You
# should use the Ferret::Index::FieldInfos class to set field properties
# across the whole index instead.
#
# === Boost
#
# The boost attribute makes a Document more important in the index. That is,
# you can increase the score of a match for queries that match a particular
# document, making it more likely to appear at the top of search results.
# You may, for example, want to boost products that have a higher user
# rating so that they are more likely to appear in search results.
#
# Note: that fields which are _not_ stored (see Ferret::Index::FieldInfos)
# are _not_ available in documents retrieved from the index, e.g.
# Ferret::Search::Searcher#doc or Ferret::Index::IndexReader#doc.
#
# Note: that modifying a Document retrieved from the index will not modify
# the document contained within the index. You need to delete the old
# version of the document and add the new version of the document.
class Document < Hash
include BoostMixin
# Create a new Document object with a boost. The boost defaults to 1.0.
def initialize(boost = 1.0)
@boost = boost
end
# Return true if the documents are equal, ie they have the same fields
def eql?(o)
return (o.is_a? Document and (o.boost == @boost) and
(self.keys == o.keys) and (self.values == o.values))
end
alias :== :eql?
# Create a string representation of the document
def to_s
buf = ["Document {"]
self.keys.sort_by {|key| key.to_s}.each do |key|
val = self[key]
val_str = if val.instance_of? Array then %{["#{val.join('", "')}"]}
elsif val.is_a? Field then val.to_s
else %{"#{val.to_s}"}
end
buf << " :#{key} => #{val_str}"
end
buf << ["}#{@boost == 1.0 ? "" : "^" + @boost.to_s}"]
return buf.join("\n")
end
end
# A Field is a section of a Document. A Field is basically an array with a
# boost attribute. It also provides pretty printing of the field with the
# #to_s method.
#
# === Boost
#
# The boost attribute makes a field more important in the index. That is,
# you can increase the score of a match for queries that match terms in a
# boosted field. You may, for example, want to boost a title field so that
# matches that match in the :title field score more highly than matches that
# match in the :contents field.
#
# Note: If you'd like to use boosted fields without having to use
# the Field class you can just include the BoostMixin in the Array class.
# See BoostMixin.
class Field < Array
include BoostMixin
# Create a new Field object. You can pass data to the field as either a
# string;
#
# f = Field.new("This is the fields data")
#
# or as an array of strings;
#
# f = Field.new(["this", "is", "an", "array", "of", "field", "data"])
#
# Of course Fields can also be boosted;
#
# f = Field.new("field data", 1000.0)
def initialize(data = [], boost = 1.0)
@boost = boost
if data.is_a? Array
data.each {|v| self << v}
else
self << data.to_s
end
end
def eql?(o)
return (o.is_a? Field and (o.boost == @boost) and super(o))
end
alias :== :eql?
def +(o)
return Field.new(super(o), self.boost)
end
def to_s
buf = %{["#{self.join('", "')}"]}
buf << "^#@boost" if @boost != 1.0
return buf
end
end
end
ferret-0.11.8.6/lib/ferret/version.rb 0000644 0000041 0000041 00000000051 12476264460 017342 0 ustar www-data www-data module Ferret
VERSION = '0.11.8.6'
end
ferret-0.11.8.6/lib/ferret/field_symbol.rb 0000644 0000041 0000041 00000005146 12476264460 020337 0 ustar www-data www-data module Ferret
FIELD_TYPES = %w(integer float string byte).map{|t| t.to_sym}
if defined?(BasicObject)
# Ruby 1.9.x
class BlankSlate < BasicObject
end
else
# Ruby 1.8.x
# BlankSlate is a class with no instance methods except for __send__ and
# __id__. It is useful for creating proxy classes. It is currently used by
# the FieldSymbol class which is a proxy to the Symbol class
class BlankSlate
instance_methods.each { |m| undef_method m unless m =~ /^__|object_id/ }
end
end
# The FieldSymbolMethods module contains the methods that are added to both
# the Symbol class and the FieldSymbol class. These methods allow you to set
# the type easily set the type of a field by calling a method on a symbol.
#
# Right now this is only useful for Sorting and grouping, but some day Ferret
# may have typed fields, in which case these this methods will come in handy.
#
# The available types are specified in Ferret::FIELD_TYPES.
#
# == Examples
#
# index.search(query, :sort => :title.string.desc)
#
# index.search(query, :sort => [:price.float, :count.integer.desc])
#
# index.search(query, :group_by => :catalogue.string)
#
# == Note
#
# If you set the field type multiple times, the last type specified will be
# the type used. For example;
#
# puts :title.integer.float.byte.string.type.inspect # => :string
#
# Calling #desc twice will set desc? to false
#
# puts :title.desc? # => false
# puts :title.desc.desc? # => true
# puts :title.desc.desc.desc? # => false
module FieldSymbolMethods
FIELD_TYPES.each do |method|
define_method(method) do
fsym = FieldSymbol.new(self, respond_to?(:desc?) ? desc? : false)
fsym.type = method
fsym
end
end
# Set a field to be a descending field. This only makes sense in sort
# specifications.
def desc
fsym = FieldSymbol.new(self, respond_to?(:desc?) ? !desc? : true)
fsym.type = type if respond_to? :type
fsym
end
# Return whether or not this field should be a descending field
def desc?
@desc == true
end
# Return the type of this field
def type
@type || nil
end
end
# See FieldSymbolMethods
class FieldSymbol < BlankSlate
include FieldSymbolMethods
def initialize(symbol, desc = false)
@symbol = symbol
@desc = desc
end
def method_missing(method, *args)
@symbol.__send__(method, *args)
end
attr_writer :type, :desc
end
end
# See FieldSymbolMethods
class Symbol
include Ferret::FieldSymbolMethods
end
ferret-0.11.8.6/lib/ferret/browser/ 0000755 0000041 0000041 00000000000 12476264460 017017 5 ustar www-data www-data ferret-0.11.8.6/lib/ferret/browser/views/ 0000755 0000041 0000041 00000000000 12476264460 020154 5 ustar www-data www-data ferret-0.11.8.6/lib/ferret/browser/views/help/ 0000755 0000041 0000041 00000000000 12476264460 021104 5 ustar www-data www-data ferret-0.11.8.6/lib/ferret/browser/views/help/index.rhtml 0000644 0000041 0000041 00000000623 12476264460 023264 0 ustar www-data www-data
Ferret Browser Help
At the moment there is no help for the Ferret Browser. Everything should be
fairly self explanatory. If not, you can post a question on the
mailing list
or you can edit the
FerretBrowser wiki page.