pacer 0.9.1.1-java

data/lib/pacer/utils/graph_analysis.rb

@@ -0,0 +1,112 @@
+module Pacer
+  module Utils
+    module GraphAnalysis
+
+      class << self
+        # Returns a TinkerGraph representing the number of each type of node and how
+        # many edges (by label) point to each other type of node.
+        def structure(graph, type_field = :type)
+          result = Pacer.tg
+          result.vertex_name = proc do |v|
+            if v[:element_type] == 'vertex'
+              "vertex '#{v[:type]}' (#{v[:count]})"
+            elsif v[:element_type] == 'edge'
+              "edge :#{v[:label]} (#{v[:count]})"
+            elsif v[:element_type] == 'property keys'
+              "properties #{v[:number]} keys (#{v[:count]})"
+            end
+          end
+          graph.v[type_field].fast_group_count.to_h.each do |type, count|
+            result.create_vertex :element_type => 'vertex', :type_field => type_field, :type => type, :count => count
+          end
+          graph.e.labels.fast_group_count.to_h.each do |label, count|
+            result.create_vertex :element_type => 'edge', :label => label, :count => count
+          end
+          result.v(:element_type => 'vertex').each do |type_node|
+            puts "vertices of type #{ type_node[:type] }: #{ type_node[:count] }"
+            graph.v(self, :type => type_node[:type]).property_variations result, type_node
+          end
+          result.v(:element_type => 'edge').each do |edge_node|
+            puts "edges with label #{ edge_node[:label] }: #{ edge_node[:count] }"
+            edge_route = graph.e(self, edge_node[:label])
+            edge_route.property_variations result, edge_node
+          end
+          result.v.each do |type_node|
+            begin
+              edges = graph.v(type_field => type_node[:type]).out_e
+              edge_types = edges.group_count do |e|
+                [e.label, e.in_vertex[type_field]]
+              end
+              edge_types.each do |(label, type), count|
+                puts "edges labelled #{ label } from #{ type_node[:type] } to #{ type }: #{ count }"
+                type_node.add_edges_to(label, result.v(:type => type), :count => count)
+              end
+            rescue => e
+              puts e.message
+            end
+          end
+          result
+        end
+      end
+
+      module Route
+        def property_variations(result, node)
+          prop_keys = group_count { |v| v.properties.keys.sort }
+          prop_keys.each do |keys, count|
+            prop_key = result.v(:element_type => 'property keys').detect { |v| v[:keys] == keys }
+            unless prop_key
+              prop_key = result.create_vertex :element_type => 'property keys', :keys => keys, :number => keys.count, :count => 0
+            end
+            prop_key[:count] += count
+            puts "  #{ count } with #{ keys.count } properties: #{ keys.inspect }"
+            node.add_edges_to :properties, prop_key, :count => count
+          end
+        end
+      end
+
+      module Vertices
+        def self.route_conditions
+          { :element_type => 'vertex' }
+        end
+
+        module Route
+          def out_edge_types
+            all_edges = graph.v(Edges)
+            out_e.labels.uniq.inject(all_edges) do |route, label|
+              route.branch { |b| b.filter(:label => label) }
+            end.v.v(Edges)
+          end
+
+          def in_edge_types
+            all_edges = graph.v(Edges)
+            in_e.labels.uniq.inject(all_edges) do |route, label|
+              route.branch { |b| b.filter(:label => label) }
+            end.v.v(Edges)
+          end
+
+          def property_variations
+            out_e(:properties).in_v(Properties)
+          end
+        end
+      end
+
+      module Edges
+        def self.route_conditions
+          { :element_type => 'edge' }
+        end
+
+        module Route
+          def property_variations
+            out_e(:properties).in_v(Properties)
+          end
+        end
+      end
+
+      module Properties
+        def self.route_conditions
+          { :element_type => 'property keys' }
+        end
+      end
+    end
+  end
+end

data/lib/pacer/utils/trie.rb

