dogviz 0.0.21 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b9eb357510d3a4de43f3cc7af60919bc6540915
-  data.tar.gz: 4bceb85921dd199a159d7f6a3340041c31ce3eb9
+  metadata.gz: a428fcd04a6f1cc90bf9225b887c94889c7667ef
+  data.tar.gz: 26363eb38c24901ae048103f99179fb7d5e2807a
 SHA512:
-  metadata.gz: 222029facb991efdcebe0bb8877c3cbbc46d8516e130255199c973809b0a018b2a6eda659e6320ff8167d2f629353149043bb318b81a1ceca38b764d3e7db966
-  data.tar.gz: 78912d906cea50c5861c39c658c97e5a0a9833a3113307a2d16519510c9544a5754dd59e35a7ef90382a41b3624a1edcf25cee8b9967f63086fa13bb6140533b
+  metadata.gz: 1e363ecd7f98e01a3218c0bcd389f952f7350fa4488fd30e1e4bc3ff7b512624208576137a05e2cd26b48f51235e9f34954b95b28b4f004eb468b16cc909f684
+  data.tar.gz: 5f9ae410f02002a7148fa66c0ecead46b0a8db9980cbf84eab671298cf3fb85a36e4de4ac83162a7a70dd23f7bd092322b9453ae67cf9606c8a37f372dd1b4a0

data/Rakefile

@@ -3,7 +3,6 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.test_files = FileList['tests/test*.rb']
-  t.verbose = true
 end
 
 require 'colorize'

data/dogviz.gemspec

@@ -18,10 +18,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency 'simplecov', '~> 0'
   spec.add_development_dependency 'colorize', '~> 0'
   spec.add_development_dependency 'nokogiri', '~> 1.6'
+  spec.add_development_dependency 'test-unit'
 
   spec.add_dependency 'ruby-graphviz', '~> 1'
+  spec.add_dependency 'json', '~> 2.1.0'
 end

data/lib/dogviz/common.rb

@@ -3,7 +3,7 @@ module Dogviz
     def create_id(name, parent)
       parts = []
       parts << parent.id if parent.respond_to? :id
-      parts += name.split /\s/
+      parts += name.split(/\s/)
       parts.join '_'
     end
 
@@ -23,6 +23,7 @@ module Dogviz
     def info(fields)
       @info.merge! fields
       setup_render_attributes(label: label_with_info)
+      self
     end
 
     def doclink(url)
@@ -38,7 +39,7 @@ module Dogviz
     end
 
     def setup_render_attributes(attributes)
-      @attributes = {} if @attributes.nil?
+      @attributes ||= {}
       @attributes.merge!(attributes)
     end
 
@@ -65,11 +66,11 @@ module Dogviz
     end
 
     def under_skip?
-      ancestors.any? &:skip?
+      ancestors.any?(&:skip?)
     end
 
     def under_rollup?
-      ancestors.any? &:rollup?
+      ancestors.any?(&:rollup?)
     end
 
     def in_rollup?

data/lib/dogviz/flow.rb

@@ -4,19 +4,85 @@ require_relative 'process'
 
 module Dogviz
   class Flow
+    FLOW_RENDERERS = {
+      sequence: WebSequenceDiagramsSequenceRenderer,
+      plantuml: PlantUmlSequenceRenderer,
+      png: PngSequenceRenderer
+    }
+
+    attr_reader :sys
+    attr_accessor :executor
+
     def initialize(sys, name)
       @sys = sys
       @name = name
-      @calls = []
+      @commands = []
+      @actors = []
+      @caller_stack = []
+      @executor = nil
     end
 
     def make_connections
