redcar 0.9.1 → 0.9.2

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

@@ -1,157 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

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

data/plugins/project_search/vendor/lucene/lucene.gemspec

@@ -1,23 +0,0 @@
-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