neon 0.1.0

data/lib/neon/relationship.rb

@@ -0,0 +1,38 @@
+module Neon
+  module Relationship
+    class << self
+      # Creates a new Relationship and immediately persists it to the database. All subsequent changes are immediately persisted.
+      #
+      # @param start_node [Node] The node from which the relationship starts i.e. is outgoing.
+      # @param end_node [Node] The node at which the relationship ends i.e. is incoming.
+      # @param attributes [Hash] An optional hash of properties to initialize the relationship with.
+      #
+      # @return [Relationship] A new relationship.
+      #
+      def new(start_node, name, end_node, attributes = {})
+        start_node.create_rel_to(end_node, name, attributes)
+      end
+
+      # Loads an existing relationship with the given id
+      #
+      # @param id [Integer] The id of the relationship to be loaded and returned.
+      # @param session [Session] An optional session from where to load the node.
+      #
+      # @return [Relationship] An existing relationship with the given id and specified session.
+      #   It returns nil if the node is not found.
+      #
+      def load(id, session = Session.current)
+        begin
+          session.load_rel(id)
+        rescue NoMethodError
+          _raise_invalid_session_error(session)
+        end
+      end
+
+      private
+        def _raise_invalid_session_error(session)
+          raise Session::InvalidSessionTypeError.new(session.class)
+        end
+    end
+  end
+end

data/lib/neon/relationship/embedded.rb

@@ -0,0 +1,59 @@
+# Extend the Java RelationshipProxy
+Java::OrgNeo4jKernelImplCore::RelationshipProxy.class_eval do
+  include Neon::PropertyContainer::Embedded
+  include Neon::TransactionHelpers
+
+  def type
+    run_in_transaction { _type }
+  end
+
+  def start
+    run_in_transaction { _start }
+  end
+
+  def end
+    run_in_transaction { _end }
+  end
+
+  def to_s
+    "Embedded Relationship[#{getId}]"
+  end
+
+  def other_node(node)
+    run_in_transaction { _other_node node }
+  end
+
+  def nodes
+    run_in_transaction { get_nodes }
+  end
+
+  private
+    def _destroy
+      nodes = get_nodes
+      delete
+      nodes.each { |node| node.delete }
+    end
+
+    def _type
+      get_type.name
+    end
+
+    def _start
+      get_start_node
+    end
+
+    def _end
+      get_end_node
+    end
+
+    def _other_node(node)
+      case node
+      when start
+        self.end
+      when self.end
+          start
+      else
+        nil
+      end
+    end
+end

data/lib/neon/relationship/rest.rb

@@ -0,0 +1,73 @@
+require "neon/property_container"
+
+module Neon
+  module Relationship
+    class Rest
+      include PropertyContainer::Rest
+      attr_reader :session, :id, :start, :end, :nodes, :type
+      
+      def initialize(relationship, session)
+        @relationship = relationship
+        @session = session
+        @id = @relationship["self"].split('/').last.to_i # Set the id
+        @start = @session.load(@relationship["start"])
+        @end = @session.load(@relationship["end"])
+        @nodes = [@start, @end]
+        @type  = @relationship["type"]
+      end
+
+      def other_node(node)
+        case node
+        when @start
+          @end
+        when @end
+          @start
+        else
+          nil
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+       end
+
+
+      def to_s
+        "REST Relationship[#{@id}]"
+      end
+
+      def type
+        @relationship["type"]
+      end
+
+      private
+        def _get_properties(*keys)
+          @session.neo.get_relationship_properties(@relationship, *keys)
+        end
+
+        def _set_properties(keys)
+          @session.neo.set_relationship_properties(@relationship, keys)
+        end
+
+        def _reset_properties(attributes)
+          @session.neo.reset_relationship_properties(@relationship, attributes)
+        end
+
+        def _remove_properties(keys_to_delete)
+          @session.neo.remove_relationship_properties(@relationship, keys_to_delete)
+        end
+
+        def _set_private_vars_to_nil
+          @relationship = @session = @start = @end = @nodes = nil
+        end
+
+        def _delete
+          @session.neo.delete_relationship(@relationship)
+        end
+
+        def _destroy
+          _delete
+          @start.del
+          @end.del
+        end
+    end
+  end
+end

data/lib/neon/session.rb

@@ -0,0 +1,68 @@
+require "neon/session/rest"
+require "neon/session/embedded"
+require "neon/session/invalid_session"
+
+module Neon
+  # A session established with a Neo4J database.
+  module Session
+    class << self
+      attr_accessor :current # The current default session running right now.
+      
+      # Create a new session with the database.
+      #
+      # @param type [:rest, :embedded] the type of session to create. Any other type will raise a InvalidSesionTypeError.
+      # @param args [Array] other args to pass to the session - usually stuff like the address of the database.
+      #
+      # @return [Session] a new session of type *type* and to the database initiated with *args*.
+      def new(type, *args)
+        session = case type
+          when :rest
+            Rest.new(*args)
+          when :embedded
+            Embedded.new(*args)
+          else
+            raise InvalidSessionTypeError.new(type)
+          end
+          # Set the current session unless one already exists
+          @current = session unless @current
+          session
+      end
+
+      # @return [Class] the class of the current session.
+      def class
+        @current.class
+      end
+
+      # @return [Boolean] wether the current session is running or not.
+      def running?
+        if @current
+          @current.running?
+        else
+          false
+        end
+      end
+
+      # Starts the current session.
+      # @return [Boolean] wether the session started successfully or not.
+      def start
+        if @current
+          @current.start
+        else
+          false
+        end
+      end
+
+      # Stops the current session
+      # @return [Boolean] wether the session stopped successfully or not.
+      def stop
+        if @current
+          result = @current.stop
+          @current = nil if result
+          result
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/neon/session/embedded.rb

