lucene 0.5.0.beta.1

data/lib/lucene/jars.rb

@@ -0,0 +1,5 @@
+include Java
+
+module Lucene
+  require 'lucene/jars/lucene-core-2.9.1.jar'
+end

data/lib/lucene/query_dsl.rb

@@ -0,0 +1,135 @@
+module Lucene
+  
+  class Expression #:nodoc:
+    attr_accessor :left, :right, :op, :query
+  
+    def self.new_complete(left, op, right)
+      expr = Expression.new
+      expr.left = left
+      expr.op = op
+      expr.right = right
+      expr
+    end
+  
+    def self.new_uncomplete(left, query)
+      expr = Expression.new
+      expr.left = left
+      expr.query = query
+      expr
+    end
+  
+    def ==(other)
+      @op = :==
+        @right = other
+      @query
+    end
+  
+    def >(other)
+      @op = :>
+        @right = other
+      @query
+    end
+  
+    #
+    # Returns the fields being used in a query
+    #
+    def _fields(fields = [])
+      if (@left.kind_of? Expression)
+        @left._fields(fields)
+      else
+        fields << @left
+      end
+      if (@right.kind_of? Expression)
+        @right._fields(fields)
+      end     
+      fields
+    end
+    
+    def to_lucene(field_infos)
+      $LUCENE_LOGGER.debug{"QueryDSL.to_lucene '#{to_s}'"}
+      
+      if @left.kind_of? Lucene::Expression
+        left_query = @left.to_lucene(field_infos)
+        raise ArgumentError.new("Right term is not an Expression, but a '#{@right.class.to_s}'") unless @right.kind_of? Lucene::Expression
+        right_query = @right.to_lucene(field_infos)
+        query = org.apache.lucene.search.BooleanQuery.new
+        clause = (@op == :&) ? org.apache.lucene.search.BooleanClause::Occur::MUST : org.apache.lucene.search.BooleanClause::Occur::SHOULD
+        query.add(left_query, clause)
+        query.add(right_query, clause)
+        return query
+      else
+        field_info = field_infos[@left]
+        field_info.convert_to_query(@left, @right)
+      end
+    end
+
+    def to_s
+      "(#@left #@op #@right)"
+    end
+  end
+  
+  class QueryDSL
+    attr_reader :stack 
+    
+    def initialize
+      @stack = []
+      #yield self
+    end
+    
+    def self.find(field_infos = IndexInfo.new(:id), &expr) 
+      exp = QueryDSL.parse(&expr)
+      exp.to_lucene(field_infos)
+    end
+      
+    
+  
+    def self.parse(&query)
+      query_dsl = QueryDSL.new
+      query_dsl.instance_eval(&query)
+      query_dsl.stack.last
+    end
+    
+    def method_missing(methodname, *args)
+      expr = Expression.new_uncomplete(methodname, self)
+      @stack.push expr
+      expr
+    end
+  
+    def ==(other)
+      puts "WRONG == '#{other}'"
+    end
+    
+    def <=>(to)
+      from = @stack.last.right
+      @stack.last.right = Range.new(from, to)
+      @stack.last
+    end
+  
+  
+    def &(other)
+      raise ArgumentError.new("Expected at least two expression on stack, got #{@stack.size}") if @stack.size < 2
+      right = @stack.pop
+      left = @stack.pop
+      expr = Expression.new_complete(left, :&, right)
+      @stack.push expr
+      self
+    end
+
+    def |(other)
+      raise ArgumentError.new("Expected at least two expression on stack, got #{@stack.size}") if @stack.size < 2
+      right = @stack.pop
+      left = @stack.pop
+      expr = Expression.new_complete(left, :|, right)
+      @stack.push expr
+      self
+    end
+
+    def to_s
+      @stack.last.to_s
+    end
+      
+  end
+  
+  
+end
+

data/lib/lucene/transaction.rb

