dogviz 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7fd14011b87419590d6395eaed53feebf8e5485
+  data.tar.gz: 692dbf2318025b7176b3deb470aadcbbc3539f4d
+SHA512:
+  metadata.gz: de38e540d402cf39df368688e07b1a405b1558b906074a925c844b2830a44988736f9d199491f5cdae43f55cd2589a745156b08f04fa2dac1c61830019ca997d
+  data.tar.gz: 676fa2fff0072567e6210001605f0286069a91629432e6941d2d86d56d41eb015000436f8252d79b3c4e2678d0c994df223d538c58bceb3322187040b41f9770

data/.gitignore

@@ -0,0 +1,6 @@
+.idea
+*-generated.*
+coverage
+sys.rb
+dogviz*gem
+Gemfile.lock

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Dan Moore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+# dogviz
+domain object graph visualisation built on graphviz
+
+bundle install
+
+bundle exec ruby examples/website.rb

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/setup'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['tests/test*.rb']
+  t.verbose = true
+end
+
+require 'colorize'
+at_exit {
+  if $?.exitstatus == 0
+    puts 'PASSED'.green
+  else
+    puts 'FAILED'.red
+  end
+}

data/dogviz.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dogviz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dogviz"
+  spec.version       = Dogviz::VERSION
+  spec.authors       = ["damned"]
+  spec.email         = ["writetodan@yahoo.com"]
+
+  spec.summary       = %q{domain object graph visualisation}
+  spec.description   = %q{leverages graphviz to generate multiple views of a domain-specific graph}
+  spec.homepage      = "https://github.com/damned/dogviz"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'simplecov', '~> 0'
+  spec.add_development_dependency 'colorize', '~> 0'
+
+  spec.add_dependency 'ruby-graphviz', '~> 0'
+end

data/examples/website.rb

@@ -0,0 +1,22 @@
+require_relative 'website_domain'
+
+def describe_tw_com(sys)
+  website = sys.thing('website')
+  sys.user('visitor').points_to website
+end
+
+def output(sys, name)
+  sys.output(dot: "#{name}-generated.dot")
+  sys.output(png: "#{name}-generated.png")
+  sys.output(svg: "#{name}-generated.svg")
+end
+
+include WebsiteDomain
+
+render_hints = {
+    splines: false
+}
+sys = WebsiteSystem.new 'website', render_hints
+
+describe_tw_com sys
+output sys, 'website'

data/examples/website_domain.rb

@@ -0,0 +1,162 @@
+require 'dogviz'
+
+module WebsiteDomain
+  include Dogviz
+  module Creators
+    def box(name, options={})
+      add Box.new(self, name, options)
+    end
+    def pipeline(name)
+      add Pipeline.new(self, name)
+    end
+    def lb(name)
+      add LoadBalancer.new self, name
+    end
+    def process(name)
+      add Process.new self, name
+    end
+    def external(name, options={})
+      add External.new self, name, options
+    end
+    def grouping(name, options = {})
+      add Grouping.new self, name, options
+    end
+    def data_centre(name)
+      add DataCentre.new self, name
+    end
+    def user(name)
+      add User.new self, name
+    end
+  end
+  class Grouping < LogicalContainer
+    include Creators
+  end
+  class WebsiteSystem < System
+    include Creators
+    def render
+      puts 'Rendering...' unless @rendered
+      super
+    end
+    def rollup_by_class(type)
+      find_all { |n|
+        n.is_a?(type)
+      }.each &:rollup!
+    end
+    def   rollup_names_starting(start)
+      find_all { |n|
+        n.name.start_with? start
+      }.each &:rollup!
+    end
+    def rollup_names_including(substring)
+      find_all { |n|
+        n.name.include? substring
+      }.each &:rollup!
+    end
+  end
+  class Box < Container
+    def initialize(parent, name, options={})
+      super parent, name, {style: 'filled', color: '#ffaaaa'}.merge(options)
+    end
+    def service(name, options={})
+      add Service.new self, name, options
+    end
+    def process(name)
+      add Process.new self, name
+    end
+  end
+  class Service < Container
+    def initialize(parent, name, options={})
+      super parent, name, options.merge(color: '#cccccc', style: 'filled')
+    end
+    include Creators
+  end
+  class DataCentre < Container
+    def initialize(parent, name, options={})
+      super parent, name
+    end
+    include Creators
+  end
+  class Pipeline < Container
+    def initialize(parent, name, options={})
+      super parent, name, options.merge(color: '#c8f8c8', style: 'filled')
+    end
+    include Creators
+    def stage(name)
+      add Stage.new self, name
+    end
+  end
+  class Stage < Thing
+    def initialize(parent, name)
+      super parent, name, color: '#aaccaa', style: 'filled'
+      doclink("http://go/#{name}")
+    end
+
+    def deploys(*apps)
+      apps.each {|app|
+        points_to app, name: 'deploys', style: 'dotted'
+      }
+    end
+    def triggers(*stages)
+      stages.each {|stage|
+        points_to stage, name: 'triggers', color: '#00bb00'
+      }
+    end
+    def configures(*things)
+      things.each {|thing|
+        points_to thing, name: 'configures', style: 'dashed'
+      }
+    end
+  end
+  class Process < Thing
+    def initialize(parent, name)
+      super parent, name, style: 'filled'
+    end
+    def calls_all(*callees)
+      points_to_all *callees
+    end
+    def calls(callee, options={})
+      points_to callee, options
+    end
+  end
+  class External < Thing
+    def initialize(parent, name, options={})
+      super parent, name, options.merge(color: 'lightyellow', style: 'filled')
+    end
+  end
+  class User < Thing
+    def initialize(parent, name)
+      super parent, name, shape: 'circle', color: 'brown'
+    end
+    def uses(used)
+      points_to used
+    end
+    def uses_all(*useds)
+      points_to_all *useds
+    end
+  end
+  class LoadBalancer < Thing
+    def initialize(parent, name)
+      super parent, name, color: '#ff6666', style: 'filled'
+    end
+  end
+
+  class Repo
+    def initialize(organisation, name)
+      @name = name
+      @organisation = organisation
+    end
+
+    def url
+      "https://github.com/#{@organisation}/#{@name}"
+    end
+
+    def source(path)
+      "#{url}/blob/master/#{path}"
+    end
+
+    def to_s
+      url
+    end
+  end
+
+end