-      calls.each { |from, to, label|
-        thing_of(from).points_to thing_of(to), label: label
+      commands.each { |type, from, to, label|
+        thing_of(from).points_to(thing_of(to), name: label.split('\n').first) if type == :call
+      }
+    end
+
+    def involves(*actors)
+      @actors += actors
+      self
+    end
+    
+    def from(initial_actor, &flowspec)
+      @actors.each { |actor|
+        actor.start_flow self
       }
+      @caller_stack << initial_actor
+      begin
+        flowspec.call
+      rescue NoMethodError => nme
+        raise "Did you call #involves for all actors? It's a common cause of the caught exception: #{nme}"
+      ensure
+        @caller_stack.pop
+        @actors.each { |actor|
+          actor.stop_flow
+        }
+      end      
+    end
+
+    def add_note(from, where, what)
+      # yukk next lets move to command classes, e.g. OptCommand, NoteCommand, CallCommand etc.
+      commands << [:note, from, where, what]
+    end
+
+    def optional(text, &block)
+      commands << [:opt, nil, nil, text]
+      block.call
+      commands << [:end, nil, nil, nil]
+    end
+
+    def divider(text)
+      commands << [:divider, nil, nil, text]
+    end
+    
+    alias :opt :optional
+
+    def add_call(from, to, label)
+      commands << [:call, from, to, label]
+    end
+
+    def next_call(to, label)
+      add_call @caller_stack.last, to, label
+      @caller_stack << to
+    end
+
+    def end_call(label)
+      current_actor = @caller_stack.pop
+      add_call(current_actor, @caller_stack.last, label) unless label.nil?
     end
 
     def flows(*steps)
+      sys.warn_on_exit 'deprecation warning: flow#flows deprecated, should use flow#from(actor) { <nested flow spec> }'
       from = nil
       to = nil
       label = nil
@@ -29,7 +95,7 @@ module Dogviz
           to = ensure_is_thing(step)
         end
         unless to.nil?
-          calls << [from, to, label]
+          add_call from, to, label
           from = to
           to = label = nil
         end
@@ -37,31 +103,46 @@ module Dogviz
     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)
+      raise "Expected some thing or process: '#{step}' already got: #{commands}" 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)
+      raise "Only support #{FLOW_RENDERERS.keys}, not: '#{type}'" unless FLOW_RENDERERS.has_key?(type)
+      render(FLOW_RENDERERS[type]).output(type_to_file, executor)
     end
 
-    def render
-      renderer = SequenceRenderer.new(@name)
-      calls.each do |from, to, label|
-        renderer.render_edge from, to, {label: label}
+    def render(renderer_class = SequenceRenderer)
+      renderer = renderer_class.new(@name)
+      commands.each do |type, from, to, label|
+        if type == :call
+          renderer.render_edge(from, to, {label: label})
+        elsif type == :end
+          renderer.end_combination
+        elsif type == :note
+          renderer.note(from, to, label)
+        elsif type == :divider
+          renderer.divider(label)
+        else
+          renderer.start_combination(type, label)
+        end
       end
       renderer.rendered
     end
 
+    def suppress_messages!
+      sys.suppress_messages!
+    end
+    
     private
 
-    attr_reader :calls, :sys
+    attr_reader :commands
 
     def thing_of(it)
       return it.processor if it.is_a?(Process)
       it
     end
+
   end
 end

data/lib/dogviz/flowable.rb

@@ -5,5 +5,55 @@ module Dogviz
     def does(action)
       Process.new(self, action)
     end
+    
+    def receives(requests, &block)
+      
+      @requests = self.requests.merge requests if requests.is_a?(Hash)
+      self.requests[requests] = block if requests.is_a?(Symbol)
+
+    end
+
+    def note(where, what)
+      @flow.add_note(self, where, what)
+    end
+    
+    def start_flow(flow)
+      @flow = flow
+    end
+    
+    def stop_flow
+      @flow = nil
+    end
+
+    def method_missing(m, *args, &block)
+      if requests.has_key?(m)
+        @flow ||= nil
+
+        request_def = requests[m]
+        if request_def.is_a?(String)
+          label = request_def
+          return_label = nil
+        else
+          request_def = request_def.call(*args) if request_def.is_a?(Proc)
+          label = request_def.keys.first
+          return_label = request_def.values.first
+        end
+        
+        @flow.next_call self, label
+        block.call if block_given?
+        @flow.end_call(return_label)
+      else
+        raise "this flowable does not know about receiving '#{m}', only know about: #{requests.keys}"
+      end
+    end
+    
+    def requests
+      @requests ||= {}
+    end
+    
+    def request_handlers
+      @request_handlers ||= {}
+    end
+    
   end
 end

