outoftime-sunspot 0.0.1

data/History.txt

@@ -0,0 +1,7 @@
+== 0.0.1 2008-12-11
+
+* 1 major enhancement:
+  * Initial release
+  * Define indexing for any class using DSL
+  * Search indexed classes using DSL
+  

data/Manifest.txt

@@ -0,0 +1,104 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/light_config.rb
+lib/sunspot.rb
+lib/sunspot/adapters.rb
+lib/sunspot/conditions.rb
+lib/sunspot/conditions_builder.rb
+lib/sunspot/configuration.rb
+lib/sunspot/field.rb
+lib/sunspot/field_builder.rb
+lib/sunspot/indexer.rb
+lib/sunspot/query.rb
+lib/sunspot/query_builder.rb
+lib/sunspot/restriction.rb
+lib/sunspot/scope_builder.rb
+lib/sunspot/search.rb
+lib/sunspot/session.rb
+lib/sunspot/type.rb
+lib/sunspot/util.rb
+lib/sunspot/version.rb
+log/test_solr.log
+setup.rb
+solr/README.txt
+solr/etc/jetty.xml
+solr/etc/webdefault.xml
+solr/exampledocs/books.csv
+solr/exampledocs/hd.xml
+solr/exampledocs/ipod_other.xml
+solr/exampledocs/ipod_video.xml
+solr/exampledocs/mem.xml
+solr/exampledocs/monitor.xml
+solr/exampledocs/monitor2.xml
+solr/exampledocs/mp500.xml
+solr/exampledocs/post.jar
+solr/exampledocs/post.sh
+solr/exampledocs/sd500.xml
+solr/exampledocs/solr.xml
+solr/exampledocs/spellchecker.xml
+solr/exampledocs/utf8-example.xml
+solr/exampledocs/vidcard.xml
+solr/lib/jetty-6.1.3.jar
+solr/lib/jetty-util-6.1.3.jar
+solr/lib/jsp-2.1/ant-1.6.5.jar
+solr/lib/jsp-2.1/core-3.1.1.jar
+solr/lib/jsp-2.1/jsp-2.1.jar
+solr/lib/jsp-2.1/jsp-api-2.1.jar
+solr/lib/servlet-api-2.5-6.1.3.jar
+solr/logs
+solr/solr/README.txt
+solr/solr/bin/abc
+solr/solr/bin/abo
+solr/solr/bin/backup
+solr/solr/bin/backupcleaner
+solr/solr/bin/commit
+solr/solr/bin/optimize
+solr/solr/bin/readercycle
+solr/solr/bin/rsyncd-disable
+solr/solr/bin/rsyncd-enable
+solr/solr/bin/rsyncd-start
+solr/solr/bin/rsyncd-stop
+solr/solr/bin/scripts-util
+solr/solr/bin/snapcleaner
+solr/solr/bin/snapinstaller
+solr/solr/bin/snappuller
+solr/solr/bin/snappuller-disable
+solr/solr/bin/snappuller-enable
+solr/solr/bin/snapshooter
+solr/solr/conf/admin-extra.html
+solr/solr/conf/protwords.txt
+solr/solr/conf/schema.xml
+solr/solr/conf/scripts.conf
+solr/solr/conf/solrconfig.xml
+solr/solr/conf/stopwords.txt
+solr/solr/conf/synonyms.txt
+solr/solr/conf/xslt
+solr/solr/conf/xslt
+solr/solr/data/spell
+solr/start.jar
+solr/webapps/solr.war
+tasks/deployment.rake
+tasks/environment.rake
+tasks/rcov.rake
+tasks/solr.rake
+tasks/website.rake
+test/api/test_build_search.rb
+test/api/test_helper.rb
+test/api/test_indexer.rb
+test/api/test_retrieve_search.rb
+test/api/test_session.rb
+test/custom_expectation.rb
+test/integration/test_field_types.rb
+test/integration/test_helper.rb
+test/integration/test_keyword_search.rb
+test/integration/test_pagination.rb
+test/mocks/base_class.rb
+test/mocks/comment.rb
+test/mocks/mock_adapter.rb
+test/mocks/post.rb
+test/test_helper.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on sunspot, see http://sunspot.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,115 @@
+= sunspot
+
+http://github.com/outoftime/sunspot
+
+Sunspot is a Ruby library for expressive, powerful interaction with the Solr search engine.
+Sunspot is built on top of the solr-ruby gem, which provides a low-level interface for Solr
+interaction; Sunspot provides a simple, intuitive, expressive DSL backed by powerful
+features for indexing objects and searching against them.
+
+Sunspot is designed to be easily plugged in to any ORM, or even non-database-backed
+objects such as the filesystem.
+
+Sunspot is currently under active development and is not feature-complete.
+
+=== Sunspot already has these features:
+
+* Define indexing strategy for each searchable class using intuitive block-based API
+* Clean separation between keyword-searchable fields and fields for scoping/ordering
+* Define fields based on existing attributes or "virtual fields" for custom indexing
+* Indexes each object's entire superclass hierarchy, for easy searching for all objects inheriting from a parent class
+* Intuitive DSL for scoping searches, with all the usual boolean operators available
+* Ability to pass dynamic conditions in as a hash, and define which operator to use for each condition
+* Full compatibility with will_paginate
+* Ordering
+
+=== Sunspot will have these features:
+
+* Adapters for DataMapper, ActiveRecord, and File objects
+* Extensible adapter architecture for easy integration of other ORMs or non-model classes
+* High-power integration with ORM features for maximum efficiency (e.g., specify AR :include argument for eager loading associations when hydrating search results)
+* Intuitive interface for requesting facets on indexed fields
+* Define association facets, which return model objects as row values
+* Access search parameters as hash or object attributes, for easy integration with form helpers or query string builders
+* Plugins for drop-in integration with Merb and Rails
+
+== Using Sunspot
+
+=== Define an index:
+
+  class Post
+    #...
+  end
+
+  Sunspot.setup(Post) do
+    text :title, :body
+    string :author_name
+    integer :blog_id
+    integer :category_ids
+    float :average_rating
+    time :published_at
+    string :sort_title do
+      title.downcase.sub(/^(an?|the)\W+/, ''/) if title = self.title
+    end
+  end
+
+=== Search for objects:
+  
+  search = Sunspot.search Post, :conditions => { :average_rating => 3.0 } do
+    keywords 'great pizza'
+    with.author_name 'Mark Twain'
+    with.blog_id.any_of [2, 14]
+    with.category_ids.all_of [4, 10]
+    with.published_at.less_than Time.now
+
+    conditions.interpret :average_rating, :greater_than
+    conditions.default :average_rating, 4.0
+
+    paginate :page => 3, :per_page => 15
+    order_by :average_rating, :desc
+  end
+
+=== Get data and parameters from search:
+
+  search.results
+  search.total
+  search.page
+  search.per_page
+  search.keywords
+  search.conditions.average_rating
+  search.attributes[:conditions]
+
+== REQUIREMENTS:
+
+1. extlib
+2. solr-ruby
+3. Java
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Mat Brown
+
+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/Rakefile

