neo4j-core 0.0.1-java

data/lib/neo4j/config.rb

@@ -0,0 +1,139 @@
+module Neo4j
+
+
+  # == Keeps configuration for neo4j
+  #
+  # The most important configuration is storage_path which is used to
+  # locate where the neo4j database is stored on the filesystem.
+  # If this directory is empty then a new database will be created, otherwise it will use the
+  # database from that directory.
+  #
+  # == Configurations keys
+  #
+  #   storage_path   where the database is stored
+  #   timestamps     if timestamps should be used when saving the model (Neo4j::Rails::Model)
+  #   lucene         lucene configuration for fulltext and exact indices
+  #   enable_rules   if false the _all relationship to all instances will not be created and custom rules will not be available. (Neo4j::NodeMixin and Neo4j::Rails::Model)
+  #   identity_map   default false, See Neo4j::IdentityMap  (Neo4j::NodeMixin and Neo4j::Rails::Model)
+  #
+  class Config
+
+    class << self
+
+      # @return [Fixnum] The location of the default configuration file.
+      def default_file
+        @default_file ||= File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config", "neo4j", "config.yml"))
+      end
+
+      # Sets the location of the configuration YAML file and old deletes configurations.
+      #
+      # @param [String] file_path represent the path to the file.
+      def default_file=(file_path)
+        @configuration = nil
+        @defaults = nil
+        @default_file = File.expand_path(file_path)
+      end
+
+      # @return [Hash] the default file loaded by yaml
+      def defaults
+        require 'yaml'
+        @defaults ||= YAML.load_file(default_file)
+      end
+
+      # @return [String] the expanded path of the Config[:storage_path] property
+      def storage_path
+        File.expand_path(self[:storage_path])
+      end
+
+      # Yields the configuration
+      #
+      # @example
+      #   Neo4j::Config.use do |config|
+      #     config[:storage_path] = '/var/neo4j'
+      #   end
+      #
+      # @return nil
+      # @yield config
+      # @yieldparam [Neo4j::Config] config - this configuration class
+      def use
+        @configuration ||= {}
+        yield @configuration
+        nil
+      end
+
+
+      # Sets the value of a config entry.
+      #
+      # @param [Symbol] key the key to set the parameter for
+      # @param val the value of the parameter.
+      def []=(key, val)
+        (@configuration ||= setup)[key.to_s] = val
+      end
+
+
+      # @param [Symbol] key The key of the config entry value we want
+      # @return the the value of a config entry
+      def [](key)
+        (@configuration ||= setup)[key.to_s]
+      end
+
+
+      # Remove the value of a config entry.
+      #
+      # @param [Symbol] key the key of the configuration entry to delete
+      # @return The value of the removed entry.
+      def delete(key)
+        @configuration.delete(key)
+      end
+
+
+      # Remove all configuration. This can be useful for testing purpose.
+      #
+      # @return nil
+      def delete_all
+        @configuration = nil
+      end
+
+
+      # @return [Hash] The config as a hash.
+      def to_hash
+        @configuration ||= setup
+      end
+
+      # @return [String] The config as a YAML
+      def to_yaml
+        @configuration.to_yaml
+      end
+
+      # Converts the defaults hash to a Java HashMap used by the Neo4j API.
+      # @return a Java HashMap used by the Java Neo4j API as configuration for the GraphDatabase
+      def to_java_map
+        map = java.util.HashMap.new
+        to_hash.each_pair do |k, v|
+          case v
+            when TrueClass
+              map[k.to_s] = "YES"
+            when FalseClass
+              map[k.to_s] = "NO"
+            when String, Fixnum, Float
+              map[k.to_s] = v.to_s
+            # skip list and hash values - not accepted by the Java Neo4j API
+          end
+        end
+        map
+      end
+
+      private
+
+      # @return The a new configuration using default values as a hash.
+      def setup()
+        @configuration = {}
+        @configuration.merge!(defaults)
+        @configuration
+      end
+
+
+    end
+  end
+
+end

data/lib/neo4j/cypher.rb