@@ -0,0 +1,93 @@
+module Pacer::Utils
+  module Trie
+    class << self
+      def trie(graph, name)
+        t = graph.v(self, :name => name).first
+        if t
+          t
+        else
+          graph.create_vertex self, :type => 'Trie', :name => name
+        end
+      end
+
+      def route_conditions
+        { :type => 'Trie' }
+      end
+    end
+
+    module Vertex
+      def find_word(word)
+        find word.scan(/./)
+      end
+
+      def find(array)
+        found = find_partial(array)
+        if found.length == array.length
+          result = found.last.in_vertex.add_extensions [Trie]
+          result.graph = graph
+          result
+        end
+      end
+
+      def find_partial(array)
+        return [] if array.empty?
+        strings = array.map &:to_s
+        max_depth = array.length - 1
+        found = []
+        v.out_e(strings.first).loop { |e| e.in_v.out_e }.while do |e, depth|
+          if e.label == "trie:#{strings[depth]}" and depth <= max_depth
+            found << e
+            :loop
+          end
+        end.to_a
+        found
+      end
+
+      def add_word(word)
+        add word.scan(/./)
+      end
+
+      def add(array)
+        found = find_partial(array)
+        if found.length == array.length
+          result = found.last.in_vertex
+        else
+          found[array.length] ||= nil
+          result = array.zip(found).inject(self) do |vertex, (part, edge)|
+            if edge
+              edge.in_vertex
+            else
+              new_vertex = graph.create_vertex :type => 'Trie'
+              graph.create_edge nil, vertex, new_vertex, "trie:#{part.to_s}"
+              new_vertex
+            end
+          end
+        end
+        result[:end] = true
+        result.graph = graph
+        result.add_extensions [Trie]
+      end
+
+      def path
+        result = []
+        v.in_e.chain_route(:pipe_class => Pacer::Pipes::LabelPrefixPipe, :pipe_args => 'trie:').loop do |e|
+          e.out_v.in_e.chain_route(:pipe_class => Pacer::Pipes::LabelPrefixPipe, :pipe_args => 'trie:')
+        end.while do |e, d|
+          if e.out_vertex[:type] == 'Trie'
+            :emit
+          else
+            :loop
+          end
+        end.paths.to_a.first.reverse.to_route(:element_type => :mixed, :graph => graph)
+      end
+
+      def array
+        path.e.labels.map { |label| label[/^trie:(.*)$/, 1] }.to_a
+      end
+
+      def word
+        array.join
+      end
+    end
+  end
+end

data/lib/pacer/utils/tsort.rb

@@ -0,0 +1,65 @@
+require 'tsort'
+
+module Pacer
+  module Utils
+    # Include this module in your traversal to use ruby's built-in TSort
+    # utility to sort your vertices according to the direction of the
+    # edges that connect them.
+    module TSort
+      module Route
+        include ::TSort
+
+        attr_accessor :tsort_anon_mod
+
+        # NOTE: this is a great example of dynamically injecting a custom method
+        # into a route.
+        def dependencies(&block)
+          anon_mod = Module.new
+          anon_mod.const_set :Route, TSort::Route
+          anon_mod.const_set :Vertex, Module.new
+          anon_mod::Vertex.const_set :DependenciesBlock, block
+          anon_mod::Vertex.instance_eval do
+            def self.included(target)
+              target.const_set :DependenciesBlock, self::DependenciesBlock
+            end
+          end
+          route = v(*(extensions - [TSort] + [anon_mod]))
+          route.tsort_anon_mod = anon_mod
+          route
+        end
+
+        def tsort_each_node
+          v.each do |vertex|
+            yield vertex
+          end
+        end
+
+        def tsort_each_child(node)
+          node.tsort_dependencies(tsort_anon_mod).each do |vertex|
+            yield vertex
+          end
+        end
+
+        def tsort
+          super.to_route(:graph => graph,
+                         :element_type => :vertex,
+                         :extensions => (extensions - [TSort, tsort_anon_mod]))
+        end
+      end
+
+      module Vertex
+        def tsort_each_node
+          yield self
+        end
+
+        def tsort_dependencies(tsort_anon_mod = nil)
+          if self.class.const_defined? :DependenciesBlock
+            self.class::DependenciesBlock.call(self).add_extension(tsort_anon_mod)
+          else
+            self.in
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer/utils/y_files.rb

