pacer 1.0.2-java → 1.0.3-java

data/lib/pacer/route_builder.rb

@@ -0,0 +1,142 @@
+module Pacer
+  class RouteBuilder
+    class << self
+      attr_writer :current
+
+      def current
+        @current ||= RouteBuilder.new
+      end
+    end
+
+    attr_reader :types
+
+    def initialize
+      @types = Hash.new do |h, type_def|
+        h[type_def] = Class.new(Route) do
+          type_def.each do |mods|
+            mods.each do |mod|
+              include mod
+            end
+          end
+        end
+      end
+    end
+
+    def chain(source, args)
+      types[type_def(source, args)].new source, configuration(source, args), arguments(source, args)
+    end
+
+    protected
+
+    def source_value(source, name)
+      source.send name if source.respond_to? name
+    end
+
+    def type_def(source, args)
+      [
+        type_modules(source, args),
+        function_modules(source, args),
+        other_modules(source, args),
+        extension_modules(source, args)
+      ]
+    end
+
+    def configuration(source, args)
+      {
+        element_type: element_type(source, args),
+        graph: graph(source, args),
+        extensions: extensions(source, args),
+        wrapper: wrapper(source, args),
+        function: function_modules(source, args).first
+      }
+    end
+
+    def arguments(source, args)
+      args.reject do |key, val|
+        Set[:element_type, :wrapper, :extensions, :modules, :graph, :back, :filter, :side_effect, :transform, :visitor].include? key
+      end
+    end
+
+    def graph(source, args)
+      args[:graph] || source_value(source, :graph)
+    end
+
+    def element_type(source, args)
+      et = args[:element_type] || source_value(source, :element_type)
+      if not et
+        fail ClientError, "No element_type specified or inferred"
+      end
+      if not graph(source, args) and (et == :vertex or et == :edge or et == :mixed)
+        fail ClientError, "Element type #{ et.inspect } specified, but no graph specified."
+      end
+      et
+    end
+
+    def type_modules(source, args)
+      case element_type source, args
+      when :vertex
+        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::VerticesRoute]
+      when :edge
+        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::EdgesRoute]
+      when :mixed
+        [Pacer::Core::Graph::ElementRoute, Pacer::Core::Graph::MixedRoute]
+      else
+        []
+      end
+    end
+
+    def other_modules(source, args)
+      [*args[:modules]]
+    end
+
+    def type_from_source?(source, args)
+      element_type(source, args) == source_value(source, :element_type)
+    end
+
+    def wrapper(source, args)
+      args.fetch(:wrapper) do
+        source_value(source, :wrapper) if type_from_source? source, args
+      end
+    end
+
+    def extensions(source, args)
+      exts = args.fetch(:extensions) do
+        source_value(source, :extensions) if type_from_source? source, args
+      end
+      if exts.is_a? Set
+        exts.to_a
+      elsif exts.is_a? Module
+        [exts]
+      elsif exts.is_a? Array
+        exts.uniq
+      else
+        []
+      end
+    end
+
+    def all_extensions(source, args)
+      w = wrapper source, args
+      exts = extensions source, args
+      if w and exts
+        (w.extensions + exts).uniq
+      elsif w
+        w.extensions
+      elsif exts
+        exts
+      else
+        []
+      end
+    end
+
+    def extension_modules(source, args)
+      all_extensions(source, args).uniq.select do |mod|
+        mod.respond_to?(:const_defined?) and mod.const_defined? :Route
+      end.map { |mod| mod::Route }
+    end
+
+
+    def function_modules(source, args)
+      FunctionResolver.function(args).compact
+    end
+  end
+end

data/lib/pacer/side_effect/as.rb

@@ -11,9 +11,7 @@ module Pacer
 
   module SideEffect
     module As
-      class AsPipe < Pacer::Pipes::AbstractPipe
-
-        field_reader :starts
+      class AsPipe < Pacer::Pipes::RubyPipe
         attr_accessor :vars
 
         def initialize(pipe, vars, variable_name)

data/lib/pacer/version.rb

@@ -1,6 +1,6 @@
 module Pacer
   unless const_defined? :VERSION
-    VERSION = "1.0.2"
+    VERSION = "1.0.3"
 
     JAR = "pacer-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"