data/lib/dogviz.rb

@@ -0,0 +1,428 @@
+require 'ruby-graphviz'
+
+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 graph
+      parent.graph
+    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 doclink(url)
+      setup_render_attributes(URL: url)
+    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 under_rollup?
+      ancestors.any? &:rollup?
+    end
+    def in_rollup?
+      rollup? || under_rollup?
+    end
+    def on_top_rollup?
+      rollup? && !under_rollup?
+    end
+  end
+  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
+
+  class Thing
+    include Common
+    attr_reader :parent
+    attr_reader :name, :id, :pointers, :edge_heads
+
+    def initialize(parent, name, options = {})
+      @parent = parent
+      @name = name
+      @id = create_id(name, parent)
+      @pointers = []
+      @rollup = false
+      @edge_heads = []
+
+      rollup! if options[:rollup]
+      options.delete(:rollup)
+
+      @render_options = options
+      setup_render_attributes label: name
+
+      parent.register name, self
+    end
+
+    def do_render_node(renderer)
+      render_options = @render_options
+      attributes = @attributes
+      renderer.render_node(parent, id, render_options, attributes)
+    end
+
+    def node
+      graph.find_node(id)
+    end
+
+    def points_to_all(*others)
+      others.each {|other|
+        points_to other
+      }
+    end
+
+    def points_to(other, options = {})
+      setup_render_edge(other, options)
+    end
+
+    def pointees
+      pointers.map {|e|
+        e[:other]
+      }
+    end
+
+    def render(renderer)
+      do_render_node(renderer) unless in_rollup?
+    end
+
+    def render_edges(renderer)
+      pointers.each {|p|
+        render_pointer p, renderer
+      }
+    end
+
+    private
+
+    def setup_render_edge(other, options)
+      pointers << {
+          other: other,
+          options: {
+              label: options[:name],
+              style: options[:style]
+          }
+      }
+    end
+
+    def render_pointer(pointer, renderer)
+      other = pointer[:other]
+      while (other.in_rollup? && !other.on_top_rollup?) do
+        other = other.parent
+      end
+      return if other.under_rollup?
+
+      from = self
+      while (from.in_rollup? && !from.on_top_rollup?) do
+        from = from.parent
+      end
+
+      return if from == self && from.in_rollup?
+
+      return if from == other
+      return if edge_heads.include? other
+
+      edge_heads << other
+      render_options = pointer[:options]
+      renderer.render_edge(from, other, render_options)
+    end
+  end
+
+  class Container
+    include Common
+    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
+      @parent = parent
+      @name = name
+      @id = create_id(name, parent)
+
+      init_rollup options
+
+      setup_render_attributes label: name
+
+      @render_options = 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
+
+    def node
+      if render_type == :node
+        graph.find_node(render_id)
+      elsif render_type == :subgraph
+        @subgraph
+      end
+    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
+
+  class LogicalContainer < Container
+    def initialize(parent, name, options)
+      super parent, name, options.merge(cluster: false)
+    end
+  end
+
+  require 'date'
+
+  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
+
+  class System
+    include Parent
+
+    attr_reader :render_hints, :title, :children, :graph
+
+    alias :name :title
+
+    def initialize(name, hints = {splines: 'line'})
+      @children = []
+      @by_name = Registry.new
+      @render_hints = hints
+      @title = create_title(name)
+      @rendered = false
+    end
+
+    def node
+      graph
+    end
+
+    def output(*args)
+      render
+      out = graph.output *args
+      puts "Created output: #{args.join ' '}"
+      out
+    end
+
+    def render(type=:graphviz)
+      return @graph if @rendered
+      raise "dunno bout that '#{type}', only know :graphviz" unless type == :graphviz
+
+      renderer = GraphvizRenderer.new @title, render_hints
+
+      children.each {|c|
+        c.render renderer
+      }
+      children.each {|c|
+        c.render_edges renderer
+      }
+      @rendered = true
+      @graph = renderer.graph
+    end
+
+    def rollup?
+      false
+    end
+
+    def register(name, thing)
+      @by_name.register name, thing
+    end
+
+    private
+
+    def create_title(name)
+      now = DateTime.now
+      "#{now.strftime '%H:%M'} #{name} #{now.strftime '%F'}"
+    end
+  end
+
+  class LookupError < StandardError
+  end
+  class MissingMatchBlockError < LookupError
+    def initialize
+      super 'need to provide match block'
+    end
+  end
+  class DuplicateLookupError < LookupError
+    def initialize(name)
+      super "More than one object registered of name '#{name}' - you'll need to search in a narrower context"
+    end
+  end
+  class Registry
+    def initialize
+      @by_name = {}
+      @all = []
+    end
+
+    def register(name, thing)
+      @all << thing
+      if @by_name.has_key?(name)
+        @by_name[name] = DuplicateLookupError.new name
+      else
+        @by_name[name] = thing
+      end
+    end
+
+    def find(&matcher)
+      raise LookupError.new("need to provide match block") unless block_given?
+      @all.find &matcher
+    end
+
+    def find_all(&matcher)
+      raise MissingMatchBlockError.new unless block_given?
+      @all.select &matcher
+    end
+
+    def lookup(name)
+      found = @by_name[name]
+      raise LookupError.new("could not find '#{name}'") if found.nil?
+      raise found if found.is_a?(Exception)
+      found
+    end
+  end
+
+end

