geoff 0.0.2.beta

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,110 @@
+PATH
+  remote: .
+  specs:
+    geoff (0.2.4.beta)
+      activesupport (~> 3.2.3)
+      json
+      neo4j
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (3.2.6)
+      activemodel (= 3.2.6)
+      activesupport (= 3.2.6)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.6)
+      activesupport (= 3.2.6)
+      builder (~> 3.0.0)
+    activesupport (3.2.6)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.0.0)
+    coderay (1.0.7)
+    columnize (0.3.6)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.4)
+    json (1.7.4-java)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    method_source (0.8)
+    multi_json (1.3.6)
+    neo4j (2.0.1-java)
+      activemodel (>= 3.0.0, < 3.3)
+      neo4j-wrapper (= 2.0.1)
+      orm_adapter (>= 0.0.3)
+      railties (>= 3.0.0, < 3.3)
+    neo4j-community (1.7.1-java)
+    neo4j-core (2.0.1-java)
+      neo4j-community (>= 1.7.0)
+    neo4j-wrapper (2.0.1-java)
+      neo4j-core (= 2.0.1)
+    orm_adapter (0.3.0)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    pry (0.9.10-java)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+      spoon (~> 0.0)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    railties (3.2.6)
+      actionpack (= 3.2.6)
+      activesupport (= 3.2.6)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rbx-require-relative (0.0.9)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base (0.10.4-java)
+    slop (3.3.2)
+    spoon (0.0.1)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.15.4)
+    tilt (1.3.3)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  geoff!
+  pry
+  rspec (~> 2.11.0)
+  ruby-debug

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 David Rouchy
+
+MIT License
+
+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.md

