dogviz 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2f28cea79616735c3ff115295186438f33407ff
-  data.tar.gz: afbe975455318158f50c85cf236f8308e385ed21
+  metadata.gz: d93013b0cc858fbd5459c5fc0794cc334df4ab7f
+  data.tar.gz: ee353c1dfe91e9b10901d2305944806b62f3e5c8
 SHA512:
-  metadata.gz: 5facef62f26a853f1569cafe84b9c66724830d461816f1ed264c66d9d379da95670e959a89512bf74baa35bd5bd08d8e6bf8e3a571c16799ad006c2a12c61b84
-  data.tar.gz: c1eac0792f9a326575726b4d321c615c331526c30081bb1fe04d3b4afac463c8851d8bf4409fdeed04be5eb952bc0e6bec0f995b5269f29dcc0b8e3c18067ef3
+  metadata.gz: 76aa31f77889f81eae728587e3660ed9650b09a04a1fced9fe87699631870a73f98f62f0acfccb9af84399b7f68c380f177df846ce13aa2458e99561061c4499
+  data.tar.gz: 7fa12c43c393cb7714e697bebdece5fb387d72df776a96aea8ec794932b56593158b906c9bb8e68e2999dd893174cea158e2e92b76c8a5968062b7cdc02e867c

data/lib/dogviz/colorizer.rb

