n4j 0.0.1

data/lib/n4j/field.rb

@@ -0,0 +1,26 @@
+module N4j::Field
+  extend ActiveSupport::Concern
+  included do
+  end
+  module ClassMethods
+    def field(name)
+      define_method name do
+        data_access(name.to_s)
+      end
+      
+      define_method "#{name}=" do |value|
+        data_set(name, value)
+      end
+    end
+  end
+  
+  def data_access(key)
+    data[key]
+  end
+
+  def data_set(key, new_value)
+    new_data = data.merge({key.to_s => new_value})
+    self.data = new_data
+  end
+    
+end

data/lib/n4j/node.rb

@@ -0,0 +1,91 @@
+module N4j::Node
+  
+  autoload :AutoRelate, 'n4j/auto_relate'
+  
+  extend ActiveSupport::Concern
+  included do
+    include AutoRelate
+    # include N4j::Entity
+  end
+  module ClassMethods
+    def find(n)
+      find_by_node_id(n)
+    end
+    
+    def find_by_node_id(n)
+      find_by_path("/node/#{n}")
+    end
+    
+    def find_by_path(path)
+      path.sub!(N4j.neo4j_url_prefix,'')
+      result = N4j.batch([{:to => path, :method => 'GET'}])
+      new(result.first['body'])      
+    end
+    
+    def service_root
+      find_by_node_id(0)
+    end
+  end
+
+  def initialize(hsh)
+    super(hsh)
+    unless N4j.neo4j_hash?(hsh)
+      self.data = hsh.dup
+    end
+  end
+
+  def create_path
+    '/node'
+  end
+
+  def body_hash
+    data
+  end
+
+  def dependent
+    relationships
+  end
+
+  def connected_unsaved
+    new_relationships
+  end
+
+  def post_save
+    clear_new_relationships!
+  end
+
+  def relationships(direction = 'all_relationships', types = [], clear_cache = false)
+    @relationship_cache ||= {}
+    if persisted?
+      path = from_neo4j_relative[direction] + '/' + [types].flatten.join('&')
+      @relationship_cache.delete(path) if clear_cache
+      @relationship_cache[path] ||= GenericRelationship.find_by_node_path(path)
+    else
+      []
+    end
+  end
+
+  def entity_type
+    'node'
+  end
+
+  def traverse(opts = {})
+    # Started this approach, stoppedto investigate Cypher
+    defaults = {:start => path, :instantiate_with => self.class }
+    N4j::Traversal.new(:start => path)
+  end
+
+  def cypher(opts = {})
+    defaults = {:start => self}
+    N4j::Cypher.new(defaults.merge(opts))
+  end
+
+  def new_relationships
+    @new_relationships ||= []
+  end
+
+  def clear_new_relationships!
+    @new_relationships = []
+  end
+
+end

data/lib/n4j/populate.rb

@@ -0,0 +1,22 @@
+module N4j::Relationship::Populate
+  extend ActiveSupport::Concern
+  included do
+  end
+  module ClassMethods
+  end
+
+  def start
+    if super.kind_of?(String)
+      @start = GenericNode.find_by_path(super)
+    else
+      super
+    end
+  end
+  def end
+    if super.kind_of?(String)
+      @end = GenericNode.find_by_path(super)
+    else
+      super
+    end
+  end
+end

data/lib/n4j/relationship.rb

@@ -0,0 +1,47 @@
+module N4j::Relationship
+  autoload :Populate, 'n4j/populate'
+  extend ActiveSupport::Concern
+  included do
+    attr_writer :type
+    
+    attribute :start
+    attribute :end
+    include Populate
+  end
+  
+  module ClassMethods
+  end
+  
+  def initialize(hsh)
+    if N4j.neo4j_hash?(hsh)
+      super(hsh)
+    else
+      opts = HashWithIndifferentAccess.new.merge(hsh)
+      opts.each_pair do |k,v|
+        send("#{k}=",v) if %w(start end data type).include?(k)
+      end
+    end
+  end
+
+  def entity_type
+    'relationship'
+  end
+
+  def prerequisites
+    [self.start, self.end]
+  end
+
+  def create_path
+    start.from_neo4j_relative['create_relationship'] ||
+    "#{start.path}/relationships"
+  end
+
+  def body_hash
+    {:to => self.end.path, :data => data, :type => type}
+  end
+
+  def type
+    @type ||= self.class.model_name.i18n_key
+  end
+    
+end

