neography-ajaycb 0.0.21

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'neography/tasks'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--color"
+  t.pattern = "spec/integration/*_spec.rb"
+end
+
+desc "Run Tests"
+task :default => :spec
+
+

data/examples/facebook.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_person(name)
+  @neo.create_node("name" => name)
+end
+
+def make_mutual_friends(node1, node2)
+  @neo.create_relationship("friends", node1, node2)
+  @neo.create_relationship("friends", node2, node1)
+end
+
+def suggestions_for(node)
+  @neo.traverse(node,"nodes", {"order" => "breadth first", 
+                                          "uniqueness" => "node global", 
+                                          "relationships" => {"type"=> "friends", "direction" => "in"}, 
+                                          "return filter" => {
+                                            "language" => "javascript",
+                                            "body" => "position.length() == 2;"},
+                                          "depth" => 2})
+end
+
+johnathan = create_person('Johnathan')
+mark      = create_person('Mark')
+phill     = create_person('Phill')
+mary      = create_person('Mary')
+luke      = create_person('Luke')
+
+make_mutual_friends(johnathan, mark)
+make_mutual_friends(mark, mary)
+make_mutual_friends(mark, phill)
+make_mutual_friends(phill, mary)
+make_mutual_friends(phill, luke)
+
+puts "Johnathan should become friends with #{suggestions_for(johnathan).map{|n| n["data"]["name"]}.join(', ')}"
+
+# RESULT
+# Johnathan should become friends with Mary, Phill

data/examples/facebook_v2.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def suggestions_for(node)
+  node.incoming(:friends).order("breadth first").uniqueness("node global").filter("position.length() == 2;").depth(2)
+end
+
+johnathan = Neography::Node.create("name" =>'Johnathan')
+mark      = Neography::Node.create("name" =>'Mark')
+phill     = Neography::Node.create("name" =>'Phill')
+mary      = Neography::Node.create("name" =>'Mary')
+luke      = Neography::Node.create("name" =>'Luke')
+
+johnathan.both(:friends) << mark
+mark.both(:friends) << mary
+mark.both(:friends) << phill
+phill.both(:friends) << mary
+phill.both(:friends) << luke
+
+puts "Johnathan should become friends with #{suggestions_for(johnathan).map{|n| n.name }.join(', ')}"
+
+# RESULT
+# Johnathan should become friends with Mary, Phill

data/examples/greatest.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'neography'
+
+def create_great(name)
+  Neography::Node.create("name" => name)
+end
+
+game      = create_great('The 1958 NFL Championship Game')
+brando    = create_great('Marlon Brando')
+alex      = create_great('Alexander the Great')
+circus    = create_great('The Ringling Bros. and Barnum and Bailey')
+beatles   = create_great('The Beatles')
+ali       = create_great('Muhammad Ali')
+bread     = create_great('Sliced Bread')
+gatsby    = create_great('The Great Gatsby')
+
+greats = [game,brando,alex,circus,beatles,ali,bread,gatsby]
+
+def as_great(great, other_greats)
+  other_greats.each do |og|
+    great.outgoing(:as_great) << og
+  end
+end
+
+greats.each do |g|
+  ogs = greats.select{|v| v != g }.sample(1 + rand(5))
+  as_great(g, ogs)
+end
+
+def the_greatest
+  neo = Neography::Rest.new
+  neo.execute_script("m = [:];
+                      c = 0;
+                      g.
+                        V.
+                        out.
+                        groupCount(m).
+                        loop(2){c++ < 1000}.iterate();
+                        
+                        m.sort{a,b -> b.value <=> a.value}.keySet().name[0];")
+end
+
+puts "The greatest is #{the_greatest}"

data/examples/linkedin.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_person(name)
+  @neo.create_node("name" => name)
+end
+
+def make_mutual_friends(node1, node2)
+  @neo.create_relationship("friends", node1, node2)
+  @neo.create_relationship("friends", node2, node1)
+end
+
+def degrees_of_separation(start_node, destination_node)
+  paths =  @neo.get_paths(start_node, destination_node, {"type"=> "friends", "direction" => "in"}, depth=4, algorithm="allSimplePaths")
+  paths.each do |p|
+   p["names"] = p["nodes"].collect {|node| @neo.get_node_properties(node, "name")["name"] }
+  end
+
+end
+
+johnathan = create_person('Johnathan')
+mark      = create_person('Mark')
+phill     = create_person('Phill')
+mary      = create_person('Mary')
+
+make_mutual_friends(johnathan, mark)
+make_mutual_friends(mark, phill)
+make_mutual_friends(phill, mary)
+make_mutual_friends(mark, mary)
+
+degrees_of_separation(johnathan, mary).each do |path|
+  puts path["names"].join(' => friends => ') 
+end
+
+# RESULT
+# Johnathan => friends => Mark => friends => Phill => friends => Mary
+# Johnathan => friends => Mark => friends => Mary

data/examples/linkedin_v2.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+johnathan = Neography::Node.create("name" =>'Johnathan')
+mark      = Neography::Node.create("name" =>'Mark')
+phill     = Neography::Node.create("name" =>'Phill')
+mary      = Neography::Node.create("name" =>'Mary')
+
+johnathan.both(:friends) << mark
+mark.both(:friends) << phill
+phill.both(:friends) << mary
+mark.both(:friends) << mary
+
+johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).nodes.each do |node|
+  puts node.map{|n| n.name }.join(' => friends => ')
+end
+
+# RESULT
+# Johnathan => friends => Mark => friends => Phill => friends => Mary
+# Johnathan => friends => Mark => friends => Mary