data/lib/dogviz/graphviz_renderer.rb

@@ -6,8 +6,14 @@ module Dogviz
     attr_reader :graph
 
     def initialize(title, hints)
-      @graph = GraphViz.digraph(title)
-      @graph[hints]
+      construction_hints = {}
+      after_hints = hints.clone
+      if hints.has_key?(:use)
+        construction_hints[:use] = hints[:use]
+        after_hints.delete :use
+      end
+      @graph = GraphViz.digraph(title, construction_hints)
+      @graph[after_hints]
       @subgraphs = {}
       @nodes = {}
       @rendered_subgraph_ids = {}
@@ -25,7 +31,7 @@ module Dogviz
       clean_node_attributes attributes
       default_attributes = {:shape => 'box', :style => ''}
       merged_attributes = default_attributes.merge(attributes)
-      node = parent_node(parent).add_nodes(id, merged_attributes)
+      parent_node(parent).add_nodes(id, merged_attributes)
     end
 
     def render_subgraph(parent, id, attributes)

data/lib/dogviz/parent.rb

@@ -2,12 +2,12 @@ module Dogviz
   module Parent
     def find_all(&matcher)
       raise MissingMatchBlockError.new unless block_given?
-      @by_name.find_all &matcher
+      @by_name.find_all(&matcher)
     end
 
     def find(name=nil, &matcher)
       if block_given?
-        @by_name.find &matcher
+        @by_name.find(&matcher)
       else
         raise 'Need to provide name or block' if name.nil?
         @by_name.lookup name

data/lib/dogviz/registry.rb

@@ -21,12 +21,12 @@ module Dogviz
 
     def find(&matcher)
       raise LookupError.new(@context, "need to provide match block") unless block_given?
-      @all.find &matcher
+      @all.find(&matcher)
     end
 
     def find_all(&matcher)
       raise MissingMatchBlockError.new(@context) unless block_given?
-      @all.select &matcher
+      @all.select(&matcher)
     end
 
     def lookup(name)

data/lib/dogviz/rendered_sequence.rb

@@ -4,10 +4,54 @@ module Dogviz
       @lines = lines
     end
 
-    def output(type_to_file)
-      text = @lines.map(&:strip).join "\n"
-      File.write type_to_file.values.first, text
-      text
+    def output(type_to_file, executor = nil)
+      File.write type_to_file.values.first, body
+      body
+    end
+
+    def body
+      @lines.map(&:rstrip).join "\n"
+    end    
+  end
+  
+  class WebSequenceDiagramsRenderedSequence < RenderedSequence
+  end
+  
+  class PlantUmlRenderedSequence < RenderedSequence
+
+    def body
+      raw_body = super
+      ['@startuml', raw_body, '@enduml'].join "\n"
+    end
+  end
+
+
+  class Executor
+    def execute(cmd)
+      system cmd
+    end
+  end
+  
+  class PngRenderedSequence < PlantUmlRenderedSequence
+    def output(type_to_file, executor = nil)
+      image_type, image_filename = type_to_file.first
+      plantuml_definition_filename = without_extension(image_filename) + '.plantuml'
+
+      super plantuml: plantuml_definition_filename
+
+      executor = Executor.new if executor.nil?
+      executor.execute(plantuml_cmd image_type, plantuml_definition_filename)
+    end
+
+    private
+
+    def plantuml_cmd(image_type, plantuml_definition_filename)
+      "plantuml -t#{image_type} #{plantuml_definition_filename}"   
+    end
+    
+    def without_extension(filename)
+      filename.gsub(/\.[a-zA-Z]*$/, '')
     end
   end
+  
 end

data/lib/dogviz/sequence_renderer.rb

@@ -7,28 +7,63 @@ module Dogviz
 
     def initialize(title)
       @lines = []
+      @indents = 0
+      @rendered_class = RenderedSequence
+      add_title title
     end
 
     def render_edge(from, other, options)
-
       detail = options[:label]
       receiver_label = other.name
       sender_label = from.name
+      annotations = nil
       if other.is_a?(Process)
