redcar 0.9.0 → 0.9.1

data/plugins/project_search/vendor/lucene/examples/railway/README

@@ -0,0 +1,111 @@
+* Railway Network Application Example (with JRuby Neo4j bindings)
+by Bert Fitié
+
+** A. Network application
+
+(1) Nodes. The nodes are railway stations
+(2) Arcs. The arcs are the connections between the stations
+(3) Paths. The (named) paths are trains
+(4) Usage. The user performs the following navigation:
+(4.1) The user selects (loads) a start station
+(4.2) The user generates a list of outgoing trains from this station
+(4.3) The user selects the train he wants to board from this station
+(4.4) The user generates the train path, i.e. the sequence of all
+stations visited by this train from this station
+(4.5) The user selects (loads) a destination station from this path
+(4.6) If this station is the final destination, the user is done,
+otherwise, the user continues has travel with (4.2)
+
+** B. Example network
+
+(1) The example network has 8 stations:
+Alpha, Bravo, Charlie, Delta, Echo, Foxtrot, Golf, Hotel
+(2) The example network has 8 arcs:
+(2.1) Alpha - Bravo
+(2.2) Bravo - Charlie
+(2.3) Charlie - Delta
+(2.4) Delta - Echo
+(2.5) Alpha - Foxtrot
+(2.6) Foxtrot - Charlie
+(2.7) Delta - Golf
+(2.8) Delta - Hotel
+(3) The example network has 3 trains
+(3.1) Train t1_ae:
+(3.1.1) Alpha (departure 11:00) - Bravo (arrival 11:45)
+(3.1.2) Bravo (departure 11:50) - Charlie (arrival 12:30)
+(3.1.3) Charlie (departure 12:35) - Delta (arrival 13:00)
+(3.1.4) Delta (departure 13:05) - Echo (arrival 14:00)
+(3.2) Train t2_ag:
+(3.2.1) Alpha (departure 13:15) - Foxtrot (arrival 13:45)
+(3.2.2) Foxtrot (departure 13:50) - Charlie (arrival 14:30)
+(3.2.3) Charlie (departure 14:35) - Delta (arrival 15:00)
+(3.2.4) Delta (departure 15:05) - Golf (arrival 15:45)
+(3.3) Train t3_gh:
+(3.3.1) Golf (departure 12:30) - Delta (arrival 13:10)
+(3.3.2) Delta (departure 13:15) - Hotel (arrival 14:30)
+
+** C. Demo objective
+
+(1) The user selects start station Alpha
+Result should be:
+ You arrived at station Alpha
+(2) The user generates a list of outgoing trains from Alpha
+Result should be:
+ Train t1_ae: departure 11:00
+ Train t2_ag: departure 13:15
+(3) The user selects Train t1_ae to board from this station
+(4) The user generates the train path for Train t1_ae from Alpha
+Result should be:
+ Alpha (departure 11:00) - Bravo (arrival 11:45)
+ Bravo (departure 11:50) - Charlie (arrival 12:30)
+ Charlie (departure 12:35) - Delta (arrival 13:00)
+ Delta (departure 13:05) - Echo (arrival 14:00)
+(5) The user selects destination station Delta from this path
+Result should be:
+ You arrived at station Delta
+(6) The user generates a list of outgoing trains from Delta
+Result should be:
+ Train t1_ae: departure 13:05
+ Train t2_ag: departure 15:05
+ Train t3_gh: departure 13:15
+(7) The user selects Train t3_gh to board from this station
+(8) The user generates the train path for Train t3_gh from Delta
+Result should be:
+ Delta (departure 13:15) - Hotel (arrival 14:30)
+(9) The user selects final destination station Hotel from this path
+Result should be:
+ You arrived at station Hotel
+
+ ** D. Data file
+See railnet-data.rb
+
+** E. Application file
+See railnet-app.rb
+
+
+ ** F. Demo session
+
+~ $> cd ~/private/sandbox/neo-jruby/examples/railnet
+railnet $> jruby railnet-data.rb
+railnet $> jirb -r railnet-app
+irb(main):001:0> alpha = select_station(1)
+ You arrived at station Alpha
+irb(main):002:0> list_trains(alpha)
+ Train t2_ag: departure: 13:15
+ Train t1_ae: departure: 11:00
+irb(main):003:0> train_path(alpha, :t1_ae)
+ Alpha #1 (departure: 11:00) - Bravo #2 (arrival: 11:45)
+ Bravo #2 (departure: 11:50) - Charlie #3 (arrival: 12:30)
+ Charlie #3 (departure: 12:35) - Delta #4 (arrival: 13:00)
+ Delta #4 (departure: 13:05) - Echo #5 (arrival: 14:00)
+irb(main):004:0> delta = select_station(4)
+ You arrived at station Delta
+irb(main):005:0> list_trains(delta)
+ Train t3_gh: departure: 13:15
+ Train t2_ag: departure: 15:05
+ Train t1_ae: departure: 13:05
+irb(main):006:0> train_path(delta, :t3_gh)
+ Delta #4 (departure: 13:15) - Hotel #8 (arrival: 14:30)
+irb(main):007:0> hotel = select_station(8)
+ You arrived at station Hotel
+irb(main):008:0>

