redcar 0.9.1 → 0.9.2

data/plugins/project_search/vendor/lucene/examples/you_might_know/YouMightKnow.java

@@ -1,60 +0,0 @@
-class YouMightKnow
-{
-    List<List<Node>> result = new ArrayList<List<Node>>();
-    int maxDistance;
-    String[] features;
-    Object[] values;
-    Set<Node> buddies = new HashSet<Node>();
-
-    YouMightKnow( Node node, String[] features, int maxDistance )
-    {
-        this.features = features;
-        this.maxDistance = maxDistance;
-        values = new Object[features.length];
-        List<Integer> matches = new ArrayList<Integer>();
-        for ( int i = 0; i < features.length; i++ )
-        {
-            values[i] = node.getProperty( features[i] );
-            matches.add( i );
-        }
-        for ( Relationship rel : node.getRelationships( RelationshipTypes.KNOWS ) )
-        {
-            buddies.add( rel.getOtherNode( node ) );
-        }
-        findFriends( Arrays.asList( new Node[] { node } ), matches, 1 );
-    }
-
-    void findFriends( List<Node> path, List<Integer> matches, int depth )
-    {
-        Node prevNode = path.get( path.size() - 1 );
-        for ( Relationship rel : prevNode.getRelationships( RelationshipTypes.KNOWS ) )
-        {
-            Node node = rel.getOtherNode( prevNode );
-            if ( (depth > 1 && buddies.contains( node )) || path.contains( node ) )
-            {
-                continue;
-            }
-            List<Integer> newMatches = new ArrayList<Integer>();
-            for ( int match : matches )
-            {
-                if ( node.getProperty( features[match] ).equals( values[match] ) )
-                {
-                    newMatches.add( match );
-                }
-            }
-            if ( newMatches.size() > 0 )
-            {
-                List<Node> newPath = new ArrayList<Node>( path );
-                newPath.add( node );
-                if ( depth > 1 )
-                {
-                    result.add( newPath );
-                }
-                if ( depth != maxDistance )
-                {
-                    findFriends( newPath, newMatches, depth + 1 );
-                }
-            }
-        }
-    }
-}

data/plugins/project_search/vendor/lucene/examples/you_might_know/all_simple_paths.rb

@@ -1,34 +0,0 @@
-require 'rubygems'
-require 'neo4j'
-require 'neo4j/extensions/graph_algo'
-include Neo4j
-
-# In this case we want to know the possible paths from one person in a social network to an other.
-# With those paths at hand we can do things similar to the "How you're connected to N.N." feature of LinkedIn.
-
-
-
-Transaction.new
-
-load "nodes.rb"
-
-node1,node2,node3,node4,node5,node6,node7 = create_nodes
-
-found_nodes = GraphAlgo.all_simple_paths.from(node1).both(:knows).to(node7).depth(4).as_nodes
-puts "Nodes between #{node1} and #{node7}"
-found_nodes.each do |path|
-  puts "path"
-  path.each {|node| puts " #{node}" }
-end
-
-sorted = found_nodes.sort_by{|path| 10 - path.size}
-
-puts "sorted: "
-sorted.each do |path|
-  puts "path"
-  path.each {|node| puts " #{node}" }
-end
-
-Transaction.finish
-
-Neo4j.stop

data/plugins/project_search/vendor/lucene/examples/you_might_know/nodes.rb

@@ -1,34 +0,0 @@
-# -----------------------------------------------------------------------------
-
-# Add a to string method printing the node name
-class Node
-  include Neo4j::NodeMixin
-
-  def to_s
-    "Node #{self[:name]}"
-  end
-end
-
-def create_nodes
-  node1 = Node.new; node1[:feat1] = 'a'; node1[:feat2] = 'b'; node1[:name] = 1
-  node2 = Node.new; node2[:feat1] = 'a'; node2[:feat2] = 'b'; node2[:name] = 2
-  node3 = Node.new; node3[:feat1] = 'a'; node3[:feat2] = 'd'; node3[:name] = 3
-  node4 = Node.new; node4[:feat1] = 'c'; node4[:feat2] = 'd'; node4[:name] = 4
-  node5 = Node.new; node5[:feat1] = 'a'; node5[:feat2] = 'b'; node5[:name] = 5
-  node6 = Node.new; node6[:feat1] = 'a'; node6[:feat2] = 'b'; node6[:name] = 6
-  node7 = Node.new; node7[:feat1] = 'a'; node7[:feat2] = 'b'; node7[:name] = 7
-
-  node1.rels.outgoing(:knows) << node3
-  node2.rels.outgoing(:knows) << node1
-  node2.rels.outgoing(:knows) << node4
-  node3.rels.outgoing(:knows) << node5
-  node3.rels.outgoing(:knows) << node4
-  node3.rels.outgoing(:knows) << node6
-  node4.rels.outgoing(:knows) << node7
-  node5.rels.outgoing(:knows) << node6
-  node5.rels.outgoing(:knows) << node1
-  node6.rels.outgoing(:knows) << node1
-  
-  [node1,node2,node3,node4,node5,node6,node7]
-end
-

data/plugins/project_search/vendor/lucene/examples/you_might_know/you_might_know.rb

@@ -1,50 +0,0 @@
-require 'rubygems'
-require 'neo4j'
-include Neo4j
-
-
-# The challenge this time is to traverse into friends of friends (or even deeper) and find people with something in common.
-# Based on this we can distill someone the user might know, or could be interested in knowing.
-# The persons in our social network all have different values for two features, feat1 and feat2.
-# The idea of the solution presented here is to keep track of the features that are common in each branch of the traversal
-# and to stop when there is nothing in common any more or the maximum distance has been reached.
-def you_might_know(node, matches, max_distance)
-  buddies = [*node.rels.both(:knows).nodes]
-  find_friends(node, [node], matches, 1, max_distance, buddies)
-end
-
-def find_friends(root_node, path, matches, depth, max_distance, buddies)
-  result = []
-  path.last.rels.both(:knows).nodes.each do |node|
-    next if (depth > 1 && buddies.include?(node)) || path.include?(node)
-    new_matches = matches.find_all{|feature| root_node[feature] == node[feature]}
-    next if new_matches.empty?
-    new_path = path + [node]
-    result = [new_path] + result if depth > 1
-    result += find_friends(node, new_path, new_matches, depth + 1, max_distance, buddies) if depth != max_distance
-  end
-  result
-end
-
-
-puts "-----------------------"
-puts "YOU MIGHT KNOW"
-puts "-----------------------"
-
-
-Transaction.new
-
-load "nodes.rb"
-
-node1,node2,node3,node4,node5,node6,node7 = create_nodes
-
-result = you_might_know(node5, [:feat1, :feat2], 4)
-result.each do |list|
-  puts "You might know nodes"
-  list.each {|n| puts n}
-end
-
-Transaction.finish
-Neo4j.stop
-
-

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

@@ -1,15 +0,0 @@
-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/plugins/project_search/vendor/lucene/lib/lucene/config.rb

@@ -1,145 +0,0 @@
-
-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/plugins/project_search/vendor/lucene/lib/lucene/document.rb

@@ -1,96 +0,0 @@
-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/plugins/project_search/vendor/lucene/lib/lucene/field_info.rb

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