@@ -0,0 +1,156 @@
+module Neo4j
+  class Cypher
+    attr_reader :expressions
+
+    include Neo4j::Core::Cypher
+    include Neo4j::Core::Cypher::MathFunctions
+
+    # Creates a Cypher DSL query.
+    # To create a new cypher query you must initialize it either an String or a Block.
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)--(x) RETURN x</tt> same as
+    #   Cypher.new { start n = node(3); match n <=> :x; ret :x }.to_s
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)-[r]->(x) RETURN r</tt> same as
+    #   node(3) > :r > :x; :r
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)-->(x) RETURN x</tt> same as
+    #   node(3) >> :x; :x
+    #
+    # @param args the argument for the dsl_block
+    # @yield the block which will be evaluated in the context of this object in order to create an Cypher Query string
+    # @yieldreturn [Return, Object] If the return is not an instance of Return it will be converted it to a Return object (if possible).
+    def initialize(*args, &dsl_block)
+      @expressions = []
+      @variables = []
+      res = self.instance_exec(*args, &dsl_block)
+      unless res.kind_of?(Return)
+        res.respond_to?(:to_a) ? ret(*res) : ret(res)
+      end
+    end
+
+    # Does nothing, just for making the DSL easier to read (maybe).
+    # @return self
+    def match(*)
+      self
+    end
+
+    # Does nothing, just for making the DSL easier to read (maybe)
+    # @return self
+    def start(*)
+      self
+    end
+
+    def where(w=nil)
+      Where.new(@expressions, w) if w.is_a?(String)
+      self
+    end
+
+    # Specifies a start node by performing a lucene query.
+    # @param [Class] index_class a class responsible for an index
+    # @param [String] q the lucene query
+    # @param [Symbol] index_type the type of index
+    # @return [NodeQuery]
+    def query(index_class, q, index_type = :exact)
+      NodeQuery.new(index_class, q, index_type, @expressions)
+    end
+
+    # Specifies a start node by performing a lucene query.
+    # @param [Class] index_class a class responsible for an index
+    # @param [String, Symbol] key the key we ask for
+    # @param [String, Symbol] value the value of the key we ask for
+    # @return [NodeLookup]
+    def lookup(index_class, key, value)
+      NodeLookup.new(index_class, key, value, @expressions)
+    end
+
+    # Creates a node variable.
+    # It will create different variables depending on the type of the first element in the nodes argument.
+    # * Fixnum - it will be be used as neo_id  for start node(s) (StartNode)
+    # * Symbol - it will create an unbound node variable with the same name as the symbol (NodeVar#as)
+    # * empty array - it will create an unbound node variable (NodeVar)
+    #
+    # @param [Fixnum,Symbol,String] nodes the id of the nodes we want to start from
+    # @return [StartNode, NodeVar]
+    def node(*nodes)
+      if nodes.first.is_a?(Symbol)
+        NodeVar.new(@expressions, @variables).as(nodes.first)
+      elsif !nodes.empty?
+        StartNode.new(nodes, @expressions)
+      else
+        NodeVar.new(@expressions, @variables)
+      end
+    end
+
+    # Similar to #node
+    # @return [StartRel, RelVar]
+    def rel(*rels)
+      if rels.first.is_a?(Fixnum) || rels.first.respond_to?(:neo_id)
+        StartRel.new(rels, @expressions)
+      elsif rels.first.is_a?(Symbol)
+        RelVar.new(@expressions, @variables, "").as(rels.first)
+      elsif rels.first.is_a?(String)
+        RelVar.new(@expressions, @variables, rels.first)
+      else
+        raise "Unknown arg #{rels.inspect}"
+      end
+    end
+
+    # Specifies a return statement.
+    # Notice that this is not needed, since the last value of the DSL block will be converted into one or more
+    # return statements.
+    # @param [Symbol, #var_name] returns a list of variables we want to return
+    # @return [Return]
+    def ret(*returns)
+      options = returns.last.is_a?(Hash) ? returns.pop : {}
+      @expressions -= @expressions.find_all { |r| r.clause == :return && returns.include?(r) }
+      returns.each { |ret| Return.new(ret, @expressions, options) unless ret.respond_to?(:clause) && [:order_by, :skip, :limit].include?(ret.clause)}
+      @expressions.last
+    end
+
+    def shortest_path(&block)
+      match = instance_eval(&block)
+      match.algorithm = 'shortestPath'
+      match.find_match_start
+    end
+
+    def shortest_paths(&block)
+      match = instance_eval(&block)
+      match.algorithm = 'shortestPaths'
+      match.find_match_start
+    end
+
+    # @param [Symbol,nil] variable the entity we want to count or wildcard (*)
+    # @return [Return] a counter return clause
+    def count(variable='*')
+      Return.new("count(#{variable.to_s})", @expressions)
+    end
+
+    def coalesce(*args)
+      s = args.map { |x| x.var_name }.join(", ")
+      Return.new("coalesce(#{s})", @expressions)
+    end
+
+    def nodes(*args)
+      s = args.map { |x| x.referenced!; x.var_name }.join(", ")
+      Return.new("nodes(#{s})", @expressions)
+    end
+
+    def rels(*args)
+      s = args.map { |x| x.referenced!; x.var_name }.join(", ")
+      Return.new("relationships(#{s})", @expressions)
+    end
+
+    # Converts the DSL query to a cypher String which can be executed by cypher query engine.
+    def to_s
+      clause = nil
+      @expressions.map do |expr|
+        next unless expr.valid?
+        expr_to_s = expr.clause != clause ? "#{expr.prefix} #{expr.to_s}" : "#{expr.separator}#{expr.to_s}"
+        clause = expr.clause
+        expr_to_s
+      end.join
+    end
+
+  end
+end

