neography-batch 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+.idea
+.rvmrc
+neo4j

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in neography-batch.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    neography-batch (1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    httpclient (2.3.3)
+    json (1.8.0)
+    multi_json (1.7.7)
+    neography (1.0.10)
+      httpclient (>= 2.3.3)
+      json (>= 1.7.7)
+      multi_json (>= 1.3.2)
+      os (>= 0.9.6)
+      rubyzip (>= 0.9.7)
+    os (0.9.6)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    rubyzip (0.9.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  neography (>= 1.0.6)
+  neography-batch!
+  rake (>= 0.8.7)
+  rspec (>= 2.11)

data/README.md

@@ -0,0 +1,25 @@
+# neography-batch
+
+## Introduction
+makes neography-batches better composable
+
+TODO: writing something nice here
+
+## Installation
+TODO: Test & Describe installation
+
+## Usage
+TODO: Describe usage
+
+# Running tests
+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")
+
+# License
+TODO: Think hard about it

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'neography/tasks'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--color"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc "Run Tests"
+task :default => :spec

data/lib/neography-batch.rb

@@ -0,0 +1,3 @@
+require 'neography'
+require_relative '../lib/neography-batch/batch'
+require_relative '../lib/neography-batch/batch_reference'

data/lib/neography-batch/batch.rb

@@ -0,0 +1,95 @@
+class Batch
+  private
+  def initialize(graph_db = Neography::Rest.new, commands = [])
+    @commands = commands
+    @db = graph_db
+    yield(self) if block_given?
+
+  end
+
+  def self.get_resolved_commands(commands)
+    result = []
+    reference_and_index = {}
+
+    # write each command_or_batch and remember index of command_or_batch
+    commands.each do |command|
+      index = result.length
+      reference_and_index[command[:reference]] = index
+      result << command[:cmd]
+    end
+
+    # replace references contained in the commands with the effective index in the batch
+    result.each do |command|
+      command.each_with_index do |element, index|
+        if reference_and_index.has_key?(element)
+          command[index] = "{#{reference_and_index[element]}}"
+        end
+      end
+    end
+    result
+  end
+
+  protected
+  def commands
+    @commands
+  end
+
+  public
+  def self.unit
+    Batch.new
+  end
+
+  def add(command_or_batch)
+    if command_or_batch.class == Batch
+      bind(command_or_batch)
+    else
+      unless command_or_batch.respond_to?(:each)
+        raise StandardError, "command_or_batch must respond to :each"
+      end
+
+      reference = BatchReference.new(command_or_batch)
+      @commands << {:cmd => command_or_batch, :reference => reference}
+      reference
+    end
+  end
+
+  def find_reference
+    @commands.select { |c| !block_given? || yield(c[:cmd]) }.map { |c| c[:reference] }
+  end
+
+  alias :<< :add
+
+  def submit
+    return [] if @commands.empty?
+    command_list = Batch.get_resolved_commands(@commands)
+    result = @db.batch(*command_list)
+    if result.nil?
+      raise StandardError, "batch returned no result (nil)"
+    end
+    batch_errors = result.select { |r| r["status"] >= 400 }
+    if batch_errors.count > 0
+      raise StandardError, "batch returned one or more errors: #{batch_errors.map { |e| e["message"] }.join("|")}"
+    end
+    results = result.map { |r| r["body"] }
+    @commands.each_with_index { |c, i| c[:reference].notify_after_submit(results[i]) }
+    @commands.clear()
+    results
+  end
+
+  def bind(batch)
+    Batch.new(@db, @commands.concat(batch.commands))
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def eql?(other)
+    if other.class != self.class
+      false
+    else
+      commands.length == other.commands.length &&
+          commands.zip(other.commands).all? { |z| z[0] == z[1] }
+    end
+  end
+end

data/lib/neography-batch/batch_reference.rb

@@ -0,0 +1,31 @@
+class BatchReference
+  def initialize(command)
+    @command = command
+  end
+
+  protected
+  def after_submit_action
+    @after_submit_action
+  end
+
+  def command
+    @command
+  end
+
+  public
+  def after_submit(&after_commit_action)
+    @after_submit_action = after_commit_action
+  end
+
+  def notify_after_submit(result)
+    unless @after_submit_action.nil?
+      @after_submit_action.call(result)
+    end
+  end
+
+  def ==(other)
+    return false if other.nil?
+    @after_submit_action.equal?(other.after_submit_action) &&
+        @command.equal?(other.command)
+  end
+end

data/neography-batch.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "neography-batch"
+  s.version     = "1.0.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = "Jorg Jenni"
+  s.email       = "jorg.jenni@jennius.co.uk"
+  s.homepage    = "https://github.com/Enceradeira/neography-batch"
+  s.summary     = "Composable neography-batches"
+  s.description = "Makes neography-batches better composable (for neography-batches see https://github.com/maxdemarzi/neography/wiki/Batch)"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "neography", ">= 1.0.6"
+  s.add_development_dependency "rspec", ">= 2.11"
+  s.add_development_dependency "rake", ">= 0.8.7"
+end

data/spec/batch_spec.rb

@@ -0,0 +1,321 @@
+require_relative 'spec_helper'
+
+class Function
+  def self.persist_inserts(elements)
+    batch = Batch.new
+    elements.each do |e|
+      batch << [:create_node, e]
+    end
+    return batch
+  end
+end
+
+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
+
+describe "Batch" do
+  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 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 "when list 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

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/neography-batch'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: neography-batch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Jorg Jenni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: neography
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+description: Makes neography-batches better composable (for neography-batches see
+  https://github.com/maxdemarzi/neography/wiki/Batch)
+email: jorg.jenni@jennius.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/neography-batch.rb
+- lib/neography-batch/batch.rb
+- lib/neography-batch/batch_reference.rb
+- neography-batch.gemspec
+- spec/batch_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Enceradeira/neography-batch
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Composable neography-batches
+test_files: []