geoff 0.0.3.beta → 0.0.4

data/lib/geoff/node_dsl.rb

@@ -4,8 +4,6 @@ require 'geoff/dsl_exception_handling'
 class NodeDsl
   include DslExceptionHandling
 
-  attr_reader :node_name
-
   def initialize(options, &block)
     @node_name  = options[:node_name]  || 'root'
     @klass_name = options[:klass_name] || 'ROOT'
@@ -43,11 +41,11 @@ class NodeDsl
   end
 
   def all_rule_to_geoff
-    "(#{@klass_name})-[:all]->(#{@node_name})"
+    "(#{@klass_name})-[:all]->(#{node_name})"
   end
 
   def self_to_geoff
-    "(#{@node_name}) #{properties.to_json}"
+    "(#{node_name}) #{properties.to_json}"
   end
 
   #refactor out wrapper specific stuff later
@@ -88,14 +86,37 @@ class NodeDsl
     to_geoff
   end
 
+  def clone
+    c = self.class.new(
+      node_name:  @node_name,
+      klass_name: @klass_name,
+      container:  @container,
+      rel_type:   @rel_type,
+      target:     @target
+    )
+
+    # sort it out, instance_variable_set is probably not the best way to clone object
+    c.instance_variable_set('@properties', @properties)
+
+    children_dsls = @children_dsls.map &:clone
+    children_dsls.each {|children_dsl| children_dsl.parent_node_dsl = c}
+
+    c.instance_variable_set('@children_dsls', children_dsls)
+    c
+  end
+
+  def node_name
+    [@node_name, object_id].compact.join '_'
+  end
+
   private
 
   def children type=nil, options={}, &block
     options.merge!({
-      parent_node_name: @node_name,
-      type:  type,
-      container: @container,
-      target: @target
+      parent_node_dsl: self,
+      type:            type,
+      container:       @container,
+      target:          @target
     })
 
     @children_dsls << ChildrenDsl.new(options, &block)

data/lib/geoff/version.rb

@@ -1,3 +1,3 @@
-module Geoff
-  VERSION = "0.0.3.beta"
+class Geoff
+  VERSION = "0.0.4"
 end

data/lib/geoff.rb

@@ -1,13 +1,93 @@
 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
+require 'geoff/children_dsl'
 
 class Geoff::Error                  < StandardError; end
 class Geoff::MissingNodeDefinition  < Geoff::Error ; end
+class Geoff::ContainerLabelMissing  < Geoff::Error ; end
 class Geoff::DslSyntaxError         < Geoff::Error;  end
+
+
+class Geoff
+  attr_reader :children_dsl, :container
+
+  def initialize *classes_and_builders, &block
+    options = classes_and_builders.last.is_a?(Hash) ? classes_and_builders.pop : {}
+
+    grouped  = classes_and_builders.group_by &:class
+    classes  = grouped[Class] || {}
+    builders = grouped[Geoff] || {}
+
+    validate grouped
+
+    @container = Container.new
+
+    builders.each do |builder|
+      @container.merge builder.container
+    end
+
+    options.merge!({
+      parent_node_dsl: nil,
+      type:            nil,
+      container:       @container
+    })
+
+    @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 <=> other
+    to_geoff == other.to_geoff ? 0 : -1
+  end
+
+  def to_s
+    to_geoff
+  end
+
+  def inspect
+    "<Geoff: #{to_s}>"
+  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 grouped_classes_and_builders
+    validate_classes grouped_classes_and_builders[Class]
+
+    unknown_argument_types = grouped_classes_and_builders.keys - [Class, Geoff]
+
+    if unknown_argument_types.any?
+      formatted = unknown_argument_types.map(&:to_s).join(', ')
+      raise ArgumentError, "Unknown argument types #{formatted}"
+    end
+  end
+
+  def validate_classes 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
+
+
+def Geoff *class_list, options, &block
+  Geoff.new(*class_list, options, &block)
+end
+

data/spec/integration/children_dsl_spec.rb

@@ -2,9 +2,13 @@ require 'spec_helper'
 require 'geoff/children_dsl'
 
 describe ChildrenDsl do
+  before { stub_node_dsl_object_id }
+
+  let(:starbucks_node_dsl) { mock node_name: 'starbucks' }
+
   describe 'with no special nodes' do
     let(:children) do
-      ChildrenDsl.new({parent_node_name: 'starbucks'}) do
+      ChildrenDsl.new({parent_node_dsl: starbucks_node_dsl}) do
         branch 'starbucks_branch_1', type: 'owns' do
           delay_time 15
         end
@@ -34,9 +38,9 @@ describe ChildrenDsl do
   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 }}
+    let(:missing){ChildrenDsl.new(parent_node_dsl: starbucks_node_dsl)           {area 'Luton' } }
+    let(:top)    {ChildrenDsl.new(parent_node_dsl: starbucks_node_dsl, type: :x ){area 'Luton' } }
+    let(:on_node){ChildrenDsl.new(parent_node_dsl: starbucks_node_dsl)           {area 'Luton', type: :x }}
 
     specify { ->{missing }.should     raise_error Geoff::DslSyntaxError}
     specify { ->{ top    }.should_not raise_error  }
