lucene 0.5.0.beta.1

data/lib/lucene.rb

@@ -0,0 +1,15 @@
+require 'logger'
+$LUCENE_LOGGER = Logger.new(STDOUT)
+$LUCENE_LOGGER.level = Logger::WARN
+
+require 'lucene/config'
+require 'lucene/document'
+require 'lucene/field_info'
+require 'lucene/hits'
+require 'lucene/index'
+require 'lucene/index_info'
+require 'lucene/index_searcher'
+require 'lucene/jars'
+require 'lucene/query_dsl'
+require 'lucene/transaction'
+

data/lib/lucene/config.rb

@@ -0,0 +1,145 @@
+
+module Lucene
+
+
+  #
+  # Keeps configuration for lucene.
+  # Contains both common configuration for all lucene indexes as well
+  # as specific configuration for each index (TODO).
+  # This code is copied from merb-core/config.rb.
+  #
+  # Contains three default configurations (Config.defaults)
+  # * :store_on_file:: default false, which will only keep the index in memory
+  # * :id_field:: default :id
+  # * :storage_path:: where the index is kept on file system if stored as a file (instead of just in memory)
+  #
+  class Config
+    class << self
+      # Returns the hash of default config values for lucene.
+      #
+      # ==== Returns
+      # Hash:: The defaults for the config.
+      #
+      def defaults
+        @defaults ||= {
+          :store_on_file => false,
+          :id_field => :id,
+          :storage_path => nil
+        }
+      end
+
+     
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c<Hash>:: The configuration parameters.
+      #
+      # ==== Examples
+      # Lucene::Config.use do |config|
+      # config[:in_memory] = true
+      # end
+      #
+      # ==== Returns
+      # nil
+      #
+      def use
+        @configuration ||= {}
+        yield @configuration
+        nil
+      end
+      
+      
+      # Set the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key to set the parameter for.
+      # val<Object>:: The value of the parameter.
+      #
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
+      end
+
+
+      # Gets the the value of a config entry
+      #
+      # ==== Parameters
+      # key<Object>:: The key of the config entry value we want
+      #
+      def [](key)
+        (@configuration ||= setup)[key]
+      end
+
+
+      # Remove the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key of the parameter to delete.
+      #
+      # ==== Returns
+      # Object:: The value of the removed entry.
+      #
+      def delete(key)
+        @configuration.delete(key)
+      end
+
+
+      # Remove all configuration. This can be useful for testing purpose.
+      #
+      #
+      # ==== Returns
+      # nil
+      #
+      def delete_all
+        @configuration = nil
+        IndexInfo.delete_all
+      end
+
+
+      # Retrieve the value of a config entry, returning the provided default if the key is not present
+      #
+      # ==== Parameters
+      # key<Object>:: The key to retrieve the parameter for.
+      # default<Object>::
+      # The default value to return if the parameter is not set.
+      #
+      # ==== Returns
+      # Object:: The value of the configuration parameter or the default.
+      #
+      def fetch(key, default)
+        @configuration.fetch(key, default)
+      end
+
+      # Sets up the configuration
+      #
+      # ==== Returns
+      # The configuration as a hash.
+      #
+      def setup()
+        @configuration = {}
+        @configuration.merge!(defaults)
+        @configuration
+      end
+
+
+      # Returns the configuration as a hash.
+      #
+      # ==== Returns
+      # Hash:: The config as a hash.
+      #
+      def to_hash
+        @configuration
+      end
+
+      # Returns the config as YAML.
+      #
+      # ==== Returns
+      # String:: The config as YAML.
+      #
+      def to_yaml
+        require "yaml"
+        @configuration.to_yaml
+      end
+    end
+  end
+
+end

data/lib/lucene/document.rb