@@ -0,0 +1,92 @@
+module Neon
+  module Session
+    # A session to an embedded instance of Neo4J
+    class Embedded
+      include TransactionHelpers
+      # @!attribute
+      #   @return [Boolean] Auto Transaction flag. Enabled by default.
+      attr_accessor :auto_tx
+
+      # Create a new session to an embedded database.
+      #
+      # @param path [String] a path to the location of the embedded database.
+      # @param auto_tx [Boolean] an optional flag to set auto transaction (defaults to true).
+      #
+      # @return [Embedded] a new embedded session.
+      def initialize(path = "neo4j", auto_tx = true)
+        raise "Cannot start a embedded session without JRuby" if RUBY_PLATFORM != 'java'
+        @db_location = path
+        @running = false
+        @auto_tx = auto_tx
+      end
+
+      # @return [Boolean] wether the session is running or not.
+      def running?
+        @running
+      end
+
+      # @return [Java::OrgNeo4jKernel::EmbeddedGraphDatabase] the Java graph database backing this session.
+      def database
+        @db
+      end
+
+      # @return [Boolean] wether the session started successfully.
+      def start
+        return false if @started
+        @started = true
+        @db = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new.new_embedded_database(@db_location)
+        @running = true
+      end
+
+      # @return [Boolean] wether the session stopped successfully.
+      def stop
+        return false if @stopped
+        @db.shutdown
+        @running = false
+        @stopped = true
+      end
+
+      def begin_tx
+        @db.begin_tx
+      end
+
+      def run_tx(&block)
+        Transaction::Placebo.run(begin_tx, &block)
+      end
+
+      # Nodes
+      # Create a new node. If auto_tx is true then we begin a new transaction and commit it after the creation
+      def create_node(attributes, labels)
+        run_in_transaction { _create_node attributes, labels }
+      end
+
+      def load(id)
+        run_in_transaction { _load id }
+      end
+
+      def load_rel(id)
+        run_in_transaction { _load_rel id }
+      end
+
+      def to_s
+        @db_location
+      end
+
+      private
+        def _create_node(attributes, labels)
+          labels.map! { |label| Java::OrgNeo4jGraphdb::DynamicLabel.label(label) }
+          node = @db.create_node(*labels)
+          node.props = attributes
+          node
+        end
+
+        def _load(id)
+          @db.get_node_by_id(id)
+        end
+
+        def _load_rel(id)
+          @db.get_relationship_by_id(id)
+        end
+    end
+  end
+end

data/lib/neon/session/invalid_session.rb

@@ -0,0 +1,6 @@
+module Neon
+  module Session
+    class InvalidSessionTypeError < StandardError
+    end
+  end
+end

data/lib/neon/session/rest.rb

@@ -0,0 +1,53 @@
+require "neography"
+
+module Neon
+  module Session
+    class Rest
+      attr_reader :neo, :url
+      attr_accessor :auto_tx
+      
+      def initialize(url = "http://localhost:7474", auto_tx = false)
+        @neo = Neography::Rest.new url
+        @url = url
+        @auto_tx = auto_tx
+      end
+
+      # These methods make no sense for a rest server so we just return true to make our specs happy
+      def start
+        true
+      end
+
+      alias :stop :start
+      alias :running? :start
+
+      def create_node(attributes, labels)
+        node = @neo.create_node(attributes)
+        return nil if node.nil?
+        @neo.add_label(node, labels)
+        Neon::Node::Rest.new(node, self)
+      end
+
+      def load(id)
+        node = @neo.get_node(id)
+        Neon::Node::Rest.new(node, self)
+      end
+
+      def load_rel(id)
+        rel = @neo.get_relationship(id)
+        Relationship::Rest.new(rel, self)
+      end
+
+      def begin_tx
+        Transaction::Rest.begin_tx(self)
+      end
+
+      def run_tx(&block)
+        Transaction::Placebo.run(begin_tx, &block)
+      end
+
+      def to_s
+        @url
+      end
+    end
+  end
+end

data/lib/neon/transaction.rb

@@ -0,0 +1,28 @@
+module Neon
+  module Transaction
+    class << self
+      # Begins a transaction
+      #
+      # @param session [Session::Rest, Session::Embedded] the current running session
+      #
+      # @return [Transaction::Rest, Java::OrgNeo4jKernel::PlaceboTransaction] a new transaction if one is not currently running.
+      #   Otherwise it returns the currently running transaction.
+      def begin(session = Session.current)
+        session.begin_tx
+      rescue NoMethodError => e
+          _raise_invalid_session_error(session, e)
+      end
+
+      def run(session = Session.current, &block)
+        session.run_tx(&block)
+      rescue NoMethodError => e
+        _raise_invalid_session_error(session, e)
+      end
+
+      private
+        def _raise_invalid_session_error(session, e)
+          raise Neon::Session::InvalidSessionTypeError.new(session.class), e.to_s
+        end
+    end
+  end
+end

data/lib/neon/transaction/placebo.rb

@@ -0,0 +1,38 @@
+module Neon
+  module Transaction
+    class Placebo
+      def success
+        @success = true
+      end
+
+      def failure
+        @success = false
+      end
+      
+      def close
+      end
+
+      def success?
+        @success
+      end
+
+      def self.run(tx)
+        placebo = new
+        placebo.success # Mark for success by default
+        result = yield(placebo) if block_given?
+        if placebo.success?
+          tx.success
+        else
+          tx.failure
+        end
+        tx.close
+        return result, placebo.success?
+      rescue Exception => e
+        # Roll back the transaction
+        tx.failure
+        tx.close
+        raise e # Let the exception bubble up
+      end
+    end
+  end
+end