-        detail = process_annotations(detail, sender_label, receiver_label, other.description)
+        annotations = extract_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}"
+      line = "#{escape sender_label} -> #{escape receiver_label}: #{detail}"
+      line = [ line, annotations ].join("\n") unless annotations.nil?
+      add_line line
+    end
+
+    def start_combination(operator, guard)
+      add_line "#{operator} #{escape guard}"
+      @indents += 1
+    end
+    
+    def end_combination
+      @indents -= 1
+      add_line 'end'
+    end
+
+    def note(from, where, what)
+      add_line "note #{where} of #{escape from.name}"
+      @indents += 1
+      add_line what
+      @indents -= 1
+      add_line "end note"
+    end
+
+    def divider(text)
+      #nop
     end
 
     def rendered
-      RenderedSequence.new lines
+      @rendered_class.new lines
     end
 
     private
 
+    def add_line(line)
+      lines << ('  ' * @indents + line)
+    end
+
+    def add_title(title)
+      add_line "title #{title}"
+    end
+
     def process_start_label(receiver_label)
       "+#{receiver_label}"
     end
@@ -37,11 +72,46 @@ module Dogviz
       "-#{receiver_label}"
     end
 
-    def process_annotations(detail, sender, receiver, process_description)
-      detail = [detail,
-                "note right of #{receiver}",
-                "  #{process_description}",
-                'end note'].join("\n")
+    def extract_annotations(detail, sender, receiver, process_description)
+      [ "note right of #{escape receiver}",
+        "  #{escape process_description}",
+        'end note' ].join("\n")
     end
+
+    def escape(s)
+      if (/\s/).match(s)
+        "\"#{s}\""
+      else
+         s
+      end
+    end
+    
+  end
+
+  class WebSequenceDiagramsSequenceRenderer < SequenceRenderer
+    def initialize title
+      super title
+      @rendered_class = WebSequenceDiagramsRenderedSequence
+    end    
+  end
+  
+  class PlantUmlSequenceRenderer < SequenceRenderer
+    def initialize title
+      super title
+      @rendered_class = PlantUmlRenderedSequence
+    end
+
+    def divider(text)
+      add_line "== #{text} =="
+    end
+  end
+
+  class PngSequenceRenderer < PlantUmlSequenceRenderer
+    def initialize title
+      super title
+      @rendered_class = PngRenderedSequence
+    end    
   end
+  
+  
 end

data/lib/dogviz/system.rb

@@ -19,12 +19,23 @@ module Dogviz
       @render_hints = hints
       @title = create_title(name)
       @rendered = false
+      
+      @warnings = Set.new
+      @messages = Set.new
+      
+      @suppress_warnings = false
+      @suppress_messages = false
+      
+      on_exit {
+        output_messages
+        output_warnings
+      }
     end
 
     def output(*args)
       render
-      out = graph.output *args
-      puts "Created output: #{args.join ' '}" if run_from_command_line?
+      out = graph.output(*args)
+      @messages << "Created output: #{args.join ' '}" unless suppress_messages?
       out
     end
 
@@ -77,10 +88,58 @@ module Dogviz
       @non_render_hints[:auto_nominate]
     end
     
+    def warn_on_exit(warning)
+      @warnings << warning
+    end
 
+    def warnings
+      @warnings.to_a
+    end
+    
+    def messages
+      @messages.to_a
+    end
+    
+    def suppress_warnings!
+      @suppress_warnings = true
+      self
+    end
+    
+    def suppress_messages!
+      @suppress_messages = true
+      self
+    end
 
     private
 
