pacer 1.1.1-java → 1.2.0-java

data/Gemfile

@@ -19,6 +19,11 @@ group :development do
     end
   end
 
+  if File.directory? "../mcfly"
+    gem 'pacer-mcfly', :path => "../mcfly" 
+  end
+
+
    
   gem 'autotest-standalone'
   gem 'autotest-growl'

data/lib/pacer/blueprints/tg.rb

@@ -5,9 +5,9 @@ module Pacer
   # its standard simple persistant mode.
   def self.tg(path = nil)
     if path
-      PacerGraph.new SimpleEncoder, proc { TinkerGraph.new(path) }
+      PacerGraph.new SimpleEncoder, TinkerGraph.new(path)
     else
-      PacerGraph.new SimpleEncoder, proc { TinkerGraph.new }
+      PacerGraph.new SimpleEncoder, TinkerGraph.new
     end
   end
 end

data/lib/pacer/core/array_route.rb

@@ -24,6 +24,21 @@ The following array route methods are available:
 #len(n)             Filter paths by length
     n: Number | Range
 
+#map_in             Map on each array
+#reduce_in          Reduce on each array
+#select_in          Select on each array
+#reject_in          Reject on each array
+
+#select_case(*cases) Simplified select on each array without needing a block
+#reject_case(*cases)
+    cases: the same type of objects you would give to case statements
+           (ie. exact match, regex, type, etc)
+
+#vertices(*exts)    Filter each array to only its vertices
+#edges(*exts)           "        "        "       edges
+#elements(*exts)        "        "        "       elements
+    exts: extensions to add to the filtered elements
+
 HELP
         else
           super
@@ -43,6 +58,10 @@ HELP
           scatter(element_type: :array)
       end
 
+      def flatten(*opts)
+        scatter(*opts)
+      end
+
       def compacted
         map element_type: element_type, route_name: 'compact' do |a|
           a.compact
@@ -72,6 +91,67 @@ HELP
           n === path.length
         end
       end
+
+      def map_in(&block)
+        map element_type: element_type do |e|
+          e.map(&block)
+        end
+      end
+
+      def reduce_in(initial, &block)
+        map { |e| e.reduce(initial, &block) }
+      end
+
+      def select_case(*cases)
+        map element_type: element_type do |e|
+          e.select { |x| cases.any? { |c| c === x } }
+        end
+      end
+
+      def reject_case(*cases)
+        map element_type: element_type do |e|
+          e.reject { |x| cases.any? { |c| c === x } }
+        end
+      end
+
+      def vertices(*exts)
+        r = select_case Pacer::Vertex
+        if exts.any?
+          r.map_in { |e| e.add_extensions exts }
+        else
+          r
+        end
+      end
+
+      def edges(*exts)
+        r = select_case Pacer::Edge
+        if exts.any?
+          r.map_in { |e| e.add_extensions exts }
+        else
+          r
+        end
+      end
+
+      def elements(*exts)
+        r = select_case Pacer::Element
+        if exts.any?
+          r.map_in { |e| e.add_extensions exts }
+        else
+          r
+        end
+      end
+
+      def select_in(&block)
+        map element_type: element_type do |e|
+          e.select(&block)
+        end
+      end
+
+      def reject_in(&block)
+        map element_type: element_type do |e|
+          e.select(&block)
+        end
+      end
     end
   end
 end

data/lib/pacer/core/graph/element_route.rb

@@ -3,10 +3,6 @@ module Pacer::Core::Graph
   # Basic methods for routes shared between all route types that emit
   # routes: {VerticesRoute}, {EdgesRoute} and {MixedRoute}
   module ElementRoute
-    def graph
-      config[:graph]
-    end
-
     # Attach a filter to the current route.
     #
     # @param [Array<Hash, extension>, Hash, extension] filter see {Pacer::Route#property_filter}
@@ -34,7 +30,7 @@ module Pacer::Core::Graph
     # rather than the elements themselves.
     # @return [Core::Route]
     def properties
-      map { |v| v.properties }
+      map(element_type: :hash) { |v| v.properties }
     end
 
     # Create a new TinkerGraph based on the paths of all matching elements.
@@ -76,26 +72,30 @@ module Pacer::Core::Graph
     def [](prop_or_subset)
       case prop_or_subset
       when String, Symbol
