neo4j 1.0.0.beta.1

data/lib/neo4j.old/relationships/traversal_position.rb

@@ -0,0 +1,50 @@
+module Neo4j
+  module Relationships
+
+    # Wrapper for org.neo4j.graphdb.TraversalPosition
+    # See Javadoc for org.neo4j.graphdb.TraversalPosition
+    # It can be used as a parameter in traversals filter functions.
+    #
+    # :api: public
+    class TraversalPosition
+      def initialize(traversal_position, raw = false)
+        @traversal_position = traversal_position
+        @raw = raw
+      end
+
+      # Return the current node.
+      def current_node
+        Neo4j.load_node(@traversal_position.currentNode.getId, @raw)
+      end
+
+      # Returns the previous node, may be nil.
+      def previous_node
+        return nil if @traversal_position.previousNode.nil?
+        Neo4j.load_node(@traversal_position.previousNode.getId, @raw)
+      end
+
+      # Return the last relationship traversed, may be nil.
+      def last_relationship_traversed
+        relationship = @traversal_position.lastRelationshipTraversed()
+        return nil if relationship.nil?
+        return relationship.wrapper unless @raw
+        relationship
+      end
+
+      # Returns the current traversal depth.
+      def depth
+        @traversal_position.depth
+      end
+
+      # Returns true if the current position is the start node, false otherwise.
+      def start_node?
+        @traversal_position.isStartNode
+      end
+
+      # Returns the number of nodes returned by traverser so far.
+      def returned_nodes_count
+        @traversal_position.returnedNodesCount
+      end
+    end
+  end
+end

data/lib/neo4j.old/relationships/wrappers.rb

@@ -0,0 +1,51 @@
+module Neo4j
+  module Relationships
+
+    # Wrapper for org.neo4j.graphdb.ReturnableEvaluator
+    #
+    # :api: private
+    class ReturnableEvaluator #:nodoc:
+      include org.neo4j.graphdb.ReturnableEvaluator
+
+      def initialize(proc, raw = false)
+        @proc = proc
+        @raw = raw
+      end
+
+      def isReturnableNode( traversal_position )
+        # if the Proc takes one argument that we give it the traversal_position
+        result = if @proc.arity == 1
+          # wrap the traversal_position in the Neo4j.rb TraversalPostion object
+          @proc.call TraversalPosition.new(traversal_position, @raw)
+        else # otherwise we eval the proc in the context of the current node
+          # do not include the start node
+          return false if traversal_position.isStartNode()
+          eval_context = Neo4j::load_node(traversal_position.currentNode.getId, @raw)
+          eval_context.instance_eval(&@proc)
+        end
+
+        # java does not treat nil as false so we need to do it instead
+        (result)? true : false
+      end
+    end
+
+    
+    # Wrapper for the neo4j org.neo4j.graphdb.StopEvalutor interface.
+    # Used in the Neo4j Traversers.
+    #
+    # :api: private
+    class DepthStopEvaluator #:nodoc:
+      include org.neo4j.graphdb.StopEvaluator
+
+      def initialize(depth)
+        @depth = depth
+      end
+
+      def isStopNode(pos)
+        pos.depth >= @depth
+      end
+    end
+
+  end
+  
+end

data/lib/neo4j.old/search_result.rb

@@ -0,0 +1,72 @@
+module Neo4j
+
+  # 
+  # Holds the search result and performs the query.
+  # The query is not performed until a search result item is requested.
+  # It is possible that one node is deleted,updated,created after the search is performed.
+  #
+  class SearchResult
+    include Enumerable
+
+    def initialize(index, query, query_for_nodes = true, &block)
+      @query = query
+      @query_for_nodes = query_for_nodes # if we are searching for nodes or relationships
+      @block = block
+      @index = index
+      @sort_by_fields = []
+    end
+
+    def hits
+      @hits ||= @index.find(query_params, &@block)
+    end
+
+    def query_params
+      unless @sort_by_fields.empty?
+        return case @query
+          when Hash
+            @query.merge({:sort_by => @sort_by_fields})
+          when String
+            [@query, { :sort_by => @sort_by_fields}]
+        end
+      end
+      return @query
+    end
+
+
+    # Returns the first item in the search result
+    #
+    # :api: public
+    def first
+      return nil if empty?
+      self[0]
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def each
+      hits.each do |doc|
+
+        node_or_rel =  @query_for_nodes ? Neo4j.load_node(doc[:id]) : Neo4j.load_rel(doc[:id])
+        # can happen that another thread has deleted it
+        raise "lucene found node/rel #{id} but it does not exist in neo" if node_or_rel.nil?
+        yield node_or_rel
+      end
+    end
+
+    def [](n)
+      doc = hits[n]
+      Neo4j.load_node(doc[:id])
+    end
+
+    def sort_by(*fields)
+      @sort_by_fields += fields
+      self
+    end
+
+    def size
+      hits.size
+    end
+  end
+end

