ruby-graph-walker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 098a0fa35d5773837d9b335237aa86d664835da3
+  data.tar.gz: 2450e77e9c9de04c866daeaad447f81f34f2d58b
+SHA512:
+  metadata.gz: 43d80e28ce884734f03b408099f8ee123e558ed631300d36f4342e5443606f45b9e94c9d22d8af579a3724313d453a55f7f2614e8e5c79081f942e4188b273a5
+  data.tar.gz: ab81246bc8d2c9f36f3aa49e598fe4086e33d89c604f29e3e1f49dee49b1528e346ef959c8f8004cb90bd7362c0191eca3ee76a2bdcb04466e9fbf0d6f1cbb3c

data/lib/colorize.rb

@@ -0,0 +1,28 @@
+module RubyGraphWalker
+  def colorize(text, color_code)
+    "\e[#{color_code}m#{text}\e[0m"
+  end
+
+  def red(text); colorize(text, 31); end
+  def green(text); colorize(text, 32); end
+  def yellow(text); colorize(text, 33); end
+  def blue(text); colorize(text, 34); end
+  def magenta(text); colorize(text, 35); end
+  def cyan(text); colorize(text, 36); end
+  def yellow_background(text); colorize(text, 43); end
+  def magenta_background(text); colorize(text, 45); end
+  def exchange_foreground_and_background(text); colorize(text, 7); end
+  def light_red(text); colorize(text, 91); end
+
+  def log_warning(msg)
+    puts magenta(msg)
+  end
+
+  def log_error(msg)
+    puts light_red(msg)
+  end
+
+  def log_info(msg)
+    puts green(msg)
+  end
+end

data/lib/dijkstra.rb

@@ -0,0 +1,57 @@
+require_relative 'pq'
+
+class Dijkstra
+  def initialize(graph, source_vertex)
+    @graph = graph
+    @vertices = @graph.vertices
+    @source_vertex = source_vertex
+    @path_to = {}
+    @distance_to = {}
+    @pq = PriorityQueue.new
+    compute_shortest_path
+  end
+
+  def shortest_path_to(vertex)
+    return [] unless reachable?(vertex)
+    return [] if @distance_to[vertex] == 0
+    path = []
+    while vertex != @source_vertex
+      path.unshift(vertex)
+      vertex = @path_to[vertex]
+    end
+    path.unshift(@source_vertex)
+  end
+
+  private
+
+  def reachable?(vertex)
+    not @distance_to[vertex] == Float::INFINITY
+  end
+
+  def compute_shortest_path
+    update_distance_of_all_edges_to(Float::INFINITY)
+    @distance_to[@source_vertex] = 0
+
+    @pq.insert(@source_vertex, 0)
+    while @pq.any?
+      vertex = @pq.remove_min
+      @vertices[vertex].edges.each do |edge|
+        update(edge)
+      end
+    end
+  end
+
+  def update_distance_of_all_edges_to(distance)
+    @vertices.each do |key, value|
+      @distance_to[key] = distance
+    end
+  end
+
+  def update(edge)
+    raise "#{edge.to} doesn't exist, check edge[:to] in #{edge.inspect}" if @distance_to[edge.to].nil?
+    return if @distance_to[edge.to] <= @distance_to[edge.from] + edge.weight
+    @distance_to[edge.to] = @distance_to[edge.from] + edge.weight
+    @path_to[edge.to] = edge.from
+    @pq.insert(edge.to, @distance_to[edge.to])
+  end
+end

data/lib/graph.rb