data/lib/pacer/wrappers/edge_wrapper.rb

@@ -9,10 +9,13 @@ module Pacer::Wrappers
       :getRawEdge
 
     class << self
+      def wrappers
+        @wrappers ||= {}
+      end
+
       def wrapper_for(exts)
-        @wrappers = {} unless defined? @wrappers
         if exts
-          @wrappers[exts.to_set] ||= build_edge_wrapper(exts)
+          EdgeWrapper.wrappers[exts] ||= build_edge_wrapper(exts)
         else
           fail Pacer::LogicError, "Extensions should not be nil"
         end
@@ -127,18 +130,12 @@ module Pacer::Wrappers
     #
     # @raise [StandardError] If this the associated vertices don't exist and :create_vertices is not set
     def clone_into(target_graph, opts = {})
-      e_idx = target_graph.index("tmp-e-#{graph.graph_id}", :edge, :create => true)
-      e = target_graph.edge(element_id)
-      unless e
-        e = e_idx.first('id', element_id)
-        if e
-          e = EdgeWrapper.new(graph, e)
-        end
-      end
+      e_idx = target_graph.temp_index("tmp-e-#{graph.graph_id}", :edge, :create => true)
+      e = e_idx.first('id', element_id)
       unless e
-        v_idx = target_graph.index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
-        iv = target_graph.vertex(in_vertex.element_id) || v_idx.first('id', in_vertex.element_id)
-        ov = target_graph.vertex(out_vertex.element_id) || v_idx.first('id', out_vertex.element_id)
+        v_idx = target_graph.temp_index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
+        iv = v_idx.first('id', in_vertex.element_id)
+        ov = v_idx.first('id', out_vertex.element_id)
         if opts[:create_vertices]
           iv ||= in_vertex.clone_into target_graph
           ov ||= out_vertex.clone_into target_graph
@@ -149,7 +146,7 @@ module Pacer::Wrappers
           raise message unless opts[:ignore_missing_vertices]
           return nil
         end
-        e = target_graph.create_edge(element_id, iv, ov, label, properties)
+        e = target_graph.create_edge(element_id, ov, iv, label, properties)
         e_idx.put('id', element_id, e)
         yield e if block_given?
       end
@@ -165,12 +162,12 @@ module Pacer::Wrappers
     #
     # @raise [StandardError] If this the associated vertices don't exist
     def copy_into(target_graph)
-      v_idx = target_graph.index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
+      v_idx = target_graph.temp_index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
       iv = v_idx.first('id', in_vertex.element_id) || target_graph.vertex(in_vertex.element_id)
       ov = v_idx.first('id', out_vertex.element_id) || target_graph.vertex(out_vertex.element_id)
 
       raise 'vertices not found' if not iv or not ov
-      e = target_graph.create_edge nil, iv, ov, label, properties
+      e = target_graph.create_edge nil, ov, iv, label, properties
       yield e if block_given?
       e
     end

data/lib/pacer/wrappers/element_wrapper.rb

@@ -20,7 +20,6 @@ module Pacer::Wrappers
       end
 
       def clear_cache
-        Pacer.send :remove_const, :Wrap if Pacer.const_defined? :Wrap
         VertexWrapper.clear_cache
         EdgeWrapper.clear_cache
       end
@@ -42,31 +41,18 @@ module Pacer::Wrappers
       def build_extension_wrapper(exts, mod_names, superclass)
         sc_name = superclass.to_s.split(/::/).last
         exts = exts.uniq unless exts.is_a? Set
-        classname = "#{sc_name}#{exts.map { |m| m.to_s }.join('')}".gsub(/::/, '_').gsub(/\W/, '')
-        begin
-          wrapper = Pacer::Wrap.const_get classname
-        rescue NameError
-          eval %{
-            module ::Pacer
-              module Wrap
-                class #{classname.to_s} < #{sc_name}
+        Class.new(superclass) do
+          exts.each do |obj|
+            if obj.is_a? Module or obj.is_a? Class
+              mod_names.each do |mod_name|
+                if obj.const_defined? mod_name
+                  include obj.const_get(mod_name)
+                  extensions << obj unless extensions.include? obj
                 end
               end
             end
-          }
-          wrapper = Pacer::Wrap.const_get classname
-        end
-        exts.each do |obj|
-          if obj.is_a? Module or obj.is_a? Class
-            mod_names.each do |mod_name|
-              if obj.const_defined? mod_name
-                wrapper.send :include, obj.const_get(mod_name)
-                wrapper.extensions << obj unless wrapper.extensions.include? obj
-              end
-            end
           end
         end
