geoff 0.0.2.beta

data/lib/geoff/node_dsl.rb

@@ -0,0 +1,107 @@
+require 'geoff/children_dsl'
+
+class NodeDsl
+  attr_reader :node_name
+
+  def initialize(options, &block)
+    @node_name  = options[:node_name]  || 'root'
+    @klass_name = options[:klass_name] || 'ROOT'
+    @container  = options[:container]  || Container.new
+    @rel_type   = options[:rel_type]
+    @outer_binding = options[:binding]
+    @properties      = {}
+    @children_dsls = []
+
+    @rendered = false
+
+    write_mode { instance_eval(&block) } if block_given?
+  end
+
+  def to_geoff
+    geoff_lines.join "\n"
+  end
+
+  def geoff_lines
+    #we need this to prevent rendering same node which is rendered already
+    return [] if @rendered
+    @rendered = true
+
+    lines = [self_to_geoff]
+    lines << all_rule_to_geoff if use_neo4j_wrapper?
+
+    lines += @children_dsls.map(&:geoff_lines)
+
+    lines
+  end
+
+  def b
+    @container
+  end
+
+  def all_rule_to_geoff
+    "(#{@klass_name})-[:all]->(#{@node_name})"
+  end
+
+  def self_to_geoff
+    "(#{@node_name}) #{properties.to_json}"
+  end
+
+  #refactor out wrapper specific stuff later
+  def use_neo4j_wrapper?
+    true
+  end
+
+  def properties
+    if use_neo4j_wrapper?
+      { '_classname' => @klass_name }.merge @properties
+    else
+      @properties
+    end
+  end
+
+  #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.
+  #sandwich "BLT", type: :on_menu do
+  #  filling 'bacon'
+  #  filling 'lettuce'
+  #  filling 'tomato'
+  #end
+  def method_missing m, *args, &blk
+
+    if args.empty?
+      @properties[m]
+    else
+      return super unless @write_mode
+      val = if args.first.is_a? Proc
+              eval("@#{m}", @outer_binding)
+            else
+              args.first
+            end
+      @properties[m] = val
+    end
+  end
+
+  def to_s
+    to_geoff
+  end
+
+  private
+
+  def children type=nil, &block
+    options = {
+      parent_node_name: @node_name,
+      type:  type,
+      container: @container,
+      binding: @outer_binding
+    }
+
+    @children_dsls << ChildrenDsl.new(options, &block)
+  end
+end

data/lib/geoff/version.rb

@@ -0,0 +1,3 @@
+module Geoff
+  VERSION = "0.0.2.beta"
+end

data/lib/geoff.rb

@@ -0,0 +1,12 @@
+require "json"
+require "geoff/version"
+require 'geoff/node_dsl'
+require 'geoff/neo4j_wrapper_dsl'
+require 'geoff/importer'
+
+def Geoff *class_list, options, &block
+  Neo4jWrapperDsl.new(*class_list, options, &block)
+end
+
+class Geoff::Error                  < StandardError; end
+class Geoff::MissingNodeDefinition  < Geoff::Error ; end

data/spec/integration/children_dsl_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'geoff/children_dsl'
+
+describe ChildrenDsl do
+  describe 'with no special nodes' do
+    let(:children) do
+      ChildrenDsl.new({parent_node_name: 'starbucks'}) do
+        branch 'starbucks_branch_1', type: 'owns' do
+          delay_time 15
+        end
+
+        branch 'starbucks_branch_2', type: 'owns' do
+          delay_time 30
+        end
+      end
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (starbucks_branch_1) {"_classname":"Branch","delay_time":15}
+        (Branch)-[:all]->(starbucks_branch_1)
+        (starbucks)-[:owns]->(starbucks_branch_1)
+        (starbucks_branch_2) {"_classname":"Branch","delay_time":30}
+        (Branch)-[:all]->(starbucks_branch_2)
+        (starbucks)-[:owns]->(starbucks_branch_2)
+      EOS
+    end
+
+    specify do
+      geoff = children.to_geoff
+
+      geoff.should == expected_geoff
+    end
+  end
+
+  context "with missing rel type" do
+    let(:missing){ChildrenDsl.new(parent_node_name: 'starbucks')           {area 'Luton' } }
+    let(:top)    {ChildrenDsl.new(parent_node_name: 'starbucks', type: :x ){area 'Luton' } }
+    let(:on_node){ChildrenDsl.new(parent_node_name: 'starbucks')           {area 'Luton', type: :x }}
+
+    specify { ->{missing }.should     raise_error ArgumentError}
+    specify { ->{ top    }.should_not raise_error ArgumentError }
+    specify { ->{ on_node}.should_not raise_error ArgumentError }
+  end
+
+  describe 'with special node' do
+    let(:children) do
+      ChildrenDsl.new({parent_node_name: 'starbucks'}) do
+        b.luton = area 'Luton', type: 'headquarters_location' do
+          name 'LU1'
+        end
+      end
+    end
+
+    specify do
+      luton = children.b.luton
+
+      luton.node_name.should      == 'Luton'
+      luton.name.should           == 'LU1'
+    end
+  end
+end