+    def on_exit(&block)
+      Kernel.at_exit(&block)
+    end
+
+    def output_messages
+      unless suppress_messages?
+        messages.each {|message|
+          STDERR.puts message
+        }
+      end
+    end
+    
+    def output_warnings
+      unless suppress_warnings?
+        warnings.each {|warning|
+          STDERR.puts warning
+        }
+      end
+    end
+
+    def suppress_warnings?
+      @suppress_warnings
+    end
+
+    def suppress_messages?
+      @suppress_messages
+    end
+
     def remove_dogviz_hints!(hints)
       dogviz_only_hints = {}
       %i(colorize_edges auto_nominate).each { |k|
@@ -93,9 +152,5 @@ module Dogviz
       now = DateTime.now
       "#{now.strftime '%H:%M'} #{name} #{now.strftime '%F'}"
     end
-
-    def run_from_command_line?
-      $stdout.isatty
-    end
   end
 end

data/lib/dogviz/thing.rb

@@ -63,11 +63,17 @@ module Dogviz
     end
 
     def setup_render_edge(other, options)
+      fontsize = 14
+      fontsize += options[:stroke] if options.has_key?(:stroke)
       pointers << {
           other: other,
           options: {
               xlabel: options[:name],
-              style: options[:style]
+              style: options[:style],
+              color: options[:color],
+              fontcolor: options[:color],
+              penwidth: options[:stroke],
+              fontsize: fontsize
           }.merge(inherited_render_options)
       }
 
@@ -105,10 +111,10 @@ module Dogviz
         others = [other]
       end
 
-      others.each do |other|
-        edge_heads << other
+      others.each do |other_to_render|
+        edge_heads << other_to_render
         render_options = pointer[:options]
-        renderer.render_edge(from, other, render_options)
+        renderer.render_edge(from, other_to_render, render_options)
       end
     end
 

data/lib/dogviz/version.rb

@@ -1,3 +1,3 @@
 module Dogviz
-  VERSION = '0.0.21'
+  VERSION = '0.0.22'
 end

data/tests/graph_checking.rb

@@ -4,7 +4,7 @@ module GraphChecking
   end
 
   def subgraph_ids_without_cluster_prefixes
-    subgraph_ids.map {|id| id.gsub /^cluster_/, '' }
+    subgraph_ids.map {|id| id.gsub(/^cluster_/, '') }
   end
 
   def subgraph(id)

data/tests/setup_tests.rb

@@ -1,3 +1,3 @@
 require "test/unit"
 require_relative '../lib/dogviz'
-SimpleCov.root('..') if Object.const_defined?('SimpleCov')
+SimpleCov.root('..') if Object.const_defined?('SimpleCov')

data/tests/svg_graph.rb

@@ -66,7 +66,7 @@ module Tests
     private
 
     def comments
-      @doc.children.select &:comment?
+      @doc.children.select(&:comment?)
     end
   end
 end

data/tests/test_dogviz_flows.rb

@@ -9,83 +9,289 @@ module Tests
       "/tmp/dogviz_flow_test.#{ext}"
     end
 
+    def delete_outfile(ext)
+      FileUtils.rm_f outfile(ext)
+    end
+
     def read_outfile(ext)
       File.read outfile(ext)
     end
 
     include Dogviz
 
-    def test_flow_generates_precise_sequence
-      sys = System.new 'takeaway'
-      eater = sys.thing 'eater'
-      server = sys.thing 'server'
-      cook = sys.thing 'chef'
+    def test_nested_flow_syntax
+      create_takeaway
 
-      order = sys.flow 'order'
-      order.flows eater, 'gimme burger',
-                  server, 'passes order',
-                  cook, server, eater
+      order = sys.flow('order').involves(sys.server, sys.cook)
 
-      order.output sequence: outfile('seq.txt')
+      sys.server.receives burger: { 'gimme burger' => 'here ya go' }, 
+                          dessert: 'gimme dessert'
+      sys.cook.receives order: { 'passes order' => '' }
+
+      order.from(sys.eater) {
+        sys.server.burger {
+          sys.cook.order
+        }
+        sys.server.dessert
+      }
+
+      definition = sequence_definition(order)
+
+      assert_equal [
+                    'eater -> server: gimme burger',
+                    'server -> cook: passes order',
+                    'cook -> server:',
+                    'server -> eater: here ya go',
+                    'eater -> server: gimme dessert'
+                  ].join("\n"), definition
+    end
+
+    def test_get_useful_error_if_not_called_involves_for_called_actor
+      create_takeaway
+
+      order = sys.flow('order')
+
+      sys.server.receives burger: 'gimme burger'
+
+      assert_raise_message(/call #involves for all actors/) {
+
+        order.from(sys.eater) {
+          sys.server.burger
+        }
+        
+      }
+    end
+
+    def test_nested_flow_with_optional_part_of_sequence
+      create_takeaway
+
+      order = sys.flow('order').involves sys.server
+
+      sys.server.receives burger: { 'gimme burger' => 'here you go' }
+
+      order.from(sys.eater) {
+        order.opt('if hungry') {
+          sys.server.burger
+        }
+      }
+
+      definition = sequence_definition(order)
+
+      assert_equal [
+                     'opt "if hungry"',
+                     '  eater -> server: gimme burger',
+                     '  server -> eater: here you go',
+                     'end'
+                   ].join("\n"), definition
+    end
+
+    def test_nested_flow_dynamic_receives_definition
+      create_takeaway
+
+      order = sys.flow('order').involves sys.server
+
+      sys.server.receives(:order) do |order_no| 
+        { "make order #{order_no}" => "deliver order #{order_no}" }
+      end
+
+      order.from(sys.eater) {
+        sys.server.order(1)
+        sys.server.order(2)
+      }
+
+      definition = sequence_definition(order)
+
+      assert_equal [
+                     'eater -> server: make order 1',
+                     'server -> eater: deliver order 1',
+                     'eater -> server: make order 2',
+                     'server -> eater: deliver order 2'
+                   ].join("\n"), definition
+    end
+
+    def test_plantuml_text_output
+      create_takeaway
+
+      order = sys.flow('the order').involves sys.server
+
+      sys.server.receives burger: 'gimme'
+
+      order.from(sys.eater) {
+        sys.server.burger
+      }
+
+      order.output plantuml: outfile('seq.plantuml')
+      definition = read_outfile('seq.plantuml')
+
+      assert_equal [
+                     '@startuml',
+                     'title the order',
+                     'eater -> server: gimme',
+                     '@enduml'
+                   ].join("\n"), definition
+    end
+
+    def test_plantuml_dividers
+      create_takeaway
+
+      order = sys.flow('order')
+
+      sys.server.receives burger: 'gimme'
+
+      order.from(sys.eater) {
+        order.divider('bob')
+      }
+
+      definition = order.output plantuml: outfile('seq.plantuml')
+
+      assert_equal [
+                     '@startuml',
+                     'title order',
+                     '== bob ==',
+                     '@enduml'
+                   ].join("\n"), definition
+    end
+    
+    
+    class MockExecutor
+      def execute(cmd)
+        @cmd = cmd
+      end
+      attr_reader :cmd
+    end
+    
+
+    def test_flow_png_image_output_via_plantuml
+      create_takeaway
+
+      order = sys.flow('order').involves sys.server
+
+      sys.server.receives burger: 'gimme'
+
+      order.from(sys.eater) {
+        sys.server.burger
+      }
+
+      plantuml_definition_file = outfile('seq.plantuml')
+      FileUtils.rm_f plantuml_definition_file
+      mock_executor = MockExecutor.new
+      order.executor = mock_executor
+      order.output png: outfile('seq.png')
+      
+      assert_equal true, File.exist?(plantuml_definition_file)
+      assert_equal 'plantuml -tpng ' + plantuml_definition_file, mock_executor.cmd
+    end
+    
+    def test_nested_flow_with_note_on_right
+      create_takeaway
+
+      order = sys.flow('order').involves sys.server, sys.eater
+
+      sys.server.receives burger: 'gimme burger'
 
-      definition = read_outfile('seq.txt')
+      order.from(sys.eater) {
+        sys.server.burger
+        sys.server.note(:right, 'a note')
+      }
+
+      definition = sequence_definition(order)
 
       assert_equal [
-                       'eater -> server: gimme burger',
-                       'server -> chef: passes order',
-                       'chef -> server:',
-                       'server -> eater:',
+                     'eater -> server: gimme burger',
+                     'note right of server',
+                     '  a note',
+                     'end note',
                    ].join("\n"), definition
     end
 
-    def create_food_flow
-      @sys = System.new 'takeaway'
-      eater = sys.thing 'eater'
-      server = sys.thing 'server'
-      cook = sys.thing 'cook'
+    def test_flow_generates_precise_sequence_with_deprecated_flows
+      create_takeaway
+      sys.suppress_warnings!
 
       order = sys.flow 'order'
-      order.flows eater, 'orders',
-                  server, 'creates order',
-                  cook.does('cooks burger'),
-                  'burger', server,
-                  'burger', eater
-      order
+      order.flows sys.eater, 'gimme burger',
+                  sys.server, 'passes order',
+                  sys.cook, sys.server, sys.eater
+
+      definition = sequence_definition(order, without_lines_starting: [])
+
+      assert_equal [
+                     'title order',
+                     'eater -> server: gimme burger',
+                     'server -> cook: passes order',
+                     'cook -> server:',
+                     'server -> eater:',
+                   ].join("\n"), definition
     end
 
-    def test_flow_generates_precise_sequence_with_action
-      order = create_food_flow
+    def test_flow_generates_precise_sequence_with_action_with_deprecated_flows
+      order = create_food_flow_with_deprecated_flows
 
-      order.output sequence: outfile('seq.txt')
-      definition = read_outfile('seq.txt')
+      definition = sequence_definition order
 
       assert_equal([
                        'eater -> server: orders',
                        'server -> +cook: creates order',
                        'note right of cook',
-                       '  cooks burger',
+                       '  "cooks burger"',
                        'end note',
                        'cook -> -server: burger',
                        'server -> eater: burger',
                    ].join("\n"), definition)
     end
 
-    def test_flow_can_be_used_to_make_connections_in_dog
-      order = create_food_flow
+    def test_flow_can_be_used_to_make_connections_in_dog_with_deprecated_flows
+      order = create_food_flow_with_deprecated_flows
 
       order.make_connections
 
       assert_equal('eater->server server->cook server->eater cook->server', connections)
     end
 
+    def test_deprecated_flows_generates_warnings
+      order = create_food_flow_with_deprecated_flows
+
+      assert_equal(1, order.sys.warnings.select {|w| w.include?('flow#flows deprecated')}.size)
+    end
+
     private
 
     attr_accessor :sys
 
+    def sequence_definition(order, without_lines_starting: ['title'])
+      order.output sequence: outfile('seq.txt')
+
+      lines = read_outfile('seq.txt').split "\n"
+      without_lines_starting.each {|prefix|
+        lines = lines.reject {|line| line.start_with?(prefix) }
+      }
+      lines.join "\n"
+    end
+
     def graph
       g = sys.render
       sys.output svg: outfile('svg')
       g
     end
+
+    def create_takeaway
+      @sys = System.new('takeaway', auto_nominate: true).suppress_messages!
+      sys.thing 'eater'
+      sys.thing 'server'
+      sys.thing 'cook'
+    end
+    
+    def create_food_flow_with_deprecated_flows
+      create_takeaway
+      order = sys.flow 'order'
+      sys.suppress_warnings!
+      order.flows sys.eater, 'orders',
+                  sys.server, 'creates order',
+                  sys.cook.does('cooks burger'),
+                  'burger', sys.server,
+                  'burger', sys.eater
+      order
+    end
+
   end
 end

data/tests/test_dogviz_functionally.rb

@@ -18,9 +18,10 @@ module Tests
 
     include Dogviz
     class Family < Dogviz::System
-      attr_reader *%i(cat dog mum son)
+      attr_reader(*%i(cat dog mum son))
       def initialize
         super 'family'
+        suppress_messages!
 
         house = container 'household'
 
@@ -60,7 +61,7 @@ module Tests
 
       dotspec = File.read outfile('dot')
 
-      assert_match /rank=sink/, dotspec
+      assert_match(/rank=sink/, dotspec)
     end
 
     def test_can_render_auto_nominate_graph
@@ -70,7 +71,7 @@ module Tests
     end
 
     def system_with_auto_nominate
-      Dogviz::System.new 'test', auto_nominate: true
+      Dogviz::System.new('test', auto_nominate: true).suppress_messages!
     end
   end
 end

data/tests/test_dogviz_graph.rb

@@ -163,7 +163,7 @@ class TestDogvizGraph < Test::Unit::TestCase
   def test_root
     group = sys.group('g')
     nested_group = group.group('nested group')
-    thing1 = group.thing('n1')
+    thing1 = nested_group.thing('n1')
 
     assert_equal sys, thing1.root
   end

data/tests/test_dogviz_graphviz_rendering.rb

@@ -34,7 +34,7 @@ class TestDogvizGraphvizRendering < Test::Unit::TestCase
 
   def test_containers_are_subgraphs_prefixed_with_cluster_for_visual_containment_in_GraphViz
     top = sys.container('top')
-    nested = top.container('nested')
+    top.container('nested')
 
     assert_equal('cluster_top', subgraph_ids.first)
     assert_equal('cluster_top_nested', subgraph_ids.last)

data/todo.txt

@@ -1,7 +1,21 @@
-* spike 'autostrap': automatically strap-on reader methods using normalised name
+* [DONE] spike 'autostrap': automatically strap-on reader methods using normalised name (auto_nominate)
 * [DONE] render generic output (sigma.js json) for ingestion -> space-dog
-* sort out fore vs back color
 * [DONE] move 'cluster_' prefix to graphviz renderer
+* flow / sequence improvements
+  [DONE] new flow syntax
+  [DONE] opt combined fragments
+  [DONE] titles
+  [DONE] indent text output 
+  - alt combined fragments
+  - allow unbalanced combined fragments (explicit start + end, not just by block)
+* plantuml flow output
+  [DONE] text output
+  [DONE] direct image output if plantuml installed
+  [DONE] sort double quotes
+  [ ] allow multiline
+* output generated flow file
+* deprecate old flows
+* sort out HACK (search for commit in git log) around flow detail used in make_connections
 * clean up init options + render attributes - not v clear / overlapping
 * make style attributes well defined -> less leaky + explicit graphviz passthroughs
 * separate style from domain-specific elements (can use same view-manipulation selection mechanisms)
@@ -15,6 +29,33 @@
   - maybe makes more seamless when collapsing/hiding for different views?
 * add sankey diagrams?
 * other renderer integrations:
-  - plantuml?
   - cyctoscape?
-* switch to proper graph lib under covers - this is just a builder + view wrapper...
+* switch to proper graph lib under covers - this is just a builder + view wrapper... https://github.com/monora/rgl?
+* #repeat(count) on containers to give multiple instances, by default expanded (to show each instance)
+* ...then can #collapse (1 instance showing, number labelled) 
+* ...then can #template or #prototype or ?? (1 instance detailed, rest simplified)
+* ...make count of repeat be complex e.g. to show auto-scaling, 1 per customer etc. etc.
+* make render 2 stages (rollups + repeats, then render) enabling:
+  - render multiple views from same dog instance
+  - separate and simplify rollup logic, which is a bit complex
+  - pave way for simplified repeat expansion logic, which is similarly complex (+ almost the reverse)
+  - pave way for cleaning graphviz specifics out of main dog ('cluster_', subgraphs)
+* edge attributes?
+  i - pass on any attributes passed as _graphviz: on to graphviz renderer for relevant entity
+  ii - map in simpler named attributes 
+      - color -> edge + font color
+      - stroke -> edge size and font size
+* render to d3 force directed graph
+* "rollup edges": where many edges from a node, rollup those to certain destination (e.g. from 'website' to all 
+   in '3rd party' container) so that not so crowded around source (would add extra view node nearer target)
+* "via": app -> service, via: load_balancer... then can omit load_balancer and get direct app -> service connection 
+* capture arbitrary info
+   - filter primitives for views
+   - default info_level to 'all', could be set to 'none'
+   - info_level applies to:
+     - entire view by default
+     - specified per node
+     - optionally inherited?
+   - allow nodes to assign summary fields? then could be set to 'summary'
+* sort out fore vs back color
+* check out structurizr.com

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dogviz
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.22
 platform: ruby
 authors:
 - damned
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-27 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 description: leverages graphviz to generate multiple views of a domain-specific graph
 email:
 - writetodan@yahoo.com