redcar 0.9.2 → 0.10

data/plugins/project_search/vendor/lucene/lib/lucene/index_searcher.rb

@@ -0,0 +1,157 @@
+module Lucene
+
+  class Asc
+    class << self
+
+      # Specifies which fields should be sorted in ascending order
+      #
+      # ==== Parameters
+      # fields:: One or more fields to sort in ascending order (Array)
+      #
+      # ==== Examples
+      #  Asc[:name, :age]
+      #
+      # ==== Returns
+      # An array of sort fields
+      #
+      def [](*fields)
+        fields.map{|x| org.apache.lucene.search.SortField.new(x.to_s)}
+      end
+    end
+  end
+
+  class Desc
+    class << self
+      # Specifies which fields should be sorted in descending order
+      #
+      # ==== Block parameters
+      # fields:: One or more fields to sort in descending order (Array)
+      #
+      # ==== Examples
+      #  Desc[:name, :age]
+      #
+      # ==== Returns
+      # An array of sort fields
+      #
+      def [](*fields)
+        fields.map{|x| org.apache.lucene.search.SortField.new(x.to_s, true)}
+        #org.apache.lucene.search.Sort.new(values.map{|x| org.apache.lucene.search.SortField.new(x.to_s, true)}.to_java(:'org.apache.lucene.search.SortField'))
+      end
+    end
+  end
+
+  #
+  # Does reuse Lucene Index Search for the same index.
+  # Reloads the index if the index has changed.
+  #
+  class IndexSearcher
+    
+    @@paths = {}
+    
+    def initialize(path)
+      @path = path
+    end
+
+    #
+    # Only create a new object if it does not already exist for this path    
+    #
+    def self.new(path)
+      @@paths[path] = super(path) if @@paths[path].nil?
+      @@paths[path]
+    end
+
+    def find_dsl(field_infos,&block)
+      exp = QueryDSL.parse(&block)  
+      query = exp.to_lucene(field_infos)
+      
+      Hits.new(field_infos, index_searcher.search(query))      
+    end
+    
+    
+    def find(field_info, query)
+      # are there any index for this node ?
+      # if not return an empty array
+      return [] unless exist?
+      
+      #puts "QUERY #{query.inspect}" # '#{query.first.class.to_s}' value #{query.first}"
+      sort_by ||= query[1].delete(:sort_by) if query[1].kind_of?(Hash)
+      sort_by ||= query.delete(:sort_by)
+      #puts "QUERY sort #{sort_by}"
+      # TODO Refactoring ! too long and complex method
+      lucene_query = case query
+      when Array
+        sort_by ||= query.last.delete(:sort_by) if query.last.kind_of?(Hash)
+        parser = org.apache.lucene.queryParser.QueryParser.new(field_info.id_field.to_s, field_info.analyzer)
+        parser.parse(query.first)
+      when Hash
+        bquery = org.apache.lucene.search.BooleanQuery.new
+        query.each_pair do |key,value|
+          field = field_info[key]
+          q = field.convert_to_query(key, value)
+          bquery.add(q, org.apache.lucene.search.BooleanClause::Occur::MUST)
+        end
+        bquery
+      else
+        raise StandardError.new("Unknown type #{query.class.to_s} for find #{query}")
+      end
+      
+      if sort_by.nil?
+        Hits.new(field_info, index_searcher.search(lucene_query))
+      else
+        sort = create_sort(sort_by) 
+        Hits.new(field_info, index_searcher.search(lucene_query, sort))
+      end
+      
+    end
+
+    def parse_field(field)
+      case field
+      when String,Symbol
+        [org.apache.lucene.search.SortField.new(field.to_s)]
+      when org.apache.lucene.search.SortField
+        [field]
+      when Array
+        raise StandardError.new("Unknown sort field '#{field}'") unless field.first.kind_of?(org.apache.lucene.search.SortField)
+        field
+      end
+    end
+
+
+    def create_sort(fields)
+      case fields
+      when String,Symbol
+        org.apache.lucene.search.Sort.new(fields.to_s)
+      when org.apache.lucene.search.SortField
+        org.apache.lucene.search.Sort.new(fields)
+      when Array
+        sorts = []
+        fields.each do |field|
+          sorts += parse_field(field)
+        end
+        org.apache.lucene.search.Sort.new(sorts.to_java(:'org.apache.lucene.search.SortField')) 
+      else
+        StandardError.new("Unknown type #{fields.class.to_s}")
+      end
+    end
+
+    #
+    # Checks if it needs to reload the index searcher
+    #
+    def index_searcher
+      if @index_reader.nil? || @index_reader.getVersion() != org.apache.lucene.index.IndexReader.getCurrentVersion(@path)
+        @index_reader = org.apache.lucene.index.IndexReader.open(@path)
+        @index_searcher = org.apache.lucene.search.IndexSearcher.new(@index_reader)
+        $LUCENE_LOGGER.debug("Opened new IndexSearcher for #{to_s}")
+      end
+      @index_searcher
+    end
+    
+    #
+    # Returns true if the index already exists.
+    #
+    def exist?
+      org.apache.lucene.index.IndexReader.index_exists(@path)
+    end
+
+  end
+end

data/plugins/project_search/vendor/lucene/lib/lucene/jars.rb

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

data/plugins/project_search/vendor/lucene/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/plugins/project_search/vendor/lucene/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/plugins/project_search/vendor/lucene/lib/lucene/version.rb

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

data/plugins/project_search/vendor/lucene/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