solrium 0.1.0

data/README.markdown

@@ -0,0 +1,51 @@
+# Solrium
+
+A JRuby integration layer for Apache Solr/Lucene with a focus on usage from within irb.
+
+## Features
+  
+  * embed solr directly into your app
+  * convenience methods for searching using ruby idioms
+  * jetty integration
+  * bundles all necessary jars (solr, lucene & jetty)
+  
+I mainly wrote it as a tool for quickly prototyping/debugging lucene queries and solr parser plugins.
+
+Note: there's limited support for remote solr queries, searching will done in-process using a [SolrIndexSearcher](http://lucene.apache.org/solr/api/org/apache/solr/search/SolrIndexSearcher.html]), bypassing the HTTP layer. If you need to do remote queries in ruby consider using something like [sunspot](http://github.com/outoftime/sunspot) instead.
+
+## Synposis
+
+### Embedding solr into jirb
+
+    $ jirb -r lib/solr.rb
+    irb> solr = Solrium::Solr.new('/path/to/solr_home')
+    irb> solr.search("foo")
+    => [[Document: {"id"=>"1", "name_t"=>"Foomatic"}, 1.2112]] 
+    
+### Embedding jetty
+
+    $ jirb -r lib/solr.rb
+    irb> Solrium::Jetty.new('/path/to_solr_home').start(2000).join
+    2009-05-14 13:47:24.444::INFO:  jetty-7.0.0.pre5
+    ....
+    INFO: SolrDispatchFilter.init() done
+    2009-05-14 13:47:25.336::INFO:  Started SelectChannelConnector@0.0.0.0:2000
+
+## Credits
+
+Lucene, Solr, Jetty are all licensed under Apache License Version 2.0.
+
+## Contact
+
+Jan Berkel <jan.berkel@gmail.com>
+
+## License
+
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+        
+    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+    and limitations under the License.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "solrium"
+    gemspec.summary = "TODO"
+    gemspec.email = "jan.berkel@gmail.com"
+    gemspec.homepage = "http://github.com/jberkel/solrium"
+    gemspec.description = "A JRuby integration layer for Apache Solr/Lucene with a focus on irb integration."
+    gemspec.authors = ["Jan Berkel"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+  

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/bin/solr

@@ -0,0 +1,9 @@
+#!/usr/bin/env jruby
+
+require 'java'
+#require 'solr'
+require File.join(File.dirname(__FILE__),  '..', 'lib', 'jetty')
+
+if __FILE__ == $0
+  Solrium::Jetty.new('solr-instance').start(8000).join
+end

data/lib/jetty.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env jruby
+
+require 'java'
+
+Dir[File.join(File.dirname(__FILE__), 'jars', 'jetty', '*.jar')].each { |jar| require jar }
+Dir[File.join(File.dirname(__FILE__), 'jars', 'solr', '*.jar')].each { |jar| require jar }
+Dir[File.join(File.dirname(__FILE__), 'jars', 'lucene', '*.jar')].each { |jar| require jar }
+
+module Solrium
+  class Jetty
+    include_class 'org.mortbay.jetty.Server'
+    include_class 'org.mortbay.jetty.servlet.Context'
+    include_class 'org.mortbay.jetty.servlet.ServletHolder'
+    include_class 'org.mortbay.jetty.servlet.DefaultServlet'
+    include_class 'org.mortbay.jetty.handler.ResourceHandler'
+    include_class 'org.mortbay.jetty.handler.MovedContextHandler'
+    include_class 'org.mortbay.jetty.handler.HandlerList'
+    include_class 'org.apache.solr.servlet.SolrServlet'
+    include_class 'org.apache.solr.servlet.SolrUpdateServlet'
+    include_class 'org.apache.jasper.servlet.JspServlet'
+    include_class 'org.mortbay.thread.QueuedThreadPool'
+    include_class 'org.mortbay.jetty.nio.SelectChannelConnector'
+    include_class 'org.mortbay.jetty.Handler'
+  
+    
+    def initialize(dir='solr-instance')
+      Java::JavaLang::System.setProperty("solr.solr.home", dir)
+    end
+      
+    def start(port=8000, servlet_path='/solr', admin_interface=true)    
+      server = create_server(port)
+      context = create_solr_context(servlet_path, admin_interface)
+
+      hl = HandlerList.new
+      hl.add_handler(context)
+      MovedContextHandler.new(hl, '/', "#{servlet_path}/admin") if admin_interface  
+    
+      server.set_handler(hl)    
+      server.start          
+    
+      at_exit do
+        server.stop rescue nil
+      end        
+      server
+    end    
+  
+    private
+    def create_server(port)
+      server = Server.new
+
+      thread_pool = QueuedThreadPool.new
+      thread_pool.min_threads  = 5
+      thread_pool.max_threads  = 50
+      server.set_thread_pool(thread_pool)
+
+      #use the more efficient NIO connector
+      connector = SelectChannelConnector.new
+      connector.port = port 
+
+      server.add_connector(connector)
+      server
+    end
+
+    def create_solr_context(path, admin_interface=true)
+      context = Context.new(nil, path, Context::SESSIONS)
+      context.add_servlet(ServletHolder.new(DefaultServlet.new), "/")
+      context.add_servlet(ServletHolder.new(JspServlet.new), "*.jsp")
+      context.add_filter('org.apache.solr.servlet.SolrDispatchFilter', '/*', Handler::DEFAULT)
+      context.set_mime_types(Java::org.mortbay.jetty.MimeTypes.new)
+      context.mime_types.add_mime_mapping('xsl', 'application/xslt+xml')
+
+      if admin_interface
+        jsp_servlet = ServletHolder.new(JspServlet.new)
+        jsp_servlet.set_forced_path('/admin/ping.jsp')
+
+        context.add_servlet(jsp_servlet, '/admin/ping')
+        context.set_resource_base(File.join(File.dirname(__FILE__), 'webapp'))
+      end
+    
+      context          
+    end
+  end
+end

data/lib/lucene.rb

@@ -0,0 +1,33 @@
+require 'java'
+require File.join(File.dirname(__FILE__), 'queries')
+
+module Solrium
+  
+  # simple lucene integration, bypassing solr completely
+  class Lucene
+    include Queries
+        
+    include_class 'org.apache.lucene.queryParser.QueryParser'
+    include_class 'org.apache.lucene.analysis.standard.StandardAnalyzer'
+    include_class 'org.apache.lucene.search.IndexSearcher'
+
+    attr_accessor :index_path
+    
+    def initialize(solr_home = "solr-instance")      
+      @index_path = File.join(solr_home, 'data', 'index')
+    end
+
+    def analyzer
+      StandardAnalyzer.new
+    end
+
+    def with_searcher(&block)        
+      searcher = IndexSearcher.new(@index_path)
+      begin
+        block.call(searcher)
+      ensure
+        searcher.close
+      end
+    end    
+  end  
+end

data/lib/queries.rb

@@ -0,0 +1,60 @@
+require 'java'
+
+require File.join(File.dirname(__FILE__), 'solr_ext')
+
+module Solrium
+  module Queries
+    
+    include_class 'org.apache.lucene.queryParser.QueryParser'      
+    include_class 'org.apache.lucene.search.MultiPhraseQuery'
+    include_class 'org.apache.lucene.search.WildcardTermEnum'
+    
+    include_class 'org.apache.lucene.search.BooleanQuery'
+    include_class 'org.apache.lucene.search.WildcardQuery'
+    include_class 'org.apache.lucene.search.TermQuery'
+            
+      
+    # convenience search method
+    def search(q, max=10, &block)      
+      q = q.is_a?(org.apache.lucene.search.Query) ? q : parse(q.to_s)
+       
+      block ||= lambda do |doc, score, searcher|       
+        [doc, score]
+      end
+         
+      with_searcher do |searcher|  
+        searcher.search(q, nil, max).scoreDocs.map do |sd|
+          block.call(searcher.doc(sd.doc), sd.score, searcher)
+        end
+      end
+    end
+    
+    def parse(q, default='default')
+      QueryParser.new(default, analyzer).parse(q)
+    end
+        
+    #a wildcard phrase query
+    def wildcard_pq(*terms)      
+      return MultiPhraseQuery.new if terms.empty?
+            
+      if terms.size == 1
+        #only one term, do simple term+wildcard query
+        bq = BooleanQuery.new
+        bq.add(TermQuery.new(Term[terms[0]]), org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+        bq.add(WildcardQuery.new(Term[terms[0] + "*"]), org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+        return bq
+      end
+        
+      mpq = MultiPhraseQuery.new
+        
+      terms[0..-2].each { |t| mpq.add(Term[t]) }
+
+      with_searcher do |s|
+        completions = WildcardTermEnum.new(s.reader, Term["#{terms[-1]}*"]).to_java_array
+        return MultiPhraseQuery.new if completions.length == 0
+        mpq.add(completions) 
+      end
+      mpq
+    end
+  end
+end

data/lib/remote.rb

@@ -0,0 +1,22 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+
+module Solrium      
+  module Remote
+    extend self
+    
+    def query(q, params={}, port=8000)  
+      params['q']  = q
+      params['wt'] = 'ruby'  
+
+      url = URI.parse("http://localhost:#{port}")
+      res = Net::HTTP.start(url.host, url.port) do |http|          
+        http.get("/solr/select?" + params.map { |k,v| "#{k}=#{CGI.escape(v)}" }.join("&"))
+      end
+      res.value    
+      eval(res.body)
+    end
+    
+  end
+end

data/lib/solr.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env jruby
+require 'java'
+require 'fileutils'
+
+Dir[File.join(File.dirname(__FILE__), 'jars', 'lucene', '*.jar')].each { |jar| require jar } 
+Dir[File.join(File.dirname(__FILE__), 'jars', 'solr', '*.jar')].each { |jar| require jar } 
+
+require File.join(File.dirname(__FILE__), 'solr_ext')
+require File.join(File.dirname(__FILE__), 'lucene')
+require File.join(File.dirname(__FILE__), 'queries')
+require File.join(File.dirname(__FILE__), 'remote')
+require File.join(File.dirname(__FILE__), 'jetty')
+
+module Solrium      
+  #wrapper for SolrCore
+  class Solr
+    include Queries
+    include Remote
+    
+    include_class 'org.apache.solr.core.SolrCore'
+    include_class 'org.apache.solr.core.SolrConfig'
+
+    attr_accessor :config, :core
+    
+    def initialize(solr_home='solr-instance')   
+      raise "solr_home #{solr_home} not found" unless File.directory?(solr_home)
+      
+      Java::JavaLang::System.setProperty("solr.solr.home", solr_home)
+    
+      yield self if block_given?
+            
+      @config = SolrConfig.new
+      @core = SolrCore.new('core', nil, @config, nil, nil)
+
+      at_exit do
+        @core.close rescue nil
+      end
+    end
+    
+    def close
+      core.close
+    end
+    
+    def logger(which="")
+      java.util.logging.Logger.getLogger(which)
+    end
+
+    def analyzer
+      core.schema.analyzer
+    end
+    
+    def with_searcher(&block)
+      searcher_ref = core.searcher
+      searcher = searcher_ref.get
+      begin
+        block.call(searcher)
+      ensure
+        searcher_ref.decref
+      end
+    end    
+    
+    def self.template_dir; File.join(File.dirname(__FILE__), '..', 'solr-instance/conf'); end
+
+    def self.init_solr_dir(dest)
+      raise "#{dest} is not a dir" unless File.directory?(dest)      
+      FileUtils.cp_r template_dir, dest      
+    end
+  end
+end

data/lib/solr_ext.rb

@@ -0,0 +1,81 @@
+# make lucene/solr a bit more rubyis
+module Solrium
+  include_class 'org.apache.lucene.index.TermEnum'
+  include_class 'org.apache.lucene.index.Term'
+  include_class 'org.apache.lucene.document.Document'
+  include_class 'org.apache.lucene.document.Field'      
+  include_class 'org.apache.lucene.document.Field'      
+  
+  include_class 'org.apache.lucene.search.Query'
+  include_class 'org.apache.lucene.search.BooleanQuery'
+    
+  #sugar, sugar... honey, honey.
+  Query.class_eval do    
+    def |(other)
+      boolean_query(self, other, org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+    end
+    
+    def &(other)
+      boolean_query(self, other, org.apache.lucene.search.BooleanClause::Occur::MUST)
+    end
+    
+    def boolean_query(a,b,occur)
+      bq = BooleanQuery.new
+      bq.add(a, occur)
+      bq.add(b, occur)
+      bq
+    end
+  end
+      
+  Document.class_eval do
+    def [](n)
+      self.getField(n)
+    end
+    
+    def inspect
+      "Document: " + to_hash.inspect
+    end
+    
+    def to_hash
+      fields.inject({}) do |h, f|
+        h[f.name] = f.stringValue()
+        h
+      end
+    end
+  end
+  
+  Field.class_eval do
+    def inspect
+      "#{name}: #{to_s}"
+    end
+    
+    def to_s
+      self.stringValue()
+    end
+  end
+  
+  # lets you use Term['foo'] ==> Term.new('default', foo)
+  Term.class_eval do
+    def self.[](t)
+      new('default', t)
+    end
+  end
+   
+  #make TermEnum a bit friendlier to use          
+  class TermEnum
+    include Enumerable
+
+    def each
+     while self.next()
+       yield(self.term())
+     end
+    end
+
+    def to_java_array
+     elements = to_a
+     array = java.lang.reflect.Array.newInstance(Term.java_class, elements.length)
+     elements.each_with_index { |e,i| array[i] = e }
+     array
+    end
+  end
+end