@@ -0,0 +1,141 @@
+geoff
+=====
+
+Ruby Geoff DSL
+
+
+Preview
+=======
+
+
+```ruby
+
+#Basic tree like structure for DSL
+#the first line generates the class nodes used by Neo4jWrapper
+Geoff(Company, Person) do
+  company 'Acme' do
+    address "13 Something Road"
+
+    children :employees do
+      person 'Geoff' do
+        name 'Geoff'
+      end
+
+      person 'Nigel' do
+        name 'Nigel Small'
+      end
+    end
+  end
+
+  company 'Github' do
+    children :customers do
+      person 'Tom'
+      person 'Dick'
+      person 'Harry'
+    end
+  end
+end
+
+```
+
+```
+(ROOT)-[:Company]->(Company)
+(ROOT)-[:Person]->(Person)
+(Acme) {"_classname":"Company","address":"13 Something Road"}
+(Company)-[:all]->(Acme)
+(Geoff) {"_classname":"Person","name":"Geoff"}
+(Person)-[:all]->(Geoff)
+(Acme)-[:employees]->(Geoff)
+(Nigel) {"_classname":"Person","name":"Nigel Small"}
+(Person)-[:all]->(Nigel)
+(Acme)-[:employees]->(Nigel)
+(Github) {"_classname":"Company"}
+(Company)-[:all]->(Github)
+(Tom) {"_classname":"Person"}
+(Person)-[:all]->(Tom)
+(Github)-[:customers]->(Tom)
+(Dick) {"_classname":"Person"}
+(Person)-[:all]->(Dick)
+(Github)-[:customers]->(Dick)
+(Harry) {"_classname":"Person"}
+(Person)-[:all]->(Harry)
+(Github)-[:customers]->(Harry)
+```
+
+#Individual relationship overrides
+
+```ruby
+Geoff(Company, Person) do
+  company 'Amazon' do
+    children do
+      person 'Tom', type: :customers
+      person 'Tom', type: :supplier
+    end
+  end
+end
+```
+
+```
+(ROOT)-[:Company]->(Company)
+(ROOT)-[:Person]->(Person)
+(Amazon) {"_classname":"Company"}
+(Company)-[:all]->(Amazon)
+(Tom) {"_classname":"Person"}
+(Person)-[:all]->(Tom)
+(Amazon)-[:customers]->(Tom)
+(Tom) {"_classname":"Person"}
+(Person)-[:all]->(Tom)
+(Amazon)-[:supplier]->(Tom)
+```
+
+
+#Link arbitrary nodes in different branches of the tree
+##Uses the magic 'b' method
+
+```ruby
+Geoff(Company, Person) do
+  company 'Amazon' do
+    children 'employees' do
+      b.judas = person 'Judas'
+    end
+  end
+
+  company 'Moonlighters' do
+    children do
+      b.judas type: 'employees'
+    end
+  end
+end
+```
+
+```
+(ROOT)-[:Company]->(Company)
+(ROOT)-[:Person]->(Person)
+(Amazon) {"_classname":"Company"}
+(Company)-[:all]->(Amazon)
+(Tom) {"_classname":"Person"}
+(Person)-[:all]->(Tom)
+(Amazon)-[:employees]->(Tom)
+(Moonlighters) {"_classname":"Company"}
+(Company)-[:all]->(Moonlighters)
+(Moonlighters)-[:employees]->(Tom)
+```
+
+
+#Using the outer bindings scope
+```ruby
+@hours = SomeFancyAttributeParser.parse <<-EOF
+Monday   09:00-15:00
+Tuesday  13:00-19:00
+Saturday 09:00-16:00
+Sunday   closed
+EOF
+
+Geoff(Company, binding: binding) do
+  company 'Amazon' do
+    opening_hours ->{ @hours }
+  end
+end
+```
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/geoff.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/geoff/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["David Rouchy", "Mark Burns", "Phyo Wai Win",
+                       "Kajetan Bojko", "Volker Pacher"]
+
+  gem.email         = ["davidr@shutl.co.uk", "phyo@shutl.co.uk",
+                       "volkerpacher@gmail.com", "kai@shutl.co.uk",
+                       "markthedeveloper@gmail.com"]
+
+  gem.description   = %q{Geoff syntax builder and Neo4j batch importer}
+  gem.summary       = %q{DSL to allow easy generating of data for Neo4j}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "geoff"
+  gem.require_paths = ["lib"]
+  gem.version       = Geoff::VERSION
+
+  gem.add_dependency 'neo4j'
+  gem.add_dependency 'activesupport', '~> 3.2.3'
+  gem.add_dependency 'json'
+
+  gem.add_development_dependency 'rspec', '~>2.11.0'
+  gem.add_development_dependency 'ruby-debug'
+  gem.add_development_dependency 'pry'
+end

data/lib/geoff/children_dsl.rb