@@ -0,0 +1,27 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/sunspot'
+
+ENV['RUBYOPT'] = '-W1'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('sunspot', Sunspot::VERSION) do |p|
+  p.developer('Mat Brown', 'mat@patch.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }

data/config/hoe.rb

@@ -0,0 +1,74 @@
+require 'sunspot/version'
+
+AUTHOR = 'Mat Brown'  # can also be an array of Authors
+EMAIL = "mat@patch.com"
+DESCRIPTION = "Awesome Solr interaction for Ruby"
+GEM_NAME = 'sunspot' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'sunspot' # The unix name for your project
+HOMEPATH = "http://github.com/outoftime/sunspot"
+DOWNLOAD_PATH = "http://github.com/outoftime/sunspot"
+EXTRA_DEPENDENCIES = [
+  ['solr-ruby', '= 0.0.6',
+   'extlib', '>= 0.9.7']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Sunspot::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'sunspot documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README.rdoc",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["spec/**/*_spec.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/light_config.rb

@@ -0,0 +1,40 @@
+module LightConfig
+  class Configuration
+    def initialize(&block)
+      @properties = {}
+      ::LightConfig::Builder.new(self).instance_eval(&block)
+      singleton = (class <<self; self; end)
+      @properties.keys.each do |property|
+        singleton.module_eval do
+          define_method property do
+            @properties[property]
+          end
+          
+          define_method "#{property}=" do |value|
+            @properties[property] = value
+          end
+        end
+      end
+    end
+  end
+
+  class Builder
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def method_missing(method, *args, &block)
+      raise ArgumentError("wrong number of arguments(#{args.length} for 1)") unless args.length < 2
+      value = if block then ::LightConfig::Configuration.new(&block)
+              else args.first
+              end
+      @configuration.instance_variable_get(:@properties)[method] = value
+    end
+  end
+end
+
+class <<LightConfig
+  def build(&block)
+    LightConfig::Configuration.new(&block)
+  end
+end

data/lib/sunspot/adapters.rb

@@ -0,0 +1,54 @@
+module Sunspot
+  module Adapters
+    module InstanceAdapter
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def index_id
+        "#{instance.class.name} #{id}"
+      end
+
+      protected
+      attr_accessor :instance
+    end
+
+    module ClassAdapter
+      def initialize(clazz)
+        @clazz = clazz
+      end
+
+      protected
+      attr_reader :clazz
+    end
+  end
+
+  class <<Adapters
+    def register(adapter, *classes)
+      for clazz in classes
+        adapters[clazz.name] = adapter
+      end
+    end
+
+    def adapt_class(clazz)
+      self.for(clazz).const_get('ClassAdapter').new(clazz)
+    end
+
+    def adapt_instance(instance)
+      self.for(instance.class).const_get('InstanceAdapter').new(instance)
+    end
+
+    def for(clazz)
+      while clazz != Object
+        return adapters[clazz.name] if adapters[clazz.name]
+        clazz = clazz.superclass
+      end
+    end
+
+    private
+
+    def adapters
+      @adapters ||= {}
+    end
+  end
+end

data/lib/sunspot/conditions.rb

@@ -0,0 +1,50 @@
+module Sunspot
+  class Conditions
+    def initialize(query, conditions_hash)
+      @query = query
+      @conditions_hash = conditions_hash.inject({}) do |hash, pair|
+        field_name, value = pair
+        hash[field_name.to_s] = value
+        hash
+      end
+    end
+    
+    def interpret(field_name, condition_type)
+      operators_hash[field_name.to_s] = Sunspot::Restriction.const_get condition_type.to_s.camel_case
+    end
+
+    def default(field_name, value)
+      conditions_hash[field_name.to_s] ||= value
+    end
+
+    def restrictions
+      conditions_hash.map { |field_name, value| condition_for(field_name, value) }.compact
+    end
+
+    protected
+    attr_reader :conditions_hash
+
+    def condition_for(field_name, value)
+      operator = operator_for(field_name) || default_operator_for(value)
+      begin
+        @query.build_condition field_name, operator, value
+      rescue ArgumentError
+        nil # fail silently if field isn't configured
+      end
+    end
+
+    def default_operator_for(value)
+      if value.is_a?(Array) then Sunspot::Restriction::AnyOf
+      else Sunspot::Restriction::EqualTo
+      end
+    end
+
+    def operator_for(field_name)
+      operators_hash[field_name.to_s] 
+    end
+
+    def operators_hash
+      @operators_hash ||= {}
+    end
+  end
+end

data/lib/sunspot/conditions_builder.rb

@@ -0,0 +1,37 @@
+module Sunspot
+  class Conditions
+    def initialize(query, conditions_hash)
+      @query, @conditions_hash = query, conditions_hash
+    end
+    
+    def interpret(field_name, condition_type)
+      operators_hash[field_name.to_s] = Sunspot::Restriction.const_get condition_type.to_s.camel_case
+    end
+
+    def conditions
+      conditions_hash.map { |field_name, value| condition_for(field_name, value) }
+    end
+
+    protected
+    attr_reader :conditions_hash
+
+    def condition_for(field_name, value)
+      operator = operator_for(field_name) || default_operator_for(value)
+      @query.build_condition field_name, operator, value
+    end
+
+    def default_operator_for(value)
+      if value.is_a?(Array) then Sunspot::Restriction::AnyOf
+      else Sunspot::Restriction::EqualTo
+      end
+    end
+
+    def operator_for(field_name)
+      operators_hash[field_name.to_s] 
+    end
+
+    def operators_hash
+      @operators_hash ||= {}
+    end
+  end
+end

data/lib/sunspot/configuration.rb

@@ -0,0 +1,17 @@
+module Sunspot
+  module Configuration
+  end
+  
+  class <<Configuration
+    def build
+      LightConfig.build do
+        solr do
+          url 'http://localhost:8983/solr'
+        end
+        pagination do
+          default_per_page 30
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/field.rb

@@ -0,0 +1,108 @@
+module Sunspot
+  module Field
+    class Base
+      attr_accessor :name, :type
+
+      def initialize(name, type, options = {})
+        @name, @type = name, type
+        @multiple = options.delete(:multiple)
+        raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
+      end
+
+      def pair_for(model)
+        if value = value_for(model)
+          { indexed_name.to_sym => to_indexed(value) }
+        else
+          {}
+        end
+      end
+
+      def ==(other)
+        other.respond_to?(:name) &&
+          other.respond_to?(:type) &&
+          self.name == other.name &&
+          self.type == other.type
+      end
+
+      def hash
+        name.hash + 31 * type.hash
+      end
+
+      def indexed_name
+        "#{type.indexed_name(name)}#{'m' if multiple?}"
+      end
+
+      def to_indexed(value)
+        if value.kind_of? Array 
+          if multiple?
+            value.map { |val| to_indexed(val) }
+          else
+            raise ArgumentError, "#{name} is not a multiple-value field, so it cannot index values #{value.inspect}"
+          end
+        else
+          type.to_indexed(value)
+        end
+      end
+
+      def multiple?
+        !!@multiple
+      end
+    end
+
+    class AttributeField < ::Sunspot::Field::Base
+      protected
+
+      def value_for(model)
+        model.send(name)
+      end
+    end
+
+    class VirtualField < ::Sunspot::Field::Base
+      def initialize(name, type, options = {}, &block)
+        super(name, type, options)
+        @block = block
+      end
+
+      protected
+      attr_accessor :block
+
+      def value_for(model)
+        model.instance_eval(&block)
+      end
+    end
+  end
+
+  class <<Field
+    def register(clazz, fields)
+      fields = [fields] unless fields.kind_of? Enumerable
+      self.for(clazz).concat fields
+    end
+
+    def register_text(clazz, fields)
+      fields = [fields] unless fields.kind_of? Enumerable
+      self.text_for(clazz).concat fields
+    end
+
+    def text_for(clazz)
+      keyword_fields_hash[clazz.object_id] ||= []
+    end
+
+    def for(clazz)
+      fields_hash[clazz.object_id] ||= []
+    end
+
+    def unregister_all!
+      fields_hash.clear
+    end
+
+    private
+
+    def fields_hash
+      @fields_hash ||= {}
+    end
+
+    def keyword_fields_hash
+      @keyword_fields_hash ||= {}
+    end
+  end
+end