-        wrapper
       end
     end
 
@@ -92,6 +78,10 @@ module Pacer::Wrappers
       after_initialize
     end
 
+    def chain_route(args_hash)
+      Pacer::RouteBuilder.current.chain self, args_hash
+    end
+
     # Convenience method to retrieve a property by name.
     #
     # @param [#to_s] key the property name
@@ -137,7 +127,7 @@ module Pacer::Wrappers
     #
     # @return [Hash]
     def properties
-      element.getPropertyKeys.inject({}) { |h, name| h[name] = element.getProperty(name); h }
+      Hash[element.getPropertyKeys.map { |name| [name, graph.decode_property(element.getProperty(name))] }]
     end
 
     # Replace the element's properties with the given hash

data/lib/pacer/wrappers/vertex_wrapper.rb

@@ -9,10 +9,13 @@ module Pacer::Wrappers
       :getRawVertex
 
     class << self
+      def wrappers
+        @wrappers ||= {}
+      end
+
       def wrapper_for(exts)
-        @wrappers = {} unless defined? @wrappers
         if exts
-          @wrappers[exts.to_set] ||= build_vertex_wrapper(exts)
+          VertexWrapper.wrappers[exts.to_set] ||= build_vertex_wrapper(exts)
         else
           fail Pacer::LogicError, "Extensions should not be nil"
         end
@@ -128,8 +131,8 @@ module Pacer::Wrappers
     # @yield [v] Optional block yields the vertex after it has been created.
     # @return [Pacer::Wrappers::VertexWrapper] the new vertex
     def clone_into(target_graph, opts = nil)
-      v_idx = target_graph.index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
-      v = target_graph.vertex(element_id) || v_idx.first('id', element_id)
+      v_idx = target_graph.temp_index("tmp-v-#{graph.graph_id}", :vertex, :create => true)
+      v = v_idx.first('id', element_id)
       unless v
         v = target_graph.create_vertex element_id, properties
         v_idx.put('id', element_id, v.element)

data/lib/pacer.rb

@@ -39,21 +39,7 @@ module Pacer
 
   require JAR
 
-  require 'pacer/exceptions'
-  require 'pacer/pipes'
-  require 'pacer/core'
-  require 'pacer/graph'
-  require 'pacer/routes'
-  require 'pacer/wrappers'
-  require 'pacer/route'
-  require 'pacer/blueprints'
-  require 'pacer/support'
-  require 'pacer/utils'
-  require 'pacer/visitors'
-  require 'pacer/filter'
-  require 'pacer/transform'
-  require 'pacer/side_effect'
-  require 'pacer/function_resolver'
+  require 'pacer/loader'
 
   class << self
     # A global place for pacer to put debug info if it's tucked deep in
@@ -180,6 +166,14 @@ module Pacer
       FunctionResolver.clear_cache
     end
 
+    def vertex_wrapper(*exts)
+      Wrappers::VertexWrapper.wrapper_for(exts)
+    end
+
+    def edge_wrapper(*exts)
+      Wrappers::EdgeWrapper.wrapper_for(exts)
+    end
+
     # Is the object a vertex?
     def vertex?(element)
       element.is_a? Pacer::Wrappers::VertexWrapper

data/pom.xml

@@ -7,7 +7,7 @@
     <artifactId>pacer</artifactId>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-neo4j/version.rb -->
     <properties>
-      <gem.version>1.0.2</gem.version>
+      <gem.version>1.0.3</gem.version>
       <blueprints.version>2.1.0</blueprints.version>
       <pipes.version>2.1.0</pipes.version>
       <gremlin.version>2.1.0</gremlin.version>

data/spec/pacer/blueprints/dex_spec.rb

@@ -1,158 +1,5 @@
 require 'spec_helper'
 
 Run.dex do