-        route = chain_route(:element_type => :object,
-                    :pipe_class => Pacer::Pipes::PropertyPipe,
-                    :pipe_args => [prop_or_subset.to_s],
-                    :lookahead_replacement => proc { |r| r.back.property?(prop_or_subset) })
-        route.map(route_name: 'decode', remove_from_lookahead: true) do |v|
-          graph.decode_property(v)
-        end
+        typed_property(:object, prop_or_subset)
       when Fixnum
         range(prop_or_subset, prop_or_subset)
       when Range
         range(prop_or_subset.begin, prop_or_subset.end)
       when Array
         if prop_or_subset.all? { |i| i.is_a? String or i.is_a? Symbol }
-          map do |element|
+          map(element_type: :array) do |element|
             element[prop_or_subset]
           end
         end
       end
     end
 
+    def typed_property(element_type, name)
+      route = chain_route(:element_type => :object,
+                          :pipe_class => Pacer::Pipes::PropertyPipe,
+                          :pipe_args => [name.to_s],
+                          :lookahead_replacement => proc { |r| r.back.property?(name) })
+      route.map(route_name: 'decode', remove_from_lookahead: true, element_type: element_type) do |v|
+        graph.decode_property(v)
+      end
+    end
+
     # Map each element to a property but filter out elements that do not
     # have the given property.
     # @param [#to_s] name the property name

data/lib/pacer/core/graph/mixed_route.rb

@@ -7,7 +7,7 @@ module Pacer::Core::Graph
     def v(*args, &block)
       route = chain_route :element_type => :vertex,
         :pipe_class => Pacer::Pipes::TypeFilterPipe,
-        :pipe_args => Pacer::Wrappers::VertexWrapper,
+        :pipe_args => graph.base_vertex_wrapper,
         :wrapper => wrapper,
         :extensions => extensions
       Pacer::Route.property_filter(route, args, block)
@@ -17,7 +17,7 @@ module Pacer::Core::Graph
     def e(*args, &block)
       route = chain_route :element_type => :edge,
         :pipe_class => Pacer::Pipes::TypeFilterPipe,
-        :pipe_args => Pacer::Wrappers::EdgeWrapper,
+        :pipe_args => graph.base_edge_wrapper,
         :wrapper => wrapper,
         :extensions => extensions
       Pacer::Route.property_filter(route, args, block)

data/lib/pacer/core/hash_route.rb

@@ -2,7 +2,31 @@ module Pacer
   module Core
     module HashRoute
       def lengths
-        map(element_type: :integer) { |s| s.length }
+        map(element_type: :integer) { |h| h.length }
+      end
+
+      def keys
+        map(element_type: :array) { |h| h.keys }
+      end
+
+      def values
+        map(element_type: :array) { |h| h.values }
+      end
+
+      def pairs
+        map(element_type: :array) { |h| h.to_a }
+      end
+
+      def [](k)
+        map { |h| h[k] }
+      end
+
+      def set(k, v)
+        process { |h| h[k] = v }
+      end
+
+      def fetch(k, *d, &block)
+        map { |h| h.fetch(k, *d, &block) }
       end
     end
   end

data/lib/pacer/core/route.rb

@@ -26,11 +26,6 @@ module Pacer
       # @return [true, false]
       attr_accessor :hide_elements
 
-      # Set which graph this route will operate on.
-      #
-      # @todo move this to graph routes.
-      attr_writer :graph
-
       # If this piece of the route is useless in a lookahead, set this to true
       # and when it is at the tail of a lookahead, it will be removed
       # automatically. (for instance the property decoder, or wrap/unwrap)
@@ -49,12 +44,12 @@ module Pacer
 
       # Return which graph this route operates on.
       #
-      # @todo move this to graph routes.
-      #
       # @return [PacerGraph]
       def graph
-        @graph = nil unless defined? @graph
-        @graph ||= (@back || @source).graph rescue nil
+        config.fetch :graph do
+          src = @back || @source
+          src.graph if src.respond_to? :graph
+        end
       end
 
       # Returns true if the given graph is the one this route operates on.

data/lib/pacer/exceptions.rb

@@ -6,11 +6,12 @@ module Pacer
 
     class LogicError < Error; end
       class ClientError < LogicError; end
