dogviz 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc41dd5fb565570c0542f852fe798a3c33bd0e92
-  data.tar.gz: 3561e4fe3f217a3a8939de36377d0a32a0ad36da
+  metadata.gz: f959437590340358149cd658e36ffbe14108dcb8
+  data.tar.gz: 54468cd372743f2f43669a12315d9b18db7f310c
 SHA512:
-  metadata.gz: ad9a6fe72533c4687e2cbfab4ba6cf582d2a3680890258707a13c4458bfb894a0bc6a9572b4685c23e8c351d36de78fa9069780a66cc531e541fee06abfb220b
-  data.tar.gz: eed194cd2f1540ab35d25ef23cb41fc3ccfc5cda34f55f84c58a8709be5a440c1faa4a641029ed850dfa49c7839a6143fbee8f922935bc5c34236c72540a5c61
+  metadata.gz: 50303617d8055c24805c2f21c9329888a247f1c8b6a84188c11d84e094f14030cf7f6e4826e6cc4a37e00f6c29992547ac26765b5fb98281da85186046438999
+  data.tar.gz: fa6ac254da3d07c81bbe56526ef7cab36d037cbc2be20bd9248290c8bb7bcb8dc51e76339a047f20a93962e50814c7058a576b293850506c3ca69d56f96c8b56

data/examples/dogfood.rb

@@ -0,0 +1,15 @@
+require 'dogviz'
+
+dogviz = Dogviz::System.new 'dogviz', splines: true
+
+classes = dogviz.container('classes')
+system = classes.thing('System')
+thing = classes.thing('Thing')
+container = classes.thing('Container')
+container.points_to thing, name: 'contains'
+container.points_to container, name: 'contains'
+system.points_to thing, name: 'contains'
+system.points_to container, name: 'contains'
+
+
+dogviz.output svg: 'dogviz-generated.svg'

data/lib/dogviz/version.rb

@@ -1,3 +1,3 @@
 module Dogviz
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

data/lib/dogviz.rb

@@ -1,6 +1,20 @@
 require 'ruby-graphviz'
 
 module Dogviz
+  class Process
+    def initialize(processor, description)
+      @processor = processor
+      @description = description
+    end
+    def name
+      @processor.name
+    end
+  end
+  module Flowable
+    def does(action)
+      Process.new(self, action)
+    end
+  end
   module Common
     def create_id(name, parent)
       parts = []
@@ -72,6 +86,13 @@ module Dogviz
     end
   end
   module Parent
+    def nominate(names_to_values)
+      names_to_values.each {|name, value|
+        self.class.send(:define_method, name) do
+          value
+        end
+      }
+    end
     def find_all(&matcher)
       raise MissingMatchBlockError.new unless block_given?
       @by_name.find_all &matcher
@@ -104,6 +125,7 @@ module Dogviz
 
   class Thing
     include Common
+    include Flowable
     attr_reader :parent
     attr_reader :name, :id, :pointers, :edge_heads
 
@@ -360,6 +382,109 @@ module Dogviz
     end
   end
 
+  class Flow
+    def initialize(sys, name)
+      @sys = sys
+      @name = name
+      @calls = []
+    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
+  end
+
+
+  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
+
+  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)
+        receiver_label = process_start_label(receiver_label)
+        detail = process_annotations(detail)
+      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)
+      detail = [detail,
+                'note right of cook',
+                '  cooks burger',
+                'end note'].join("\n")
+    end
+  end
+
   class System
     include Parent
 
@@ -382,6 +507,10 @@ module Dogviz
       out
     end
 
+    def flow(name)
+      Flow.new self, name
+    end
+
     def render(type=:graphviz)
       return @graph if @rendered
       raise "dunno bout that '#{type}', only know :graphviz" unless type == :graphviz

data/tests/test_dogviz_functionally.rb

@@ -4,41 +4,124 @@ require_relative 'svg_graph'
 module Tests
   class TestDogvizFunctionally < Test::Unit::TestCase
 
-    def svg_outfile
-      '/tmp/dogviz_functional_test.svg'
+    def outfile(ext)
+      "/tmp/dogviz_functional_test.#{ext}"
+    end
+
+    def read_outfile(ext)
+      File.read outfile(ext)
     end
 
     def setup
-      File.delete svg_outfile if File.exist?(svg_outfile)
+      File.delete outfile('svg') if File.exist?(outfile('svg'))
     end
 
     include Dogviz
-    def test_outputs_svg_graph
+    class Family < Dogviz::System
+      attr_reader *%i(cat dog mum son)
+      def initialize
+        super 'family'
 
-      sys = System.new 'family'
+        house = container 'household'
 
-      house = sys.container 'household'
+        @cat = house.thing 'cat'
+        @dog = house.thing 'dog'
 
-      cat = house.thing 'cat'
-      dog = house.thing 'dog'
+        @mum = house.thing 'mum'
+        @son = house.thing 'son'
 