data/spec/integration/node_dsl_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'geoff/node_dsl'
+require 'geoff'
+
+describe NodeDsl do
+  describe 'with properties and no children' do
+    let(:node) do
+      NodeDsl.new(node_name: 'starbucks_branch', klass_name: 'Branch') do
+        delay_time 15
+      end
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (starbucks_branch) {"_classname":"Branch","delay_time":15}
+        (Branch)-[:all]->(starbucks_branch)
+      EOS
+    end
+
+    specify do
+      node.to_geoff.should == expected_geoff
+    end
+  end
+
+  describe 'with children' do
+    let(:node) do
+
+      NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe') do
+        children do
+          branch 'starbucks_branch_1', type: 'owns', some: 'property' do
+            closing_buffer 30
+            delay_time 15
+            postcode 'LU1 1CN'
+            schedule 'DEFAULT_SCHEDULE'
+          end
+        end
+      end
+
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (starbucks) {"_classname":"Cafe"}
+        (Cafe)-[:all]->(starbucks)
+        (starbucks_branch_1) {"_classname":"Branch","closing_buffer":30,"delay_time":15,"postcode":"LU1 1CN","schedule":"DEFAULT_SCHEDULE"}
+        (Branch)-[:all]->(starbucks_branch_1)
+        (starbucks)-[:owns]->(starbucks_branch_1) {"some":"property"}
+      EOS
+    end
+
+    specify do
+      node.to_geoff.should == expected_geoff
+    end
+  end
+
+  describe "#with a lambda to access the outer scope" do
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (starbucks) {"_classname":"Cafe"}
+        (Cafe)-[:all]->(starbucks)
+        (starbucks_branch_1) {"_classname":"Branch","delay_time":15,"hours":"3"}
+        (Branch)-[:all]->(starbucks_branch_1)
+        (starbucks)-[:owns]->(starbucks_branch_1) {"some":"property"}
+      EOS
+    end
+
+    specify do
+      @hours = "3"
+
+      node = NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe', binding: binding) do
+        children do
+          branch 'starbucks_branch_1', type: 'owns', some: 'property' do
+            delay_time 15
+            hours ->{@hours}
+          end
+        end
+      end
+
+      node.to_s.should == expected_geoff
+    end
+  end
+
+  describe 'with non-tree graphs' do
+    let(:node) do
+
+      NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe') do
+        children do
+          b.luton = area 'luton', type: 'headquarters_location' do
+            name 'LU1'
+          end
+
+          branch 'starbucks_branch_1', type: 'owns', some: 'property' do
+            delay_time 15
+
+            children do
+              b.luton type: 'location'
+            end
+          end
+        end
+      end
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (starbucks) {"_classname":"Cafe"}
+        (Cafe)-[:all]->(starbucks)
+        (luton) {"_classname":"Area","name":"LU1"}
+        (Area)-[:all]->(luton)
+        (starbucks)-[:headquarters_location]->(luton)
+        (starbucks_branch_1) {"_classname":"Branch","delay_time":15}
+        (Branch)-[:all]->(starbucks_branch_1)
+        (starbucks_branch_1)-[:location]->(luton)
+        (starbucks)-[:owns]->(starbucks_branch_1) {"some":"property"}
+      EOS
+    end
+
+    specify do
+      geoff = node.to_geoff
+      geoff.should == expected_geoff
+    end
+
+    context "with relation type at the children level" do
+      let(:expected_geoff) do
+        strip_whitespace <<-EOS
+        (starbucks) {"_classname":"Cafe"}
+        (Cafe)-[:all]->(starbucks)
+        (luton) {"_classname":"Area","name":"LU1"}
+        (Area)-[:all]->(luton)
+        (starbucks)-[:location]->(luton)
+        EOS
+      end
+
+
+      specify do
+        node = NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe') do
+          children "location" do
+            area 'luton' do
+              name 'LU1'
+            end
+          end
+        end
+        node.to_geoff.should == expected_geoff
+      end
+    end
+
+ end
+end