@@ -45,7 +49,7 @@ describe ChildrenDsl do
 
   describe 'with special node' do
     let(:children) do
-      ChildrenDsl.new({parent_node_name: 'starbucks'}) do
+      ChildrenDsl.new({parent_node_dsl: starbucks_node_dsl}) do
         b.luton = area 'Luton', type: 'headquarters_location' do
           name 'LU1'
         end

data/spec/integration/geoff_spec.rb

@@ -0,0 +1,171 @@
+require File.expand_path('spec/spec_helper')
+require 'neo4j'
+require 'geoff'
+
+describe Geoff do
+  class Branch;        include Neo4j::NodeMixin; end
+  class CoffeeMachine; include Neo4j::NodeMixin; end
+  class Grinder;       include Neo4j::NodeMixin; end
+  class Table;         include Neo4j::NodeMixin; end
+
+  describe 'injecting builders' do
+    context 'with object_id ignored' do
+      before { stub_node_dsl_object_id }
+
+      let(:builder) do
+        Geoff(
+          Branch,
+          coffee_machines_builder,
+          tables_builder
+        ) do
+          branch 'starbucks_luton_branch' do
+            delay_time 15
+
+            children do
+              b.small_coffee_machines type: 'uses', lease: '3 years'
+              b.tables type: 'has'
+            end
+          end
+
+          branch 'starbucks_reading_branch' do
+            delay_time 10
+
+            children do
+              b.large_coffee_machines type: 'uses', lease: '3 years'
+              b.tables type: 'has'
+              table 'octagonal_table', type: 'has' do
+                capacity 8
+              end
+            end
+          end
+        end
+      end
+
+      let(:coffee_machines_builder) do
+        Geoff(CoffeeMachine) do
+          b.large_coffee_machines = children do
+            coffee_machine('large_illy'  ) { power 2300 }
+            coffee_machine('large_gaggia') { power 2600 }
+          end
+
+          b.small_coffee_machines = children do
+            coffee_machine('small_illy'  ) { power 600 }
+            coffee_machine('small_gaggia') { power 750 }
+          end
+        end
+      end
+
+      let(:tables_builder) do
+        Geoff(Table) do
+          b.tables = children do
+            table('round_table' ) { capacity 3 }
+            table('square_table') { capacity 4 }
+          end
+        end
+      end
+
+      let(:expected_geoff) do
+        strip_whitespace <<-EOS
+          (ROOT)-[:Branch]->(Branch)
+          (starbucks_luton_branch) {"_classname":"Branch","delay_time":15}
+          (Branch)-[:all]->(starbucks_luton_branch)
+          (small_illy) {"_classname":"CoffeeMachine","power":600}
+          (CoffeeMachine)-[:all]->(small_illy)
+          (starbucks_luton_branch)-[:uses]->(small_illy) {"lease":"3 years"}
+          (small_gaggia) {"_classname":"CoffeeMachine","power":750}
+          (CoffeeMachine)-[:all]->(small_gaggia)
+          (starbucks_luton_branch)-[:uses]->(small_gaggia) {"lease":"3 years"}
+          (round_table) {"_classname":"Table","capacity":3}
+          (Table)-[:all]->(round_table)
+          (starbucks_luton_branch)-[:has]->(round_table)
+          (square_table) {"_classname":"Table","capacity":4}
+          (Table)-[:all]->(square_table)
+          (starbucks_luton_branch)-[:has]->(square_table)
+          (starbucks_reading_branch) {"_classname":"Branch","delay_time":10}
+          (Branch)-[:all]->(starbucks_reading_branch)
+          (large_illy) {"_classname":"CoffeeMachine","power":2300}
+          (CoffeeMachine)-[:all]->(large_illy)
+          (starbucks_reading_branch)-[:uses]->(large_illy) {"lease":"3 years"}
+          (large_gaggia) {"_classname":"CoffeeMachine","power":2600}
+          (CoffeeMachine)-[:all]->(large_gaggia)
+          (starbucks_reading_branch)-[:uses]->(large_gaggia) {"lease":"3 years"}
+          (round_table) {"_classname":"Table","capacity":3}
+          (Table)-[:all]->(round_table)
+          (starbucks_reading_branch)-[:has]->(round_table)
+          (square_table) {"_classname":"Table","capacity":4}
+          (Table)-[:all]->(square_table)
+          (starbucks_reading_branch)-[:has]->(square_table)
+          (octagonal_table) {"_classname":"Table","capacity":8}
+          (Table)-[:all]->(octagonal_table)
+          (starbucks_reading_branch)-[:has]->(octagonal_table)
+        EOS
+      end
+
+      specify do
+        geoff = builder.to_geoff
+        geoff.should == expected_geoff
+      end
+    end
+
+    context 'with object_id sequence' do
+      class NodeDsl
+        def self.object_id node_dsl
+          @object_ids ||= {}
+          @object_id ||= 0
+
+          @object_id += 1
+          @object_ids[node_dsl] ||= @object_id
+        end
+
+        def object_id
+          self.class.object_id self
+        end
+      end
+
+      let(:builder) do
+        Geoff(
+          Branch,
+          coffee_machines_builder
+        ) do
+          branch 'starbucks_luton_branch' do
+            children do
+              b.coffee_machine type: 'uses', lease: '3 years'
+            end
+          end
+        end
+      end
+
+      let(:coffee_machines_builder) do
+        Geoff(CoffeeMachine) do
+          b.coffee_machine = coffee_machine('illy') do
+            power 2300
+
+            children 'includes' do
+              grinder 'fine_grinder'
+            end
+          end
+        end
+      end
+
+      let(:expected_geoff) do
+        strip_whitespace <<-EOS
+          (ROOT)-[:Branch]->(Branch)
+          (starbucks_luton_branch_1) {"_classname":"Branch"}
+          (Branch)-[:all]->(starbucks_luton_branch_1)
+          (illy_3) {"_classname":"CoffeeMachine","power":2300}
+          (CoffeeMachine)-[:all]->(illy_3)
+          (fine_grinder_5) {"_classname":"Grinder"}
+          (Grinder)-[:all]->(fine_grinder_5)
+          (illy_3)-[:includes]->(fine_grinder_5)
+          (starbucks_luton_branch_1)-[:uses]->(illy_3) {"lease":"3 years"}
+        EOS
+      end
+
+      specify do
+        geoff = builder.to_geoff
+        geoff.should == expected_geoff
+      end
+    end
+
+  end
+end

