neo4j-core 3.0.0.alpha.1

data/lib/neo4j/property_container.rb

@@ -0,0 +1,22 @@
+module Neo4j
+  module PropertyContainer
+    include Neo4j::PropertyValidator
+
+    # Returns the Neo4j Property of given key
+    def [](key)
+      get_property(key)
+    end
+
+
+    # Sets the neo4j property
+    def []=(key,value)
+      validate_property(value)
+
+      if value.nil?
+        remove_property(key)
+      else
+        set_property(key,value)
+      end
+    end
+  end
+end

data/lib/neo4j/property_validator.rb

@@ -0,0 +1,23 @@
+module Neo4j
+  module PropertyValidator
+
+    class InvalidPropertyException < Exception
+
+    end
+
+    # the valid values on a property, and arrays of those.
+    VALID_PROPERTY_VALUE_CLASSES = Set.new([Array, NilClass, String, Float, TrueClass, FalseClass, Fixnum])
+
+    # @param [Object] value the value we want to check if it's a valid neo4j property value
+    # @return [True, False] A false means it can't be persisted.
+    def valid_property?(value)
+      VALID_PROPERTY_VALUE_CLASSES.include?(value.class)
+    end
+
+    def validate_property(value)
+      unless valid_property?(value)
+        raise Neo4j::PropertyValidator::InvalidPropertyException.new("Not valid Neo4j Property value #{value.class}, valid: #{Neo4j::Node::VALID_PROPERTY_VALUE_CLASSES.to_a.join(', ')}")
+      end
+    end
+  end
+end

data/lib/neo4j/relationship.rb

@@ -0,0 +1,84 @@
+module Neo4j
+  # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
+  # You can attach properties to relationships like Neo4j::Node.
+  #
+  # The fact that the relationship API gives meaning to start and end nodes implicitly means that all relationships have a direction.
+  # In the example above, rel would be directed from node to otherNode.
+  # A relationship's start node and end node and their relation to outgoing and incoming are defined so that the assertions in the following code are true:
+  #
+  # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
+  # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-nil nodes.
+  class Relationship
+
+    include PropertyContainer
+    include EntityEquality
+
+    # @abstract
+    def start_node
+      raise 'not implemented'
+    end
+
+    # @abstract
+    def end_node
+      raise 'not implemented'
+    end
+
+    # @abstract
+    def del
+      raise 'not implemented'
+    end
+
+    # The unique neo4j id
+    # @abstract
+    def neo_id
+      raise 'not implemented'
+    end
+
+    # @return [true, false] if the relationship exists
+    # @abstract
+    def exist?
+      raise 'not implemented'
+    end
+
+    # Returns the relationship name
+    #
+    # @example
+    #   a = Neo4j::Node.new
+    #   a.create_rel(:friends, node_b)
+    #   a.rels.first.rel_type # => :friends
+    # @return [Symbol] the type of the relationship
+    def rel_type
+      raise 'not implemented'
+    end
+
+    # A convenience operation that, given a node that is attached to this relationship, returns the other node.
+    # For example if node is a start node, the end node will be returned, and vice versa.
+    # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels
+    # method on a node. For example, to get the node "at the other end" of a relationship, use the following:
+    #
+    # @example
+    #   end_node = node.rels.first.other_node(node)
+    #
+    # @raise This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
+    #
+    # @param [Neo4j::Node] node the node that we don't want to return
+    # @return [Neo4j::Node] the other node wrapper
+    # @see #_other_node
+    def other_node(node)
+      if node == start_node
+        return end_node
+      elsif node == end_node
+        return start_node
+      else
+        raise "Node #{node.inspect} is neither start nor end node"
+      end
+    end
+
+    class << self
+      def load(neo_id, session = Neo4j::Session.current)
+        session.load_relationship(neo_id)
+      end
+
+    end
+  end
+end

data/lib/neo4j/session.rb