-        class TransactionConcludedError < ClientError; end
-        class NestedTransactionError < ClientError; end
-        class NestedTransactionRollback < ClientError; end
-        class NestedMockTransactionRollback < NestedTransactionRollback; end
-        class MockTransactionRollback < ClientError; end
+        class TransactionError < ClientError; end
+          class TransactionConcludedError < TransactionError; end
+          class NestedTransactionError < TransactionError; end
+          class NestedTransactionRollback < TransactionError; end
+          class NestedMockTransactionRollback < NestedTransactionRollback; end
+          class MockTransactionRollback < TransactionError; end
         class UnsupportedOperation < ClientError; end
 
       class InternalError < LogicError; end

data/lib/pacer/filter/property_filter/filters.rb

@@ -57,12 +57,6 @@ module Pacer
         # @attr [Boolean] search_manual_indices
         attr_accessor :search_manual_indices
 
-      protected
-
-        attr_accessor :non_ext_props
-
-      public
-
         def initialize(filters)
           @properties = []
           @blocks = []
@@ -163,6 +157,8 @@ module Pacer
 
       protected
 
+        attr_accessor :non_ext_props
+
         def add_filter(filter, extension)
           case filter
           when Hash

data/lib/pacer/filter/range_filter.rb

@@ -11,10 +11,12 @@ module Pacer
       def limit(max)
         chain_route :filter => :range, :limit => max
       end
+      alias take limit
 
       def offset(amount)
         chain_route :filter => :range, :offset => amount
       end
+      alias drop offset
 
       def at(pos)
         chain_route :filter => :range, :index => pos
@@ -83,7 +85,7 @@ module Pacer
         from = @range.begin
         to = @range.end
         if @range.exclude_end?
-          if to == 0 
+          if to == 0
             pipe = Pacer::Pipes::NeverPipe.new
             pipe.set_starts end_pipe if end_pipe
             return pipe

data/lib/pacer/graph/graph_transactions_mixin.rb

@@ -50,8 +50,38 @@ module Pacer
     # Set this to true if you don't want to use transactions.
     #
     # By default, transactions are enabled.
+    #
+    # Note that this does not prevent blueprints implicit transactions from
+    # being created.
     attr_accessor :disable_transactions
 
+    # This is to work around the bad transaction design in Blueprints.
+    # Blueprints will always automatically start a transaction for you that it
+    # doesn't commits automatically and which you can not check the status of
+    # in any way. To deal with that, Pacer will (by default) commit implicit
+    # transactions before an explicit transaction is created. You can change
+    # that behavior by setting one of :commit, :rollback or :ignore. Ignore
+    # effectively folds changes from before the transaction into the current
+    # transaction.
+    attr_accessor :implicit_transaction
+
+    def close_implicit_transaction
+      case implicit_transaction
+      when nil, :commit
+        commit_implicit_transaction
+      when :rollback
+        rollback_implicit_transaction
+      end
+    end
+
+    def rollback_implicit_transaction
+      blueprints_graph.stopTransaction TransactionalGraph::Conclusion::FAILURE
+    end
+
+    def commit_implicit_transaction
+      blueprints_graph.stopTransaction TransactionalGraph::Conclusion::SUCCESS
+    end
+
   private
 
     def threadlocal_graph_info
@@ -63,20 +93,26 @@ module Pacer
       tgi = threadlocal_graph_info
       tx_depth = tgi[:tx_depth] ||= 0
       tgi[:tx_depth] += 1
-      if (not disable_transactions) and blueprints_graph.is_a? TransactionalGraph
-        if tx_depth == 0
-          base_tx_finalizers
-        elsif opts[:nesting] == true
-          nested_tx_finalizers
-        else
-          fail NestedTransactionError, "To use nested transactions, use nesting: true"
-        end
-      else
-        if tx_depth == 0
-          mock_base_tx_finalizers
+      begin
+        if (not disable_transactions) and blueprints_graph.is_a? TransactionalGraph
+          if tx_depth == 0
+            close_implicit_transaction
+            base_tx_finalizers
+          elsif opts[:nesting] == true
+            nested_tx_finalizers
+          else
+            fail NestedTransactionError, "To use nested transactions, use nesting: true"
+          end
         else
-          mock_nested_tx_finalizers
+          if tx_depth == 0
+            mock_base_tx_finalizers
+          else
+            mock_nested_tx_finalizers
+          end
         end