@@ -0,0 +1,110 @@
+require 'geoff/node_dsl'
+require 'geoff/container'
+require 'active_support/core_ext/string'
+
+class ChildrenDsl
+  def initialize options, &block
+    @parent_node_name = options[:parent_node_name]
+    @parent_rel_type  = options[:type]
+    @outer_binding    = options[:binding]
+    @outer_geoff      = options[:geoff]
+
+    @write_mode = false
+
+    @node_dsls = {}
+    @container = options[:container] || Container.new
+    write_mode { instance_eval(&block) }
+  end
+
+  def to_geoff
+    "#{@outer_geoff}\n#{geoff_lines.join("\n")}".strip
+  end
+
+  def geoff_lines
+    lines = []
+
+    @node_dsls.each do |node_dsl, properties|
+      lines += node_dsl.geoff_lines
+      lines << rel_geoff(node_dsl, properties) unless top_level_node?
+    end
+
+    lines
+  end
+
+  def rel_geoff node_dsl, properties
+    properties = properties.dup
+    type       = properties.delete :type
+
+    "(#{@parent_node_name})-[:#{type}]->(#{node_dsl.node_name})".tap do |r|
+      r << " #{properties.to_json}" if properties.any?
+    end
+  end
+
+  def b
+    @container.set_recipient_of_node_dsl self
+    @container
+  end
+
+  def add_node_dsl node_dsl, rel_properties
+    @node_dsls[node_dsl] = rel_properties
+  end
+
+  private
+
+  #prevent very confusing method_missing calls during debugging by
+  #only writing to the object when expected
+  def write_mode
+    @write_mode = true
+    yield
+    @write_mode = false
+  end
+
+  # e.g.
+  #company "ACME" do
+  #  children "works_at" do
+  #    employee 'Bob'
+  #    employee 'Lenny'
+  #    employee 'Tom'
+  #  end
+  #end
+  #
+  def method_missing m, *args, &blk
+    return super unless @write_mode
+    relationship, options = parse_method_missing m, *args
+
+    options.merge!(binding: @outer_binding)
+    NodeDsl.new(options, &blk).tap do |n|
+      @node_dsls[n] = relationship
+    end
+  end
+
+  def parse_method_missing m, *args
+    node_name = args.first
+    relationship = args[1] || {}
+    relationship[:type] ||= @parent_rel_type
+
+    if type_missing? relationship
+      raise ArgumentError, "Missing relationship type for node #{node_name}"
+    end
+
+    return [
+      relationship,
+
+      {
+        node_name:  node_name,
+        klass_name: m.to_s.camelize,
+        rel_type:   relationship[:type],
+        container:  @container
+      }
+    ]
+
+  end
+
+  def type_missing? r
+    !top_level_node? and !r[:type]
+  end
+
+  def top_level_node?
+    @parent_node_name == "ROOT"
+  end
+end

data/lib/geoff/container.rb

@@ -0,0 +1,21 @@
+class Container
+  def initialize validator=nil
+    @node_dsls = {}
+    @validator = validator || ->(_, _){}
+  end
+
+  def method_missing m, *args, &blk
+    if m.to_s.last == "=" # assignment
+      @node_dsls[m.to_s[0..-2]] = args.first
+    else
+      node_dsl = @node_dsls[m.to_s]
+      rel_properties = args.first
+      @recipient.add_node_dsl node_dsl, rel_properties
+      node_dsl
+    end
+  end
+
+  def set_recipient_of_node_dsl children_dsl
+    @recipient = children_dsl
+  end
+end

data/lib/geoff/importer.rb