data/lib/n4j/representation.rb

@@ -0,0 +1,63 @@
+module N4j::Entity::Representation
+  extend ActiveSupport::Concern
+  included do
+    include Comparable
+  end
+  module ClassMethods
+  end
+
+  def <=>(another_object)
+    if self.class.ancestors.include?(N4j::Entity)
+      url <=> another_object.url
+    else
+      super(another_object)
+    end
+  end
+
+  def to_key
+    persisted? ? [path[/\d+\Z/]] : nil
+  end
+
+  def url
+    from_neo4j['self']
+  end
+
+  def path
+    from_neo4j_relative['self'] ||
+    (place_in_batch ? "{#{place_in_batch}}" : nil)
+  end
+
+  def create_path
+    raise 'Override in Node/Relationship'
+  end
+
+  def update_path
+    from_neo4j_relative['properties']
+  end
+
+  def body_hash
+    raise 'Override in Node/Relationship'
+  end
+
+  def persist_hash(opts = {})
+    if needs_persist?
+      persisted? ? update_hash(opts) : create_hash(opts)
+    end
+  end
+
+  def create_hash(opts={})
+    { :to => create_path, :method => 'POST', :body => body_hash }.merge(opts)
+  end
+
+  def update_hash(opts={})
+    {:to => update_path, :method => 'PUT', :body => body_hash}.merge(opts)
+  end
+
+  def destroy_hash(opts={})
+    {:to => path, :method => 'DELETE'}.merge(opts)
+  end
+
+  def show_hash(opts={})
+    {:to => path, :method => 'GET'}.merge(opts)
+  end
+end

data/lib/n4j/request.rb

@@ -0,0 +1,39 @@
+module N4j::Request
+  extend ActiveSupport::Concern
+  included do
+  end
+  module ClassMethods
+    def neo4j_url_prefix
+      @neo4j_url_prefix ||= "http://localhost:#{port}/db/data"
+    end
+
+    def port
+      config = YAML.load_file("#{Rails.root}/config/n4j.yml")
+      config[Rails.env]['port']
+    end
+
+    def neo4j_hash?(hsh)
+      hsh && hsh['self'] && hsh['property'] && hsh['properties']
+    end
+
+    def batch(commands) # [{'to'=> '', 'method' => '', 'body' => '', 'id' => 0},...]
+      commands.flatten!
+      commands.each_with_index {|command, index| command[:id] ||= index }
+      # puts "Batch job: #{commands.inspect}"
+      begin
+        result = RestClient.post("#{neo4j_url_prefix}/batch",
+                                  commands.to_json,
+                                  :accept => :json,
+                                  :content_type => :json)
+        JSON.parse(result)
+      rescue RestClient::InternalServerError => e
+        message = JSON.parse(JSON.parse(e.response)['message'])['message']
+        exception = JSON.parse(JSON.parse(e.response)['message'])['exception']
+        puts "Neo4j error: #{message}" if message
+        puts "Neo4j excpetion: #{exception}" if exception
+      rescue JSON::ParserError => e
+        puts "JSON::ParserError ... raw result:\n #{result}"
+      end
+    end
+  end
+end

data/lib/n4j/traversal.rb