+      rescue Exception
+        tgi[:tx_depth] -= 1
+        raise
       end
     end
 

data/lib/pacer/graph/pacer_graph.rb

@@ -8,7 +8,11 @@ module Pacer
 
     attr_reader :blueprints_graph, :encoder
 
-    def initialize(encoder, open, shutdown = nil)
+    attr_accessor :base_vertex_wrapper, :base_edge_wrapper
+
+    def initialize(encoder, open, shutdown = nil, graph_id = nil)
+      self.base_vertex_wrapper = Pacer::Wrappers::VertexWrapper
+      self.base_edge_wrapper = Pacer::Wrappers::EdgeWrapper
       if open.is_a? Proc
         @reopen = open
       else
@@ -17,6 +21,7 @@ module Pacer
       @shutdown = shutdown
       reopen
       @encoder = encoder
+      @graph_id = graph_id
     end
 
     # The current graph
@@ -47,6 +52,10 @@ module Pacer
       self
     end
 
+    def copy_object
+      self.class.new @encoder, @reopen, @shutdown, graph_id
+    end
+
     def use_wrapper(klass)
       reopen = proc do
         klass.new unwrap_graph(@reopen.call)
@@ -59,7 +68,7 @@ module Pacer
     end
 
     def graph_id
-      blueprints_graph.object_id
+      @graph_id ||= blueprints_graph.object_id
     end
 
     def equals(other)
@@ -85,7 +94,7 @@ module Pacer
           v = wrapper.new graph, v
           modules.delete wrapper
         else
-          v = Pacer::Wrappers::VertexWrapper.new graph, v
+          v = base_vertex_wrapper.new graph, v
         end
         v.add_extensions modules
       else
@@ -112,7 +121,7 @@ module Pacer
           v = wrapper.new graph, v
           modules.delete wrapper
         else
-          v = Pacer::Wrappers::EdgeWrapper.new graph, v
+          v = base_edge_wrapper.new graph, v
         end
         v.add_extensions modules
       end
@@ -136,7 +145,7 @@ module Pacer
       if wrapper
         vertex = wrapper.new graph, raw_vertex
       else
-        vertex = Pacer::Wrappers::VertexWrapper.new graph, raw_vertex
+        vertex = base_vertex_wrapper.new graph, raw_vertex
       end
       if modules.any?
         vertex = vertex.add_extensions modules
@@ -162,7 +171,7 @@ module Pacer
       if wrapper
         edge = wrapper.new graph, raw_edge
       else
-        edge = Pacer::Wrappers::EdgeWrapper.new graph, raw_edge
+        edge = base_edge_wrapper.new graph, raw_edge
       end
       if modules.any?
         edge = edge.add_extensions modules
@@ -310,10 +319,12 @@ module Pacer
         @temp_indices ||= {}
         idx = @temp_indices[name]
         unless idx
-          if name and type and opts[:create]
-            idx = @temp_indices[name] = Pacer::Graph::HashIndex.new type, name
-          elsif opts[:create]
-            idx = Pacer::Graph::HashIndex.new type, nil
+          if opts[:temp] != false
+            if name and type and opts[:create]
+              idx = @temp_indices[name] = Pacer::Graph::HashIndex.new type, name
+            elsif opts[:create]
+              idx = Pacer::Graph::HashIndex.new type, nil
+            end
           end
         end
         Pacer::Wrappers::IndexWrapper.new self, idx, idx.type if idx
@@ -382,6 +393,26 @@ module Pacer
           []
         end
       end
+
+      def vertices_by_key(key, value, *extensions)
+        if key_indices(:vertex).include? key.to_s
+          pipe = Pacer::Pipes::WrappingPipe.new self, :vertex, extensions
+          pipe.setStarts blueprints_graph.getVertices(key.to_s, value).iterator
+          pipe
+        else
+          fail ClientError, "The key #{ key } is not indexed"
+        end
+      end
+
+      def edges_by_key(key, value, *extensions)
+        if key_indices(:edge).include? key.to_s
+          pipe = Pacer::Pipes::WrappingPipe.new self, :edge, extensions
+          pipe.setStarts blueprints_graph.getEdges(key.to_s, value).iterator
+          pipe
+        else
+          fail ClientError, "The key #{ key } is not indexed"
+        end
+      end
     end
     include KeyIndices