@@ -0,0 +1,155 @@
+require 'java'
+require 'fileutils'
+Dir["lib/jars/*"].each {|file| require file }
+
+module Geoff
+  class MissingIndexedProperty < StandardError; end
+
+  class Importer
+    class << self
+
+      def import_files *files, options
+        concatenated = files.map{|f|File.read f}.join "\n"
+
+        import concatenated, options
+      end
+
+      def import_file(file, options = {})
+        rules = File.read(file)
+        import(rules, options)
+      end
+
+      def import(geoff, options = {})
+        db_path = options[:test] ? 'db/test' : 'db/development'
+
+        Neo4j::Config[:storage_path] = db_path
+
+        geoff = geoff.to_geoff unless geoff.is_a? String
+
+        geoff = geoff.split "\n" if geoff.is_a? String
+
+        new(geoff, options).go
+      end
+    end
+
+    def initialize(rules, options)
+      @rules = rules
+      @options = options
+      log @options.inspect
+    end
+
+    def go
+      raise 'Invalid rules' unless validate_rules(@rules)
+      delete_database if drop?
+
+      log 'importing the database'
+
+      import_geoff_rules @rules
+      rebuild_indexes
+
+      true
+    end
+
+    private
+
+    def delete_database
+      if testmode?
+        Neo4j::Transaction.run do
+          Neo4j.db.each_node do |n|
+            n.del unless n.neo_id == 0
+          end
+        end
+      else
+        Neo4j.db.shutdown
+        FileUtils.rm_rf Neo4j::Config[:storage_path]
+        log "restarting the database #{Neo4j::Config[:storage_path]}"
+        Neo4j.db.start
+      end
+    end
+
+    def import_geoff_rules(rules)
+      sub_graph = org.neo4j.geoff.Subgraph.new(rules)
+      node_map = { '0' => root_node }
+      org.neo4j.geoff.Geoff.insertIntoNeo4j(sub_graph, Neo4j.db.graph, node_map );
+    end
+
+    def rebuild_indexes
+      log 're-building indexes'
+      types = root_node.relationships.map { |r| Kernel.const_get(r.get_type.to_s) }
+
+      Neo4j::Transaction.run do
+        types.each do |type|
+          re_index(type)
+        end
+      end
+    end
+
+    def re_index(type)
+      log "-> re-indexing #{type}"
+      props = type.instance_variable_get(:@_decl_props)
+      indexed_props = props.find_all { |_, p| p.has_key?(:index) }
+
+      indexed_props.each do |index|
+        all = type.all
+
+        all.each do |node|
+          @current_node = node
+          @current_index = index.first
+          node.add_index index.first
+        end
+      end
+
+    rescue NativeException => e
+      log "-" * 80
+      message = "Exception during re-indexing #{type} with #{@current_node} and index #{@current_index}"
+      log message
+      log "-" * 80
+      log e.message
+      log "-" * 80
+      #raise Geoff::MissingIndexedProperty, message
+    end
+
+    def tx
+      Neo4j::Transaction.run { yield if block_given? }
+    end
+
+    def root_node
+      Neo4j.ref_node
+    end
+
+    def log(message)
+      $stdout.puts message unless silent?
+    end
+
+    def drop?
+      option_value?(:drop, false)
+    end
+
+    def silent?
+      option_value? :silent
+    end
+
+    def testmode?
+      option_value? :test
+    end
+
+    def option_value?(key, default = false)
+      @options[key].nil? ? default : @options[key]
+    end
+
+    def validate_rules(rules)
+      invalid = Array(rules).reject{ |r| validate_rule(r) }
+      invalid.each { |r| log "Rule '#{r}' is invalid" }
+      invalid.empty?
+    end
+
+    def validate_rule(rule)
+      org.neo4j.geoff.Subgraph.new(Array(rule))
+      true
+    rescue
+      false
+    end
+
+  end
+
+end

data/lib/geoff/neo4j_wrapper_dsl.rb

@@ -0,0 +1,46 @@
+require 'geoff/children_dsl'
+
+class Neo4jWrapperDsl
+  def initialize *classes, &block
+    options = classes.last.is_a?(Hash) ? classes.pop : {}
+
+    validate classes
+
+    options.merge!({
+      parent_node_name: 'ROOT',
+      type:       nil,
+      container: Container.new
+    })
+
+    @children_dsl = ChildrenDsl.new(options, &block) if block_given?
+  end
+
+  def to_geoff
+    geoff = "#{add_classes}\n"
+    geoff += @children_dsl.to_geoff if @children_dsl
+    geoff.chomp
+  end
+
+  def to_s
+    to_geoff
+  end
+
+  private
+
+  def add_classes
+    @classes.map{|c| root_to_class_as_geoff c }.join("\n")
+  end
+
+  def root_to_class_as_geoff c
+    "(ROOT)-[:#{c}]->(#{c})"
+  end
+
+  def validate classes
+    @classes = classes || []
+
+    @classes.each do |c|
+      m = "Class #{c} should include Neo4j::NodeMixin"
+      raise ArgumentError, m unless c.is_a?(Class) and c.included_modules.include? Neo4j::NodeMixin
+    end
+  end
+end

data/lib/geoff/neo4j_wrapper_validator.rb

@@ -0,0 +1,17 @@
+class Neo4jWrapperValidator
+  NODE_NAME_REGEX = /^\(([^\)]+)\)/
+
+  def call container, node
+    node_name = node.match(NODE_NAME_REGEX)[1]
+
+    unless class_present? container, node_name
+      raise Geoff::MissingNodeDefinition, node_name
+    end
+
+    true
+  end
+
+  def class_present? container, node_name
+    container.node_list.include? node_name
+  end
+end