-  describe Pacer::Dex do
-    let(:v0) { graph.create_vertex }
-    let(:v1) { graph.create_vertex }
-    let(:e0) { graph.create_edge '0', v0, v1, :default }
-
-    describe '#element_type' do
-      context 'invalid' do
-        it { expect { graph.element_type(:nothing) }.to raise_error(ArgumentError) }
-      end
-
-      context ':vertex' do
-        subject { graph.element_type(:vertex) }
-        it { should == :vertex }
-      end
-
-      context 'a vertex' do
-        subject { graph.element_type(v0) }
-        it { should == :vertex }
-      end
-
-      context ':edge' do
-        subject { graph.element_type(:edge) }
-        it { should == :edge }
-      end
-
-      context 'an edge' do
-        subject { graph.element_type(e0) }
-        it { should == :edge }
-      end
-
-      context ':mixed' do
-        subject { graph.element_type(:mixed) }
-        it { should == :mixed }
-      end
-
-      context ':object' do
-        subject { graph.element_type(:object) }
-        it { should == :object }
-      end
-
-      context 'from element_type' do
-        context ':vertex' do
-          subject { graph.element_type(graph.element_type :vertex) }
-          it { should == :vertex }
-        end
-
-        context ':edge' do
-          subject { graph.element_type(graph.element_type :edge) }
-          it { should == :edge }
-        end
-
-        context ':mixed' do
-          subject { graph.element_type(graph.element_type :mixed) }
-          it { should == :mixed }
-        end
-
-        context ':object' do
-          subject { graph.element_type(graph.element_type :object) }
-          it { should == :object }
-        end
-      end
-
-      context 'from index_class' do
-        context ':vertex' do
-          subject { graph.element_type(graph.index_class :vertex) }
-          it { should == :vertex }
-        end
-      end
-    end
-
-    describe '#indices' do
-      subject { graph.indices.to_a }
-      it { should_not be_empty }
-    end
-
-    describe '#sanitize_properties' do
-      let(:original) do
-        { :string => ' bob ',
-          :symbol => :abba,
-          :empty => '',
-          :integer => 121,
-          :float => 100.001,
-          :time => Time.utc(1999, 11, 9, 9, 9, 1),
-          :object => { :a => 1, 1 => :a },
-          99 => 'numeric key',
-          'string key' => 'string value'
-        }
-      end
-
-      subject { graph.sanitize_properties original }
-
-      it { should_not equal(original) }
-      specify 'original should be unchanged' do
-        original.should == {
-          :string => ' bob ',
-          :symbol => :abba,
-          :empty => '',
-          :integer => 121,
-          :float => 100.001,
-          :time => Time.utc(1999, 11, 9, 9, 9, 1),
-          :object => { :a => 1, 1 => :a },
-          99 => 'numeric key',
-          'string key' => 'string value'
-        }
-      end
-
-      specify 'string should be stripped' do
-        subject[:string].should == 'bob'
-      end
-
-      specify 'empty string becomes nil' do
-        subject[:empty].should be_nil
-      end
-
-      specify 'numbers should be javafied' do
-        subject[:integer].should == 121.to_java(:int)
-        subject[:float].should == 100.001
-      end
-
-      specify 'everything else should be yaml' do
-        subject[:time].should == YAML.dump(Time.utc(1999, 11, 9, 9, 9, 1))
-      end
-
-      its(:keys) { should == original.keys }
-    end
-
-    describe '#in_vertex' do
-      it 'should wrap the vertex' do
-        v = e0.in_vertex(Tackle::SimpleMixin)
-        v.should == v1
-        v.extensions.should include(Tackle::SimpleMixin)
-      end
-
-      it 'should wrap the vertex 2' do
-        v = e0.in_vertex([Tackle::SimpleMixin])
-        v.should == v1
-        v.extensions.should include(Tackle::SimpleMixin)
-      end
-    end
-
-    describe '#out_vertex' do
-      it 'should wrap the vertex' do
-        v = e0.out_vertex(Tackle::SimpleMixin)
-        v.should == v0
-        v.extensions.should include(Tackle::SimpleMixin)
-      end
-
-      it 'should wrap the vertex 2' do
-        v = e0.out_vertex([Tackle::SimpleMixin])
-        v.should == v0
-        v.extensions.should include(Tackle::SimpleMixin)
-      end
-    end
-  end
+  # no special cases?
 end