pacer 0.9.1.1-java

data/lib/pacer/filter/property_filter.rb

@@ -0,0 +1,111 @@
+require 'pacer/filter/property_filter/filters'
+require 'pacer/filter/property_filter/edge_filters'
+
+module Pacer
+  class Route
+    class << self
+      def filters(filters)
+        if filters? filters
+          filters
+        elsif filters? filters.first
+          filters.first
+        else
+          Pacer::Filter::PropertyFilter::Filters.new(filters)
+        end
+      end
+
+      def edge_filters(filters)
+        if filters? filters
+          filters
+        elsif filters? filters.first
+          filters.first
+        else
+          Pacer::Filter::PropertyFilter::EdgeFilters.new(filters)
+        end
+      end
+
+      def filters?(filters)
+        filters.is_a? Pacer::Filter::PropertyFilter::Filters
+      end
+
+      def property_filter_before(base, filters, block)
+        filters = Pacer::Route.edge_filters(filters)
+        filters.blocks = [block] if block
+        if filters.extensions_only? and base.is_a? Route
+          base.wrapper ||= filters.wrapper if filters.wrapper
+          base.add_extensions(filters.extensions)
+          yield base
+        elsif filters and filters.any?
+          yield new(:back => base, :filter => :property, :filters => filters)
+        else
+          yield base
+        end
+      end
+
+      def property_filter(base, filters, block)
+        filters = Pacer::Route.edge_filters(filters)
+        filters.blocks = [block] if block
+        if filters.extensions_only? and base.is_a? Route
+          base.wrapper ||= filters.wrapper if filters.wrapper
+          base.add_extensions(filters.extensions)
+        elsif filters and filters.any?
+          new(:back => base, :filter => :property, :filters => filters)
+        elsif Pacer.vertex? base
+          new(:back => base, :pipe_class => Pacer::Pipes::IdentityPipe)
+        elsif Pacer.edge? base
+          new(:back => base, :pipe_class => Pacer::Pipes::IdentityPipe)
+        else
+          base
+        end
+      end
+    end
+  end
+
+  module Filter
+    module PropertyFilter
+      #import com.tinkerpop.pipes.filter.LabelCollectionFilterPipe
+      import com.tinkerpop.pipes.filter.PropertyFilterPipe
+
+      def filters=(f)
+        if f.is_a? Filters
+          @filters = f
+        else
+          @filters = EdgeFilters.new(f)
+        end
+        self.wrapper ||= f.wrapper if f.wrapper
+        add_extensions f.extensions
+      end
+
+      # Return an array of filter options for the current route.
+      def filters
+        @filters ||= EdgeFilters.new(nil)
+      end
+
+      def block=(block)
+        if block
+          filters.blocks = [block]
+        else
+          filters.blocks = []
+        end
+      end
+
+      def block
+        filters.blocks.first
+      end
+
+      protected
+
+      def build_pipeline
+        filters.build_pipeline(self, *pipe_source)
+      end
+
+      def inspect_string
+        if filters.any?
+          "#{inspect_class_name}(#{filters})"
+        else
+          inspect_class_name
+        end
+      end
+    end
+  end
+end

data/lib/pacer/filter/random_filter.rb

@@ -0,0 +1,13 @@
+module Pacer
+  module Core
+    module Route
+      # Return elements based on a bias:1 chance.
+      #
+      # If given an integer (n) > 0, bias is calcualated at 1 / n.
+      def random(bias = 0.5)
+        bias = 1 / bias.to_f if bias.is_a? Fixnum and bias > 0
+        chain_route :pipe_class => Pacer::Pipes::RandomFilterPipe, :pipe_args => bias
+      end
+    end
+  end
+end

data/lib/pacer/filter/range_filter.rb