@@ -0,0 +1,124 @@
+module Neo4j
+  class Session
+
+    @@current_session = nil
+    @@factories = {}
+
+    # @abstract
+    def close
+      self.class.unregister(self)
+    end
+
+    # Only for embedded database
+    # @abstract
+    def start
+      raise "not impl."
+    end
+
+    # Only for embedded database
+    # @abstract
+    def shutdown
+      raise "not impl."
+    end
+
+    # Only for embedded database
+    # @abstract
+    def running
+      raise "not impl."
+    end
+
+    def auto_commit?
+      true # TODO
+    end
+
+    # @abstract
+    def begin_tx
+      raise "not impl."
+    end
+
+    class CypherError < StandardError
+      attr_reader :error_msg, :error_status, :error_code
+      def initialize(error_msg, error_code, error_status)
+        super(error_msg)
+        @error_msg = error_msg
+        @error_status = error_status
+      end
+    end
+
+    # Executes a Cypher Query
+    # Returns an enumerable of hash values, column => value
+    #
+    # @example Using the Cypher DSL
+    #  q = Neo4j.query("START n=node({param}) RETURN n", :param => 0)
+    #  q.first[:n] #=> the node
+    #  q.columns.first => :n
+    #
+    # @example Using the Cypher DSL
+    #  q = Neo4j.query{ match node(3) <=> node(:x); ret :x}
+    #  q.first[:n] #=> the @node
+    #  q.columns.first => :n
+    #
+    # @example Using the Cypher DSL and one parameter (n=Neo4j.ref_node)
+    #  q = Neo4j.query(Neo4j.ref_node){|n| n <=> node(:x); :x}
+    #  q.first[:n] #=> the @node
+    #  q.columns.first => :n
+    #
+    # @example Using an array of nodes
+    #  # same as - two_nodes=node(Neo4j.ref_node.neo_id, node_b.neo_id), b = node(b.neo_id)
+    #  q = Neo4j.query([Neo4j.ref_node, node_b], node_c){|two_nodes, b| two_nodes <=> b; b}
+    #
+    # @see Cypher
+    # @see http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html The Cypher Query Language Documentation
+    # @note Returns a read-once only forward iterable.
+    # @param params parameter for the query_dsl block
+    # @return [Neo4j::Cypher::ResultWrapper] a forward read once only Enumerable, containing hash values.
+    #
+    # @abstract
+    def query(*params, &query_dsl)
+      cypher_params = params.pop if params.last.is_a?(Hash)
+      q = query_dsl ? Neo4j::Cypher.query(*params, &query_dsl).to_s : params[0]
+      _query(q, cypher_params)
+    end
+
+    # Same as #query but does not accept an DSL and returns the raw result from the database.
+    # Notice, it might return different values depending on which database is used, embedded or server.
+    # @abstract
+    def _query(*params)
+      raise 'not implemented'
+    end
+
+    class << self
+      # Creates a new session
+      # @param db_type the type of database, e.g. :embedded_db, or :server_db
+      def open(db_type, *params)
+        unless (@@factories[db_type])
+          raise "Can't connect to database '#{db_type}', available #{@@factories.keys.join(',')}"
+        end
+        session = @@factories[db_type].call(*params)
+        register(session)
+      end
+
+      def current
+        @@current_session
+      end
+
+      def set_current(session)
+        @@current_session = session
+      end
+
+      def register(session)
+        set_current(session) unless @@current_session
+        @@current_session
+      end
+
+      def unregister(session)
+        @@current_session = nil if @@current_session == session
+      end
+
+      def register_db(db, &session_factory)
+        raise "Factory for #{db} already exists" if @@factories[db]
+        @@factories[db] = session_factory
+      end
+    end
+  end
+end

data/lib/neo4j/tasks/neo4j_server.rb