data/examples/traversal_example1.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_node(level, type)
+  @neo.create_node("NODE_LEVEL" => level, "TYPE" => type)
+end
+
+def create_other_node(type)
+  @neo.create_node("TYPE" => type)
+end
+
+
+def get_nodes_by_level(level, node)
+  starting_id = node["self"].split('/').last
+
+  @neo.traverse(node,"nodes", {"order" => "breadth first", 
+                                          "uniqueness" => "node global", 
+                                          "relationships" => {"type"=> "linked", "direction" => "out"}, 
+                                          "prune evaluator" => {
+                                            "language" => "javascript",
+                                            "body" => "position.startNode().hasProperty('NODE_LEVEL') 
+                                                    && position.startNode().getProperty('NODE_LEVEL')==5 
+                                                    && position.startNode().getId()!=#{starting_id};"},
+                                         "return filter" => {
+                                            "language" => "javascript",
+                                            "body" => "position.endNode().hasProperty('NODE_LEVEL') && position.endNode().getProperty('NODE_LEVEL')==5;"}})
+end
+
+node1 = create_node(5, "N")
+node2 = create_node(5, "N")
+node3 = create_node(5, "N")
+node4 = create_node(5, "N")
+node5 = create_node(5, "N")
+node6 = create_node(5, "N")
+node7 = create_node(5, "N")
+
+node8 = create_other_node("Y")
+node9 = create_other_node("Y")
+node10 = create_other_node("Y")
+
+node11 = create_node(6, "N")
+node12 = create_node(7, "N")
+node13 = create_node(8, "N")
+
+
+@neo.create_relationship("linked", node1, node2)
+@neo.create_relationship("linked", node2, node3)
+@neo.create_relationship("linked", node3, node4)
+@neo.create_relationship("linked", node4, node5)
+@neo.create_relationship("linked", node5, node6)
+@neo.create_relationship("linked", node6, node7)
+
+@neo.create_relationship("linked", node2, node8)
+@neo.create_relationship("linked", node3, node9)
+@neo.create_relationship("linked", node4, node10)
+
+@neo.create_relationship("linked", node5, node11)
+@neo.create_relationship("linked", node6, node12)
+@neo.create_relationship("linked", node7, node13)
+
+puts "The node levels returned are  #{get_nodes_by_level(5, node1).map{|n| n["data"]["NODE_LEVEL"]}.join(', ')}"
+
+# The node levels returned are  5, 5, 5, 5, 5, 5, 5

data/examples/traversal_example2.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'neography'
+
+@neo = Neography::Rest.new
+
+def create_node(name, mysql_id)
+  @neo.create_node("name" => name, "mysql_id" => mysql_id)
+end
+
+def attended(student, school, degree, graduated)
+  @neo.create_relationship("attended", student, school, {"degree" => degree, "graduated" => graduated})
+end
+
+
+def graduated_with_me(student)
+  student = student["self"].split('/').last
+  student_attended = @neo.get_node_relationships(student)[0]
+  graduated = student_attended["data"]["graduated"]
+  school = student_attended["end"].split('/').last
+ 
+  @neo.traverse(school,"nodes", {"order" => "breadth first", 
+                                          "uniqueness" => "node global", 
+                                          "relationships" => {"type"=> "attended", "direction" => "in"}, 
+                                          "return filter" => {
+                                            "language" => "javascript",
+                                            "body" => "position.length() == 1  
+                                                       && position.endNode().getId() != #{student} 
+                                                       && position.lastRelationship().getProperty(\"graduated\") == #{graduated};"}})
+end
+
+charlie = create_node("Charlie", 1)
+max     = create_node("Max",     2)
+peter   = create_node("Peter",   3)
+carol   = create_node("Carol",   3)
+tom     = create_node("Tom",     4)
+jerry   = create_node("Jerry",   5)
+larry   = create_node("Larry",   6)
+
+yale    = create_node("Yale",    7)
+harvard = create_node("Harvard", 8)
+rutgers = create_node("Rutgers", 9)
+
+attended(charlie,yale,"engineering", 2010)
+attended(max,yale,"mathematics", 2005)
+attended(peter,yale,"biology", 2010)
+attended(carol,yale,"engineering", 2010)
+attended(tom,harvard,"biology", 2008)
+attended(jerry,rutgers,"physics", 2007)
+attended(larry,rutgers,"mathematics", 2010)
+
+
+puts "Charlie graduated with #{graduated_with_me(charlie).map{|n| n["data"]["name"]}.join(', ')}"
+
+# The node levels returned are Peter, Carol

data/lib/neography.rb

@@ -0,0 +1,46 @@
+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
+  end
+end
+
+DIRECTIONS = ["incoming", "in", "outgoing", "out", "all", "both"]
+
+require 'cgi'
+require 'httparty'
+require 'json'
+require 'logger'
+require 'ostruct'
+require 'os'
+require 'zip/zipfilesystem'
+
+require 'neography/config'
+require 'neography/rest'
+require 'neography/neography'
+
+require 'neography/property_container'
+require 'neography/property'
+require 'neography/node_relationship'
+require 'neography/node_path'
+require 'neography/relationship_traverser'
+require 'neography/node_traverser'
+require 'neography/path_traverser'
+require 'neography/equal'
+require 'neography/index'
+
+require 'neography/node'
+require 'neography/relationship'
+
+require 'neography/railtie' if defined? Rails::Railtie
+
+find_and_require_user_defined_code
+

data/lib/neography/config.rb

@@ -0,0 +1,17 @@
+module Neography
+  class Config 
+    class << self; attr_accessor :protocol, :server, :port, :directory, :log_file, :log_enabled, :logger, :max_threads, :authentication, :username, :password end
+
+    @protocol = 'http://'
+    @server = 'localhost'
+    @port = 7474 
+    @directory = ''
+    @log_file = 'neography.log'
+    @log_enabled = false
+    @logger = Logger.new(@log_file) if @log_enabled
+    @max_threads = 20
+    @authentication = {}
+    @username = nil
+    @password = nil
+  end
+end

data/lib/neography/equal.rb

@@ -0,0 +1,21 @@
+module Neography
+
+  # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
+  #
+  module Equal
+    def equal?(o)
+      eql?(o)
+    end
+
+    def eql?(o)
+      return false unless o.respond_to?(:neo_id)
+      o.neo_id == neo_id
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+  end
+
+end

data/lib/neography/index.rb

@@ -0,0 +1,13 @@
+module Neography
+  module Index
+
+    def index(*args)
+
+    end
+
+    def find(*args)
+
+    end
+
+  end
+end

data/lib/neography/neography.rb

@@ -0,0 +1,10 @@
+module Neography
+
+  class << self
+
+    def ref_node(this_db = Neography::Rest.new)
+      this_db.get_root
+    end
+
+  end
+end

data/lib/neography/node.rb

@@ -0,0 +1,45 @@
+module Neography
+  class Node < PropertyContainer
+    extend  Neography::Index
+    include Neography::NodeRelationship
+    include Neography::NodePath
+    include Neography::Equal
+    include Neography::Property
+
+    attr_accessor :neo_server
+
+    class << self
+      def create(*args)
+        # the arguments can be an hash of properties to set or a rest instance
+        props = (args[0].respond_to?(:each_pair) && args[0]) || args[1]
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        node = self.new(db.create_node(props))
+        node.neo_server = db
+        node
+      end
+
+      def load(*args)
+        # the first argument can be an hash of properties to set
+        node = !args[0].is_a?(Neography::Rest) && args[0] || args[1]
+
+        # a db instance can be given, it is the first argument or the second
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        node = db.get_node(node)
+        node = self.new(node) unless node.nil?
+        node.neo_server = db unless node.nil?
+        node
+      end
+
+      #alias_method :new, :create
+    end
+
+    def del
+      self.neo_server.delete_node!(self.neo_id)
+    end
+
+    def exist?
+      !self.neo_server.get_node(self.neo_id).nil?
+    end
+
+  end
+end