@@ -0,0 +1,104 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      def range(from, to)
+        args = { :filter => :range }
+        args[:begin] = from if from
+        args[:end] = to if to
+        chain_route args
+      end
+
+      def limit(max)
+        chain_route :filter => :range, :limit => max
+      end
+
+      def offset(amount)
+        chain_route :filter => :range, :offset => amount
+      end
+
+      def at(pos)
+        chain_route :filter => :range, :index => pos
+      end
+    end
+  end
+
+  module Filter
+    module RangeFilter
+      def limit(n = nil)
+        @limit = n
+        if range.begin == -1
+          @range = range.begin...n
+        else
+          @range = range.begin...(range.begin + n)
+        end
+        self
+      end
+
+      def limit=(n)
+        limit n
+        n
+      end
+
+      def offset(n = nil)
+        s = n
+        s += 1 if range.begin == -1
+        if range.end == -1
+          @range = (range.begin + s)..-1
+        elsif range.exclude_end?
+          @range = (range.begin + s)...(range.end + n)
+        else
+          @range = (range.begin + s)..(range.end + n)
+        end
+        self
+      end
+
+      def offset=(n)
+        offset n
+        n
+      end
+
+      def range=(range)
+        @range = range
+      end
+
+      def begin=(n)
+        @range = n..range.end
+      end
+
+      def end=(n)
+        @range = range.begin..n
+      end
+
+      def index=(index)
+        @range = index..index
+      end
+
+      def range
+        @range ||= -1..-1
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        from = @range.begin
+        to = @range.end
+        if @range.exclude_end?
+          if to == 0 
+            pipe = Pacer::Pipes::NeverPipe.new
+            pipe.set_starts end_pipe if end_pipe
+            return pipe
+          elsif to > 0
+            to -= 1
+          end
+        end
+        pipe = Pacer::Pipes::RangeFilterPipe.new from, to
+        pipe.set_starts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        "#{ inspect_class_name }(#{ range.inspect })"
+      end
+    end
+  end
+end

data/lib/pacer/filter/uniq_filter.rb

@@ -0,0 +1,12 @@
+module Pacer
+  module Routes
+    module RouteOperations
+      # Do not return duplicate elements.
+      def uniq(*filters, &block)
+        Pacer::Route.property_filter_before(self, filters, block) do |r|
+          chain_route :pipe_class => Pacer::Pipes::DuplicateFilterPipe, :route_name => 'uniq'
+        end
+      end
+    end
+  end
+end

data/lib/pacer/filter/where_filter/node_visitor.rb