data/lib/neo4j/neo4j.rb

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+
+# = Neo4j
+#
+# The Neo4j modules is used to interact with an Neo4j Database instance.
+# You can for example start and stop an instance and list all the nodes that exist in the database.
+#
+# === Starting and Stopping Neo4j
+# You don't normally need to start the Neo4j database since it will be automatically started when needed.
+# Before the database is started you should configure where the database is stored, see {Neo4j::Config]}.
+#
+module Neo4j
+
+  # @return [String] The version of the Neo4j jar files
+  NEO_VERSION = Neo4j::Community::VERSION
+
+  class << self
+
+    # Start Neo4j using the default database.
+    # This is usually not required since the database will be started automatically when it is used.
+    # If the global variable $NEO4J_SERVER is defined then it will use that as the Java Graph DB. This can
+    # be used if you want to embed neo4j.rb and already got an instance of the Java Neo4j Database service.
+    #
+    # @param [String] config_file (optionally) if this is nil or not given use the Neo4j::Config, otherwise setup the Neo4j::Config file using the provided YAML configuration file.
+    # @param [Java::OrgNeo4jKernel::EmbeddedGraphDatabase] external_db (optionally) use this Java Neo4j instead of creating a new neo4j database service.
+    def start(config_file=nil, external_db = $NEO4J_SERVER)
+      return if @db && @db.running?
+
+      Neo4j.config.default_file = config_file if config_file
+      if external_db
+        @db ||= Neo4j::Core::Database.new
+        self.db.start_external_db(external_db)
+      else
+        db.start
+      end
+    end
+
+
+    # Sets which Neo4j::Database instance to use. It wraps both the Neo4j Database and Lucene Database.
+    # @param [Neo4j::Database] my_db - the database instance to use
+    def db=(my_db)
+      @db = my_db
+    end
+
+    # Returns the database holding references to both the Neo4j Graph Database and the Lucene Database.
+    # Creates a new one if it does not exist, but does not start it.
+    #
+    # @return [Neo4j::Database] the created or existing database
+    def db
+      @db ||= Neo4j::Core::Database.new
+    end
+
+    # Checks read only mode of the database. Only one process can have write access to the database.
+    # @return [true, false] if the database has started up in read only mode
+    def read_only?
+      (@db && @db.graph && @db.read_only?)
+    end
+
+    # Returns a started db instance. Starts it's not running.
+    # if $NEO4J_SERVER is defined then use that Java Neo4j Database service instead of creating a new one.
+    # @return [Neo4j::Database] a started database
+    def started_db
+      start unless db.running?
+      db
+    end
+
+    # Runs all user defined migrations.
+    def migrate!
+
+    end
+
+    # @return [String, nil] the current storage path of a running neo4j database. If the database is not running it returns nil.
+    def storage_path
+      return nil unless db.running?
+      db.storage_path
+    end
+
+    # Same as typing; Neo4j::Config
+    # @return [Neo4j::Config] the Neo4j::Config class
+    def config
+      Neo4j::Config
+    end
+
+    # Executes a Cypher Query
+    # Check the neo4j 
+    # Returns an enumerable of hash values.
+    #
+    # @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 With an string
+    #  q = Neo4j._query("START n=node(42) RETURN n")
+    #  q.first(:n) #=> the @node
+    #  q.columns.first => :n
+    #
+    # @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::Core::Cypher::ResultWrapper] a forward read once only Enumerable, containing hash values.
+    def query(*params, &query_dsl)
+      q = Cypher.new(*params, &query_dsl).to_s
+      _query(q)
+    end
+
+    # Performs a cypher query with given string
+    # @param [String] q the cypher query as a String
+    # @return (see #query)
+    def _query(q)
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(db)
+      result = engine.execute(q)
+      Neo4j::Core::Cypher::ResultWrapper.new(result)
+    end
+
+
+    # Returns the logger used by neo4j.
+    # If not specified (with Neo4j.logger=) it will use the standard Ruby logger.
+    # You can change standard logger threshold by configuration :logger_level.
+    #
+    # You can also specify which logger class should take care of logging with the
+    # :logger configuration.
+    #
+    # @example
+    #
+    #  Neo4j::Config[:logger] = Logger.new(STDOUT)
+    #  Neo4j::Config[:logger_level] = Logger::ERROR
+    #
+    # @see #logger=
+    def logger
+      @logger ||= Neo4j::Config[:logger] || default_logger
+    end
+
+    # Sets which logger should be used.
+    # If this this is not called then the standard Ruby logger will be used.
+    # @see #logger
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # @return the default Ruby logger
+    def default_logger #:nodoc:
+      require 'logger'
+      logger = Logger.new(STDOUT)
+      logger.sev_threshold = Neo4j::Config[:logger_level] || Logger::INFO
+      logger
+    end
+
+
+    # Returns an unstarted db instance
+    #
+    # This is typically used for configuring the database, which must sometimes
+    # be done before the database is started
+    # if the database was already started an exception will be raised
+    # @return [Neo4j::Database] an not started database
+    def unstarted_db
+      @db ||= Neo4j::Core::Database.new
+      raise "database was already started" if @db.running?
+      @db
+    end
+
+    # @return [true,false] if the database is running
+    def running?
+      !!(@db && @db.running?)
+    end
+
+
+    # Stops this database
+    # There are Ruby hooks that will do this automatically for you.
+    def shutdown(this_db = @db)
+      this_db.shutdown if this_db
+    end
+
+
+    # @return the default reference node, which is a "starting point" in the node space.
+    def default_ref_node(this_db = self.started_db)
+      this_db.graph.reference_node
+    end
+
+    # Usually, a client attaches relationships to this node that leads into various parts of the node space.
+    # ®return the reference node, which is a "starting point" in the node space.
+    # @note In case the ref_node has been assigned via the threadlocal_ref_node method,
+    #       then that node will be returned instead.
+    # @see the design guide at http://wiki.neo4j.org/content/Design_Guide
+    def ref_node(this_db = self.started_db)
+      return Thread.current[:local_ref_node] if Thread.current[:local_ref_node]
+      default_ref_node(this_db)
+    end
+
+    # Changes the reference node on a threadlocal basis.
+    # This can be used to achieve multitenancy. All new entities will be attached to the new ref_node,
+    # which effectively partitions the graph, and hence scopes traversals.
+    def threadlocal_ref_node=(reference_node)
+      Thread.current[:local_ref_node] = reference_node.nil? ? nil : reference_node._java_node
+    end
+
+    # Returns a Management JMX Bean.
+    #
+    # Notice that this information is also provided by the jconsole Java tool, check http://wiki.neo4j.org/content/Monitoring_and_Deployment
+    # and http://docs.neo4j.org/chunked/milestone/operations-monitoring.html
+    #
+    # By default it returns the Primitivies JMX Bean that can be used to find number of nodes in use.
+    #
+    # @example Example Neo4j Primititives
+    #
+    #   Neo4j.management.get_number_of_node_ids_in_use
+    #   Neo4j.management.getNumberOfPropertyIdsInUse
+    #   Neo4j.management.getNumberOfRelationshipIdsInUse
+    #   Neo4j.management.get_number_of_relationship_type_ids_in_use
+    #
+    # @example Example Neo4j HA Cluster Info
+    #
+    # Neo4j.management(org.neo4j.management.HighAvailability).isMaster
+    #
+    # @param jmx_clazz the JMX class http://api.neo4j.org/current/org/neo4j/management/package-summary.html
+    # @param this_db default currently runnig instance or a newly started neo4j db instance
+    # @see for the jmx_clazz p
+    def management(jmx_clazz = org.neo4j.jmx.Primitives, this_db = self.started_db)
+      this_db.management(jmx_clazz)
+    end
+
+    # @return [Enumerable] all nodes in the database
+    def all_nodes(this_db = self.started_db)
+      Enumerable::Enumerator.new(this_db, :each_node)
+    end
+
+    # @return [Enumerable] all nodes in the database but not wrapped in ruby classes.
+    def _all_nodes(this_db = self.started_db)
+      Enumerator.new(this_db, :_each_node)
+    end
+
+    # @return [Neo4j::Core::EventHandler] the event handler
+    def event_handler(this_db = db)
+      this_db.event_handler
+    end
+
+  end
+end