neography 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+log/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in neography.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    neography (0.0.1)
+      httparty (~> 0.6.1)
+      json
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    fakeweb (1.3.0)
+    httparty (0.6.1)
+      crack (= 0.1.8)
+    json (1.4.6-java)
+    net-http-spy (0.2.1)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  fakeweb (~> 1.3.0)
+  httparty (~> 0.6.1)
+  json
+  neography!
+  net-http-spy (~> 0.2.1)
+  rspec (~> 2.0.0.beta.22)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Max De Marzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,94 @@
+== Welcome to Neography
+
+Neography is a thin ruby wrapper to the Neo4j Rest API, for more information:
+* {Getting Started with Neo4j Server}[http://wiki.neo4j.org/content/Getting_Started_with_Neo4j_Server]
+* {Neo4j Rest API Reference}[http://components.neo4j.org/neo4j-rest/]
+
+
+=== Installation
+
+  gem install 'neography'
+  require 'neography'
+
+=== Dependencies
+
+  for use:
+  json
+  httparty 
+
+  for development:
+  rspec 
+  net-http-spy 
+  fakeweb 
+
+==== Rails
+
+Just add gem 'neography' to your Gemfile and run bundle install
+
+=== Documentation
+
+A thin ruby wrapper Neography::Rest which tries to mirror the Neo4j Rest API and returns JSON or Nil:
+
+  #                            protocol,  server,        port,  log_file,           log_enabled
+  @neo = Neography::Rest.new ('http://', '192.168.10.1', 7479, 'log/neography.log', true)
+
+Default Parameters are:   
+
+  @neo = Neography::Rest.new ('http://', 'localhost', 7474, '/neography.log', false)
+
+To Use:
+
+  @neo = Neography::Rest.new 
+
+  @neo.get_root                                     # Get the root node
+  @neo.create_node                                  # Create an empty node
+  @neo.create_node("age" => 31, "name" => "Max")    # Create a node with some properties
+  @neo.get_node(id)                                 # Get a node and its properties
+  @neo.delete_node(id)                              # Delete an unrelated node
+  @neo.delete_node!(id)                             # Delete a node and all its relationships
+
+  @neo.reset_node_properties(id, {"age" => 31})     # Reset a node's properties
+  @neo.set_node_properties(id, {"weight" => 200})   # Set a node's properties
+  @neo.get_node_properties(id)                      # Get just the node properties
+  @neo.get_node_properties(id, ["weight","age"])    # Get some of the node properties
+  @neo.remove_node_properties(id)                   # Remove all properties of a node
+  @neo.remove_node_properties(id, "weight")         # Remove one property of a node
+  @neo.remove_node_properties(id, ["weight","age"]) # Remove multiple properties of a node
+
+  @neo.create_relationship("friends", node1, node2)        # Create a relationship between node1 and node2
+  @neo.get_node_relationships(id)                          # Get all relationships
+  @neo.get_node_relationships(id, "in")                    # Get only incoming relationships
+  @neo.get_node_relationships(id, "all", "enemies")        # Get all relationships of type enemies
+  @neo.get_node_relationships(id, "in", "enemies")         # Get only incoming relationships of type enemies
+  @neo.delete_relationship(id)                             # Delete a relationship
+
+  @neo.reset_relationship_properties(id, {"age" => 31})    # Reset a relationship's properties
+  @neo.set_relationship_properties(id, {"weight" => 200})  # Set a relationship's properties
+  @neo.get_relationship_properties(id)                     # Get just the relationship properties
+  @neo.get_relationship_properties(id, ["since","met"])    # Get some of the relationship properties
+  @neo.remove_relationship_properties(id)                  # Remove all properties of a relationship
+  @neo.remove_relationship_properties(id, "since")         # Remove one property of a relationship
+  @neo.remove_relationship_properties(id, ["since","met"]) # Remove multiple properties of a relationship
+
+  @neo.list_indexes                        # doesn't really seam to do what the api says it does
+  @neo.add_to_index(key, value, id)        # adds a node to an index with the given key/value pair
+  @neo.remove_from_index(key, value, id)   # removes a node to an index with the given key/value pair
+  @neo.get_index(key, value)               # gets an index with the given key/value pair
+
+  @neo.get_path(from, to, relationships, depth=4, algorithm="shortestPath") # finds the shortest path between two nodes 
+  @neo.get_paths(from, to, relationships, depth=3, algorithm="allPaths")    # finds all paths between two nodes
+
+=== To Do
+
+Path tests
+Traverse tests
+@neo.traverse()
+examples
+
+=== License
+
+* Neography - MIT, see the LICENSE file http://github.com/maxdemarzi/neography/tree/master/LICENSE.
+* Lucene -  Apache, see http://lucene.apache.org/java/docs/features.html
+* Neo4j - Dual free software/commercial license, see http://neo4j.org/
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/neography.rb

@@ -0,0 +1,26 @@
+def find_and_require_user_defined_code
+  extensions_path = ENV['neography_extensions'] || "~/.neography"
+  extensions_path = File.expand_path(extensions_path)
+  if File.exists?(extensions_path)
+    Dir.open extensions_path do |dir|
+      dir.entries.each do |file|
+        if file.split('.').size > 1 && file.split('.').last == 'rb'
+          extension = File.join(File.expand_path(extensions_path), file) 
+          require(extension) && puts("Loaded Extension: #{extension}")
+        end
+      end
+    end
+  else
+    puts "No Extensions Found: #{extensions_path}"
+  end
+end
+
+
+require 'httparty'
+require 'json'
+require 'logger'
+
+require 'neography/rest'
+
+find_and_require_user_defined_code
+

data/lib/neography/config.rb

@@ -0,0 +1,152 @@
+module Neography
+
+  # == Keeps configuration for neography
+  #
+  # The most important configuration options are <tt>Neograophy::Config[:server]</tt> and <tt>Neograophy::Config[:port]</tt> which are
+  # used to locate where the neo4j database and is stored on the network.
+  # If these options are not supplied then the default of localhost:9999 will be used.
+  #
+  # ==== Default Configurations
+  # <tt>:protocol</tt>:: default <tt>http://</tt> protocol to use (can be https://)
+  # <tt>:server</tt>::   default <tt>localhost</tt> where the database is stored on the network
+  # <tt>:port</tt>::     default <tt>7474</tt> what port is listening
+  #
+  class Config
+    # This code is copied from merb-core/config.rb.
+    class << self
+      # Returns the hash of default config values for neography
+      #
+      # ==== Returns
+      # Hash:: The defaults for the config.
+      def defaults
+        @defaults ||= {
+          :protocol => 'http://',
+          :server => 'localhost',
+          :port => '7474'
+        }
+      end
+
+     
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c :: The configuration parameters, a hash.
+      #
+      # ==== Examples
+      # Neography::Config.use do |config|
+      #   config[:server] = '192.168.1.13'
+      # end
+      #
+      # ==== Returns
+      # nil
+      def use
+        @configuration ||= {}
+        yield @configuration
+        nil
+      end
+      
+      
+      # Set the value of a config entry.
+      #
+      # ==== Parameters
+      # key :: The key to set the parameter for.
+      # val :: The value of the parameter.
+      #
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
+      end
+
+
+      # Gets the the value of a config entry
+      #
+      # ==== Parameters
+      # key:: 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
+      # 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
+      end
+
+
+      # Retrieve the value of a config entry, returning the provided default if the key is not present
+      #
+      # ==== Parameters
+      # key:: The key to retrieve the parameter for.
+      # default::The default value to return if the parameter is not set.
+      #
+      # ==== Returns
+      # 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
+      # The config as a hash.
+      #
+      def to_hash
+        @configuration
+      end
+
+      # Returns the config as YAML.
+      #
+      # ==== Returns
+      # The config as YAML.
+      #
+      def to_yaml
+        require "yaml"
+        @configuration.to_yaml
+      end
+
+      # Returns the configuration as a string.
+      #
+      # ==== Returns
+      # The config as a string.
+      #
+      def to_s
+        setup
+        @configuration[:protocol] + @configuration[:server].to_s + ':' + @configuration[:port].to_s
+      end
+
+
+    end
+  end
+
+end

data/lib/neography/rest.rb

@@ -0,0 +1,241 @@
+module Neography
+  class Rest
+    include HTTParty
+    attr_accessor :protocol, :server, :port, :log_file, :log_enabled, :logger
+
+      def initialize(protocol='http://', server='localhost', port=7474, log_file='neography.log', log_enabled=true)
+        @protocol = protocol
+        @server = server
+        @port = port 
+        @log_file = log_file
+        @log_enabled = log_enabled
+        @logger = Logger.new(@log_file) if @log_enabled
+      end
+
+      def configure(protocol, server, port)
+        @protocol = protocol
+        @server = server
+        @port = port 
+      end
+
+      def configuration
+        @protocol + @server + ':' + @port.to_s + "/db/data"
+      end
+
+      def get_root
+        get('/') 
+      end
+
+      def create_node(*args)
+        if args[0].respond_to?(:each_pair) && args[0] 
+          options = { :body => args[0].to_json, :headers => {'Content-Type' => 'application/json'} } 
+          post("/node", options) 
+        else
+          post("/node") 
+        end
+      end
+
+      def get_node(id)
+        get("/node/#{id}")
+      end
+
+      def reset_node_properties(id, properties)
+        options = { :body => properties.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        put("/node/#{id}/properties", options)
+      end
+
+      def get_node_properties(id, properties = nil)
+        if properties.nil?
+          get("/node/#{id}/properties")
+        else
+          node_properties = Hash.new 
+          properties.to_a.each do |property| 
+            value = get("/node/#{id}/properties/#{property}")
+            node_properties[property] = value unless value.nil?
+          end
+          return nil if node_properties.empty?
+          node_properties
+        end
+      end
+
+      def remove_node_properties(id, properties = nil)
+        if properties.nil?
+          delete("/node/#{id}/properties")
+        else 
+          properties.to_a.each do |property| 
+            delete("/node/#{id}/properties/#{property}") 
+          end
+        end
+      end
+
+      def set_node_properties(id, properties)
+          properties.each do |key, value| 
+            options = { :body => value.to_json, :headers => {'Content-Type' => 'application/json'} } 
+            put("/node/#{id}/properties/#{key}", options) 
+          end
+      end
+
+      def delete_node(id)
+        delete("/node/#{id}")
+      end
+
+      def create_relationship(type, from, to, props = nil)
+         options = { :body => {:to => self.configuration + "/node/#{to}", :data => props, :type => type }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+         post("/node/#{from}/relationships", options)
+      end
+
+      def reset_relationship_properties(id, properties)
+        options = { :body => properties.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        put("/relationship/#{id}/properties", options)
+      end
+
+      def get_relationship_properties(id, properties = nil)
+        if properties.nil?
+          get("/relationship/#{id}/properties")
+        else
+          relationship_properties = Hash.new 
+          properties.to_a.each do |property| 
+            value = get("/relationship/#{id}/properties/#{property}")
+            relationship_properties[property] = value unless value.nil?
+          end
+          return nil if relationship_properties.empty?
+          relationship_properties
+        end
+      end
+
+      def remove_relationship_properties(id, properties = nil)
+        if properties.nil?
+          delete("/relationship/#{id}/properties")
+        else 
+          properties.to_a.each do |property| 
+            delete("/relationship/#{id}/properties/#{property}")
+          end
+        end
+      end
+
+      def set_relationship_properties(id, properties)
+          properties.each do |key, value| 
+            options = { :body => value.to_json, :headers => {'Content-Type' => 'application/json'} } 
+            put("/relationship/#{id}/properties/#{key}", options)
+          end
+      end
+
+      def delete_relationship(id)
+        delete("/relationship/#{id}")
+      end
+
+      def get_node_relationships(id, dir=nil, types=nil)
+        dir = get_dir(dir)
+
+        if types.nil?
+          node_relationships = get("/node/#{id}/relationships/#{dir}") || Array.new
+        else
+          node_relationships = get("/node/#{id}/relationships/#{dir}/#{types.to_a.join('&')}") || Array.new
+        end
+        return nil if node_relationships.empty?
+        node_relationships
+      end
+
+      def delete_node!(id)
+        relationships = get_node_relationships(id)
+        relationships.each { |r| delete_relationship(r["self"].split('/').last) } unless relationships.nil?
+        delete("/node/#{id}")
+      end
+
+      def list_indexes
+        get("/index")
+      end
+
+      def add_to_index(key, value, id)
+        options = { :body => (self.configuration + "/node/#{id}").to_json, :headers => {'Content-Type' => 'application/json'} } 
+        post("/index/node/#{key}/#{value}", options)
+      end
+
+      def remove_from_index(key, value, id)
+        delete("/index/node/#{key}/#{value}/#{id}")
+      end
+
+      def get_index(key, value)
+        index = get("/index/node/#{key}/#{value}") || Array.new
+        return nil if index.empty?
+        index
+      end
+
+      def get_path(from, to, relationships, depth=1, algorithm="shortestPath")
+        options = { :body => {"to" => self.configuration + "/node/#{to}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        path = post("/node/#{from}/path", options) || Hash.new
+      end
+
+      def get_paths(from, to, relationships, depth=1, algorithm="allPaths")
+        options = { :body => {"to" => self.configuration + "/node/#{to}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        paths = post("/node/#{from}/paths", options) || Array.new
+      end
+
+      private
+
+      def evaluate_response(response)
+        code = response.code
+        body = response.body
+     
+        case code 
+          when 200 
+            @logger.debug "OK" if @log_enabled
+            response
+          when 201
+            @logger.debug "OK, created #{body}" if @log_enabled
+            response
+          when 204  
+            @logger.debug "OK, no content returned" if @log_enabled
+            nil
+          when 400
+            @logger.error "Invalid data sent #{body}"  if @log_enabled
+            nil
+          when 404
+            @logger.error "#{body}" if @log_enabled
+            nil
+          when 409
+            @logger.error "Node could not be deleted (still has relationships?)" if @log_enabled
+            nil
+        end
+      end
+
+       def get(path,options={})
+          evaluate_response(HTTParty.get(configuration + path, options))
+       end
+
+       def post(path,options={})
+          evaluate_response(HTTParty.post(configuration + path, options))
+       end
+
+       def put(path,options={})
+          evaluate_response(HTTParty.put(configuration + path, options))
+       end
+
+       def delete(path,options={})
+          evaluate_response(HTTParty.delete(configuration + path, options))
+       end
+
+      def get_dir(dir)
+        case dir
+          when :incoming, "incoming", :in, "in"
+            "in"
+          when :outgoing, "outgoing", :out, "out"
+            "out"
+          else
+            "all"
+        end
+      end
+
+      def get_algorithm(algorithm)
+        case algorithm
+          when :shortest, "shortest", :shortestPath, "shortestPath", :short, "short"
+            "shortestPath"
+          when :allSimplePaths, "allSimplePaths", :simple, "simple"
+            "allSimplePaths"
+          else
+            "allPaths"
+        end
+      end
+
+  end
+end