@@ -0,0 +1,25 @@
+module Dogviz
+  class Colorizer
+    def initialize
+      @i = 0
+      @colors = %w(#9e0142
+#d53e4f
+#e45d33
+#ed9e61
+#762a83
+#9970ab
+#c6f578
+#abdda4
+#66c2a5
+#3288bd
+#5e4fa2)
+    end
+
+    def next
+      color = @colors[@i]
+      @i += 1
+      @i = 0 unless @i < @colors.length
+      color
+    end
+  end
+end

data/lib/dogviz/common.rb

@@ -0,0 +1,89 @@
+module Dogviz
+  module Common
+    def create_id(name, parent)
+      parts = []
+      parts << parent.id if parent.respond_to? :id
+      parts += name.split /\s/
+      parts.join '_'
+    end
+
+    def root
+      ancestors.last
+    end
+
+    def ancestors
+      ancestors = [parent]
+      loop do
+        break unless ancestors.last.respond_to?(:parent)
+        ancestors << ancestors.last.parent
+      end
+      ancestors
+    end
+
+    def info(fields)
+      @info.merge! fields
+      setup_render_attributes(label: label_with_info)
+    end
+
+    def doclink(url)
+      setup_render_attributes(URL: url)
+    end
+
+    def label_with_info
+      lines = [name]
+      @info.each { |k, v|
+        lines << "#{k}: #{v}"
+      }
+      lines.join "\n"
+    end
+
+    def setup_render_attributes(attributes)
+      @attributes = {} if @attributes.nil?
+      @attributes.merge!(attributes)
+    end
+
+    def rollup?
+      @rollup
+    end
+
+    def rollup!
+      @rollup = true
+      self
+    end
+
+    def skip!
+      @skip = true
+      self
+    end
+
+    def skip?
+      @skip
+    end
+
+    def in_skip?
+      skip? || under_skip?
+    end
+
+    def under_skip?
+      ancestors.any? &:skip?
+    end
+
+    def under_rollup?
+      ancestors.any? &:rollup?
+    end
+
+    def in_rollup?
+      rollup? || under_rollup?
+    end
+
+    def on_top_rollup?
+      rollup? && !under_rollup?
+    end
+
+    def inherited_render_options
+      inherited = {}
+      inherited[:fontname] = parent.render_options[:fontname] if parent.render_options.include?(:fontname)
+      inherited
+    end
+  end
+end

data/lib/dogviz/container.rb

@@ -0,0 +1,88 @@
+require_relative 'common'
+require_relative 'nominator'
+require_relative 'parent'
+
+module Dogviz
+  class Container
+    include Common
+    include Nominator
+    include Parent
+
+    attr_reader :parent
+    attr_reader :name, :id, :node, :render_id, :render_type, :render_options, :children
+
+    def initialize(parent, name, options = {})
+      @children = []
+      @by_name = Registry.new name
+      @parent = parent
+      @name = name
+      @id = create_id(name, parent)
+      @skip = false
+      @info = {}
+
+      init_rollup options
+
+      setup_render_attributes label: name
+
+      @render_options = options.merge inherited_render_options
+
+      parent.register name, self
+    end
+
+    def register(name, thing)
+      @by_name.register name, thing
+      parent.register name, thing
+    end
+
+    def render(renderer)
+      if on_top_rollup?
+        do_render_node renderer
+      elsif !under_rollup?
+        do_render_subgraph renderer
+      end
+
+      children.each { |c|
+        c.render renderer
+      }
+    end
+
+    def render_edges(renderer)
+      children.each { |c|
+        c.render_edges renderer
+      }
+    end
+
+    private
+
+    def do_render_subgraph(renderer)
+      @render_type = :subgraph
+      render_id = cluster_prefix + id
+      attributes = @attributes
+      @render_id = render_id
+      @subgraph = renderer.render_subgraph(parent, render_id, render_options, attributes)
+    end
+
+    def do_render_node(renderer)
+      @render_type = :node
+      @render_id = id
+      render_id = @render_id
+      attributes = @attributes
+      renderer.render_node(parent, render_id, render_options, attributes)
+    end
+
+    def init_rollup(options)
+      @rollup = false
+      rollup! if options[:rollup]
+      options.delete(:rollup)
+    end
+
+    def cluster_prefix
+      is_cluster = true
+      if @render_options.has_key? :cluster
+        is_cluster = @render_options[:cluster]
+        @render_options.delete :cluster
+      end
+      cluster_prefix = (is_cluster ? 'cluster_' : '')
+    end
+  end
+end

data/lib/dogviz/duplicate_lookup_error.rb

@@ -0,0 +1,7 @@
+module Dogviz
+  class DuplicateLookupError < LookupError
+    def initialize(context, name)
+      super context, "More than one object registered of name '#{name}' - you'll need to search in a narrower context"
+    end
+  end
+end

data/lib/dogviz/flow.rb

@@ -0,0 +1,67 @@
+require_relative 'sequence_renderer'
+require_relative 'thing'
+require_relative 'process'
+
+module Dogviz
+  class Flow
+    def initialize(sys, name)
+      @sys = sys
+      @name = name
+      @calls = []
+    end
+
+    def make_connections
+      calls.each { |from, to, label|
+        thing_of(from).points_to thing_of(to), label: label
+      }
+    end
+
+    def flows(*steps)
+      from = nil
+      to = nil
+      label = nil
+      steps.each do |step|
+        if from.nil?
+          from = ensure_is_thing(step)
+        elsif label.nil? && step.is_a?(String)
+          label = step
+        elsif to.nil?
+          to = ensure_is_thing(step)
+        end
+        unless to.nil?
+          calls << [from, to, label]
+          from = to
+          to = label = nil
+        end
+      end
+    end
+
+    def ensure_is_thing(step)
+      raise "Expected some thing or process: '#{step}' already got: #{calls}" unless step.is_a?(Thing) || step.is_a?(Process)
+      step
+    end
+
+    def output(type_to_file)
+      type = type_to_file.keys.first
+      raise "Only support sequence, not: '#{type}'" unless type == :sequence
+      render.output(type_to_file)
+    end
+
+    def render
+      renderer = SequenceRenderer.new(@name)
+      calls.each do |from, to, label|
+        renderer.render_edge from, to, {label: label}
+      end
+      renderer.rendered
+    end
+
+    private
+
+    attr_reader :calls, :sys
+
+    def thing_of(it)
+      return it.processor if it.is_a?(Process)
+      it
+    end
+  end
+end

data/lib/dogviz/flowable.rb

@@ -0,0 +1,9 @@
+require_relative 'process'
+
+module Dogviz
+  module Flowable
+    def does(action)
+      Process.new(self, action)
+    end
+  end
+end

data/lib/dogviz/graphviz_renderer.rb

@@ -0,0 +1,60 @@
+require 'ruby-graphviz'
+require 'date'
+
+module Dogviz
+  class GraphvizRenderer
+    attr_reader :graph
+
+    def initialize(title, hints)
+      @graph = GraphViz.digraph(title)
+      @graph[hints]
+      @subgraphs = {}
+      @nodes = {}
+    end
+
+    def render_edge(from, other, options)
+      edge = graph.add_edges from.id, other.id
+      options.each { |key, value|
+        edge[key] = value unless value.nil?
+      }
+      edge
+    end
+
+    def render_node(parent, id, options, attributes)
+      clean_node_options options
+      default_options = {:shape => 'box', :style => ''}
+      node = parent_node(parent).add_nodes(id, default_options.merge(options))
+      apply_render_attributes node, attributes
+    end
+
+    def render_subgraph(parent, id, options, attributes)
+      subgraph = parent_node(parent).add_graph(id, options)
+      apply_render_attributes subgraph, attributes
+      @subgraphs[id] = subgraph
+      subgraph
+    end
+
+    private
+
+    def clean_node_options(options)
+      options.delete(:rank)
+      options.delete(:cluster)
+      options
+    end
+
+    def parent_node(parent)
+      return graph unless parent.respond_to?(:render_id)
+      node = graph.search_node(parent.render_id)
+      return node unless node.nil?
+      subgraph = @subgraphs[parent.render_id]
+      raise "couldn't find node or graph: #{parent.render_id}, out of graphs: #{graph_ids}" if subgraph.nil?
+      subgraph
+    end
+
+    def apply_render_attributes(node, attributes)
+      attributes.each do |key, value|
+        node[key] = value
+      end
+    end
+  end
+end

data/lib/dogviz/logical_container.rb

@@ -0,0 +1,8 @@
+require_relative 'container'
+module Dogviz
+  class LogicalContainer < Container
+    def initialize(parent, name, options)
+      super parent, name, options.merge(cluster: false)
+    end
+  end
+end

data/lib/dogviz/lookup_error.rb

@@ -0,0 +1,7 @@
+module Dogviz
+  class LookupError < StandardError
+    def initialize(context, message)
+      super "(in context '#{context}') #{message}"
+    end
+  end
+end

data/lib/dogviz/missing_match_block_error.rb

@@ -0,0 +1,7 @@
+module Dogviz
+  class MissingMatchBlockError < LookupError
+    def initialize(context)
+      super context, 'need to provide match block'
+    end
+  end
+end

data/lib/dogviz/nominator.rb

@@ -0,0 +1,18 @@
+module Dogviz
+  module Nominator
+    def nominate(names_to_nominees)
+      names_to_nominees.each { |name, nominee|
+        self.class.send(:define_method, name) do
+          nominee
+        end
+      }
+    end
+
+    def nominate_from(nominee_nominator, *nominee_names)
+      nominee_names.each { |name|
+        accessor_sym = name.to_s.to_sym
+        nominate accessor_sym => nominee_nominator.send(accessor_sym)
+      }
+    end
+  end
+end

data/lib/dogviz/parent.rb

@@ -0,0 +1,38 @@
+module Dogviz
+  module Parent
+    def find_all(&matcher)
+      raise MissingMatchBlockError.new unless block_given?
+      @by_name.find_all &matcher
+    end
+
+    def find(name=nil, &matcher)
+      if block_given?
+        @by_name.find &matcher
+      else
+        raise 'Need to provide name or block' if name.nil?
+        @by_name.lookup name
+      end
+    end
+
+    def thing(name, options={})
+      add Thing.new self, name, options
+    end
+
+    def container(name, options={})
+      add Container.new self, name, options
+    end
+
+    def logical_container(name, options={})
+      add LogicalContainer.new self, name, options
+    end
+
+    def group(name, options={})
+      logical_container name, options
+    end
+
+    def add(child)
+      @children << child
+      child
+    end
+  end
+end

data/lib/dogviz/process.rb

@@ -0,0 +1,18 @@
+module Dogviz
+  class Process
+    def initialize(processor, description)
+      @processor = processor
+      @description = description
+    end
+
+    def name
+      @processor.name
+    end
+
+    def description
+      @description
+    end
+
+    attr_reader :processor
+  end
+end

data/lib/dogviz/registry.rb

@@ -0,0 +1,39 @@
+require_relative 'lookup_error.rb'
+require_relative 'missing_match_block_error.rb'
+require_relative 'duplicate_lookup_error.rb'
+
+module Dogviz
+  class Registry
+    def initialize(context)
+      @context = context
+      @by_name = {}
+      @all = []
+    end
+
+    def register(name, thing)
+      @all << thing
+      if @by_name.has_key?(name)
+        @by_name[name] = DuplicateLookupError.new @context, name
+      else
+        @by_name[name] = thing
+      end
+    end
+
+    def find(&matcher)
+      raise LookupError.new(@context, "need to provide match block") unless block_given?
+      @all.find &matcher
+    end
+
+    def find_all(&matcher)
+      raise MissingMatchBlockError.new(@context) unless block_given?
+      @all.select &matcher
+    end
+
+    def lookup(name)
+      found = @by_name[name]
+      raise LookupError.new(@context, "could not find '#{name}'") if found.nil?
+      raise found if found.is_a?(Exception)
+      found
+    end
+  end
+end

data/lib/dogviz/rendered_sequence.rb

@@ -0,0 +1,13 @@
+module Dogviz
+  class RenderedSequence
+    def initialize(lines)
+      @lines = lines
+    end
+
+    def output(type_to_file)
+      text = @lines.map(&:strip).join "\n"
+      File.write type_to_file.values.first, text
+      text
+    end
+  end
+end

data/lib/dogviz/sequence_renderer.rb

@@ -0,0 +1,47 @@
+require_relative 'process'
+require_relative 'rendered_sequence'
+
+module Dogviz
+  class SequenceRenderer
+    attr_reader :lines
+
+    def initialize(title)
+      @lines = []
+    end
+
+    def render_edge(from, other, options)
+
+      detail = options[:label]
+      receiver_label = other.name
+      sender_label = from.name
+      if other.is_a?(Process)
+        detail = process_annotations(detail, sender_label, receiver_label, other.description)
+        receiver_label = process_start_label(receiver_label)
+      elsif from.is_a?(Process)
+        receiver_label = process_end_label(receiver_label)
+      end
+      lines << "#{sender_label} -> #{receiver_label}: #{detail}"
+    end
+
+    def rendered
+      RenderedSequence.new lines
+    end
+
+    private
+
+    def process_start_label(receiver_label)
+      "+#{receiver_label}"
+    end
+
+    def process_end_label(receiver_label)
+      "-#{receiver_label}"
+    end
+
+    def process_annotations(detail, sender, receiver, process_description)
+      detail = [detail,
+                "note right of #{receiver}",
+                "  #{process_description}",
+                'end note'].join("\n")
+    end
+  end
+end

data/lib/dogviz/sigma_graph_hash.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Dogviz
+  class SigmaGraphHash < Hash
+    def initialize(hash)
+      hash.each { |k, v|
+        self[k] = v
+      }
+    end
+
+    def output(type_to_filename)
+      raise StandardError.new('must provide hash (json: somejsonfilename.json)') unless type_to_filename.is_a?(Hash)
+      filename = get_json_filename(type_to_filename)
+      File.write filename, to_json
+    end
+
+    private
+
+    def get_json_filename(type_to_filename)
+      type = type_to_filename.keys.first
+      raise StandardError.new('json output only supported') unless type == :json
+      type_to_filename[type]
+    end
+  end
+end

data/lib/dogviz/sigma_renderer.rb

@@ -0,0 +1,32 @@
+require_relative 'sigma_graph_hash'
+
+module Dogviz
+  class SigmaRenderer
+    def initialize(title)
+      @title = title
+      @nodes = []
+      @edges = []
+    end
+
+    def graph
+      SigmaGraphHash.new(nodes: nodes, edges: edges)
+    end
+
+    def render_node(parent, id, render_options, attributes)
+      @nodes << {id: id, label: id}
+    end
+
+    def render_edge(from, to, options)
+      @edges << {
+          id: "#{from.id}->#{to.id}",
+          label: "#{from.id}->#{to.id}",
+          source: from.id,
+          target: to.id
+      }
+    end
+
+    private
+
+    attr_reader :nodes, :edges
+  end
+end