data/lib/dogviz/version.rb

@@ -0,0 +1,3 @@
+module Dogviz
+  VERSION = '0.0.3'
+end

data/tests/test_sisvis_graph.rb

@@ -0,0 +1,83 @@
+require "test/unit"
+
+require_relative '../lib/dogviz'
+
+class TestDogvizGraph < Test::Unit::TestCase
+  include Dogviz
+
+  attr_reader :sys
+
+  def setup
+    @sys = Dogviz::System.new 'test'
+  end
+
+  def test_container_gets_rolled_up
+    g = sys.group('g')
+    assert_equal(false, g.rollup?)
+    g.rollup!
+    assert_equal(true, g.rollup?)
+  end
+
+  def test_stuff_isnt_under_or_on_top_of_rollup_without_rollup
+    g = sys.group('g')
+    a = g.thing('a')
+
+    assert_equal(false, a.under_rollup?)
+    assert_equal(false, a.on_top_rollup?)
+    assert_equal(false, g.under_rollup?)
+    assert_equal(false, g.on_top_rollup?)
+  end
+
+  def test_rolled_up_containers_arent_under_rollup_when_on_top
+    g = sys.group('g')
+    g.rollup!
+
+    assert_equal(false, g.under_rollup?)
+    assert_equal(true, g.on_top_rollup?)
+  end
+
+  def test_nested_containers_and_things_are_under_rollup
+    g = sys.group('g')
+    g.rollup!
+    nested = g.group('nested')
+    a = g.thing('a')
+
+    assert_equal(true, nested.under_rollup?)
+    assert_equal(true, a.under_rollup?)
+    assert_equal(false, nested.on_top_rollup?)
+  end
+
+  def test_nested_things_are_in_rollup_if_under_one
+    g = sys.group('g').rollup!
+    a = g.thing('a')
+
+    assert_equal(true, a.in_rollup?)
+  end
+
+  def test_nested_things_are_in_rollup_if_rolled_up_themselves
+    a = sys.thing('a').rollup!
+    assert_equal(true, a.in_rollup?)
+  end
+
+  def test_find_with_match_block
+    nested_group = sys.group('g').group('nested group')
+    nested_thing = nested_group.thing('nested thing')
+    nested_group.thing('other thing')
+
+    assert_equal(nested_thing, sys.find {|n|
+      n.is_a?(Thing) && n.name.start_with?('nested')
+    })
+  end
+
+  def test_find_all
+    group = sys.group('g')
+    nested_group = group.group('nested group')
+    thing1 = group.thing('n1')
+    thing2 = nested_group.thing('n2')
+
+    assert_equal([thing1, thing2], sys.find_all {|n|
+      n.is_a?(Thing)
+    })
+  end
+
+end