data/spec/integration/node_dsl_spec.rb

@@ -3,6 +3,8 @@ require 'geoff/node_dsl'
 require 'geoff'
 
 describe NodeDsl do
+  before { stub_node_dsl_object_id }
+
   describe 'with properties and no children' do
     let(:node) do
       NodeDsl.new(node_name: 'starbucks_branch', klass_name: 'Branch') do
@@ -23,21 +25,6 @@ describe NodeDsl do
   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"}
@@ -48,8 +35,47 @@ describe NodeDsl do
       EOS
     end
 
-    specify do
-      node.to_geoff.should == expected_geoff
+    context 'having properties defined at node level' 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
+
+      specify do
+        node.to_geoff.should == expected_geoff
+      end
+    end
+
+    context 'having properties defined at children level' do
+      let(:node) do
+
+        NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe') do
+          children 'owns', some: 'property' do
+            branch 'starbucks_branch_1' do
+              closing_buffer 30
+              delay_time 15
+              postcode 'LU1 1CN'
+              schedule 'DEFAULT_SCHEDULE'
+            end
+          end
+        end
+
+      end
+
+      specify do
+        pending 'properties at children level get ignored'
+        node.to_geoff.should == expected_geoff
+      end
     end
   end
 
@@ -81,25 +107,6 @@ describe NodeDsl do
   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"}
@@ -114,12 +121,34 @@ describe NodeDsl do
       EOS
     end
 
-    specify do
-      geoff = node.to_geoff
-      geoff.should == expected_geoff
+    context 'and relationship type at node level' 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
+
+      specify do
+        geoff = node.to_geoff
+        geoff.should == expected_geoff
+      end
     end
+  end
 
-    context "with relation type at the children level" do
+  context "with relation type at the children level" do
+    context 'and tree graph' do
       let(:expected_geoff) do
         strip_whitespace <<-EOS
         (starbucks) {"_classname":"Cafe"}
@@ -130,7 +159,6 @@ describe NodeDsl do
         EOS
       end
 
-
       specify do
         node = NodeDsl.new(node_name: 'starbucks', klass_name: 'Cafe') do
           children "location" do
@@ -142,6 +170,34 @@ describe NodeDsl do
         node.to_geoff.should == expected_geoff
       end
     end
+  end
 
- end
+  # Cloning nodes is needed for injecting same builder multiple times.
+  describe '#clone' 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
+
+    specify do
+      geoff = node.to_geoff
+      geoff_of_clone = node.clone.to_geoff
+
+      geoff.should == geoff_of_clone
+    end
+
+    specify do
+      node.should_not == node.clone
+    end
+  end
 end

data/spec/models/container_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('spec/spec_helper')
+require 'geoff'
+require 'geoff/container'
+
+describe Container do
+  subject(:container) { Container.new }
+
+  context 'attempt to access missing key' do
+    specify do
+      lambda do
+        container.egg
+      end.should raise_error Geoff::ContainerLabelMissing
+    end
+  end
+
+  context '#merge' do
+    let(:other_container) do
+      Container.new(node_dsls: {egg: 'cheese'})
+    end
+
+    specify do
+      container.merge other_container
+
+      container.node_dsls[:egg].should == 'cheese'
+    end
+  end
+end