@@ -0,0 +1,153 @@
+require 'dijkstra'
+require 'colorize'
+
+module RubyGraphWalker
+  class Vertex
+    attr_accessor :name, :weight, :edges, :trait, :visited, :zindex
+    def initialize(args = {})
+      [:name, :edges, :trait].each { |key| raise "#{key} is not defined for Vertex #{args}" unless args[key] }
+      @name = args[:name]
+      @weight = args[:weight] || 1
+      @trait = args[:trait]
+      @visited = args[:visited] || false
+      @weight = args[:zindex] || 0
+      @edges = []
+
+      args[:edges].each do |edge|
+        e = Edge.new(edge)
+        e.from = @name
+        e.to = edge[:to]
+        add_edge(e)
+      end
+    end
+
+    private 
+    def add_edge(e)
+      @edges << e
+    end
+  end
+
+  class Edge
+    attr_accessor :name, :from, :to, :weight, :visited, :proc, :error_count
+    def initialize(args = {})
+      [:name, :to, :proc].each { |key| raise "#{key} is not defined for Edge #{args}" unless args[key] }
+      @name = args[:name]
+      @from = args[:from]
+      @to = args[:to]
+      @weight = args[:weight] || 1
+      @visited = args[:visited] || false
+      @proc = args[:proc]
+      @error_count = 0
+    end
+
+    def run
+      @proc.call
+      @visited = true
+    end
+  end
+
+  class Graph
+    attr_accessor :vertices, :edges, :edges_by_name
+    def initialize(vertices)
+      @vertices = {}
+      @edges_by_name = {}
+      @edges = []
+      vertices.each do |v_params|
+        v = Vertex.new(v_params)
+        @vertices[v_params[:name]] = v
+        v.edges.each do |edge|
+          puts "Warning: multiple edges named '#{edge.name}'" if @edges_by_name[edge.name]
+          @edges_by_name[edge.name] = edge
+          @edges << edge
+        end
+      end
+    end
+
+    def find_path_via_edge(from, to, edge_name)
+      log_info "#{from} -> #{to} via: (#{edge_name}): "
+      matched_edges = @edges.select { |edge| edge.name == edge_name }
+      log_error "no edge found for '#{edge_name}'" if matched_edges.size == 0
+      log_error "multiple edges matched for '#{edge_name}'" if matched_edges.size > 1
+      via_edge = matched_edges.first
+      plan = []
+
+      first_path = Dijkstra.new(self, from).shortest_path_to(via_edge.from)
+
+      first_path.each_cons(2) do |path|
+        start, dest = path
+        vertex = @vertices[start]
+        edge = vertex.edges.select { |e| e.to == dest}.first
+        plan << {v: vertex, e: edge}
+      end
+
+      via_v = @vertices[via_edge.from]
+      plan << {v: via_v, e: via_edge}
+
+      second_path = Dijkstra.new(self, via_edge.to).shortest_path_to(to)
+
+      second_path.each_cons(2) do |path|
+        start, dest = path
+        vertex = @vertices[start]
+        edge = vertex.edges.select { |e| e.to == dest }.first
+        plan << {v: vertex, e: edge}
+      end
+      plan 
+    end
+
+    def find_path(from, to, args = {})  
+      vertex_path = []
+      plan = []
+      via_type = args.keys.join
+
+      case via_type
+      when "via"
+        via = args[:via]
+        vertex_path = Dijkstra.new(self, from).shortest_path_to(via) + Dijkstra.new(self, via).shortest_path_to(to).drop(1)
+        vertex_path.each_cons(2) do |path|
+          f, d = path
+          vertex = @vertices[d]
+          edge = vertex.edges.select { |e| e.to == d}.first
+          plan << {v: vertex, e: edge}
+        end
+      when "via_edge"
+        via_edge = args[:via_edge]
+        plan = find_path_via_edge(from, to, via_edge)
+
+      # when "via_edges"
+      #   edges = args[:via_edges]
+      #   if edges.size < 2
+      #     raise "please specify multiple edges"
+      #   end
+      #   v = nil
+      #   edges[0..-2].each do |edge|
+      #     start = (plan.last[:v].name if plan.last) || from
+      #     v = @edges_by_name[edge].to
+      #     plan += find_path_via_edge(start, v, edge)
+      #   end
+      #   plan += find_path_via_edge(v, to, edges.last)
+      when ""
+        vertex_path = Dijkstra.new(self, from).shortest_path_to(to)
+        
+        vertex_path.each_cons(2) do |path|
+          from, d = path
+          vertex = @vertices[from]
+          edge = vertex.edges.select { |e| e.to == d}.first
+          plan << {v: vertex, e: edge}
+        end
+        if plan.empty? and from == to
+          return  :on_the_spot
+        end
+      end
+
+      if plan.any?
+        puts plan.map {|p| "#{p[:v].name if p[:v]} (#{p[:e].name if p[:e]})" }.join(" -> ") + " >> #{@vertices[to].name}" 
+      else
+        raise "No path from #{from} to #{to}" 
+      end
+      plan
+    end
+  end
+
+end
+
+