@@ -0,0 +1,117 @@
+module Lucene
+  
+  class TransactionAlreadyRunningException < StandardError; end
+  class TransactionNotRunningException < StandardError; end
+  
+  class Transaction
+    
+    def initialize
+      raise TransactionAlreadyRunningException.new if Transaction.running?
+      Thread.current[:lucene_transaction] = self
+      
+      @rollback = false
+      @commited = false
+      @indexes = {} # key is the path to index, value is the index instance
+    end
+
+    def to_s
+      "Transaction [commited=#@commited, rollback=#@rollback, indexes=#{@indexes.size}, object_id=#{object_id}]"
+    end
+
+    
+    # Commits all registered Indexes.
+    # Stops this transaction (running? will be false)
+    #
+    def commit
+      if !@rollback
+        @indexes.each_value do |index| 
+          index.commit
+        end 
+      end
+      @commited = true
+      @indexes.clear
+      Thread.current[:lucene_transaction] = nil
+    end
+    
+    def failure
+      @rollback = true
+      $LUCENE_LOGGER.debug{"Rollback Lucene Transaction"}      
+    end
+    
+    def rollback?
+      @rollback
+    end
+
+    def rollback!
+      @rollback = true
+    end
+    
+    #
+    # Registers an index to take part of this transaction
+    #
+    def register_index(key, index)
+      @indexes[key] = index
+      $LUCENE_LOGGER.debug{"Registered index for #{index}"}
+    end
+
+    #
+    # Deregister the index so that it will not be part of the transaction
+    # any longer.
+    #
+    def deregister_index(index)
+      @indexes.delete index.path
+      $LUCENE_LOGGER.debug{"Deregistered index for #{index}"}
+    end
+
+    #
+    # Deregister all indexes, used for testing purpose.
+    #
+    def deregister_all_indexes
+      @indexes.clear
+      $LUCENE_LOGGER.debug{"Deregistered all index, #{@indexes.inspect}"}
+    end
+    
+    
+    def index?(path)
+      @indexes[path] != nil
+    end
+    
+    def index(path)
+      @indexes[path]
+    end
+    
+    #
+    # Class methods
+    #
+    class << self
+      def run
+        tx = Transaction.new
+        begin
+          yield tx
+        rescue => ex
+          tx.failure
+          # TODO reuse of error handling and logging
+          $LUCENE_LOGGER.error{"Got exception #{ex}"}      
+          ex.backtrace.each {|t| $LUCENE_LOGGER.error(t)}
+          raise
+        ensure
+          tx.commit unless tx.rollback?
+        end
+      end
+
+      #
+      # Returns the current transaction or nil
+      #
+      def current
+        Thread.current[:lucene_transaction]
+      end
+      
+      
+      def running?
+        self.current != nil 
+      end
+    end
+  end
+  
+  
+end

data/lib/lucene/version.rb

@@ -0,0 +1,3 @@
+module Lucene
+  VERSION = '0.5.0.beta.1'
+end

data/lucene.gemspec

@@ -0,0 +1,23 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+ 
+require 'lucene/version'
+
+
+Gem::Specification.new do |s|
+  s.name = "lucene"
+  s.version = Lucene::VERSION
+#  s.platform = Gem::Platform::CURRENT  # will probably support  C Ruby via RJB also in the future
+  s.authors = "Andreas Ronge"
+  s.email = 'andreas.ronge@gmail.com'
+  s.homepage = "http://github.com/andreasronge/lucene/tree"
+  s.rubyforge_project = 'lucene'
+  s.summary = "A lucene wrapper for JRuby"
+  s.description = s.summary
+  s.require_path = 'lib'
+  s.files        = Dir.glob("{bin,lib}/**/*") + %w(README.rdoc CHANGELOG CONTRIBUTORS Gemfile lucene.gemspec)
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README.rdoc )
+  s.rdoc_options = ["--quiet", "--title", "Lucene.rb", "--opname", "index.html", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+  s.required_ruby_version = ">= 1.8.7"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: lucene
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+    - 0
+    - 5
+    - 0
+    - beta
+    - 1
+  version: 0.5.0.beta.1
+platform: ruby
+authors: 
+  - Andreas Ronge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-20 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: A lucene wrapper for JRuby
+email: andreas.ronge@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - lib/lucene.rb
+  - lib/lucene/document.rb
+  - lib/lucene/index_searcher.rb
+  - lib/lucene/config.rb
+  - lib/lucene/transaction.rb
+  - lib/lucene/field_info.rb
+  - lib/lucene/index_info.rb
+  - lib/lucene/hits.rb
+  - lib/lucene/jars.rb
+  - lib/lucene/index.rb
+  - lib/lucene/query_dsl.rb
+  - lib/lucene/version.rb
+  - lib/lucene/jars/lucene-core-2.9.1.jar
+  - README.rdoc
+  - CHANGELOG
+  - CONTRIBUTORS
+  - Gemfile
+  - lucene.gemspec
+has_rdoc: true
+homepage: http://github.com/andreasronge/lucene/tree
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --quiet
+  - --title
+  - Lucene.rb
+  - --opname
+  - index.html
+  - --line-numbers
+  - --main
+  - README.rdoc
+  - --inline-source
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 8
+          - 7
+        version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 3
+          - 1
+        version: 1.3.1
+requirements: []
+
+rubyforge_project: lucene
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A lucene wrapper for JRuby
+test_files: []
+