@@ -0,0 +1,62 @@
+class N4j::Traversal
+  PARAMETERS = [:order, :uniqueness, :return_filter, :prune_evaluator, :relationships, :max_depth]
+  attr_accessor *PARAMETERS
+  attr_accessor :start, :return_type
+  
+  def initialize(opts ={})
+    opts.each_pair do |k,v|
+      send "#{k}=", v if respond_to?("#{k}=")
+    end
+  end
+  
+  def return_type
+    @return_type || 'node'
+  end
+  
+  def outbound(type)
+    self.relationships ||= []
+    self.relationships << {'direction' => 'out', 'type' => type}
+    self
+  end
+  
+  def inbound(type)
+    self.relationships ||= []
+    self.relationships << {'direction' => 'in', 'type' => type}
+    self
+  end
+  
+  # {
+  #   "order" : "breadth_first",
+  #   "return_filter" : {
+  #     "body" : "position.endNode().getProperty('name').toLowerCase().contains('t')",
+  #     "language" : "javascript"
+  #   },
+  #   "prune_evaluator" : {
+  #     "body" : "position.length() > 10",
+  #     "language" : "javascript"
+  #   },
+  #   "uniqueness" : "node_global",
+  #   "relationships" : [ {
+  #     "direction" : "all",
+  #     "type" : "knows"
+  #   }, {
+  #     "direction" : "all",
+  #     "type" : "loves"
+  #   } ],
+  #   "max_depth" : 3
+  # }
+  
+  def traversal
+    # {"relationships" => [{'direction' => 'in', 'type' => 'is_a' }]}
+    self.class::PARAMETERS.inject({}) do |sum, n|
+      key = :"@#{n}"
+      val = instance_variable_defined?(key) && instance_variable_get(key)
+      sum[n] = val if val
+      sum
+    end
+  end
+  
+  def go
+    N4j.batch([{:to => "#{start}/traverse/#{return_type}", :method => 'POST', :body => traversal}])
+  end
+end

data/lib/n4j/version.rb

@@ -0,0 +1,3 @@
+module N4j
+  VERSION = "0.0.1"
+end

data/n4j.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "n4j/version"
+
+Gem::Specification.new do |s|
+  s.name        = "n4j"
+  s.version     = N4j::VERSION
+  s.authors     = ["Sam Schenkman-Moore"]
+  s.email       = ["samsm@samsm.com"]
+  s.homepage    = ""
+  s.summary     = %q{Help using Neo4j Rest server.}
+  s.description = %q{A little spiked out thing.}
+
+  s.rubyforge_project = "n4j"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "activesupport"
+  s.add_runtime_dependency "activemodel"
+end

data/tasks/n4j.rake