data/lib/neo4j.old/transaction.rb

@@ -0,0 +1,254 @@
+module Neo4j
+
+  #
+  # Raised when an operation was called without a running transaction.
+  #
+  class NotInTransactionError < StandardError;
+  end
+
+
+  #
+  # Raised when an operation was called when an transaction was already running.
+  #
+  class AlreadyInTransactionError < StandardError;
+  end
+
+
+  #
+  # Wraps a Neo4j java transaction and lucene transactions.
+  # There can only be one transaction per thread.
+  #
+  class Transaction
+    attr_reader :neo_tx
+
+    @@counter = 0 # just for debugging purpose
+
+
+    # --------------------------------------------------------------------------
+    #
+    # Class methods
+    #
+    class << self
+
+
+      # :nodoc:
+      # debugging method
+      #
+      def called
+        res = ""
+        for i in 2..7 do
+          res << /\`([^\']+)\'/.match(caller(i).first)[1]
+          res << ', '
+        end
+        res
+      end
+
+
+      def placebo?(tx)
+        tx.java_object.java_type == 'org.neo4j.kernel.EmbeddedGraphDbImpl$PlaceboTransaction'
+      end
+
+      # Creates a transaction. If one is already running then a 'placebo' transaction will be created instead.
+      # A placebo transactions wraps the real transaction by not allowing the finish method to finish the
+      # real transaction.
+      #
+      def new
+        tx = Neo4j.instance.begin_tx
+        if running?
+          # expects a placebo transaction, check just in case
+          raise "Expected placebo transaction since one normal is already running" unless placebo?(tx)
+          tx = Transaction.current.create_placebo_tx_if_not_already_exists
+          tx
+        else
+          raise "Expected NOT placebo transaction since no TX is running" if placebo?(tx)
+          super(tx)
+        end
+      end
+
+      # Runs a block in a Neo4j transaction
+      #
+      # Most operations on neo requires an transaction. You will get much better performance if
+      # one transaction is wrapped around several neo operation instead of running one transaction per
+      # neo operation.
+      # If one transaction is already running then a 'placebo' transaction will be created.
+      # Performing a finish on a placebo transaction will not finish the 'real' transaction.
+      #  
+      # ==== Params
+      # @yield the block to be performed in one transaction
+      # @yieldparam [Neo4j::Transaction] The transaction
+      #
+      # ==== Examples
+      #  include 'neo4j'
+      #
+      #  Neo4j::Transaction.run {
+      #    node = PersonNode.new
+      #  }
+      #
+      # You have also access to transaction object
+      #
+      #   Neo4j::Transaction.run { |t|
+      #     # something failed
+      #     t.failure # will cause a rollback
+      #   }
+      #
+      #
+      # ==== Returns
+      # The value of the evaluated provided block
+      #
+      def run # :yield: transaction
+        raise ArgumentError.new("Expected a block to run in Transaction.run") unless block_given?
+
+        begin
+          tx = Neo4j::Transaction.new
+          ret = yield tx
+        rescue Exception => bang
+#          puts "BANG #{bang}"
+#          puts bang.backtrace.join("\n")
+          tx.failure unless tx.nil?
+          raise
+        ensure
+          tx.finish unless tx.nil?
+        end
+        ret
+      end
+
+
+      # Returns the current running transaction or nil
+      #
+      def current
+        Thread.current[:transaction]
+      end
+
+
+      # Returns true if there is a transaction for the current thread
+      #
+      def running?
+        self.current != nil # && self.current.neo_tx != nil
+      end
+
+
+      # Returns true if the transaction has been marked for failure/rollback
+      #
+      def failure?
+        current.failure?
+      end
+
+      # Finish the current transaction if it is running.
+      #
+      # See Neo4j::Transaction#failure
+      #
+      def failure
+        current.failure if running?
+      end
+
+
+      # Finish the current transaction if it is running
+      def finish
+        current.finish if running?
+      end
+    end
+
+
+    #
+    # --------------------------------------------------------------------------
+    # Instance methods
+    #
+
+
+    def initialize(neo_tx)
+      raise AlreadyInTransactionError.new if Transaction.running?
+      @neo_tx = neo_tx
+      @@counter += 1
+      @id = @@counter
+      @failure = false
+      Thread.current[:transaction] = self
+    end
+
+    def to_s
+      "Transaction: placebo: #{placebo?}, #{@id} failure: #{failure?}, running #{Transaction.running?}, lucene: #{Lucene::Transaction.running?}, thread: #{Thread.current.to_s} #{@neo_tx}"
+    end
+
+
+    # Returns true if the transaction will rollback
+    def failure?
+      @failure == true
+    end
+
+
+    def placebo?
+      false
+    end
+
+    def create_placebo_tx_if_not_already_exists # :nodoc:
+      @placebo ||= PlaceboTransaction.new(self)
+    end
+
+
+    # Marks this transaction as successful, which means that it will be commited 
+    # upon invocation of finish() unless failure()  has or will be invoked before then.
+    def success
+      raise NotInTransactionError.new unless Transaction.running?
+      @neo_tx.success
+    end
+
+
+    # Commits or marks this transaction for rollback, depending on whether
+    # success() or failure() has been previously invoked.
+    #
+    def finish
+      return unless Transaction.running?
+      Neo4j.event_handler.tx_finished(self) unless failure?
+      begin
+        @neo_tx.success unless failure?
+        @neo_tx.finish
+        @neo_tx=nil
+      rescue Exception => bang
+        raise
+      end
+
+      Thread.current[:transaction] = nil
+      if Lucene::Transaction.running?
+        # mark lucene transaction for failure if the neo transaction fails
+        Lucene::Transaction.current.failure if failure?
+        Lucene::Transaction.current.commit
+      end
+    end
+
+    # Marks this transaction as failed, which means that it will inexplicably
+    # be rolled back upon invocation of finish().
+    def failure
+      raise NotInTransactionError.new unless Transaction.running?
+      @neo_tx.failure
+      @failure = true
+      $NEO_LOGGER.info{"failure #{self.to_s}"}
+    end
+
+  end
+
+  #
+  # This is returned when trying to create a new transaction while a transaction is already running.
+  # This class will do nothing when the finish method is called.
+  # Finish will only be called when the 'real' transaction does it.
+  #
+  class PlaceboTransaction < DelegateClass(Transaction) #:nodoc:
+
+    def initialize(tx)
+      super(tx)
+      @tx = tx # store it only for logging purpose
+    end
+
+    def placebo?
+      true
+    end
+
+    # Do nothing since Neo4j does not support chained transactions.
+    # 
+    def finish
+    end
+
+    def to_s
+      "PLACEBO TX"
+    end
+  end
+
+end

data/lib/neo4j.old/version.rb

@@ -0,0 +1,3 @@
+module Neo4j
+  VERSION = '0.4.4' unless defined?(Neo4j::VERSION)
+end

data/lib/neo4j.rb

@@ -0,0 +1,50 @@
+include Java
+
+require 'enumerator'
+require 'forwardable'
+require 'time'
+require 'date'
+
+require 'neo4j/jars/neo4j-kernel-1.1.1.jar'
+#require 'neo4j/jars/neo4j-kernel-1.2-20100916.085228-39.jar'
+require 'neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar'
+require 'neo4j/jars/lucene-core-3.0.1.jar'
+require 'neo4j/jars/neo4j-lucene-index-0.1-20100916.085626-67.jar'
+require 'neo4j/to_java'
+require 'neo4j/version'
+require 'neo4j/equal'
+require 'neo4j/index'
+require 'neo4j/relationship_traverser'
+require 'neo4j/event_handler'
+require 'neo4j/database'
+require 'neo4j/node_traverser'
+require 'neo4j/property'
+require 'neo4j/transaction'
+require 'neo4j/node_relationship'
+require 'neo4j/relationship'
+require 'neo4j/node'
+require 'neo4j/config'
+require 'neo4j/neo4j'
+require 'neo4j/mapping/class_methods/property'
+require 'neo4j/mapping/class_methods/index'
+require 'neo4j/mapping/class_methods/relationship'
+require 'neo4j/mapping/decl_relationship_dsl'
+require 'neo4j/mapping/has_n'
+require 'neo4j/mapping/node_mixin'
+require 'neo4j/node_mixin'
+require 'neo4j/mapping/class_methods/rule'
+
+# rails
+require 'rails/railtie'
+require 'active_model'
+require 'neo4j/rails/transaction'
+require 'neo4j/rails/railtie'
+require 'neo4j/rails/model'
+require 'neo4j/rails/value'
+require 'neo4j/rails/lucene_connection_closer'
+
+
+
+# hmm, looks like Enumerator have been moved in some ruby versions
+Enumerator = Enumerable::Enumerator unless defined? Enumerator
+