data/lib/pq.rb

@@ -0,0 +1,23 @@
+class PriorityQueue
+  def initialize
+    @queue = {}
+  end
+
+  def any?
+    @queue.any?
+  end
+
+  def insert(key, value)
+    @queue[key] = value
+    order_queue
+  end
+
+  def remove_min
+    @queue.shift.first
+  end
+
+  private
+  def order_queue
+    @queue.sort_by {|_key, value| value }
+  end
+end

data/lib/ruby_graph_walker.rb

@@ -0,0 +1,2 @@
+require 'graph'
+require 'test_planner'

data/lib/test_planner.rb

@@ -0,0 +1,98 @@
+require 'colorize'
+
+module RubyGraphWalker
+  module TestPlanner
+    def search_vertex(query_method = 'query')
+      vertices = @graph.vertices.values
+      candidates = vertices.select do |v|
+        trait = v.trait
+        if trait.is_a?(Proc)
+          trait.call
+        elsif trait.is_a?(Array)
+          trait.any? { |t| (send query_method, t).any? }
+        else
+          send(query_method, trait).any?
+        end
+      end
+
+      if candidates.size > 1
+        log_warning "Warning: multiple vertices found: #{candidates.map {|c| c[:name]}.join(' ') }"   
+      elsif candidates.size == 0
+        if send(query_method, "*").any?
+          raise "No vertex found"
+        else
+          raise "Connection refused"
+        end
+      end
+      candidates.max_by {|v| v.zindex}
+    end
+
+    def path_to(to, args = {})
+      v = search_vertex
+      @graph.find_path(v.name, to, args)
+    end
+
+    def run(plan, args = {})
+      raise "on the spot" if plan == :on_the_spot
+
+      plan.each do |p|
+        edge = p[:e]
+        raise "edge is nil" if edge.nil?
+        edge.run
+        @graph.vertices[edge.from].visited = true
+      end
+    end
+
+    def text_logger(args = {})
+      log_file_name = "#{Time.now.strftime('%Y_%m_%d_%H_%M_%S')}.txt"
+      @log_file ||= File.open(log_file_name, 'w') 
+    end
+
+    def log(msg)
+      text_logger.puts(msg)
+    end
+
+    def start(graph, args = {})
+      @graph = graph
+      unvisited_edges = @graph.edges_by_name.select { |k, v| v.visited == false and v.weight > 1 }
+      starting_point = args[:start] || @graph.vertices.keys.first
+      while unvisited_edges.any?
+        edge_name = largest_weight(unvisited_edges).first
+        edge = @graph.edges_by_name[edge_name]
+        plan = path_to(starting_point, via_edge: edge_name)
+        begin
+          run(plan)
+        rescue => e
+          edge.error_count += 1
+          log edge.name + " failed! #{edge.error_count}"
+          e.backtrace.each do |text|
+            log text
+          end 
+
+          retries = 3
+          begin
+            sleep 10
+            new_plan = path_to(edge.from)
+            run(new_plan, args)
+          rescue
+            edge.error_count += 1
+            retry unless (retries -= 1).zero?
+          end
+        end
+        unvisited_edges = @graph.edges_by_name.select { |k, v| v.visited == false and v.weight > 1 and v.error_count < 3}
+      end
+
+      @graph.edges_by_name.each do |k, v|
+        log "#{k} error count: #{v.error_count}"
+      end
+
+      text_logger.close
+    end
+
+    private
+    def largest_weight(hash)
+      hash.max_by{|k,v| v.weight}
+    end
+
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: ruby-graph-walker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- astro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-09 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email: astro2linus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/colorize.rb
+- lib/dijkstra.rb
+- lib/graph.rb
+- lib/pq.rb
+- lib/ruby_graph_walker.rb
+- lib/test_planner.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby Graph Walker
+test_files: []