@@ -0,0 +1,280 @@
+module Pacer
+  module Filter
+    module WhereFilter
+      class NodeVisitor
+        import com.tinkerpop.pipes.filter.OrFilterPipe
+        import com.tinkerpop.pipes.filter.FilterPipe
+        import com.tinkerpop.pipes.filter.AndFilterPipe
+        import com.tinkerpop.pipes.filter.OrFilterPipe
+        import com.tinkerpop.pipes.filter.ObjectFilterPipe
+        import com.tinkerpop.pipes.transform.PropertyPipe
+        import com.tinkerpop.pipes.transform.HasCountPipe
+        NeverPipe = Pacer::Pipes::NeverPipe
+        IdentityPipe = Pacer::Pipes::IdentityPipe
+        PropertyComparisonFilterPipe = Pacer::Pipes::PropertyComparisonFilterPipe
+        Pipeline = Pacer::Pipes::Pipeline
+        CrossProductTransformPipe = Pacer::Pipes::CrossProductTransformPipe
+        UnaryTransformPipe = Pacer::Pipes::UnaryTransformPipe
+        BlockFilterPipe = Pacer::Pipes::BlockFilterPipe
+
+        Filters = {
+          '==' => FilterPipe::Filter::EQUAL,
+          '='  => FilterPipe::Filter::EQUAL,
+          '!=' => FilterPipe::Filter::NOT_EQUAL,
+          '>'  => FilterPipe::Filter::GREATER_THAN,
+          '<'  => FilterPipe::Filter::LESS_THAN,
+          '>=' => FilterPipe::Filter::GREATER_THAN_EQUAL,
+          '<=' => FilterPipe::Filter::LESS_THAN_EQUAL
+        }
+
+        ReverseFilters = Filters.merge(
+          '<'  => FilterPipe::Filter::GREATER_THAN,
+          '>'  => FilterPipe::Filter::LESS_THAN,
+          '<=' => FilterPipe::Filter::GREATER_THAN_EQUAL,
+          '>=' => FilterPipe::Filter::LESS_THAN_EQUAL
+        )
+
+        COMPARITORS = %w[ == != > < >= <= ] 
+        METHODS = %w[ + - * / % ]
+        REGEX_COMPARITORS = %w[ =~ !~ ]
+
+        VALID_OPERATIONS = COMPARITORS + METHODS # + REGEX_COMPARITORS
+
+        class Pipe
+          def initialize(pipe, *args)
+            @pipe = pipe
+            @args = args
+          end
+
+          attr_reader :pipe
+          attr_reader :args
+
+          def inspect(depth = 0)
+            ([" " * depth + pipe.to_s] + args.map do |arg|
+              if arg.is_a? Pipe or arg.is_a? Value
+                arg.inspect(depth + 2)
+              else
+                " " * (depth + 2) + arg.to_s
+              end
+            end).join "\n"
+          end
+
+          def build
+            pipe.new *build_args
+          end
+
+          def build_args
+            args.map do |arg|
+              if arg.is_a? Pipe
+                arg.build
+              elsif arg.is_a? Value
+                arg.value
+              else
+                arg
+              end
+            end
+          end
+        end
+
+        class Value
+          def initialize(value)
+            @value = value
+          end
+
+          def pipe; end
+          attr_reader :value
+
+          def inspect(depth = 0)
+            " " * depth + "Value: #{ value.inspect }"
+          end
+
+          def build
+            value
+          end
+
+          def values!
+            if value.is_a? Array
+              value.map do |v|
+                if v.is_a? Value
+                  v.values!
+                else
+                  raise "Arrays may not contain other properties"
+                end
+              end
+            else
+              value
+            end
+          end
+        end
+
+        attr_reader :route, :values
+
+        def initialize(route, values = {})
+          @route = route
+          @values = values
+        end
+
+        def build_comparison(a, b, name)
+          # TODO: support regex matches
+
+          raise "Operation not supported: #{ name }" unless VALID_OPERATIONS.include? name
+          if COMPARITORS.include? name
+            if a.is_a? Value and b.is_a? Value
+              if a.value.send name, b.value
+                Pipe.new IdentityPipe
+              else
+                Pipe.new NeverPipe
+              end
+            elsif a.pipe == PropertyPipe and b.pipe == PropertyPipe
+              Pipe.new PropertyComparisonFilterPipe, a, b, Filters[name]
+            elsif b.pipe == PropertyPipe and a.is_a? Value
+              Pipe.new Pipeline, b, Pipe.new(ObjectFilterPipe, a, ReverseFilters[name])
+            else
+              Pipe.new Pipeline, a, Pipe.new(ObjectFilterPipe, b, Filters[name])
+            end
+          elsif METHODS.include? name
+            if a.is_a? Value and b.is_a? Value
+              Value.new a.value.send(name, b.value)
+            else
+              Pipe.new CrossProductTransformPipe, name, a, b
+            end
+          end
+        end 
+
+        def visitAndNode(node)
+          a = node.first_node.accept(self)
+          b = node.second_node.accept(self)
+
+          if a.pipe == AndFilterPipe and b.pipe == AndFilterPipe
+            Pipe.new AndFilterPipe, *a.args, *b.args
+          elsif a.pipe == AndFilterPipe
+            Pipe.new AndFilterPipe, *a.args, b
+          elsif b.pipe == AndFilterPipe
+            Pipe.new AndFilterPipe, a, *b.args
+          else
+            Pipe.new AndFilterPipe, a, b
+          end
+        end 
+
+        def visitArrayNode(node)
+          Value.new Value.new(node.child_nodes.map { |n| n.accept self }).values!
+        end 
+
+        def visitBignumNode(node)
+          Value.new node.value.to_s
+        end
+
+        def visitCallNode(node)
+          a = node.receiver_node.accept(self)
+          if node.args_node
+            b = node.args_node.child_nodes.first.accept(self)
+            build_comparison(a, b, node.name)
+          else
+            return a if node.name == '+'
+            if a.is_a? Value
+              Value.new a.value.send(a.name)
+            elsif a.pipe == PropertyPipe
+              Pipe.new(UnaryTransformPipe, node.name, a)
+            else
+              case node.name
+              when '!'
+                # Special case for "a == 1 and not (b == 1)", etc.
+                Pipe.new(Pipeline, a, Pipe.new(HasCountPipe, -1, 0), Pipe.new(ObjectFilterPipe, true, Filters['==']))
+              else
+                raise 'not sure'
+              end
+            end
+          end
+        end
+
+        def visitFalseNode(node)
+          Pipe.new NeverPipe
+        end 
+
+        def visitFixnumNode(node)
+          Value.new node.value
+        end 
+
+        def visitFloatNode(node)
+          Value.new node.value
+        end
+
+        def visitHashNode(node)
+          Value.new Hash[*node.child_nodes.first.accept(self).value.map { |v| v.value }]
+        end
+
+        def visitLocalAsgnNode(node)
+          a = Pipe.new PropertyPipe, node.name
+          b = node.value_node.accept(self)
+          build_comparison(a, b, '==')
+        end 
+
+        def visitLocalVarNode(node)
+          Pipe.new PropertyPipe, node.name
+        end
+
+        def visitNewlineNode(node)
+          node.next_node.accept(self)
+        end 
+
+        def visitNilNode(node)
+          Value.new nil
+        end 
+
+        def visitOrNode(node)
+          a = node.first_node.accept(self)
+          b = node.second_node.accept(self)
+          if a.pipe == OrFilterPipe and b.pipe == OrFilterPipe
+            Pipe.new OrFilterPipe, *a.args, *b.args
+          elsif a.pipe == OrFilterPipe
+            Pipe.new OrFilterPipe, *a.args, b
+          elsif b.pipe == OrFilterPipe
+            Pipe.new OrFilterPipe, a, *b.args
+          else
+            Pipe.new OrFilterPipe, a, b
+          end
+        end 
+
+        def visitRootNode(node)
+          pipe = node.body_node.accept self
+          if pipe.pipe == AndFilterPipe or pipe.pipe == OrFilterPipe
+            pipe
+          elsif pipe.is_a? Value
+            if pipe.value
+              Pipe.new IdentityPipe
+            else
+              Pipe.new NeverPipe
+            end
+          else
+            Pipe.new AndFilterPipe, pipe
+          end
+        end 
+
+        def visitStrNode(node)
+          Value.new node.value
+        end 
+
+        def visitSymbolNode(node)
+          Value.new values.fetch(node.name.to_sym, node.name.to_sym)
+        end 
+
+        def visitTrueNode(node)
+          Pipe.new IdentityPipe
+        end 
+
+        def visitVCallNode(node)
+          Pipe.new PropertyPipe, node.name
+        end 
+
+        def visitYieldNode(node)
+          block = node.args_node.child_nodes.first.accept(self)
+          Pipe.new BlockFilterPipe, Value.new(route), block
+        end
+
+        def visitZArrayNode(node)
+          Value.new []
+        end
+      end
+    end
+  end
+end