@@ -0,0 +1,131 @@
+# borrowed from architect4r
+require 'os'
+
+namespace :neo4j do
+  desc "Install Neo4j"
+  task :install, :edition, :version do |t, args|
+    args.with_defaults(:edition => "community", :version => "1.7")
+    puts "Installing Neo4j-#{args[:edition]}-#{args[:version]}"
+    
+    if OS::Underlying.windows?
+      # Download Neo4j    
+      unless File.exist?('neo4j.zip')
+        df = File.open('neo4j.zip', 'wb')
+        begin
+          df << HTTParty.get("http://dist.neo4j.org/neo4j-#{args[:edition]}-#{args[:version]}-windows.zip")
+        ensure
+          df.close()
+        end
+      end
+
+      # Extract and move to neo4j directory
+      unless File.exist?('neo4j')
+        Zip::ZipFile.open('neo4j.zip') do |zip_file|
+          zip_file.each do |f|
+           f_path=File.join(".", f.name)
+           FileUtils.mkdir_p(File.dirname(f_path))
+           begin
+             zip_file.extract(f, f_path) unless File.exist?(f_path)
+           rescue
+             puts f.name + " failed to extract."
+           end
+          end
+        end
+        FileUtils.mv "neo4j-#{args[:edition]}-#{args[:version]}", "neo4j"
+     end
+
+      # Install if running with Admin Privileges
+      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+        %x[neo4j/bin/neo4j install]
+        puts "Neo4j Installed as a service."
+      end
+
+    else    
+      %x[wget http://dist.neo4j.org/neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[tar -xvzf neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[mv neo4j-#{args[:edition]}-#{args[:version]} neo4j]
+      %x[rm neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      puts "Neo4j Installed in to neo4j directory."
+    end
+    puts "Type 'rake neo4j:start' to start it"
+  end
+  
+  desc "Start the Neo4j Server"
+  task :start do
+    puts "Starting Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+        %x[neo4j/bin/Neo4j.bat start]  #start service
+      else
+        puts "Starting Neo4j directly, not as a service."
+        %x[neo4j/bin/Neo4j.bat]
+      end      
+    else
+      %x[neo4j/bin/neo4j start]  
+    end
+  end
+  
+  desc "Stop the Neo4j Server"
+  task :stop do
+    puts "Stopping Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+         %x[neo4j/bin/Neo4j.bat stop]  #stop service
+      else
+        puts "You do not have administrative rights to stop the Neo4j Service"   
+      end
+    else  
+      %x[neo4j/bin/neo4j stop]
+    end
+  end
+
+  desc "Restart the Neo4j Server"
+  task :restart do
+    puts "Restarting Neo4j..."
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+         %x[neo4j/bin/Neo4j.bat restart] 
+      else
+        puts "You do not have administrative rights to restart the Neo4j Service"   
+      end
+    else  
+      %x[neo4j/bin/neo4j restart]
+    end
+  end
+
+  desc "Reset the Neo4j Server"
+  task :reset_yes_i_am_sure do
+    # Stop the server
+    if OS::Underlying.windows? 
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
+         %x[neo4j/bin/Neo4j.bat stop]
+         
+        # Reset the database
+        FileUtils.rm_rf("neo4j/data/graph.db")
+        FileUtils.mkdir("neo4j/data/graph.db")
+        
+        # Remove log files
+        FileUtils.rm_rf("neo4j/data/log")
+        FileUtils.mkdir("neo4j/data/log")
+
+        %x[neo4j/bin/Neo4j.bat start]
+      else
+        puts "You do not have administrative rights to reset the Neo4j Service"   
+      end
+    else  
+      %x[neo4j/bin/neo4j stop]
+      
+      # Reset the database
+      FileUtils.rm_rf("neo4j/data/graph.db")
+      FileUtils.mkdir("neo4j/data/graph.db")
+      
+      # Remove log files
+      FileUtils.rm_rf("neo4j/data/log")
+      FileUtils.mkdir("neo4j/data/log")
+      
+      # Start the server
+      %x[neo4j/bin/neo4j start]
+    end
+  end
+
+end  

data/lib/neo4j/transaction.rb

@@ -0,0 +1,52 @@
+module Neo4j
+  class Transaction
+    def self.new(current = Session.current)
+      current.begin_tx
+    end
+
+
+    class << self
+
+      def run(run_in_tx=true)
+        raise ArgumentError.new("Expected a block to run in Transaction.run") unless block_given?
+
+        return yield(nil) unless run_in_tx
+
+        begin
+          tx = Neo4j::Transaction.new
+          ret = yield tx
+          tx.success
+        rescue Exception => e
+          if e.respond_to?(:cause) && e.cause
+            puts "Java Exception in a transaction, cause: #{e.cause}"
+            e.cause.print_stack_trace
+          end
+          tx.failure unless tx.nil?
+          raise
+        ensure
+          tx.finish unless tx.nil?
+        end
+        ret
+      end
+
+      def current
+        Thread.current[:neo4j_curr_tx]
+      end
+
+      def unregister(tx)
+        Thread.current[:neo4j_curr_tx] = nil if tx == Thread.current[:neo4j_curr_tx]
+      end
+
+      def register(tx)
+        # we don't support running more then one transaction per thread
+        raise "Already running a transaction" if current
+        Thread.current[:neo4j_curr_tx] = tx
+      end
+
+      def unregister_current
+        Thread.current[:neo4j_curr_tx] = nil
+      end
+    end
+
+  end
+end

data/neo4j-core.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'neo4j-core/version'
+
+Gem::Specification.new do |s|
+  s.name     = "neo4j-core"
+  s.version  = Neo4j::Core::VERSION
+  s.required_ruby_version = ">= 1.8.7"
+
+  s.authors  = "Andreas Ronge"
+  s.email    = 'andreas.ronge@gmail.com'
+  s.homepage = "http://github.com/andreasronge/neo4j-core/tree"
+  s.rubyforge_project = 'neo4j-core'
+  s.summary = "A graph database for JRuby"
+  s.description = <<-EOF
+You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
+The programmer works with an object-oriented, flexible network structure rather than with strict and static tables 
+yet enjoys all the benefits of a fully transactional, enterprise-strength database.
+It comes included with the Apache Lucene document database.
+  EOF
+
+  s.require_path = 'lib'
+  s.files = Dir.glob("{bin,lib,config}/**/*") + %w(README.md Gemfile neo4j-core.gemspec)
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README.md )
+  s.rdoc_options = ["--quiet", "--title", "Neo4j::Core", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+
+  # Not released yet
+  s.add_dependency("httparty")
+  s.add_dependency("json")
+  s.add_dependency("neo4j-cypher")
+#  s.add_dependency("neo4j-community", '>=1.9.M05', '<2.0')
+#  s.add_dependency("neo4j-cypher", '~> 1.0.0')
+end