@@ -0,0 +1,96 @@
+module Lucene
+  
+  #
+  # A document is like a record or row in a relationship database.
+  # Contains the field infos which can be used for type conversions or
+  # specifying if the field should be stored or only searchable.
+  # 
+  class Document
+    
+    attr_reader :id_field, :field_infos, :props
+    
+    def initialize(field_infos, props = {})
+      @id_field = field_infos.id_field
+      @field_infos = field_infos
+
+      @props = {}
+      props.each_pair do |key,value|
+        @props[key] = field_infos[key].convert_to_ruby(value)
+        $LUCENE_LOGGER.debug{"FieldInfo #{key} type: #{field_infos[key][:type]}"}
+        $LUCENE_LOGGER.debug{"Converted #{key} '#{value}' type: '#{value.class.to_s}' to '#{@props[key]}' type: '#{@props[key].class.to_s}'"}
+      end
+    end
+
+    def [](key)
+      @props[key]
+    end
+    
+    #
+    # Convert a java Document to a ruby Lucene::Document
+    #
+    def self.convert(field_infos, java_doc)
+      fields = {}
+      field_infos.each_pair do |key, field|
+        next unless field.store?
+        raise StandardError.new("expected field '#{key.to_s}' to exist in document") if java_doc.getField(key.to_s).nil?
+        value = java_doc.getField(key.to_s).stringValue
+        fields.merge!({key => value})
+      end
+      Document.new(field_infos, fields)
+    end
+
+    def id
+      raise IdFieldMissingException.new("Missing id field: '#{@id_field}'") if self[@id_field].nil?
+      @props[@id_field]      
+    end
+
+    def eql?(other)
+      return false unless other.is_a? Document
+      return id == other.id
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+    
+    def hash
+      id.hash
+    end
+    
+    #
+    # removes the document and adds it again
+    #
+    def update(index_writer)
+      index_writer.updateDocument(java_key_term, java_document)
+    end
+    
+    
+    def java_key_term
+      org.apache.lucene.index.Term.new(@id_field.to_s, id.to_s)
+    end
+    
+    def java_document
+      java_doc   =   org.apache.lucene.document.Document.new
+      @props.each_pair do |key,value|
+        field_info = @field_infos[key]
+        # TODO value could be an array if value.kind_of? Enumerable
+        if (value.kind_of?(Array))
+          value.each do |v|
+            field = field_info.java_field(key,v)
+            java_doc.add(field) unless field.nil?
+          end
+        else
+          field = field_info.java_field(key,value)
+          java_doc.add(field) unless field.nil?
+        end
+      end
+      java_doc
+    end
+    
+    def to_s
+      p = ""
+      @props.each_pair { |key,value| p << "'#{key}' = '#{value}' " }
+      "Document [#@id_field='#{self[@id_field]}', #{p}]"
+    end
+  end
+end

data/lib/lucene/field_info.rb