data/lib/pacer/filter/where_filter.rb

@@ -0,0 +1,47 @@
+require 'pacer/filter/where_filter/node_visitor'
+
+module Pacer
+  module Routes
+    module RouteOperations
+      def where(str, values = {})
+        chain_route :filter => :where, :where_statement => str, :values => values
+      end
+    end
+  end
+
+  module Filter
+    module WhereFilter
+      attr_reader :where_statement
+      attr_accessor :values
+
+      def where_statement=(str)
+        @where_statement = str
+        @built = @parsed = @intermediate = nil
+      end
+
+      def parsed
+        @parsed ||= JRuby.parse @where_statement
+      end
+
+      def intermediate
+        @intermediate ||= parsed.accept(NodeVisitor.new(self, values || {}))
+      end
+
+      def build!
+        @built ||= intermediate.build
+      end
+
+      protected
+
+      def attach_pipe(end_pipe)
+        pipe = build!
+        pipe.setStarts end_pipe if end_pipe
+        pipe
+      end
+
+      def inspect_string
+        "where(#@where_statement)"
+      end
+    end
+  end
+end

data/lib/pacer/filter.rb

@@ -0,0 +1,17 @@
+module Pacer
+  module Filter
+  end
+end
+
+require 'pacer/filter/collection_filter'
+require 'pacer/filter/empty_filter'
+require 'pacer/filter/future_filter'
+require 'pacer/filter/property_filter'
+require 'pacer/filter/range_filter'
+require 'pacer/filter/uniq_filter'
+require 'pacer/filter/index_filter'
+require 'pacer/filter/loop_filter'
+require 'pacer/filter/block_filter'
+require 'pacer/filter/object_filter'
+require 'pacer/filter/where_filter'
+require 'pacer/filter/random_filter'

data/lib/pacer/function_resolver.rb

@@ -0,0 +1,43 @@
+module Pacer
+  module FunctionResolver
+    class << self
+      def clear_cache
+        @lookup_path = nil
+      end
+
+      def function(args)
+        lookup_path.each do |key, map, extension|
+          if value = args[key]
+            function = map.fetch(value, value.is_a?(Module) && value)
+            return [function, extension] if function
+          end
+        end
+        nil
+      end
+
+      def lookup_path
+        @lookup_path ||= [
+          [:filter, filter_map, nil],
+          [:transform, transform_map, nil],
+          [:side_effect, side_effect_map, Pacer::Core::SideEffect]
+        ]
+      end
+
+      def filter_map
+        Hash[Pacer::Filter.constants.map { |name| [symbolize_module_name(name), Pacer::Filter.const_get(name)] }]
+      end
+
+      def side_effect_map
+        Hash[Pacer::SideEffect.constants.map { |name| [symbolize_module_name(name), Pacer::SideEffect.const_get(name)] }]
+      end
+
+      def transform_map
+        Hash[Pacer::Transform.constants.map { |name| [symbolize_module_name(name), Pacer::Transform.const_get(name)] }]
+      end
+
+      def symbolize_module_name(name)
+        name.to_s.sub(/(Filter|SideEffect|Transform)$/, '').gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase.to_sym
+      end
+    end
+  end
+end