data/spec/models/geoff_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path('spec/spec_helper')
+require 'neo4j'
+require 'geoff'
+
+describe Geoff do
+  class CoverageArea
+    include Neo4j::NodeMixin
+  end
+  class Cafe
+    include Neo4j::NodeMixin
+  end
+
+  class Carrier
+    include Neo4j::NodeMixin
+  end
+
+  class Branch
+    include Neo4j::NodeMixin
+  end
+  describe 'base nodes' do
+
+    let(:builder) do
+      Geoff(Cafe, Carrier, Branch, CoverageArea)
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (ROOT)-[:Cafe]->(Cafe)
+        (ROOT)-[:Carrier]->(Carrier)
+        (ROOT)-[:Branch]->(Branch)
+        (ROOT)-[:CoverageArea]->(CoverageArea)
+      EOS
+    end
+
+    specify do
+      builder.to_s.should == expected_geoff
+    end
+  end
+
+  describe 'Geoff sugar' do
+    let(:node) do
+      Geoff(Branch) do
+        branch 'starbucks_branch' do
+          delay_time 15
+        end
+      end
+    end
+
+    let(:expected_geoff) do
+      strip_whitespace <<-EOS
+        (ROOT)-[:Branch]->(Branch)
+        (starbucks_branch) {"_classname":"Branch","delay_time":15}
+        (Branch)-[:all]->(starbucks_branch)
+      EOS
+    end
+
+    specify do
+      node.to_geoff.should == expected_geoff
+    end
+
+    specify do
+      pending 'not implemented'
+      ->{
+        Geoff do
+          branch 'starbucks_branch' do
+            delay_time 15
+          end
+        end
+      }.should raise_error Geoff::MissingClassDefinition, "branch"
+    end
+  end
+end

data/spec/models/neo4j_wrapper_dsl_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path('spec/spec_helper')
+require 'neo4j'
+require './lib/geoff/neo4j_wrapper_dsl'
+
+describe Neo4jWrapperDsl do
+  let(:expected_geoff) do
+    strip_whitespace <<-EOS
+      (ROOT)-[:Sandwich]->(Sandwich)
+      (ROOT)-[:Cheese]->(Cheese)
+      (ROOT)-[:Egg]->(Egg)
+    EOS
+  end
+
+  class Sandwich
+    include Neo4j::NodeMixin
+  end
+
+  class Cafe
+    include Neo4j::NodeMixin
+  end
+
+  class Branch
+    include Neo4j::NodeMixin
+  end
+
+
+  class Cheese
+    include Neo4j::NodeMixin
+  end
+
+  class Egg
+    include Neo4j::NodeMixin
+  end
+
+
+  describe "#to_s" do
+    specify do
+      dsl = Neo4jWrapperDsl.new Sandwich, Cheese, Egg
+      dsl.to_s.should == dsl.to_geoff
+    end
+  end
+
+  describe "#to_geoff" do
+    it "outputs root node geoff syntax" do
+      dsl = Neo4jWrapperDsl.new(Sandwich, Cheese, Egg)
+      dsl.to_geoff.should == expected_geoff
+    end
+
+    specify do
+      ->{Neo4jWrapperDsl.new 2 }  .should raise_error ArgumentError
+      ->{Neo4jWrapperDsl.new '' } .should raise_error ArgumentError
+      ->{Neo4jWrapperDsl.new ['']}.should raise_error ArgumentError
+      ->{Neo4jWrapperDsl.new [1]} .should raise_error ArgumentError
+
+      ->{Neo4jWrapperDsl.new(Egg)}.should_not raise_error ArgumentError
+    end
+
+
+    context "with a block" do
+      let(:expected) {
+        strip_whitespace <<-EOS
+        (ROOT)-[:Cafe]->(Cafe)
+        (ROOT)-[:Branch]->(Branch)
+        (Starbucks) {"_classname":"Cafe"}
+        (Cafe)-[:all]->(Starbucks)
+        (starbucks_branch) {"_classname":"Branch"}
+        (Branch)-[:all]->(starbucks_branch)
+        (Starbucks)-[:owns]->(starbucks_branch)
+        EOS
+      }
+
+      specify "with parent node is root node, but no relationship,
+      don't create relationship to root node" do
+        Neo4jWrapperDsl.new(Cafe, Branch) do
+          cafe 'Starbucks' do
+            children 'owns' do
+              #create relationship to parent node of type owns (comes from children DSL)
+              branch 'starbucks_branch'
+            end
+          end
+
+        end.to_geoff.should == expected
+      end
+    end
+  end
+end