data/plugins/project_search/vendor/lucene/examples/railway/railnet-app.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'neo4j'
+
+def select_station(id)
+ station = nil
+ Neo4j::Transaction.run do
+   station = Neo4j.load_node(id)
+   puts "You arrived at station #{station[:name]}"
+ end
+ return station
+end
+
+def list_trains(station)
+ Neo4j::Transaction.run do
+   station.rels.outgoing.each do |rel|
+     puts "Train #{rel[:train]}: departure: #{rel[:dep]}"
+   end
+ end
+end
+
+def train_path(station, train)
+ Neo4j::Transaction.run do
+   station.traverse.outgoing(train).depth(:all).each do |station|
+     rel = station.rel(train, dir = :incoming)
+     puts "#{rel.start_node[:name]} ##{rel.start_node.neo_id}" +
+       " (departure: #{rel[:dep]})" +
+       " - #{rel.end_node[:name]} ##{rel.end_node.neo_id}" +
+       " (arrival: #{rel[:arr]})"
+   end;
+ end;
+end

data/plugins/project_search/vendor/lucene/examples/railway/railnet-data.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'neo4j'
+
+Neo4j::Transaction.run do
+
+# Stations
+alpha = Neo4j::Node.new :name => 'Alpha'
+bravo = Neo4j::Node.new :name => 'Bravo'
+charlie = Neo4j::Node.new :name => 'Charlie'
+delta = Neo4j::Node.new :name => 'Delta'
+echo = Neo4j::Node.new :name => 'Echo'
+foxtrot = Neo4j::Node.new :name => 'Foxtrot'
+golf = Neo4j::Node.new :name => 'Golf'
+hotel = Neo4j::Node.new :name => 'Hotel'
+
+# Train t1_ae
+t1_ab = Neo4j::Relationship.new(:t1_ae, alpha, bravo)
+t1_bc = Neo4j::Relationship.new(:t1_ae, bravo, charlie)
+t1_cd = Neo4j::Relationship.new(:t1_ae, charlie, delta)
+t1_de = Neo4j::Relationship.new(:t1_ae, delta, echo)
+t1_ab[:dep] = '11:00'; t1_ab[:arr] = '11:45'; t1_ab[:train] = 't1_ae'
+t1_bc[:dep] = '11:50'; t1_bc[:arr] = '12:30'; t1_bc[:train] = 't1_ae'
+t1_cd[:dep] = '12:35'; t1_cd[:arr] = '13:00'; t1_cd[:train] = 't1_ae'
+t1_de[:dep] = '13:05'; t1_de[:arr] = '14:00'; t1_de[:train] = 't1_ae'
+
+# Train t2_ag
+t2_af = Neo4j::Relationship.new(:t2_ag, alpha, foxtrot)
+t2_fc = Neo4j::Relationship.new(:t2_ag, foxtrot, charlie)
+t2_cd = Neo4j::Relationship.new(:t2_ag, charlie, delta)
+t2_dg = Neo4j::Relationship.new(:t2_ag, delta, golf)
+t2_af[:dep] = '13:15'; t2_af[:arr] = '13:45'; t2_af[:train] = 't2_ag'
+t2_fc[:dep] = '13:50'; t2_fc[:arr] = '14:30'; t2_fc[:train] = 't2_ag'
+t2_cd[:dep] = '14:35'; t2_cd[:arr] = '15:00'; t2_cd[:train] = 't2_ag'
+t2_dg[:dep] = '15:05'; t2_dg[:arr] = '15:45'; t2_dg[:train] = 't2_ag'
+
+# Train t3_gh
+t3_gd = Neo4j::Relationship.new(:t3_gh, golf, delta)
+t3_dh = Neo4j::Relationship.new(:t3_gh, delta, hotel)
+t3_gd[:dep] = '12:30'; t3_gd[:arr] = '13:10'; t3_gd[:train] = 't3_gh'
+t3_dh[:dep] = '13:15'; t3_dh[:arr] = '14:30'; t3_dh[:train] = 't3_gh'
+
+end

data/plugins/project_search/vendor/lucene/examples/rest/example.rb

@@ -0,0 +1,41 @@
+#####################################
+#
+# A simple example how to expose neo nodes as REST resources.
+#
+# IMPORTANT
+#
+# This example requires the latest version from GITHUB of the sinatra gem
+# and  json-jruby (>=1.1.6) (or another compatible json gem)
+#
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/..")
+require 'rubygems'
+require 'neo4j'
+require 'neo4j/extensions/rest'
+
+FileUtils.rm_rf Neo4j::Config[:storage_path]  # NEO_STORAGE
+FileUtils.rm_rf Lucene::Config[:storage_path] unless Lucene::Config[:storage_path].nil?
+
+
+class Person
+  include Neo4j::NodeMixin
+  # by includeing the following mixin we will expose this node as a RESTful resource
+  include Neo4j::RestMixin
+  property :name
+  has_n :friends
+  index :name
+end
+
+Neo4j.start
+puts "-----------------------"
+Neo4j::Transaction.run do
+  a = Person.new :name => 'andreas', :foo => 'bar', :fav_number => 14
+  b = Person.new :name => 'kalle'
+  c = Person.new :name => 'anders'
+  a.friends << b
+  a.rels.outgoing(:other) << c
+  puts "Created Nodes at URI:\n\t#{a._uri}\n\t#{b._uri}\n\t#{c._uri}"
+end
+
+Neo4j::Rest::RestServer.thread.join

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

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

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

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

@@ -0,0 +1,50 @@
+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/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/plugins/project_search/vendor/lucene/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