@@ -0,0 +1,127 @@
+require 'nokogiri'
+require 'set'
+
+module Pacer
+  module Utils
+
+    # Exports a graph to GraphML with some yworks.com graphml formatting extensions.
+    class YFilesExport
+
+      # a proc that takes a vertex and returns a label string
+      attr_accessor :vertex_label
+      # a proc that takes a vertex and returns a color in hex format: "#aaee00"
+      attr_accessor :vertex_fill
+      # a proc that takes a vertex and returns a hash of properties to be exported
+      attr_accessor :vertex_properties
+
+      # a proc that takes an edge and returns a label string
+      attr_accessor :edge_label
+      # a proc that takes an edge and returns a color in hex format: "#aaee00"
+      attr_accessor :edge_color
+      # a proc that takes an edge and returns a hash of properties to be exported
+      attr_accessor :edge_properties
+
+      def initialize
+        self.vertex_label = proc { |v| v[:name] }
+        self.edge_label = proc { |e| e.label }
+        self.vertex_properties = self.edge_properties = proc { |x| x.properties }
+        self.vertex_fill = proc { |v| "#FFCC00" }
+        self.edge_color = proc { |e| "#000000" }
+      end
+
+      # Export the given graph to the given path in an extended .graphml format.
+      def export(graph, path)
+        x = xml(graph)
+        File.open(File.expand_path(path), 'w') do |f|
+          f.puts x.to_xml
+        end
+      end
+
+      # Returns the xml builder used to construct the xml for the given graph.
+      def xml(graph)
+        node_keys = Set[]
+        edge_keys = Set[]
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.graphml('xmlns' => "http://graphml.graphdrawing.org/xmlns",
+                      'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
+                      'xmlns:y' => "http://www.yworks.com/xml/graphml",
+                      'xsi:schemaLocation' => "http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd") do
+            xml.key 'for' => "node", 'id' => "y.nodegraphics", 'yfiles.type' => "nodegraphics"
+            xml.key 'attr.name' => "description", 'attr.type' => "string", 'for' => "node", 'id' => "d2"
+            xml.key 'for' => "edge", 'id' => "y.edgegraphics", 'yfiles.type' => "edgegraphics"
+            graph.v.each do |v|
+              xml.node :id => v.element_id do
+                xml.data :key => 'y.nodegraphics' do
+                  xml['y'].ShapeNode do
+                    #xml['y'].Geometry 'height' => "30.0", 'width' => "30.0", 'x' => "15.0", 'y' => "0.0"
+                    xml['y'].Fill 'color' => vertex_fill.call(v), 'transparent' => "false"
+                    xml['y'].BorderStyle 'color' => "#000000", 'type' => "line", 'width' => "1.0"
+                    xml['y'].NodeLabel('alignment' => "center",
+                                       'autoSizePolicy' => "content",
+                                       'fontFamily' => "Dialog",
+                                       'fontSize' => "12",
+                                       'fontStyle' => "plain",
+                                       'hasBackgroundColor' => "false",
+                                       'hasLineColor' => "false",
+                                       #'height' => "4.0",
+                                       'modelName' => "internal",
+                                       'modelPosition' => "c",
+                                       'textColor' => "#000000",
+                                       'visible' => "true"
+                                       #'width' => "4.0",
+                                       #'x' => "13.0",
+                                       #'y' => "13.0"
+                                      ) { xml.text vertex_label.call(v) }
+                    xml['y'].Shape 'type' => "rectangle"
+                  end
+                end
+                vertex_properties.call(v).each do |name, value|
+                  node_keys << name
+                  xml.data(:key => name) { xml.text value }
+                end
+              end
+            end
+            graph.e.each do |e|
+              xml.edge :id => e.element_id, :source => e.out_vertex.element_id, :target => e.in_vertex.element_id, :label => e.label do
+                xml.data :key => 'y.edgegraphics' do
+                  xml['y'].PolyLineEdge do
+                    xml['y'].LineStyle 'color' => edge_color.call(e), 'type' => 'line', 'width' => '1.0'
+                    xml['y'].Arrows 'source' => 'none', 'target' => 'standard'
+                    xml['y'].EdgeLabel('alignment' => "center",
+                                       #'distance' => "2.0",
+                                       'fontFamily' => "Dialog",
+                                       'fontSize' => "12",
+                                       'fontStyle' => "plain",
+                                       'hasBackgroundColor' => "false",
+                                       'hasLineColor' => "false",
+                                       #'height' => "18.1328125",
+                                       'modelName' => "side_slider",
+                                       #'preferredPlacement' => "right",
+                                       #'ratio' => "0.43751239324621083",
+                                       'textColor' => "#000000",
+                                       'visible' => "true"
+                                       #'width' => "28.87890625",
+                                       #'x' => "49.62109375",
+                                       #'y' => "-27.201349990172957"
+                                      ) { xml.text edge_label.call(e) }
+                  end
+                end
+                edge_properties.call(e).each do |name, value|
+                  edge_keys << name
+                  xml.data(:key => name) { xml.text value }
+                end
+              end
+            end
+
+            node_keys.each do |key|
+              xml.key :id => key, :for => 'node', 'attr.name' => key, 'attr.type' => 'string'
+            end
+            edge_keys.each do |key|
+              xml.key :id => key, :for => 'edge', 'attr.name' => key, 'attr.type' => 'string'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pacer/utils.rb