data/spec/models/neo4j_wrapper_validator_spec.rb

@@ -0,0 +1,28 @@
+require './lib/geoff'
+require './lib/geoff/neo4j_wrapper_validator'
+
+describe Neo4jWrapperValidator do
+  let(:validator) { Neo4jWrapperValidator.new }
+
+    {
+      "(Egg)-[:relates]->(1)"      => {existing_nodes: %w(Branch Starbucks Cafe), node_name: "Egg",     valid: false},
+      "((Branch)-[:relates]->(1)"   => {existing_nodes: %w(Branch Cafe Starbucks), node_name: "Branch",   valid: false},
+      "(Starbucks)-[:relates]->(1)"   => {existing_nodes: %w(Branch Cafe Starbucks), node_name: "Starbucks",  valid: true},
+      "((_Branch)-[:relates]->(1)"  => {existing_nodes: %w(Branch),                 node_name: "(_Branch", valid: false},
+      "((Bra nch)-[:relates]->(1)"  => {existing_nodes: %w(Branch Cafe),        node_name: "(Bra nch", valid: false},
+      "((Branch)-[:relates]->(1)"   => {existing_nodes: %w(Branch Cafe),        node_name: "(Branch",  valid: false},
+      "(Branch)-[:relates]->(1)"    => {existing_nodes: [],                        node_name: "Branch",   valid: false}}.each do |input, details|
+    specify do
+      valid   = details[:valid]
+      existing_nodes = details[:existing_nodes]
+      node_name = details[:node_name]
+      container = mock 'container', node_list: existing_nodes
+
+      if valid
+        validator.call(container, input).should == true
+      else
+        ->{validator.call(container, input)}.should raise_error Geoff::MissingNodeDefinition, node_name
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+
+Dir["spec/support/**/*.rb"].each {|f| require_relative File.join('..', f)}
+
+RSpec.configure do |config|
+end

data/spec/support/geof_matchers.rb

@@ -0,0 +1,51 @@
+require 'json'
+
+def parse_geoff_node(expr)
+  GeoffNodeMatcher.new(expr)
+end
+
+def parse_geoff_relation(expr)
+  GeoffRelationshipMatcher.new(expr)
+end
+
+def strip_whitespace s
+  s.gsub(/^\s*/, '').chomp
+end
+
+class GeoffNodeMatcher
+
+  @@regex = /\((\w+)\) (.*)/
+
+  def initialize(expression)
+    @@regex.match expression
+
+    @node_name = $1
+    @attributes = JSON.parse($2, symbolize_names: true)
+  rescue
+    @attributes = {}
+  end
+
+  def named?(name)
+    @node_name == name
+  end
+
+  def has_attribute?(name, value)
+    @attributes[name.to_sym] == value
+  end
+end
+
+class GeoffRelationshipMatcher
+  @@regex = /\((.*)\)-\[\:(.*)\]->\((.*)\)/
+
+  def initialize(expression)
+    @@regex.match expression
+
+    @source_name = $1
+    @relationship_name = $2
+    @dest_name = $3
+  end
+
+  def named?(name)
+    @relationship_name == name
+  end
+end