data/tests/test_sisvis_graphviz_rendering.rb

@@ -0,0 +1,242 @@
+require "test/unit"
+
+require_relative '../lib/dogviz'
+
+class TestDogvizGraphvizRendering < Test::Unit::TestCase
+  include Dogviz
+
+  attr_reader :sys
+
+  def setup
+    @sys = Dogviz::System.new 'test'
+  end
+
+  def graph
+    sys.render
+  end
+
+  def test_points_to_links_nodes
+    sys.thing('a').points_to sys.thing('b')
+
+    assert_equal('a->b', connections)
+  end
+
+  def test_points_to_all_makes_multiple_links_to_nodes
+    sys.thing('a').points_to_all sys.thing('b'), sys.thing('c')
+
+    assert_equal(2, edges.size)
+    assert_equal(find('a').id, edges[0].tail_node)
+    assert_equal(find('b').id, edges[0].head_node)
+    assert_equal(find('a').id, edges[1].tail_node)
+    assert_equal(find('c').id, edges[1].head_node)
+    assert_equal('a->b a->c', connections)
+  end
+
+  def test_containers_are_subgraphs_prefixed_with_cluster_for_visual_containment_in_GraphViz
+    top = sys.container('top')
+    nested = top.container('nested')
+
+    assert_equal('cluster_top', subgraph_ids.first)
+    assert_equal('cluster_top_nested', subgraph_ids.last)
+  end
+
+  def test_logical_containers_have_no_cluster_prefix_so_will_not_be_visible_in_Graphviz
+    top = sys.logical_container('top')
+    top_thing = top.thing('top thing')
+
+    assert_equal(['top'], subgraph_ids)
+    assert_equal(top_thing.id, subgraph('top').get_node("#{top_thing.id}").id)
+  end
+
+  def test_nested_containers_have_things
+    top = sys.container('top')
+    top_thing = top.thing('top thing')
+    nested = top.container('nested')
+    nested_thing = nested.thing('nested thing')
+
+    graph
+
+    assert_equal([top.render_id, nested.render_id], subgraph_ids)
+
+    top_subgraph = subgraph(top.render_id)
+    nested_subgraph = subgraph(nested.render_id)
+
+    assert_equal(top_thing.id, top_subgraph.get_node(top_thing.id).id)
+    assert_equal(nested_thing.id, nested_subgraph.get_node(nested_thing.id).id)
+    assert_nil(top_subgraph.get_node(nested_thing.id), 'should not be in other container')
+    assert_nil(nested_subgraph.get_node(top_thing.id), 'should not be in other container')
+  end
+
+  def test_point_into_target_in_container
+    container = sys.container('container')
+    target = container.thing('target')
+    pointer = sys.thing('pointer')
+
+    pointer.points_to target
+
+    assert_equal("pointer->#{target.id}", connections)
+  end
+
+  def test_node_names_are_displayed
+    thing = sys.container('whatever').thing('the thing')
+    assert_equal('whatever_the_thing', thing.id)
+    assert_equal('"the thing"', find(thing.id)[:label].to_s)
+  end
+
+  def test_point_into_target_in_nested_containers
+    top = sys.container('top')
+    target_parent = top.container('nested').container('subnested')
+    target = target_parent.thing('target')
+    pointer = sys.thing('pointer')
+
+    pointer.points_to target
+
+    assert_equal('pointer->top_nested_subnested_target', connections)
+  end
+
+  def test_points_to_rolled_up_container_of_target
+    group = sys.container('group')
+    group.rollup!
+    target = group.thing('target')
+    pointer = sys.thing('pointer')
+
+    pointer.points_to target
+
+    assert_equal('pointer->group', connections)
+  end
+
+  def test_do_not_render_rolled_up_thing
+    sys.thing('a').rollup!
+
+    assert_nil(find('a'))
+  end
+
+  def test_points_from_thing_in_rolled_up_container
+    group = sys.group('group')
+    group.rollup!
+
+    pointer = group.thing('pointer')
+    target = sys.thing('target')
+
+    pointer.points_to target
+
+    assert_equal('group->target', connections)
+  end
+
+  def test_points_to_rolled_up_nested_containers_of_target
+    top = sys.container('top', rollup: false)
+    nested = top.container('nested', rollup: true)
+    target = nested.container('subnested').thing('target')
+    pointer = sys.thing('pointer')
+
+    top.thing('thing in top')
+    nested.thing('thing in nested')
+
+    pointer.points_to target
+
+    assert_equal('pointer->top_nested', connections)
+    assert_not_nil(graph.find_node('top_thing_in_top'))
+  end
+
+  def test_points_to_multiple_things_in_rolled_up_group
+    group = sys.group('group', rollup: true)
+    pointer = sys.thing('pointer')
+
+    pointer.points_to_all group.thing('a'), group.thing('b'), group.thing('c')
+
+    assert_equal('pointer->group', connections)
+  end
+
+  def test_pointing_from_rolled_up_thing_in_non_rolled_up_group_creates_no_links
+    a = sys.thing('a', rollup: true)
+    b = sys.thing('b')
+    c = sys.thing('c')
+    a.points_to b
+    b.points_to c
+    assert_equal('b->c', connections)
+  end
+
+  def test_point_to_between_and_from_things_in_rolled_up_container
+    entry = sys.thing('entry')
+    group = sys.group('group')
+    a = group.thing('a')
+    b = group.thing('b')
+    exit = sys.thing('exit')
+    entry.points_to a
+    a.points_to b
+    b.points_to exit
+
+    group.rollup!
+
+    assert_equal('entry->group group->exit', connections)
+  end
+
+  def test_find_thing
+    sys.group('top').thing('needle')
+
+    assert_equal('needle', sys.find('needle').name)
+  end
+
+  def test_find_duplicate_show_blow_up
+    sys.group('A').thing('needle')
+    sys.group('B').thing('needle')
+
+    assert_raise DuplicateLookupError do
+      sys.find('needle').name
+    end
+  end
+
+  def test_find_nothing_show_blow_up
+    sys.group('A').thing('needle')
+
+    assert_raise LookupError do
+      sys.find('not a needle')
+    end
+  end
+
+  def test_doclinks_create_links
+    a = sys.thing('a')
+    doc_url = 'http://some.url/'
+    a.doclink doc_url
+
+    assert_equal(doc_url, find('a')['URL'].to_ruby)
+  end
+
+  private
+
+  def subgraph_ids
+    subgraphs.map(&:id)
+  end
+
+  def subgraph(id)
+    subgraphs.find {|sub| sub.id == id }
+  end
+
+  def subgraphs(from=graph)
+    subs = []
+    from.each_graph {|sub_name, sub|
+      subs << sub
+      subs += subgraphs(sub)
+    }
+    subs
+  end
+
+  def connections(sep=' ')
+    edges.map {|e|
+      "#{e.tail_node}->#{e.head_node}"
+    }.join sep
+  end
+
+  def connected_ids
+    (edges.map(&:tail_node) + edges.map(&:head_node)).uniq
+  end
+
+  def edges
+    graph.each_edge
+  end
+
+  def find(name)
+    graph.find_node name
+  end
+
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: dogviz
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- damned
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: leverages graphviz to generate multiple views of a domain-specific graph
+email:
+- writetodan@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- dogviz.gemspec
+- examples/website.rb
+- examples/website_domain.rb
+- lib/dogviz.rb
+- lib/dogviz/version.rb
+- tests/test_sisvis_graph.rb
+- tests/test_sisvis_graphviz_rendering.rb
+homepage: https://github.com/damned/dogviz
+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.3
+signing_key: 
+specification_version: 4
+summary: domain object graph visualisation
+test_files: []