pacer 0.9.1.1-java → 1.0.0-java

data/lib/pacer/graph/vertex_mixin.rb

@@ -1,119 +0,0 @@
-module Pacer
-  # This module is mixed into the raw Blueprints Vertex class from any
-  # graph implementation.
-  #
-  # Adds more convenient/rubyish methods and adds support for extensions
-  # to some methods where needed.
-  module VertexMixin
-    # Add extensions to this vertex.
-    #
-    # If any extension has a Vertex module within it, this vertex will
-    # be extended with the extension's Vertex module.
-    #
-    # @see Core::Route#add_extension
-    #
-    # @param [[extensions]] exts the extensions to add
-    # @return [Pacer::EdgeWrapper] this vertex wrapped up and including
-    #   the extensions
-    def add_extensions(exts)
-      if exts.any?
-        Wrappers::VertexWrapper.wrap(self, exts)
-      else
-        self
-      end
-    end
-
-    # Returns a human-readable representation of the vertex using the
-    # standard ruby console representation of an instantiated object.
-    # @return [String]
-    def inspect
-      "#<#{ ["V[#{element_id}]", display_name].compact.join(' ') }>"
-    end
-
-    # Returns the display name of the vertex.
-    # @return [String]
-    def display_name
-      graph.vertex_name.call self if graph and graph.vertex_name
-    end
-
-    # Deletes the vertex from its graph along with all related edges.
-    def delete!
-      graph.removeVertex element
-    end
-
-    # Copies including the vertex id unless a vertex with that id
-    # already exists.
-    # @param [Pacer::GraphMixin] target_graph
-    # @param opts for compatibility with {Pacer::EdgeMixin#clone_into}
-    # @yield [v] Optional block yields the vertex after it has been created.
-    # @return [Pacer::VertexMixin] the new vertex
-    def clone_into(target_graph, opts = nil)
-      v_idx = target_graph.index_name("tmp:v:#{graph.to_s}", :vertex, :create => true)
-      v = target_graph.vertex(element_id) || v_idx.get('id', element_id).first
-      unless v
-        v = target_graph.create_vertex element_id, properties
-        v_idx.put('id', element_id, v)
-        yield v if block_given?
-      end
-      v
-    end
-
-    # Make a new copy of the element with the next available vertex id.
-    #
-    # @param [Pacer::GraphMixin] target_graph
-    # @yield [v] Optional block yields the vertex after it has been created.
-    # @return [Pacer::VertexMixin] the new vertex
-    def copy_into(target_graph)
-      v = target_graph.create_vertex properties
-      yield v if block_given?
-      v
-    end
-
-    def raw_out_edges(*labels)
-      element.getOutEdges *labels
-    end
-
-    def raw_in_edges(*labels)
-      element.getInEdges *labels
-    end
-
-    def out_edges(*labels_and_extensions)
-      labels, exts = split_labels_and_extensions(labels_and_extensions)
-      edge_iterator(raw_out_edges(*labels).iterator, exts)
-    end
-
-    def in_edges(*labels_and_extensions)
-      labels, exts = split_labels_and_extensions(labels_and_extensions)
-      edge_iterator(raw_in_edges(*labels).iterator, exts)
-    end
-
-    def both_edges(*labels_and_extensions)
-      labels, exts = split_labels_and_extensions(labels_and_extensions)
-      ins = raw_in_edges(*labels).iterator
-      outs = raw_out_edges(*labels).iterator
-      edge_iterator(Pacer::Pipes::MultiIterator.new(ins, outs), exts)
-    end
-
-    protected
-
-    def split_labels_and_extensions(mixed)
-      labels = Set[]
-      exts = Set[]
-      mixed.each do |obj|
-        if obj.is_a? Symbol or obj.is_a? String
-          labels << obj
-        else
-          exts << obj
-        end
-      end
-      [labels, exts]
-    end
-
-    def edge_iterator(iter, exts)
-      iter.extend Pacer::Core::Route::IteratorExtensionsMixin
-      iter.graph = self.graph
-      iter.extensions = exts
-      iter
-    end
-  end
-end

data/lib/pacer/pipe/map_pipe.rb

@@ -1,36 +0,0 @@
-module Pacer::Pipes
-  class MapPipe < AbstractPipe
-    field_reader :starts
-
-    def initialize(back, block)
-      super()
-      @block = block
-      @back = back
-      @graph = back.graph if back
-      @extensions = back.extensions + [Pacer::Extensions::BlockFilterElement]
-      @is_element = @graph.element_type?(back.element_type) if @graph
-    end
-
-    def processNextStart
-      while true
-        obj = starts.next
-        begin
-          if @is_element
-            obj = obj.add_extensions(@extensions)
-            obj.back = @back
-            obj.graph = @back.graph
-          end
-        rescue
-        end
-        result = @block.call(obj)
-        return result
-      end
-    rescue NativeException => e
-      if e.cause.getClass == Pacer::NoSuchElementException.getClass
-        raise e.cause
-      else
-        raise e
-      end
-    end
-  end
-end

data/lib/pacer/pipe/variable_store_iterator_wrapper.rb

@@ -1,26 +0,0 @@
-module Pacer::Pipes
-  class VariableStoreIteratorWrapper < AbstractPipe
-
-    field_reader :starts
-    attr_accessor :vars
-
-    def initialize(pipe, vars, variable_name)
-      super()
-      setStarts pipe if pipe
-      @vars = vars
-      @variable_name = variable_name
-    end
-
-    protected
-
-    def processNextStart
-      @vars[@variable_name] = starts.next
-    rescue NativeException => e
-      if e.cause.getClass == Pacer::NoSuchElementException.getClass
-        raise e.cause
-      else
-        raise e
-      end
-    end
-  end
-end

data/lib/pacer/route/mixin/variable_route_module.rb

@@ -1,26 +0,0 @@
-module Pacer::Routes
-
-  # Adds support to a route to store a variable inline during processing. See
-  # Pacer::Routes::RouteOperations#as
-  module VariableRouteModule
-    attr_accessor :variable_name
-
-    def root?
-      false
-    end
-
-    protected
-
-    def attach_pipe(pipe)
-      Pacer::Pipes::VariableStoreIteratorWrapper.new(pipe, vars, @variable_name)
-    end
-
-    def has_routable_class?
-      false
-    end
-
-    def inspect_class_name
-      @variable_name.inspect
-    end
-  end
-end

data/lib/pacer/side_effect/section.rb

@@ -1,25 +0,0 @@
-module Pacer
-  module Routes
-    module RouteOperations
-      def section(section_name = nil)
-        chain_route side_effect: :section, section_name: section_name
-      end
-    end
-  end
-
-  module SideEffect
-    module Section
-      attr_accessor :section_name
-
-      protected
-
-      attr_reader :section_visitor
-
-      def attach_pipe(end_pipe)
-        @section_visitor = pipe = Pacer::Pipes::SimpleVisitorPipe.new
-        pipe.setStarts end_pipe if end_pipe
-        pipe
-      end
-    end
-  end
-end

data/lib/pacer/support/iterator_mixins.rb

@@ -1,110 +0,0 @@
-module Pacer::Core::Route
-  # This mixin allows an iterator to be returned from methods that perform a
-  # transformation on the elements in their collection. Set the block property
-  # to the proc that does the transformation.
-  module IteratorBlockMixin
-    attr_accessor :graph
-
-    # Set the block that does the transformation.
-    def block=(block)
-      @block = block
-    end
-
-    def next
-      item = super
-      item.graph ||= @graph
-      @block.call(item)
-    end
-  end
-
-  module IteratorPathMixin
-    attr_accessor :graph
-
-    def next
-      super.collect do |e|
-        e.graph ||= @graph if e.respond_to? :graph=
-        e
-      end
-    end
-  end
-
-  module IteratorExtensionsMixin
-    attr_accessor :graph, :extensions
-
-    def next
-      item = super
-      # TODO: optimize this (and other) check:
-      #   - exception?
-      #   - type check?
-      #   - method check?
-      #   - ...?
-      if item.respond_to? :graph=
-        item = item.add_extensions @extensions
-        item.graph ||= @graph
-      end
-      item
-    end
-  end
-
-  module IteratorWrapperMixin
-    attr_reader :graph, :extensions, :wrapper
-
-    def wrapper=(w)
-      @base_wrapper = w
-      @wrapper = build_wrapper?
-      @set_graph = set_graph?
-    end
-
-    def graph=(g)
-      @graph = g
-      @wrapper = build_wrapper?
-      @set_graph = set_graph?
-    end
-
-    def extensions=(exts)
-      @extensions = exts
-      @wrapper = build_wrapper?
-      @set_graph = set_graph?
-    end
-
-    def build_wrapper?
-      @base_wrapper = nil unless defined? @base_wrapper
-      @extensions = nil unless defined? @extensions
-      if @base_wrapper and @extensions
-        @wrapper = @base_wrapper.wrapper_for(@base_wrapper.extensions + @extensions.to_a)
-      elsif @base_wrapper
-        @wrapper = @base_wrapper
-      elsif @extensions
-        # We don't know what type of wrapper to create
-      end
-    end
-
-    if RUBY_VERSION =~ /^1\.8\./
-      def set_graph?
-        graph and wrapper and wrapper.instance_methods.include?('graph=')
-      end
-    else
-      def set_graph?
-        graph and wrapper and wrapper.instance_methods.include?(:graph=)
-      end
-    end
-
-    def next
-      item = wrapper.new(super)
-      item.graph ||= graph if @set_graph
-      item
-    end
-  end
-
-  module IteratorMixin
-    attr_accessor :graph
-
-    def next
-      item = super
-      if item.respond_to? :graph=
-        item.graph ||= @graph
-      end
-      item
-    end
-  end
-end

data/lib/pacer/wrappers/new_element.rb

@@ -1,106 +0,0 @@
-module Pacer::Wrappers
-  class NewElement
-    include Pacer::Element
-
-    def initialize
-      @properties = {}
-      @out_edges = []
-      @in_edges = []
-    end
-
-    def getId
-      nil
-    end
-    alias get_id getId
-
-    def getPropertyKeys
-      @properties.keys
-    end
-    alias property_keys getPropertyKeys
-
-    def getProperty(prop)
-      @properties[prop]
-    end
-    alias get_property getProperty
-
-    def setProperty(prop, value)
-      @properties[prop] = value
-    end
-    alias set_property setProperty
-
-    def removeProperty(prop)
-      @properties.delete prop
-    end
-    alias remove_property removeProperty
-
-    def graph
-      @graph
-    end
-
-    def graph=(graph)
-      @graph = graph
-    end
-
-    def <=>(other)
-      object_id <=> other.object_id
-    end
-
-    def ==(other)
-      equal? other
-    end
-  end
-
-  class NewVertex < NewElement
-    include Pacer::Vertex
-
-    def getOutEdges(*args)
-      @out_edges
-    end
-    alias out_edges getOutEdges
-    alias get_out_edges getOutEdges
-
-    def getInEdges(*args)
-      @in_edges
-    end
-    alias in_edges getInEdges
-    alias get_in_edges getInEdges
-
-    def getRawVertex
-      self
-    end
-    alias raw_vertex getRawVertex
-  end
-
-  class NewEdge < NewElement
-    include Pacer::Edge
-
-    def getInVertex
-      @in_vertex
-    end
-    alias in_vertex getInVertex
-    alias inVertex getInVertex
-
-    def getOutVertex
-      @out_vertex
-    end
-    alias out_vertex getOutVertex
-    alias outVertex getOutVertex
-
-    def getLabel
-      @label
-    end
-    alias get_label getLabel
-    alias label getLabel
-
-    def setLabel(label)
-      @label = label
-    end
-    alias set_label setLabel
-    alias label= setLabel
-
-    def getRawEdge
-      self
-    end
-    alias raw_edge getRawEdge
-  end
-end

data/spec/pacer/graph/edge_mixin_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for Pacer::EdgeMixin do
-  use_simple_graph_data
-
-  describe '#e' do
-    subject { e0.e }
-    it { should be_an_edges_route }
-    it { should_not be_a(graph.element_type(:edge)) }
-    it { should_not be_an_instance_of(graph.element_type(:edge)) }
-  end
-
-  describe '#add_extensions' do
-    context 'no extensions' do
-      subject { e0.add_extensions([]) }
-      its('extensions.to_a') { should == [] }
-      it { should_not be_a(Pacer::Wrappers::ElementWrapper) }
-    end
-
-    context 'with extensions' do
-      subject { e0.add_extensions([Tackle::SimpleMixin]) }
-      its('extensions.to_a') { should == [Tackle::SimpleMixin] }
-      it { should be_a(Pacer::Wrappers::ElementWrapper) }
-      it { should be_a(Pacer::Wrappers::EdgeWrapper) }
-      it { should_not be_a(Pacer::Wrappers::VertexWrapper) }
-
-      describe '#e' do
-        subject { e0.add_extensions([Tackle::SimpleMixin]).e }
-        its('extensions.to_a') { should == [Tackle::SimpleMixin] }
-        it { should be_an_edges_route }
-        it { should be_a(Tackle::SimpleMixin::Route) }
-      end
-    end
-  end
-
-  describe '#delete!' do
-    before do
-      @edge_id = e0.element_id
-      e0.delete!
-      graph.checkpoint # deleted edges in neo may be looked up during the transaction
-    end
-    it 'should be removed' do
-      graph.edge(@edge_id).should be_nil
-    end
-  end
-
-  contexts(
-  'into new tg' => proc {
-    let(:dest) { Pacer.tg }
-  },
-  'into graph2' => proc {
-    let(:dest) { graph2 }
-  }) do
-    describe '#clone_into', :transactions => false do
-      before { pending 'support temporary hash indices for clone/copy' unless graph.supports_manual_indices? }
-      context 'including vertices' do
-        subject { e0.clone_into(dest, :create_vertices => true) }
-
-        its('element_id.to_s') { should == e0.element_id.to_s if graph.supports_custom_element_ids? }
-        its(:label) { should == 'links' }
-        its(:graph) { should equal(dest) }
-        its('in_vertex.properties') { should == { 'name' => 'eliza' } }
-        its('out_vertex.properties') { should == { 'name' => 'darrick' } }
-      end
-
-      context 'without vertices' do
-        subject { e0.clone_into(dest) rescue nil }
-        it { should be_nil }
-
-        context 'but already existing' do
-          before do
-            v0.clone_into(dest)
-            v1.clone_into(dest)
-          end
-          its('element_id.to_s') { should == e0.element_id.to_s if graph.supports_custom_element_ids? }
-          its(:label) { should == 'links' }
-          its(:graph) { should equal(dest) }
-          its('in_vertex.properties') { should == { 'name' => 'eliza' } }
-          its('out_vertex.properties') { should == { 'name' => 'darrick' } }
-        end
-      end
-    end
-
-    describe '#copy_into', :transactions => false do
-      before { pending unless graph.supports_manual_indices? }
-      subject { v0.clone_into(dest); v1.clone_into(dest); e0.copy_into(dest) }
-      its(:label) { should == 'links' }
-      its(:graph) { should equal(dest) }
-      its('in_vertex.properties') { should == { 'name' => 'eliza' } }
-      its('out_vertex.properties') { should == { 'name' => 'darrick' } }
-    end
-
-  end
-
-  subject { e0 }
-  its(:graph) { should equal(graph) }
-  its(:display_name) { should == "#{ v0.element_id }-links-#{ v1.element_id }" }
-  its(:inspect) { should == "#<E[#{ e0.element_id }]:#{ v0.element_id }-links-#{ v1.element_id }>" }
-  context 'with label proc' do
-    before do
-      graph.edge_name = proc { |e| "some name" }
-    end
-    its(:display_name) { should == "some name" }
-    its(:inspect) { should == "#<E[#{ e0.element_id }]:some name>" }
-  end
-
-  context '', :transactions => true do
-    it { should_not == e1 }
-    it { should == e0 }
-    it { should_not == v0 }
-  end
-end
-
-Run.all do
-  it_uses Pacer::EdgeMixin
-end