@@ -0,0 +1,10 @@
+module Pacer
+  module Utils
+    autoload :YFilesExport, 'pacer/utils/y_files'
+    autoload :GraphAnalysis, 'pacer/utils/graph_analysis'
+    autoload :TSort, 'pacer/utils/tsort'
+    autoload :Trie, 'pacer/utils/trie'
+    import com.tinkerpop.blueprints.pgm.util.AutomaticIndexHelper
+  end
+end
+

data/lib/pacer/version.rb

@@ -0,0 +1,13 @@
+module Pacer
+  unless const_defined? :VERSION
+    VERSION = "0.9.1.1"
+
+    JAR = "pacer-#{ VERSION }-standalone.jar"
+    JAR_PATH = "lib/#{ JAR }"
+
+    START_TIME = Time.now
+
+    BLUEPRINTS_VERSION = "1.0"
+    PIPES_VERSION = "0.8"
+  end
+end

data/lib/pacer/wrappers/edge_wrapper.rb

@@ -0,0 +1,51 @@
+module Pacer::Wrappers
+  class EdgeWrapper < ElementWrapper
+    include Pacer::Edge
+    include Pacer::Core::Graph::EdgesRoute
+    include Pacer::ElementMixin
+    include Pacer::EdgeMixin
+
+    def_delegators :@element,
+      :getId, :getLabel, :getPropertyKeys, :getProperty, :setProperty, :removeProperty,
+      :getInVertex, :getOutVertex,
+      :getRawEdge, 
+      :graph, :graph=, :<=>, :==
+
+    class << self
+      def wrapper_for(exts)
+        @wrappers = {} unless defined? @wrappers
+        @wrappers[exts.to_set] ||= build_edge_wrapper(exts)
+      end
+
+      def clear_cache
+        @wrappers = {}
+      end
+
+      protected
+
+      def build_edge_wrapper(exts)
+        build_extension_wrapper(exts, [:Route, :Edge], EdgeWrapper)
+      end
+    end
+
+    # This method must be defined here rather than in the superclass in order
+    # to correctly override the method in an included module
+    def extensions
+      self.class.extensions
+    end
+
+    # This method must be defined here rather than in the superclass in order
+    # to correctly override the method in an included module
+    def element
+      @element
+    end
+
+    def add_extensions(exts)
+      if exts.any?
+        self.class.wrap(element, extensions + exts.to_a)
+      else
+        self
+      end
+    end
+  end
+end

data/lib/pacer/wrappers/element_wrapper.rb

@@ -0,0 +1,78 @@
+module Pacer::Wrappers
+  class ElementWrapper
+    include Pacer::Element
+    extend Forwardable
+    include Comparable
+
+    class << self
+      def wrap(element, exts)
+        wrapper_for(exts).new(element.element)
+      end
+
+      def extensions
+        @extensions ||= []
+      end
+
+      def clear_cache
+        Pacer.send :remove_const, :Wrap if Pacer.const_defined? :Wrap
+        VertexWrapper.clear_cache
+        EdgeWrapper.clear_cache
+      end
+
+      def route_conditions
+        return @route_conditions if defined? @route_conditions
+        @route_conditions = extensions.inject({}) do |h, ext|
+          if ext.respond_to? :route_conditions
+            h.merge! ext.route_conditions
+          else
+            h
+          end
+        end
+        @route_conditions
+      end
+
+      protected
+
+      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/, '')
+        eval "module ::Pacer; module Wrap; class #{classname.to_s} < #{sc_name}; end; end; end"
+        wrapper = Pacer::Wrap.const_get classname
+        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
+
+    def initialize(element)
+      @element = element
+      after_initialize
+    end
+
+    def element_id
+      @element.get_id
+    end
+
+    def hash
+      @element.hash
+    end
+
+    def eql?(other)
+      @element.eql?(other)
+    end
+
+    protected
+
+    def after_initialize
+    end
+  end
+end

data/lib/pacer/wrappers/new_element.rb

@@ -0,0 +1,106 @@
+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