@@ -0,0 +1,125 @@
+require 'erb'
+
+namespace :n4j do
+  
+  desc "Bug du jour"
+  task :bug => :environment do
+    require 'n4j'
+    gn = GenericNode.new({:test => 'foo'})
+    gn.save
+    gn.data = {:test => 'bar'}
+    gn.save
+  end
+  
+  desc "Clear development database."
+  task :clear_development do
+    port = YAML.parse_file('config/n4j.yml').to_ruby['development']['port']
+    result = `curl --request DELETE http://localhost:#{port}/cleandb/all-gone`
+    puts result
+  end
+  
+  desc "Status of Neo4j servers"
+  task :status do
+    number_of_neo4j_instances = `ps aux | grep ne[o]4j | wc -l`
+    number_of_neo4j_instances.strip!
+    puts "#{number_of_neo4j_instances} total instances of Neo4j running, system wide."
+    unless number_of_neo4j_instances.to_i < 1
+      YAML.parse_file('config/n4j.yml').to_ruby.each_pair do |environment, conf|
+        pid = IO.read "tmp/pids/n4j_#{environment}_pid"
+        pid.chomp!
+        result = `ps p#{pid} | grep #{pid} | wc -l`
+        result.strip!
+        puts "#{result} instances running for #{environment} (pid: #{pid})."
+      end
+    end
+  end
+  
+  desc 'Start servers'
+  task :start do  |task_name|
+    YAML.parse_file('config/n4j.yml').to_ruby.each_pair do |environment, conf|
+      @environment = environment
+      @port        = conf['port']
+      @secure_port = conf['secure_port']
+      @server_version = 1.6
+      
+      neo4j_bin_link = `which neo4j`
+      neo4j_bin_link.chomp!
+      neo4j_bin = Pathname.new(neo4j_bin_link).realpath
+
+      libexec = Pathname.new(neo4j_bin_link).realpath.dirname.dirname
+
+      libdir     = "#{libexec}/lib"
+      syslib     = "#{libexec}/system/lib"
+      plugin_dir = "#{libexec}/plugins"
+      n4j_plugins = 'lib/n4j/neo4j_plugins'
+      # coordinator ???
+
+      class_path = [libdir, syslib, plugin_dir, n4j_plugins].collect {|dir| Dir.glob(dir + '/*.jar')}.flatten.join(':')
+
+      java_opts = "-server -XX:+DisableExplicitGC -Dorg.neo4j.server.properties=conf/neo4j-server.properties -Djava.util.logging.config.file=conf/logging.properties -Xms3m -Xmx64m"
+
+
+
+      neo4j_home     = "tmp/n4j/#{@environment}"
+
+      FileUtils.mkdir_p neo4j_home
+      FileUtils.mkdir_p "#{neo4j_home}/data/log"
+
+      FileUtils.mkdir_p 'tmp/pids'
+      pid_file = "tmp/pids/n4j_#{@environment}_pid"
+
+      java_command = `which java`
+      java_command.chomp!
+
+      system "cp lib/n4j/templates/neo4j.properties tmp/n4j/#{@environment}/"
+      system "cp lib/n4j/templates/logging.properties tmp/n4j/#{@environment}/"
+
+      system " touch #{neo4j_home}/data/log/console.log"
+
+      neo4j_server_properties = "##### Genereated file! May be overwritten. ##### \n" +
+                                ERB.new(IO.read("lib/n4j/templates/neo4j-server-#{@server_version}.properties")).result
+      neo4j_server_properties_path = "#{neo4j_home}/neo4j-server.properties"
+      File.open(neo4j_server_properties_path, 'w') {|f| f.write(neo4j_server_properties) }
+      
+      neo4j_wrapper_conf = "##### Genereated file! May be overwritten. ##### \n" +
+                           ERB.new(IO.read('lib/n4j/templates/neo4j-wrapper.conf')).result
+      neo4j_wrapper_conf_path = "#{neo4j_home}/neo4j-wrapper.conf"
+      File.open(neo4j_wrapper_conf_path, 'w') {|f| f.write(neo4j_wrapper_conf) }
+
+      launch_neo4j_command = "#{java_command} 
+          -cp #{class_path} 
+          -server 
+          -XX:+DisableExplicitGC 
+          -Dorg.neo4j.server.properties=#{neo4j_server_properties_path} 
+          -Djava.util.logging.config.file=#{neo4j_home}/logging.properties 
+          -Xms3m 
+          -Xmx64m 
+          -Dlog4j.configuration=file:#{neo4j_home}/log4j.properties 
+          -Dorg.neo4j.server.properties=#{neo4j_server_properties_path} 
+          -Djava.util.logging.config.file=#{neo4j_home}/logging.properties 
+          -Dneo4j.home=#{neo4j_home} 
+          -Dneo4j.instance=#{libexec} org.neo4j.server.Bootstrapper
+          >> #{neo4j_home}/data/log/console.log 2>&1 & echo $! > \"#{pid_file}\" 
+          "
+      # puts launch_neo4j_command
+      system launch_neo4j_command.gsub(/\n/,' ').gsub(/\s+/, ' ')
+      puts "#{environment.capitalize} Neo4j launched."
+      
+    end
+  end
+  
+  desc "Stop server"
+  task :stop do
+    YAML.parse_file('config/n4j.yml').to_ruby.each_pair do |environment, conf|
+      pid = IO.read "tmp/pids/n4j_#{environment}_pid"
+      pid.chomp!
+      result = `ps p#{pid} | grep #{pid} | wc -l`
+      if result.to_i > 0
+        Process.kill("HUP", pid.to_i)
+        puts "Killed #{environment} Neo4j."
+      else
+        puts "#{environment.capitalize} Neo4j wasn't running."
+      end
+    end
+  end
+end