-      mum = house.thing 'mum'
-      son = house.thing 'son'
+        mum.points_to son, name: 'parents'
+        son.points_to mum, name: 'ignores'
 
-      mum.points_to son, name: 'parents'
-      son.points_to mum, name: 'respects'
+        cat.points_to dog, name: 'chases'
+        dog.points_to son, name: 'follows'
+      end
+    end
 
-      cat.points_to dog, name: 'chases'
-      dog.points_to son, name: 'follows'
+    def test_outputs_svg_graph
+
+      sys = Family.new
 
-      sys.output svg: svg_outfile
+      sys.output svg: outfile('svg')
 
-      graph = SvgGraph.parse_file svg_outfile
+      graph = SvgGraph.parse_file outfile('svg')
 
       assert_include graph.title, 'family'
       assert_equal ['household'], graph.names_of.containers
       assert_equal ['cat', 'dog', 'son', 'mum'], graph.names_of.things
-      assert_equal ['chases', 'follows', 'parents', 'respects'], graph.names_of.edges
+      assert_equal ['chases', 'follows', 'parents', 'ignores'], graph.names_of.edges
+    end
+
+    def test_flow_generates_precise_sequence
+      sys = System.new 'takeaway'
+      eater = sys.thing 'eater'
+      server = sys.thing 'server'
+      cook = sys.thing 'cook'
+
+      order = sys.flow 'order'
+      order.flows eater, 'asks for burger',
+                  server, 'passes order',
+                  cook, server, eater
+
+      order.output sequence: outfile('seq.txt')
+
+      definition = read_outfile('seq.txt')
+
+      assert_equal [
+                       'eater -> server: asks for burger',
+                       'server -> cook: passes order',
+                       'cook -> server:',
+                       'server -> eater:',
+                   ].join("\n"), definition
+    end
+
+    def test_flow_generates_precise_sequence_with_action
+      sys = System.new 'takeaway'
+      eater = sys.thing 'eater'
+      server = sys.thing 'server'
+      cook = sys.thing 'cook'
+
+      order = sys.flow 'order'
+      order.flows eater, 'orders',
+                  server, 'creates order',
+                  cook.does('cooks burger'),
+                  'burger', server,
+                  'burger', eater
+
+      order.output sequence: outfile('seq.txt')
+      definition = read_outfile('seq.txt')
+
+      assert_equal([
+                       'eater -> server: orders',
+                       'server -> +cook: creates order',
+                       'note right of cook',
+                       '  cooks burger',
+                       'end note',
+                       'cook -> -server: burger',
+                       'server -> eater: burger',
+                   ].join("\n"), definition)
+    end
+
+    def xtest_flows_render_sequence_diagrams_and_form_edges
+
+      sys = System.new 'service'
+
+      organisation = sys.container 'organisation'
+
+      customer = sys.thing 'customer'
+
+      support = organisation.thing 'support phone line'
+      ivr = organisation.thing 'ivr'
+      first = organisation.thing 'first level support'
+      second = organisation.thing 'second level support'
+
+      complaint = sys.flow 'complaint'
+
+      complain.flows customer, 'calls',
+          support, 'connects to',
+          ivr, ''
+
+
     end
 
   end

data/tests/test_dogviz_graph.rb

@@ -114,6 +114,19 @@ class TestDogvizGraph < Test::Unit::TestCase
     })
   end
 
+  class Dog
+  end
+  def test_nominate_elevates_values_as_method_on_group
+    group = sys.group('g')
+
+    dog = Dog.new
+
+    group.nominate foobar: :any_value, dog: dog
+
+    assert_equal :any_value, group.foobar
+    assert_equal dog, group.dog
+  end
+
   def test_root
     group = sys.group('g')
     nested_group = group.group('nested group')

data/tests/test_dogviz_graphviz_rendering.rb

@@ -329,6 +329,24 @@ class TestDogvizGraphvizRendering < Test::Unit::TestCase
     assert_equal('"a\nip: 1.1.1.1"', find('a')['label'].to_ruby)
   end
 
+  def test_nominate_reduces_need_to_find_when_piecing_together_chunks_built_in_other_methods
+    def build_haystack
+      haystack = sys.group 'haystack'
+      needle = haystack.group('nested').group('hidden away').thing('needle')
+
+      haystack.nominate needle: needle
+      haystack
+    end
+
+    haystack = build_haystack
+
+    thread = sys.thing 'thread'
+    thread.points_to haystack.needle
+
+    assert_equal('thread->haystack_nested_hidden_away_needle', connections)
+  end
+
+
   private
 
   def subgraph_ids

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dogviz
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - damned
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-09 00:00:00.000000000 Z
+date: 2016-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,7 @@ files:
 - README.md
 - Rakefile
 - dogviz.gemspec
+- examples/dogfood.rb
 - examples/website.rb
 - examples/website_domain.rb
 - lib/dogviz.rb