neography-batch 1.0.3 → 1.0.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    neography-batch (1.0.3)
+    neography-batch (1.0.4)
 
 GEM
   remote: http://rubygems.org/

data/LICENSE

@@ -0,0 +1,15 @@
+neography-batch makes neography-batches better composable
+Copyright (C) 2013 Jorg Jenni
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -1,25 +1,96 @@
-# neography-batch
-
 ## Introduction
-makes neography-batches better composable
+Makes [neography-batches](https://github.com/maxdemarzi/neography/wiki/Batch "Neography Batch") better composable. By composing batches you can
+* reduce the number of calls to the neo4j-server and therefore reducing network latency
+* implement transactions by aggregating the results of smaller calculations into one large transactional batch
 
-TODO: writing something nice here
+```ruby
+batch_1 = Neography::Composable::Batch.new
+john = batch_1 << [:create_node, {'name' => 'john'}]
 
-## Installation
-TODO: Test & Describe installation
+batch_2 = Neography::Composable::Batch.new
+lucy = batch_2 << [:create_node, {'name' => 'lucy'}]
+
+batch_3 = Neography::Composable::Batch.new
+batch_3 << [:create_relationship, 'friend_of', john, lucy]
 
+super_batch = batch_1 << batch_2 << batch_3
+super_batch.submit()
+```
+Batches might be the foundation to more advanced concepts like [UnitOfWork](http://www.martinfowler.com/eaaCatalog/unitOfWork.html) or [Aggregates](http://en.wikipedia.org/wiki/Domain-driven_design).
+## Installation
+### Gemfile:
+Add `neography-batch` to your Gemfile:
+```ruby
+gem 'neography-batch'
+```
+And run Bundler:
+```sh
+$ bundle install
+```
+### Manually:
+Or install `neography-batch` manually:
+```sh
+$ gem install 'neography-batch'
+```
+And require the gem in your Ruby code:
+```ruby
+require 'neography-batch'
+```
 ## Usage
-TODO: Describe usage
+### Creating a batch
+A batch is be created by
+```ruby
+batch = Neography::Composable::Batch.new
+# add commands to the batch here
+```
+or
+```ruby
+batch = Neography::Composable::Batch.new do |b|
+    # add commands to the batch here
+end
+```
+See also [read and write examples](https://github.com/Enceradeira/neography-batch/blob/master/spec/examples/read_and_write_examples_spec.rb).
+### Adding commands & submitting
+```ruby
+batch << [:create_node, {'name' => 'john'}]
+batch << [:create_node, {'name' => 'lucy'}]
+batch.submit()
+```
+You can add everything that is supported by neography's-batch. See [here](https://github.com/maxdemarzi/neography/wiki/Batch) for details.
+### Aggregating & submitting
+```ruby
+super_batch = persons_batch << employee_batch << wages_batch
+super_batch.submit()
+```
+See also [reference and notification examples](https://github.com/Enceradeira/neography-batch/blob/master/spec/examples/references_and_notification_examples_spec.rb).
+### Referencing & submitting
+ ```ruby
+ibm = company_batch << [:create_node, {'name' => 'IBM'}]
+john = persons_batch << [:create_node, {'name' => 'john'}]
+lucy = persons_batch << [:create_node, {'name' => 'lucy'}]
+employee_batch <<  [:create_relationship, 'employee', ibm, john]
+employee_batch <<  [:create_relationship, 'employee', ibm, lucy]
 
-# Running tests
+super_batch = company_batch << persons_batch << employee_batch
+super_batch.submit()
+ ```
+See also [reference and notification examples](https://github.com/Enceradeira/neography-batch/blob/master/spec/examples/references_and_notification_examples_spec.rb).
+## Running tests
+### Installing & starting neo4j
 A few tests run against a neo4j-instance. This instance can be installed and run using following rake commands:
 ```sh
 rake neo4j:install                           # Install Neo4j to the neo4j directory under your project
 rake neo4j:start                             # Start Neo4j
 rake neo4j:stop                              # Stop Neo4j
 ```
+For a complete documentation see [neography's rake tasks](https://github.com/maxdemarzi/neography/wiki/Rake-tasks "Rake tasks").
+### Tests
+Tests can best be executed with:
+```sh
+rake spec
+```
+## License
+This work is licensed under [GNU General Public License (v3 or later)](http://www.gnu.org/licenses/gpl-3.0.html)
 
-For a complete documentation see [neography's rake tasks](https://github.com/maxdemarzi/neography/wiki/Rake-tasks "Rake tasks")
-
-# License
-TODO: Think hard about it
+### 3-party licenses
+* Neography - MIT, see the LICENSE file http://github.com/maxdemarzi/neography/tree/master/LICENSE.

data/lib/neography-batch/batch_reference.rb

@@ -1,3 +1,5 @@
+require_relative 'neography_context.rb'
+
 module Neography
   module Composable
     class BatchReference
@@ -21,7 +23,7 @@ module Neography
 
       def notify_after_submit(result)
         unless @after_submit_action.nil?
-          @after_submit_action.call(result)
+          NeographyContext.new(&@after_submit_action).eval(result)
         end
       end
 

data/lib/neography-batch/neography_context.rb

@@ -0,0 +1,16 @@
+module Neography
+  module Composable
+    class NeographyContext
+      include Neography::Rest::Helpers
+
+      def initialize(&block)
+        @block = block
+      end
+
+      public
+      def eval(result)
+        instance_exec(result, &@block)
+      end
+    end
+  end
+end

data/neography-batch.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "neography-batch"
-  s.version     = "1.0.3"
+  s.version     = "1.0.4"
   s.platform    = Gem::Platform::RUBY
   s.authors     = "Jorg Jenni"
   s.email       = "jorg.jenni@jennius.co.uk"

data/spec/examples/read_and_write_examples_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'read and write examples' do
+  describe 'simple write and read' do
+    it 'writes to neo4j and reads from neo4j' do
+
+      # write some data
+      batch = Neography::Composable::Batch.new
+      batch << [:create_unique_node, 'person', 'name', 'john', {'age' => 33}]
+      batch.submit()
+
+      # read data
+      read_batch = Neography::Composable::Batch.new
+      read_batch << [:get_node_index, 'person', 'name', 'john']
+      result = read_batch.submit()
+
+      # test if it worked?
+      expect(result).to have(1).item
+      expect(result.first.first['data']).to eq({'age' => 33})
+    end
+  end
+  describe 'simple write and read using a block for initialization' do
+    it 'writes to neo4j and reads from neo4j' do
+
+      # write & submit some data
+      Neography::Composable::Batch.new do |b|
+        b << [:create_unique_node, 'person', 'name', 'john', {'age' => 33}]
+      end.submit()
+
+      # read & submit
+      result = Neography::Composable::Batch.new do |b|
+        b << [:get_node_index, 'person', 'name', 'john']
+      end.submit()
+
+      # test if it worked?
+      expect(result).to have(1).item
+      expect(result.first.first['data']).to eq({'age' => 33})
+    end
+  end
+  describe 'aggregating two batches into one' do
+    it 'writes all data in one batch/transaction' do
+
+      batch1 = Neography::Composable::Batch.new do |b|
+        b << [:create_unique_node, 'person', 'name', 'john', {'age' => 33}]
+        b << [:create_unique_node, 'person', 'name', 'carl', {'age' => 45}]
+      end
+
+      batch2 = Neography::Composable::Batch.new do |b|
+        b << [:create_unique_node, 'salary', 'employee', 'john', {'wage' => 1200}]
+        b << [:create_unique_node, 'salary', 'employee', 'carl', {'wage' => 1055}]
+      end
+
+      # combining the two batches and submitting it in one transfer/transaction
+      super_batch = batch1 << batch2
+      super_batch.submit()
+
+      # test if it worked?
+      result = Neography::Composable::Batch.new do |b|
+        b << [:get_node_index, 'person', 'name', 'john']
+        b << [:get_node_index, 'person', 'name', 'carl']
+        b << [:get_node_index, 'salary', 'employee', 'john']
+        b << [:get_node_index, 'salary', 'employee', 'carl']
+      end.submit()
+
+      expect(result).to have(4).items
+      expect(result[0][0]['data']).to eq({'age' => 33})
+      expect(result[1][0]['data']).to eq({'age' => 45})
+      expect(result[2][0]['data']).to eq({'wage' => 1200})
+      expect(result[3][0]['data']).to eq({'wage' => 1055})
+    end
+  end
+end

data/spec/examples/references_and_notification_examples_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe 'references and notification examples' do
+  let(:neo) { Neography::Rest.new }
+  let(:root) { neo.get_root }
+
+  describe 'referencing nodes from different batches' do
+    it 'works perfectly' do
+      # creating a company
+      company_batch = Neography::Composable::Batch.new
+      ibm = company_batch << [:create_node, {'name' => 'IBM'}]
+      company_batch << [:create_relationship, 'company', root, ibm]
+
+      # create some persons
+      persons_batch = Neography::Composable::Batch.new
+      john = persons_batch << [:create_node, {'name' => 'john'}]
+      lucy = persons_batch << [:create_node, {'name' => 'lucy'}]
+
+      # connect persons with company
+      hr_batch = Neography::Composable::Batch.new
+      hr_batch << [:create_relationship, 'employee', ibm, john]
+      hr_batch << [:create_relationship, 'employee', ibm, lucy]
+
+      # query the inserted nodes
+      query_batch = Neography::Composable::Batch.new
+      query_batch << [:execute_query, 'start r=node(0) match r-[:company]->c-[:employee]->e return e.name']
+
+      # join batches and execute all in one go
+      super_batch = company_batch << persons_batch << hr_batch << query_batch
+      result = super_batch.submit()
+
+      # test if it worked?
+      query_result = result.last['data'].map { |r| r.first }
+      expect(query_result).to include('john')
+      expect(query_result).to include('lucy')
+    end
+  end
+
+  describe 'notification after submitting a command' do
+    it 'notifies reference with result returned from server' do
+      johns_id = nil
+
+      batch = Neography::Composable::Batch.new
+      john = batch << [:create_node, {'name' => 'john'}]
+
+      # ask for being notified after submit
+      john.after_submit do |n|
+        johns_id = get_id(n)
+      end
+
+      batch.submit()
+
+      # test if it worked?
+      johns_node = neo.get_node(johns_id)
+      expect(johns_node['data']['name']).to eq('john')
+    end
+  end
+end

data/spec/examples/showcase_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'showcase' do
+  it 'shows essential features' do
+    batch_1 = Neography::Composable::Batch.new
+    john = batch_1 << [:create_node, {'name' => 'john'}]
+
+    batch_2 = Neography::Composable::Batch.new
+    lucy = batch_2 << [:create_node, {'name' => 'lucy'}]
+
+    batch_3 = Neography::Composable::Batch.new
+    batch_3 << [:create_relationship, 'friend_of', john, lucy]
+
+    super_batch = batch_1 << batch_2 << batch_3
+    super_batch.submit()
+  end
+end

data/spec/lib/batch_reference_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Neography
+  module Composable
+    describe BatchReference do
+      describe '==' do
+        context 'different command-instances' do
+          let(:command1) { [:create, {"id" => 1}] }
+          let(:command2) { [:create, {"id" => 1}] }
+          let(:ref1) { BatchReference.new(command1) }
+          let(:ref2) { BatchReference.new(command2) }
+
+          it 'is not equal' do
+            expect(ref1).not_to eq(ref2)
+          end
+        end
+        context 'same command-instances' do
+          let(:command) { [:create, {"id" => 1}] }
+          let(:ref1) { BatchReference.new(command) }
+          let(:ref2) { BatchReference.new(command) }
+
+          it 'is equal' do
+            expect(ref1).to eq(ref2)
+          end
+          context 'same after_submit block' do
+            let(:block) { Proc.new { | |} }
+            before do
+              ref1.after_submit(&block)
+              ref2.after_submit(&block)
+            end
+
+            it 'is equal' do
+              expect(ref1).to eq(ref2)
+            end
+          end
+          context 'different after_submit block' do
+            let(:block1) { Proc.new { | |} }
+            let(:block2) { Proc.new { | |} }
+            before do
+              ref1.after_submit(&block1)
+              ref2.after_submit(&block2)
+            end
+
+            it 'is equal' do
+              expect(ref1).not_to eq(ref2)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/batch_spec.rb

@@ -0,0 +1,326 @@
+require 'spec_helper'
+
+
+module Neography
+  module Composable
+    describe Batch do
+      let(:neo) { Neography::Rest.new }
+      describe '#new' do
+        context 'without block' do
+          let(:batch) { Batch.new(neo) }
+
+          it 'is equal unit' do
+            expect(batch).to eq(Batch.unit())
+          end
+        end
+        context 'with block containing one command' do
+          let(:command) { [:command] }
+          let(:batch) do
+            Batch.new(neo) do |b|
+              b << command
+            end
+
+            it 'is equal batch with one command added' do
+              other_batch = Batch.new(neo)
+              other_batch << command
+              expect(batch).to eq(other_batch)
+            end
+          end
+        end
+      end
+      describe '==' do
+        context 'two empty batches' do
+          let(:empty_batch) { Batch.new(neo) }
+          let(:another_empty_batch) { Batch.new(neo) }
+
+          it 'are equal' do
+            expect(empty_batch).to eq(another_empty_batch)
+          end
+        end
+        context 'batch and something else' do
+          let(:batch) { Batch.new(neo) }
+          let(:something_different) { [] }
+
+          it 'are different' do
+            expect(batch).not_to eq(something_different)
+          end
+        end
+        context 'two batches with same command instances' do
+          let(:command) { [:command] }
+          let(:batch) { Batch.new(neo) { |b| b << command } }
+          let(:another_batch) { Batch.new(neo) { |b| b << command } }
+
+          it 'are equal' do
+            expect(batch).to eq(another_batch)
+          end
+        end
+        context 'two batches with different command instances' do
+          let(:batch) { Batch.new(neo) { |b| b << [:command] } }
+          let(:another_batch) { Batch.new(neo) { |b| b << [:command] } }
+
+          it 'are different' do
+            expect(batch).not_to eq(another_batch)
+          end
+        end
+        context 'batch with empty command and batch with none-empty command' do
+          let(:empty_cmd_batch) { Batch.new(neo) { |b| b << [] } }
+          let(:batch) { Batch.new(neo) { |b| b << [:command] } }
+
+          it 'are different' do
+            expect(batch).not_to eq(empty_cmd_batch)
+            expect(empty_cmd_batch).not_to eq(batch)
+          end
+        end
+        context 'empty batch and batch with one command' do
+          let(:empty_batch) { Batch.new(neo) }
+          let(:batch) { Batch.new(neo) { |b| b << [:command] } }
+
+          it 'are different' do
+            expect(batch).not_to eq(empty_batch)
+            expect(empty_batch).not_to eq(batch)
+          end
+        end
+      end
+
+      describe '#bind' do
+        context "batch" do
+          let(:command) { [[:create_node, {'id' => 7}]] }
+          let(:batch) { Batch.new(neo) { |b| b << command } }
+          context 'with unit' do
+            let(:unit) { Batch.unit() }
+
+            it 'is equal batch' do
+              expect(unit.bind(batch)).to eq(batch)
+            end
+          end
+        end
+        context 'unit' do
+          let(:unit) { Batch.unit() }
+          context 'with batch' do
+            let(:command) { [[:create_node, {'id' => 7}]] }
+            let(:batch) { Batch.new(neo) { |b| b << command } }
+
+            it 'is equal batch' do
+              expect(unit.bind(batch)).to eq(batch)
+            end
+          end
+        end
+        context 'three batches' do
+          let(:command1) { [:create_node, {'id' => 7}] }
+          let(:command2) { [:create_unique_node, {'id' => 8}] }
+          let(:command3) { [:create_node, {'id' => 9}] }
+          let(:batch1) { Batch.new(neo) { |b| b << command1 } }
+          let(:batch2) { Batch.new(neo) { |b| b << command2 } }
+          let(:batch3) { Batch.new(neo) { |b| b << command3 } }
+
+          context 'once chained and once inner bound' do
+            let(:chained_batch) { batch3.bind(batch1).bind(batch2) }
+            let(:inner_bound_batch) { batch3.bind(batch1.bind(batch2)) }
+
+            it "are equal" do
+              expect(chained_batch).to eq(inner_bound_batch)
+            end
+          end
+        end
+        context 'two batches containing commands that reference into other batch' do
+          let(:two_batches) do
+            batch1 = Batch.new(neo)
+            batch2 = Batch.new(neo)
+
+            ref11 = batch1 << [:create_node, {'id' => 1}]
+            ref12 = batch1 << [:create_node, {'id' => 2}]
+            ref21 = batch2 << [:create_node, {'id' => 3}]
+            ref22 = batch2 << [:create_node, {'id' => 4}]
+
+            batch1 << [:create_relationship, ref11, ref22, {}]
+            batch2 << [:create_relationship, ref21, ref22, {}]
+            [batch1, batch2]
+          end
+          let(:super_batch) { two_batches[1].bind(two_batches[0]) }
+
+          describe "#submit" do
+
+            it "updates references" do
+              neo.should_receive(:batch).with do |*commands|
+                commands[0].should == [:create_node, {'id' => 3}]
+                commands[1].should == [:create_node, {'id' => 4}]
+                commands[2].should == [:create_relationship, "{0}", "{1}", {}]
+                commands[3].should == [:create_node, {'id' => 1}]
+                commands[4].should == [:create_node, {'id' => 2}]
+                commands[5].should == [:create_relationship, "{3}", "{1}", {}]
+              end.and_return([])
+
+              super_batch.submit()
+            end
+          end
+        end
+      end
+      describe '#find_reference' do
+        let(:batch) { Batch.new(neo) }
+        context 'with three commands' do
+          let(:command1) { [:create_node, {'id' => 7}] }
+          let(:command2) { [:create_node, {'id' => 8}] }
+          let(:command3) { [:create_relationship, ref1, ref2, {}] }
+          let!(:ref1) { batch << command1 }
+          let!(:ref2) { batch << command2 }
+          let!(:ref3) { batch << command3 }
+
+          context 'when predicate matches one command' do
+            let!(:result) { batch.find_reference { |c| c == command2 } }
+
+            it 'returns one reference' do
+              expect(result).to have(1).item
+            end
+            it 'returns matching reference' do
+              expect(result).to include(ref2)
+            end
+          end
+
+          context 'when predicate does not match' do
+            let!(:result) { batch.find_reference { |c| false } }
+            it 'returns no reference' do
+              expect(result).to be_empty
+            end
+          end
+
+          context 'when no predicate specified' do
+            let!(:result) { batch.find_reference }
+            it 'returns all references' do
+              expect(result).to have(3).items
+            end
+          end
+        end
+      end
+      describe '<<' do
+        context 'with command' do
+          let(:command) { [:create_node] }
+          it 'behaves like add command' do
+            batch_with_add = Batch.new(neo)
+            batch = Batch.new(neo)
+
+            batch_with_add.add(command)
+            batch << command
+
+            expect(batch).to eq(batch_with_add)
+          end
+        end
+        context 'with batch' do
+          let(:another_batch) { Batch.new(neo) { |b| b << [:create_node] } }
+          it 'behaves like bind batch' do
+            batch_with_bind = Batch.new(neo)
+            batch = Batch.new(neo)
+
+            batch_with_bind.bind(another_batch)
+            batch << another_batch
+
+            expect(batch).to eq(batch_with_bind)
+          end
+        end
+      end
+
+      describe '#add' do
+        context "subclassed batch class" do
+          class SubclassedBatch < Batch
+          end
+          let(:command1) { [:create_node] }
+          let(:command2) { [:create_relationship] }
+          let(:batch) { Batch.new { |b| b << command1 } }
+          let(:subclassed_batch) { SubclassedBatch.new(neo) { |b| b << command2 } }
+
+          it "combines batches" do
+            expected_batch = Batch.new(neo) do |b|
+              b << command1
+              b << command2
+            end
+
+            result = batch.add(subclassed_batch)
+            expect(result).to eq(expected_batch)
+          end
+        end
+        context 'element that does not respond to :each' do
+          it 'raises StandardError' do
+            -> { subject.add(1) }.should raise_exception(StandardError)
+          end
+        end
+      end
+
+      describe '#submit' do
+        let(:batch) { Batch.new(neo) }
+        context 'with one added command' do
+          let(:command) { [:create_node, {'id' => 1}] }
+          before { batch.add(command) }
+
+          it 'calls neography-batch with added command' do
+            neo.should_receive(:batch).with(command).and_return([])
+
+            batch.submit()
+          end
+          context '#submit' do
+            before { batch.submit() }
+
+            it 'does nothing the second time' do
+              neo.should_not_receive(:batch)
+
+              batch.submit()
+            end
+          end
+        end
+        context 'with a relationship between two commands' do
+          let!(:ref_1) { batch << [:create_node] }
+          let!(:ref_2) { batch << [:create_node] }
+          let!(:relation) { batch << [:create_relationship, ref_2, ref_1] }
+
+          it 'resolves references to preceding commands' do
+            neo.should_receive(:batch).with do |*commands|
+              relationship_cmd = commands.select { |r| r[0]==:create_relationship }.first
+              relationship_cmd[1].should == "{1}"
+              expect(relationship_cmd[1]).to eq("{1}")
+              expect(relationship_cmd[2]).to eq("{0}")
+            end.and_return([])
+
+            batch.submit()
+          end
+        end
+        context 'with commands that trigger a server error' do
+          before do
+            # this provokes a server error, because the second create_unique_node cannot be reference in create_relationship
+            batch << [:create_unique_node, "test", "id", "1", {}]
+            batch << [:create_unique_node, "test", "id", "2", {}]
+            batch << [:create_relationship, "test", "{0}", "{1}", {}]
+          end
+          it 'raises StandardError' do
+            ->() { batch.submit() }.should raise_error(StandardError)
+          end
+        end
+        context 'with two after_submit handlers' do
+          let(:command1) { [:create_node, {'id' => 1}] }
+          let!(:reference1) { batch << command1 }
+          let(:command2) { [:create_node, {'id' => 2}] }
+          let!(:reference2) { batch << command2 }
+          it 'notifies reference1' do
+            node = nil
+            reference1.after_submit do |n|
+              node = n
+            end
+
+            batch.submit()
+
+            expect(node).not_to be_nil
+            expect(node['data']['id']).to be(command1[1]['id'])
+          end
+          it 'notifies reference2' do
+            node = nil
+            reference2.after_submit do |n|
+              node = n
+            end
+
+            batch.submit()
+
+            expect(node).not_to be_nil
+            expect(node['data']['id']).to be(command2[1]['id'])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,10 @@
-require_relative '../lib/neography-batch'
+require_relative '../lib/neography-batch'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    neo = Neography::Rest.new
+    neo.batch(
+        [:execute_query, "START n = node(*) MATCH n-[r]-() WHERE ID(n) > 0 DELETE r"],
+        [:execute_query, "START n = node(*) WHERE ID(n) > 0 DELETE n"])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neography-batch
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-22 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: neography
@@ -69,15 +69,20 @@ files:
 - .gitignore
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - lib/neography-batch.rb
 - lib/neography-batch/batch.rb
 - lib/neography-batch/batch_reference.rb
+- lib/neography-batch/neography_context.rb
 - neography-batch.gemspec
 - publish.sh
-- spec/batch_reference_spec.rb
-- spec/batch_spec.rb
+- spec/examples/read_and_write_examples_spec.rb
+- spec/examples/references_and_notification_examples_spec.rb
+- spec/examples/showcase_spec.rb
+- spec/lib/batch_reference_spec.rb
+- spec/lib/batch_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Enceradeira/neography-batch
 licenses: []

data/spec/batch_reference_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-module Neography
-  module Composable
-    describe BatchReference do
-      describe "==" do
-        specify do
-          ref1 = BatchReference.new([:create, {"id" => 1}])
-          ref2 = BatchReference.new([:create, {"id" => 1}])
-          (ref1==ref2).should be_false
-        end
-        specify do
-          command = [:create, {"id" => 1}]
-          ref1 = BatchReference.new(command)
-          ref2 = BatchReference.new(command)
-          (ref1==ref2).should be_true
-        end
-        specify do
-          command = [:create, {"id" => 1}]
-          ref1 = BatchReference.new(command)
-          ref1.after_submit do
-            puts "Do this"
-          end
-          ref2 = BatchReference.new(command)
-          ref2.after_submit do
-            puts "Do something else"
-          end
-          (ref1==ref2).should be_false
-        end
-      end
-    end
-  end
-end

data/spec/batch_spec.rb

@@ -1,336 +0,0 @@
-require_relative 'spec_helper'
-
-
-module Neography
-  module Composable
-    describe Batch do
-
-      def create_batches(command1, command2, command3)
-        batch1 = Batch.new do |b|
-          b<<command1
-        end
-
-        batch2 = Batch.new do |b|
-          b<<command2
-        end
-
-        batch3 = Batch.new do |b|
-          b<<command3
-        end
-        return batch1, batch2, batch3
-      end
-
-      let(:db) { Neography::Rest.new }
-      subject { Batch.new(db) }
-
-      describe "new" do
-        it "should create unit when no block provided" do
-          Batch.new.should == Batch.unit()
-        end
-        it "should call block with itself when block is provided" do
-          command = [:command]
-          batch_configured_without_block = Batch.new
-          batch_configured_without_block << command
-
-          batch_with_block = Batch.new do |b|
-            b << command
-          end
-
-          batch_with_block.should == batch_configured_without_block
-        end
-      end
-
-      describe "==" do
-        specify { (Batch.new==Batch.new).should be_true }
-        specify { (Batch.new==[]).should be_false }
-        specify do
-          command1 = [:command_1]
-          command2 = [:command_2]
-          batch1 = Batch.new do |b|
-            b << command1
-            b << command2
-          end
-          batch2 = Batch.new do |b|
-            b << command1
-            b << command2
-          end
-          (batch1==batch2).should be_true
-        end
-        specify do
-          batch1 = Batch.new do |b|
-            b << [:command_1]
-            b << [:command_2]
-          end
-          batch2 = Batch.new do |b|
-            b << [:command_2]
-            b << [:command_1]
-          end
-          (batch1==batch2).should be_false
-        end
-        specify do
-          batch1 = Batch.new do |b|
-            b << [:command_1, {:id => 7}]
-            b << [:command_2, {:id => 9}]
-          end
-          batch2 = Batch.new do |b|
-            b << [:command_1, {:id => 7}]
-            b << [:command_2, {:id => 8}]
-          end
-          (batch1==batch2).should be_false
-        end
-        specify do
-          batch1 = Batch.new { |b| b << [:command_1] }
-          batch2 = Batch.new { |b| b << [:command_2] }
-          (batch1==batch2).should be_false
-        end
-        specify do
-          batch1 = Batch.new { |b| b << [] }
-          batch2 = Batch.new { |b| b << [:command_2] }
-          (batch1==batch2).should be_false
-        end
-        specify do
-          batch1 = Batch.new
-          batch2 = Batch.new { |b| b << [:command_2] }
-          (batch1==batch2).should be_false
-        end
-        specify do
-          batch1 = Batch.new { |b| b << [:command_1] }
-          batch2 = Batch.new { |b| b << [] }
-          (batch1==batch2).should be_false
-        end
-      end
-
-      describe "bind" do
-        let(:command1) { [:create_node, {"id" => 7}] }
-        let(:command2) { [:create_unique_node, {"id" => 8}] }
-        let(:command3) { [:create_node, {"id" => 9}] }
-        it "on unit with f should be equal f" do
-          batch1, _, _ = create_batches(command1, command2, command3)
-
-          Batch.unit().bind(batch1).should == batch1
-        end
-
-        it "with unit should be equal Batch" do
-          batch1, _, _ = create_batches(command1, command2, command3)
-
-          batch1.bind(Batch.unit()).should == batch1
-        end
-
-        it "chained should be equal to bind with inner binds" do
-          batch1, batch2, batch3 = create_batches(command1, command2, command3)
-          result1 = batch3.bind(batch1).bind(batch2)
-
-          batch1, batch2, batch3 = create_batches(command1, command2, command3)
-          f = ->() { batch1 }
-          g = ->() { batch2 }
-          result2 = batch3.bind(batch1.bind(batch2))
-
-          result1.should == result2
-        end
-        describe "and submit" do
-          it "should combine separate batches into one batch" do
-            batch1 = Batch.new(db)
-            ref11 = batch1 << [:create_node, {"id" => 1}]
-            ref12 = batch1 << [:create_node, {"id" => 2}]
-            batch1 << [:create_relationship, ref11, ref12, {}]
-
-            batch2 = Batch.new(db)
-            ref21 = batch2 << [:create_node, {"id" => 3}]
-            ref22 = batch2 << [:create_node, {"id" => 4}]
-            batch2 << [:create_relationship, ref21, ref22, {}]
-
-            batch = batch2.bind(batch1)
-
-            db.should_receive(:batch).with do |*commands|
-              commands[0].should == [:create_node, {"id" => 3}]
-              commands[1].should == [:create_node, {"id" => 4}]
-              commands[2].should == [:create_relationship, "{0}", "{1}", {}]
-              commands[3].should == [:create_node, {"id" => 1}]
-              commands[4].should == [:create_node, {"id" => 2}]
-              commands[5].should == [:create_relationship, "{3}", "{4}", {}]
-            end.and_return([])
-
-            batch.submit()
-          end
-        end
-      end
-      describe "find_reference" do
-        it "should return reference when command is found" do
-          ref1 = subject << [:create_node, {"id" => 7}]
-          ref2 = subject << [:create_node, {"id" => 8}]
-          subject << [:create_relationship, ref2, ref1, {}]
-
-          result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
-          result.should have(1).item
-          result.should include(ref2)
-        end
-
-        it "should return empty when command is not found" do
-          result = subject.find_reference { |c| c[0] == :create_node && c[1]["id"] == 8 }
-          result.should be_empty
-        end
-
-        it "should return all reference when no predicate specified" do
-          ref1 = subject << [:create_node, {"id" => 7}]
-          ref2 = subject << [:create_node, {"id" => 8}]
-
-          result = subject.find_reference()
-          result.should have(2).item
-        end
-      end
-      describe "<<" do
-        it "should be the same as add when command is argument" do
-          command = [:create_node]
-          batch_used_with_add = Batch.new
-          batch_used_with_add.add command
-
-          subject << command
-
-          subject.should == batch_used_with_add
-        end
-        it "should be the same as bind when command is Batch" do
-          another_batch = Batch.new do |b|
-            b << [:create_node]
-          end
-          subject << [:create_node]
-
-          subject << another_batch
-
-          db.should_receive(:batch) do |*commands|
-            commands.should have(2).items
-          end.and_return([])
-          subject.submit()
-        end
-      end
-      describe "add" do
-        context "with subclassed batch class" do
-          class SubclassedBatch < Batch
-          end
-          let(:batch) { Batch.new }
-          let(:subclassed_batch) { SubclassedBatch.new }
-
-          context "combines commands" do
-            before do
-              batch << [:create_node, {"id" => 2}]
-              subclassed_batch << [:create_node, {"id" => 45}]
-            end
-            it "combines commands" do
-              batch.add(subclassed_batch)
-              batch.should have(2).commands
-            end
-          end
-
-        end
-      end
-      describe "add and submit" do
-        it "should raise exception when added element doesn't respond to :each" do
-          -> { subject.add(1) }.should raise_exception(StandardError)
-        end
-
-        it "should add command to be submitted later" do
-          command = [:create_node]
-          subject.add(command)
-
-          db.should_receive(:batch).with(command).and_return([])
-
-          subject.submit()
-        end
-
-        it "should resolve references to preceding commands" do
-          jim = subject << [:create_node]
-          john = subject << [:create_node]
-          subject << [:create_relationship, john, jim]
-
-          db.should_receive(:batch).with do |*commands|
-            relationship_cmd = commands.last
-            relationship_cmd[1].should == "{1}" # john was resolved to index where john was created
-            relationship_cmd[2].should == "{0}" # jim was resolved to index where john was created
-          end.and_return([])
-
-          subject.submit()
-        end
-
-        context "list contains 2 commands" do
-          before do
-            @john = subject.add [:create_node]
-            @markus = subject.add [:create_node]
-          end
-          context "and another command is added" do
-            let(:another_command) { [:create_relationship] }
-            before do
-              subject.add(another_command)
-            end
-            it "should contain 3 commands" do
-              db.should_receive(:batch).with do |*commands|
-                commands.should have(3).items
-              end.and_return([])
-
-              subject.submit()
-            end
-            it "should append command" do
-              db.should_receive(:batch).with do |*commands|
-                commands.last.should == another_command
-              end.and_return([])
-
-              subject.submit()
-            end
-          end
-        end
-      end
-      describe "submit" do
-        it "should raise exception when server returns error" do
-          # this provokes a server error, because the second create_unique_node cannot be reference in create_relationship
-          subject << [:create_unique_node, "test", "id", "1", {}]
-          subject << [:create_unique_node, "test", "id", "2", {}]
-          subject << [:create_relationship, "test", "{0}", "{1}", {}]
-
-          ->() { subject.submit() }.should raise_error(StandardError)
-        end
-        it "should notify reference handler" do
-          node_1_result = nil
-          node_2_result = nil
-          ref1 = subject << [:create_node, {"id" => 1}]
-          ref2 = subject << [:create_node, {"id" => 2}]
-          ref1.after_submit do |node|
-            node_1_result = node
-          end
-          ref2.after_submit do |node|
-            node_2_result = node
-          end
-
-          subject.submit()
-
-          node_1_result.should_not be_nil
-          node_2_result.should_not be_nil
-          node_1_result["data"]["id"].should == 1
-          node_2_result["data"]["id"].should == 2
-        end
-
-        it "should reset state of batch" do
-          subject << [:create_node, {"id" => 1}]
-          subject.submit()
-
-          db.should_not_receive(:batch)
-          result = subject.submit()
-          result.should be_empty
-        end
-
-        context "one create_node added" do
-          before { subject << [:create_node, {}] }
-          it "should return created node" do
-            result = subject.submit()
-            result.should have(1).items
-          end
-          it "should create-node on Db" do
-            result = subject.submit()
-
-            node = result.first
-            node_id = db.get_id(node)
-            count = db.execute_query("start s=node(#{node_id}) return count(*)")
-            count["data"][0][0].should == 1
-          end
-        end
-      end
-    end
-  end
-end