@@ -0,0 +1,144 @@
+require 'date'
+
+module Lucene
+  class ConversionNotSupportedException < StandardError; end
+
+  class FieldInfo 
+    DEFAULTS = {:store => false, :type => String, :analyzer => :standard}.freeze
+    
+    def initialize(values = {})
+      @info = DEFAULTS.dup
+      @info.merge! values
+      $LUCENE_LOGGER.debug{"new FieldInfo: #{@info.inspect}"}
+    end
+
+    def dup
+      FieldInfo.new(@info)
+    end
+    
+    def [](key)
+      @info[key]
+    end
+    
+    def []=(key,value)
+      @info[key] = value
+    end
+    
+    def java_field(key, value)
+      # convert the ruby value to a string that lucene can handle
+      cvalue = convert_to_lucene(value)
+
+      # check if this field should be indexed 
+      return nil if cvalue.nil?
+
+      # decide if the field should be stored in the lucene index or not
+      store = store? ? org.apache.lucene.document.Field::Store::YES : org.apache.lucene.document.Field::Store::NO
+
+      # decide if it should be tokenized/analyzed by lucene
+      token_type = tokenized? ? org.apache.lucene.document.Field::Index::ANALYZED : org.apache.lucene.document.Field::Index::NOT_ANALYZED
+      $LUCENE_LOGGER.debug{"java_field store=#{store} key='#{key.to_s}' value='#{cvalue}' token_type=#{token_type}"}
+
+      # create the new Field
+      org.apache.lucene.document.Field.new(key.to_s, cvalue, store, token_type ) #org.apache.lucene.document.Field::Index::NO_NORMS)
+    end
+
+    
+    def convert_to_ruby(value)
+      if (value.kind_of?(Array))
+        value.collect{|v| convert_to_ruby(v)}
+      else case @info[:type].to_s
+        when NilClass.to_s then  ""  # TODO, should we accept nil values in indexes ?
+        when String.to_s then value.to_s
+        when Fixnum.to_s then  value.to_i
+        when Float.to_s  then  value.to_f
+        when Date.to_s
+          return value if value.kind_of? Date
+          return nil if value.nil?
+          year = value[0..3].to_i
+          month = value[4..5].to_i
+          day = value[6..7].to_i
+          Date.new year,month,day
+        when DateTime.to_s
+          return value if value.kind_of? DateTime
+          return nil if value.nil?
+          year = value[0..3].to_i
+          month = value[4..5].to_i
+          day = value[6..7].to_i
+          hour = value[8..9].to_i
+          min = value[10..11].to_i
+          sec = value[12..13].to_i
+          DateTime.civil(year,month,day,hour,min,sec)
+        else
+          raise ConversionNotSupportedException.new("Can't convert key '#{value}' of with type '#{@info[:type].class.to_s}'")
+        end
+      end
+    end
+
+    def convert_to_lucene(value)
+      if (value.kind_of?(Array))
+        value.collect{|v| convert_to_lucene(v)}
+      elsif value.nil?
+        value
+      else
+        case @info[:type].to_s # otherwise it will match Class
+        when Fixnum.to_s then  sprintf('%011d',value)     # TODO: configurable
+        when Float.to_s  then  sprintf('%024.12f', value)  # TODO: configurable
+        when Bignum.to_s then  sprintf('%024d, value')
+        when Date.to_s
+          t = Time.utc(value.year, value.month, value.day)
+          d = t.to_i * 1000
+          org.apache.lucene.document.DateTools.timeToString(d,org.apache.lucene.document.DateTools::Resolution::DAY )
+        when DateTime.to_s
+          # only utc times are supported 
+          t = Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec)
+          d = t.to_i * 1000
+          org.apache.lucene.document.DateTools.timeToString(d,org.apache.lucene.document.DateTools::Resolution::SECOND )
+        else value.to_s
+        end
+      end
+    end
+    
+    def convert_to_query(key,value)
+      if (value.kind_of? Range)
+        first_value = convert_to_lucene(value.first)
+        last_value = convert_to_lucene(value.last)
+        first = org.apache.lucene.index.Term.new(key.to_s, first_value)
+        last = org.apache.lucene.index.Term.new(key.to_s, last_value)
+        $LUCENE_LOGGER.debug{"convert_to_query: Range key '#{key.to_s}' #{first_value}' to '#{last_value}'"}
+        org.apache.lucene.search.RangeQuery.new(first, last, !value.exclude_end?)
+      elsif
+        converted_value = convert_to_lucene(value)
+        term = org.apache.lucene.index.Term.new(key.to_s, converted_value)
+        org.apache.lucene.search.TermQuery.new(term)
+      end
+    end
+
+    def tokenized?
+      @info[:tokenized]
+    end
+    
+    def store?
+      @info[:store]
+    end
+
+    def eql?(other)
+      return false unless other.kind_of?(FieldInfo)
+      @info.each_pair do |key,value|
+        return false if other[key] != value
+      end
+      return true
+    end
+    
+    def ==(other)
+      eql? other
+    end
+    
+    def to_s
+      infos = @info.keys.inject(""){|s, key| s << "#{key}=#{@info[key]} "}
+      "FieldInfo(#{self.object_id.to_s}) [#{infos}]"
+    end
+    
+    
+  end
+end
+

data/lib/lucene/hits.rb

@@ -0,0 +1,54 @@
+module Lucene
+  
+   
+  #
+  # Contains the result as a collection of Documents from a lucene query.
+  # Is a wrapper for the Java org.apache.lucene.search.Hits class
+  # 
+  class Hits
+    include Enumerable
+  
+    def initialize(field_infos, hits)
+      @hits = hits
+      @field_infos = field_infos
+    end
+  
+    
+    #
+    # Returns the n:th hit document.
+    #
+    def [](n)
+      doc = @hits.doc(n)
+      Document.convert(@field_infos, doc)
+    end
+  
+    
+    #
+    # Returns true if there are no hits
+    # 
+    def empty?
+      @hits.length == 0
+    end
+    
+    def each
+      iter = @hits.iterator
+    
+      while (iter.hasNext && hit = iter.next)
+        yield Document.convert(@field_infos, hit.getDocument)
+      end
+    end
+  
+    
+    #
+    # The number of documents the query gave.
+    #
+    def size
+      @hits.length
+    end
+    
+    def to_s
+      "Hits [size=#{size}]"
+    end
+    
+  end
+end