n4j 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+tmp/

data/.rvmrc

@@ -0,0 +1,2 @@
+#!/bin/bash
+rvm gemset use ${PWD##*/}

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem 'rake', '>0.9'
+
+# Specify your gem's dependencies in n4j.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,5 @@
+= N4j
+
+Some help for modeling Neo4j Rest server.
+
+Decided to rush and break this out so I could use it on several little projects.

data/Rakefile

@@ -0,0 +1,137 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = FileList['test/*_test.rb']
+  test.verbose = true
+  # test.warning = true
+end
+
+
+namespace :n4j do
+  desc "Create n4j.yml"
+  task :create_n4j_config do
+    require 'psych'
+    conf_file = Psych.dump({'development' => {'port' => 7480, 'secure_port' => 7481},
+                            'test'        => {'port' => 7481, 'secure_port' => 7483}})
+    FileUtils.mkdir_p 'config'
+    File.open('config/n4j.yml', 'w') {|f| f.write(conf_file) }
+  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_filename = "tmp/pids/n4j_#{environment}_pid"
+        if File.exist?(pid_filename)
+          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
+  end
+
+  desc 'Start servers'
+  task :start do  |task_name|
+    require 'erb'
+
+    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
+
+      java_command = `which java`
+      java_command.chomp!
+
+      libexec = Pathname.new(neo4j_bin_link).realpath.dirname.dirname
+
+      libdir      = "#{libexec}/lib"
+      syslib      = "#{libexec}/system/lib"
+      plugin_dir  = "#{libexec}/plugins"
+      n4j_plugins = 'neo4j_plugins'
+      neo4j_home  = "tmp/n4j/#{@environment}"
+      pid_file    = "tmp/pids/n4j_#{@environment}_pid"
+
+      FileUtils.mkdir_p neo4j_home
+      FileUtils.mkdir_p "#{neo4j_home}/data/log"
+      FileUtils.mkdir_p 'tmp/pids'
+
+      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"
+
+      # system "cp lib/n4j/templates/neo4j.properties tmp/n4j/#{@environment}/"
+      # system "cp lib/n4j/templates/logging.properties tmp/n4j/#{@environment}/"
+      FileUtils.cp 'templates/neo4j.properties', "tmp/n4j/#{@environment}/neo4j.properties"
+      FileUtils.cp 'templates/logging.properties', "tmp/n4j/#{@environment}/logging.properties"
+
+      FileUtils.touch "#{neo4j_home}/data/log/console.log"
+
+      neo4j_server_properties = ERB.new(IO.read("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 = ERB.new(IO.read('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}\"
+          "
+
+      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_filename = "tmp/pids/n4j_#{environment}_pid"
+      if File.exist?(pid_filename)
+        pid = IO.read pid_filename
+        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
+
+
+
+end

data/config/n4j.yml

@@ -0,0 +1,7 @@
+---
+development:
+  port: 7480
+  secure_port: 7481
+test:
+  port: 7481
+  secure_port: 7483

data/lib/n4j.rb

@@ -0,0 +1,46 @@
+require "n4j/version"
+require 'active_support/all'
+require 'active_model'
+
+module N4j
+  autoload :Attributes,   'n4j/attributes'
+  autoload :Request,      'n4j/request'
+  autoload :Entity,       'n4j/entity'
+  autoload :Node,         'n4j/node'
+  autoload :Relationship, 'n4j/relationship'
+  autoload :Field,        'n4j/field'
+  autoload :Traversal,    'n4j/traversal'
+  autoload :Cypher,       'n4j/cypher'
+
+  include Request
+
+  module Dummy
+    extend ActiveSupport::Concern
+    included do
+    end
+    module ClassMethods
+    end
+  end
+
+end
+
+class GenericNode
+  include N4j::Entity
+  include N4j::Node
+
+end
+
+class RootNode < GenericNode
+  skip_callback :initialize, :after, :relate_to_root
+end
+
+class GenericRelationship
+  include N4j::Entity
+  include N4j::Relationship
+
+  def self.find_by_node_path(path)
+    result = N4j.batch([{:to => path ,:method => 'GET'}])
+    result.first['body'].collect {|r| GenericRelationship.new(r) }
+  end
+end
+

data/lib/n4j/attributes.rb

@@ -0,0 +1,48 @@
+module N4j::Attributes
+  extend ActiveSupport::Concern
+
+  include ActiveModel::AttributeMethods
+  include ActiveModel::Dirty
+
+  included do
+    attribute_method_suffix('=')
+  end
+
+  module ClassMethods
+    def attributes
+      @attributes ||= Set.new
+    end
+
+    def attribute(name)
+      attributes << name.to_s
+      define_attribute_methods [name.to_s]
+    end
+  end
+
+  def attribute(key)
+    instance_variable_get("@#{key}")
+  end
+
+  def attribute=(key,value)
+    # puts "Setting attribute #{key}!"
+    send("#{key}_will_change!") unless value == send(key)
+    instance_variable_set("@#{key}", value)
+  end
+
+  def attributes
+    self.class.attributes.inject({}) do |hsh, attr|
+      hsh[attr] = send(attr)
+      hsh
+    end
+  end
+
+  def load_attributes(new_attributes)
+    self.place_in_batch = nil
+    self.class.attributes.each do |key|
+      unless new_attributes[key].blank?
+        value = new_attributes[key].dup
+        instance_variable_set("@#{key}", value)
+      end
+    end
+  end
+end

data/lib/n4j/auto_relate.rb

@@ -0,0 +1,41 @@
+module N4j::Node::AutoRelate
+  extend ActiveSupport::Concern
+  included do
+    define_singleton_method "#{model_name.param_key}_root" do
+      model_root
+    end
+    after_initialize :relate_to_root
+  end
+  module ClassMethods
+    def model_root
+      # Turned off cache here until I can figure out how to keep this from messing with tests.
+      # root = instance_variable_get("@#{model_root_name}")
+      # return root if root
+
+      root = follow_path_from_root || create_root_node
+      instance_variable_set("@#{model_root_name}", root)
+    end
+
+    def model_root_name
+      variable_name = model_name.param_key
+      model_root_name = "#{variable_name}_root"
+    end
+
+    def follow_path_from_root
+      service_root.relationships('outgoing_relationships', model_root_name).first.try(:end)
+    end
+
+    def create_root_node
+      node = RootNode.new({:name => model_name.human})
+      node.new_relationships << GenericRelationship.new(:start => service_root, :end => node, :type => "#{model_root_name}")
+      node.save
+      node
+    end
+  end
+
+  def relate_to_root
+    unless persisted?
+      new_relationships << GenericRelationship.new(:start => self.class.model_root, :end => self, :type => 'is_a')
+    end
+  end
+end

data/lib/n4j/cypher.rb

@@ -0,0 +1,45 @@
+class N4j::Cypher
+  PARAMETERS = [:start, :match, :where, :return]
+  attr_accessor *PARAMETERS
+  
+  def initialize(opts ={})
+    opts.each_pair do |k,v|
+      send "#{k}=", v if respond_to?("#{k}=")
+    end
+  end
+  
+  def next(type = nil) # hops?
+    start_var = start.sub(/start\s+/,'').sub(/\s*=.+/,'')
+    self.match = "match (#{start_var})-->(b)"
+    self
+  end
+  
+  def start=(entity)
+    @start = if entity.kind_of?(String)
+      entity
+    else
+      "start a = #{entity.entity_type}(#{entity.to_key.first})"
+    end
+  end
+  
+  def return
+    @return || (match && "return #{match.split(/\W+/).last}")
+  end
+  
+  def go
+    self.class.query(to_query)
+  end
+  
+  def to_query
+    raise "start must contain 'start' (currently: '#{start}')" if start && !start.index('start')
+    raise "match must contain 'match' (currently: '#{match}')" if match && !match.index('match')
+    raise "where must contain 'where' (currently: '#{where}')" if where && !where.index('where')
+    raise "return must contain 'return' (currently: '#{self.return}')" if self.return && !self.return.index('return')
+    
+    "#{start} #{match} #{where} #{self.return}"
+  end
+  
+  def self.query(query)
+    N4j.batch([{:to => '/ext/CypherPlugin/graphdb/execute_query', :method => 'POST', :body => {'query' => query}}]).first['body']
+  end
+end

data/lib/n4j/entity.rb

@@ -0,0 +1,117 @@
+module N4j
+  module Entity
+
+    autoload :Representation, 'n4j/representation'
+
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Naming
+      include ActiveModel::Conversion
+      include N4j::Attributes
+      include N4j::Field
+
+      extend ActiveModel::Callbacks
+      define_model_callbacks :initialize
+
+      include Representation
+
+      attr_accessor :from_neo4j
+      attr_accessor :destroyed
+      attribute :data
+    end
+
+    module ClassMethods
+    end
+
+    def initialize(hsh)
+      run_callbacks :initialize do
+        if N4j.neo4j_hash?(hsh)
+          load_neo4j_data(hsh)
+          load_attributes(from_neo4j)
+        end
+      end
+    end
+
+    def note_update!
+      changed_attributes.clear
+    end
+
+    def load_neo4j_data(hsh)
+      changed_attributes.clear
+      if hsh # update requests do not return data
+        self.from_neo4j = HashWithIndifferentAccess.new.merge(hsh)
+      end
+    end
+
+    def from_neo4j_relative
+      # Use try here?
+      @from_neo4j_relative ||= Hash.new do |hash,key|
+        from_neo4j &&
+        from_neo4j[key].try(:sub, /http.+\/db\/data/, '')
+      end
+    end
+
+    def persisted?
+      N4j.neo4j_hash?(from_neo4j) && !destroyed?
+    end
+
+    def needs_persist?
+      !persisted? || changed?
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def destroy
+      destroyable = destroy_bundle.select(&:persisted?)
+      commands = destroyable.collect(&:destroy_hash)
+      results = N4j.batch(commands)
+      destroy_bundle.each {|entity| entity.destroyed = true }
+    end
+
+    def save
+      updateable_bundle = create_bundle.select(&:persist_hash)
+      commands = updateable_bundle.collect {|entity| entity.persist_hash(:id => entity.place_in_batch) }
+      results = N4j.batch(commands)
+      updateable_bundle.zip(results).each do |entity,result|
+        entity.load_neo4j_data(result['body'])
+        entity.post_save
+      end
+    end
+
+    def prerequisites     ; [] ; end
+    def dependent         ; [] ; end
+    def connected_unsaved ; [] ; end
+    def post_save         ; [] ; end
+
+    # Self and related nodes/relationships
+    def create_bundle(accumulated_bundle = [])
+      unless accumulated_bundle.detect {|entity| entity == self || entity.path == path }
+        accumulated_bundle = prerequisites.inject(accumulated_bundle) {|bundle, entity| entity.create_bundle(bundle) }
+        self.place_in_batch = accumulated_bundle.length
+        accumulated_bundle << self
+        connected_unsaved.inject(accumulated_bundle) {|bundle, entity| entity.create_bundle(bundle) }
+      end
+      accumulated_bundle
+    end
+
+    def destroy_bundle(accumulated_bundle = [])
+      unless accumulated_bundle.detect {|entity| entity == self || entity.path == path }
+        accumulated_bundle = dependent.inject(accumulated_bundle) {|bundle, entity| entity.destroy_bundle(bundle) }
+        accumulated_bundle << self
+      end
+      accumulated_bundle
+    end
+
+    def place_in_batch=(num)
+      @place_in_batch = num
+    end
+
+    def place_in_batch
+      @place_in_batch
+    end
+  end
+
+end