trailblazer-developer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41c30437086de2bc9a0148eccf3db59603e484f92c032ff923cd0275fd369db0
+  data.tar.gz: bd45234bd028d5a5ef5348959da4b834ffdc6bf79af3821689718d76055ef4df
+SHA512:
+  metadata.gz: a66246114d6111e30c76993e18308675544b7623a8afcf732c9e0feab79cdda46dbcc3f789c20ea990c2276f1ef48321802b8f59c40706beab6480aa587bee80
+  data.tar.gz: 4bfdbbb63921aadf36c77c4c96a2da0e2efc0d283140b0263c504743bca92fbbc26a6f31ad7910bae09654e80a58c8d1deb53513fb1866c9e49bb060cc5ad313

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop-https---raw-githubusercontent-com-trailblazer-meta-master-rubocop-yml

@@ -0,0 +1,115 @@
+AllCops:
+  TargetRubyVersion: 2.5.0
+  DisplayCopNames: true
+Layout/CaseIndentation:
+  IndentOneStep: true
+Layout/FirstArrayElementLineBreak:
+  Enabled: true
+Layout/FirstHashElementLineBreak:
+  Enabled: true
+Layout/FirstMethodArgumentLineBreak:
+  Enabled: true
+Layout/FirstMethodParameterLineBreak:
+  Enabled: true
+Layout/MultilineAssignmentLayout:
+  Enabled: true
+  EnforcedStyle: same_line
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+Metrics/LineLength:
+  Max: 130
+Metrics/ParameterLists:
+  Max: 5
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+Style/AndOr:
+  EnforcedStyle: conditionals
+Style/AutoResourceCleanup:
+  Enabled: true
+Style/CollectionMethods:
+  Enabled: true
+Style/Documentation:
+  Enabled: false
+Style/EmptyLiteral:
+  Enabled: false
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+Style/FormatStringToken:
+  EnforcedStyle: template
+Style/ImplicitRuntimeError:
+  Enabled: true
+Style/MethodCalledOnDoEndBlock:
+  Enabled: true
+Style/MethodDefParentheses:
+  EnforcedStyle: require_parentheses
+Style/MissingElse:
+  Enabled: true
+  EnforcedStyle: case
+Style/NumericLiterals:
+  Enabled: false
+Style/OptionHash:
+  Enabled: true
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    "%w": "[]"
+    "%W": "[]"
+    "%i": "[]"
+    "%I": "[]"
+    "%r": "()"
+Style/ReturnNil:
+  Enabled: true
+Style/SafeNavigation:
+  Enabled: false
+Style/Send:
+  Enabled: true
+Style/SignalException:
+  EnforcedStyle: semantic
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+Style/StringMethods:
+  Enabled: true
+Style/SymbolArray:
+  Enabled: true
+# this allows in rspec to have expect { } with multiple lines
+Style/BlockDelimiters:
+  EnforcedStyle: braces_for_chaining
+Layout/EndOfLine:
+  Enabled: false
+# don't need these checks in test folders
+Metrics/ModuleLength:
+  Exclude:
+    - "spec/**/*"
+    - "test/**/*"
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "test/**/*"
+    - "*.gemspec" # definitely not in the gemspec
+Metrics/MethodLength:
+  Max: 20
+Lint/UnreachableCode:
+  Description: 'Unreachable code.'
+  Enabled: false
+Lint/Void:
+  Enabled: false
+Layout/AlignHash:
+  EnforcedLastArgumentHashStyle: ignore_implicit
+Metrics/AbcSize:
+  Max: 25
+Style/LambdaCall:
+  Enabled: false
+Style/Semicolon:
+  Enabled: false
+Naming/UncommunicativeMethodParamName:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Layout/LeadingCommentSpace:
+  Exclude:
+    - 'test/docs/**/*'
+Layout/AlignHash:
+  EnforcedHashRocketStyle: table
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/.rubocop.yml

@@ -0,0 +1,36 @@
+inherit_from:
+  - https://raw.githubusercontent.com/trailblazer/meta/master/rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.1
+  Exclude:
+    - 'test/hash/bla.rb'
+
+Metrics/LineLength:
+  Exclude:
+    - test/diagram_test.rb
+
+Naming/MethodName:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# DISCUSS: user map instead of collect
+Style/CollectionMethods:
+  Enabled: false
+
+# DISCUSS: Use raise with an explicit exception class and message, rather than just a message
+Style/ImplicitRuntimeError:
+  Enabled: false
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+# DISCUSS: Use fail instead of raise to signal exceptions
+Style/SignalException:
+  Enabled: false
+
+# DISUSS: this could be false because we have if locals blabla
+Bundler/DuplicatedGem:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in trailblazer-developer.gemspec
+gemspec
+
+# gem "trailblazer-activity", ">= 0.7.1"
+gem "trailblazer-activity", path: "../trailblazer-activity"
+gem "trailblazer-activity-dsl-linear", path: "../trailblazer-activity-dsl-linear"
+
+# gem "json"
+
+gem "representable"

data/README.md

@@ -0,0 +1,17 @@
+# Trailblazer::Developer
+
+_Developer tools for Trailblazers._
+
+## Documentation
+
+Find the complete documentation on the project website: [http://trb.to/2.1#developer]
+
+## Summary
+
+The `developer` gem provides the following neat tools.
+
+* Quick rendering of activities, including their taskWraps.
+* `wtf?` mode™: Run a broken activity and trace where an exception happened.
+* Connect to the visual TRB-editor: load, store, organize and render your app's activities.
+* Generate {Intermediate} data structures from TRB-editor.js files.
+* Debugging mode: run and debug workflows in the TRB-editor.

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+RuboCop::RakeTask.new(:rubocop)
+
+desc "Running Tests"
+task default: %i[test rubocop]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "trailblazer/developer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/trailblazer/developer.rb

@@ -0,0 +1,12 @@
+require "trailblazer/developer/version"
+
+module Trailblazer
+  module Developer
+    # Your code goes here...
+  end
+end
+
+require "trailblazer/developer/generate"
+require "trailblazer/developer/render/circuit"
+
+# require "trailblazer/developer/client"

data/lib/trailblazer/developer/activity.rb

@@ -0,0 +1,51 @@
+module Trailblazer
+  module Developer
+    # Transforms an {Activity::Graph} into an abstract data structure that represents the graph via a
+    # well-defined API. The goal is to decouple graph internals from the presentation layer.
+    # The {Model} is usually passed into Renderer and Layouter, to render the bpmn:Diagram XML or JSON.
+    #
+    # It returns {Model} with {Task}s and {Flow}s.
+    module Activity
+      module Graph
+        class << self
+          Model = Struct.new(:id, :start_events, :end_events, :task, :sequence_flow)
+          Task  = Struct.new(:id, :name, :options, :incoming, :outgoing)
+          # DISCUSS: direction ATM is the "condition" for the BPMN rendering.
+          Flow  = Struct.new(:id, :sourceRef, :targetRef, :direction)
+
+          # @param Graph an object implementing the Activity::Graph interface
+          # @return Model Generic representation of the graph, ready for rendering.
+          def self.to_model(graph, id: "some-process") # rubocop:disable Metrics/AbcSize
+            start_events = graph.find_all("Start.default") # FIXME. this is a static assumption.
+            end_events   = graph.find_all { |node| graph.successors(node).size.zero? }
+            tasks        = graph.find_all { |_node| true }
+            tasks       -= start_events
+            tasks       -= end_events
+
+            # transform nodes into BPMN elements.
+            start_events = start_events.collect do |evt|
+              Task.new(evt[:id], evt[:id], evt, Incomings(graph, evt), Outgoings(graph, evt))
+            end
+            end_events = end_events.collect do |evt|
+              Task.new(evt[:id], evt[:id], evt, Incomings(graph, evt), Outgoings(graph, evt))
+            end
+            tasks        = tasks.collect { |evt| Task.new(evt[:id], evt[:id], evt, Incomings(graph, evt), Outgoings(graph, evt)) }
+            edges        = (start_events + end_events + tasks).collect { |task| [task.incoming, task.outgoing] }.flatten(2).uniq
+
+            Model.new(id, start_events, end_events, tasks, edges)
+          end
+
+          private
+
+          def Outgoings(graph, source)
+            graph.successors(source).collect { |target, edge| Flow.new(edge[:id], source[:id], target[:id], edge[:_wrapped]) }
+          end
+
+          def Incomings(graph, target)
+            graph.predecessors(target).collect { |source, edge| Flow.new(edge[:id], source[:id], target[:id], edge[:_wrapped]) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/developer/client.rb

@@ -0,0 +1,21 @@
+require "faraday"
+
+module Trailblazer::Developer
+  module Client
+    def self.push(operation:, name:)
+      xml = Trailblazer::Diagram::BPMN.to_xml(operation["__activity__"], operation["__sequence__"].map(&:id))
+      token = "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJpZCI6MywidXNlcm5hbWUiOiJhcG90b25pY2siLCJlbWFpbCI6Im5pY2tAdHJhaWxibGF6ZXIudG8ifQ." # rubocop:disable Metrics/LineLength
+      conn = Faraday.new(url: "https://api.trb.to")
+      response = conn.post do |req|
+        req.url "/dev/v1/import"
+        req.headers["Content-Type"] = "application/json"
+        req.headers["Authorization"] = token
+        require "base64"
+
+        req.body = %({ "name": "#{name}", "xml":"#{Base64.strict_encode64(xml)}" })
+      end
+
+      puts response.status.inspect
+    end
+  end
+end

data/lib/trailblazer/developer/generate.rb

@@ -0,0 +1,66 @@
+require "representable/hash"
+
+module Trailblazer
+  module Developer
+    # Computes an {Intermediate} data structure from a TRB-editor.js file.
+    module Generate
+      module_function
+
+      Element = Struct.new(:id, :type, :linksTo, :data, :label)
+      Arrow   = Struct.new(:target, :label)
+
+      module Representer
+        class Activity < Representable::Decorator
+          include Representable::Hash
+
+          collection :elements, class: Element do
+            property :id
+            property :type
+            collection :linksTo, class: Arrow, default: [] do
+              property :target
+              property :label
+            end
+            property :data, default: {}
+            property :label
+          end
+        end
+      end
+
+      def call(hash)
+        elements = Representer::Activity.new(OpenStruct.new).from_hash(hash).elements
+
+        start_events = elements.find_all { |el| el.type == "Event" }
+        end_events   = elements.find_all { |el| el.type == "EndEventTerminate" }# DISCUSS: TERMINATE?
+
+        inter = Activity::Schema::Intermediate
+
+        wiring = elements.collect { |el| [inter.TaskRef(el.id, el.data), el.linksTo.collect { |arrow| inter.Out(semantic_for(arrow.to_h), arrow.target) } ] }
+        wiring = Hash[wiring]
+
+        # end events need this stupid special handling
+        wiring = wiring.merge(Hash[
+          end_events.collect do |_end|
+            ref, outputs = wiring.find { |ref, _| ref.id == _end.id }
+
+            [ref, [inter.Out(semantic_for(_end.to_h), nil)]]
+          end
+        ])
+        # pp wiring
+
+        inter.new(wiring, end_events.collect(&:id), start_events.collect(&:id))
+      end
+
+      # private
+
+      # We currently use the {:label} field of an arrow to encode an output semantic.
+      # The {:symbol_style} part will be filtered out as semantic. Defaults to {:success}.
+      def semantic_for(label:nil, **)
+        return :success unless label
+
+        m = label.match(/:(\w+)/)
+        return m[1].to_sym
+      end
+    end
+  end
+end
+# [Inter::Out(:success, nil)]

data/lib/trailblazer/developer/render/circuit.rb

@@ -0,0 +1,51 @@
+module Trailblazer
+  module Developer
+    module Render
+      module Circuit
+        module_function
+
+        # Render an {Activity}'s circuit as a simple hash.
+        def call(activity, **options)
+          graph = Activity::Introspect::Graph(activity)
+
+          circuit_hash(graph, **options)
+        end
+
+        def circuit_hash(graph, **options)
+          content = graph.collect do |node|
+            conns = node.outgoings.collect do |outgoing|
+              " {#{outgoing.output.signal}} => #{inspect_with_matcher(outgoing.task, **options)}"
+            end
+
+            [ inspect_with_matcher(node.task, **options), conns.join("\n") ]
+          end
+
+          content = content.join("\n")
+
+          return "\n#{content}".gsub(/0x\w+/, "0x")#.gsub(/0.\d+/, "0.")
+        end
+
+        # If Ruby had pattern matching, this function wasn't necessary.
+        def inspect_with_matcher(task, inspect_task: method(:inspect_task), inspect_end: method(:inspect_end))
+          return inspect_task.(task) unless task.kind_of?(Trailblazer::Activity::End)
+          inspect_end.(task)
+        end
+
+        def inspect_task(task)
+          task.inspect
+        end
+
+        def inspect_end(task)
+          class_name = strip(task.class)
+          options    = task.to_h
+
+          "#<#{class_name}/#{options[:semantic].inspect}>"
+        end
+
+        def strip(string)
+          string.to_s.sub("Trailblazer::Activity::", "")
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/developer/version.rb

@@ -0,0 +1,5 @@
+module Trailblazer
+  module Developer
+    VERSION = "0.0.1".freeze
+  end
+end

data/lib/trailblazer/developer/wtf.rb

@@ -0,0 +1,92 @@
+module Trailblazer::Developer
+  module_function
+
+  def wtf(activity, args)
+    Wtf.invoke(activity, args)
+  end
+  alias_method :wtf?, :wtf
+
+  module Wtf
+    module_function
+
+    # Run {activity} with tracing enabled and inject a mutable {Stack} instance.
+    # This allows to display the trace even when an exception happened
+    def invoke(activity, (ctx, flow_options))
+      flow_options ||= {} # Ruby sucks.
+
+      # this instance gets mutated with every step. unfortunately, there is
+      # no other way in Ruby to keep the trace even when an exception was thrown.
+      stack = Trailblazer::Activity::Trace::Stack.new
+
+      begin
+        returned_stack, _ = Trailblazer::Activity::Trace.invoke( activity,
+          [
+            ctx,
+            flow_options.merge(stack: stack)
+          ]
+        )
+      rescue
+
+        # DISCUSS: we shouldn't use internal knowledge of the Stack/Level API here.
+        closest = stack.to_a
+        while closest.is_a?(Trailblazer::Activity::Trace::Level) && closest = closest.last do # FIXME: deep-dive via Stack API.
+        end
+
+        # pp closest.task # this was the last executed task
+
+        handle(stack, $!, closest.task, activity, [ctx, flow_options])
+      end
+    end
+
+    def exception_renderer(stack:, level:, input:, name:, closest_task:)
+      return [ level, %{#{fmt(fmt(name, :red), :bold)}} ] if input.task == closest_task
+      [ level, %{#{name}} ]
+    end
+
+    # TODO: make this injectable
+    def handle(stack, exception, closest_task, activity, *args)
+      puts "[Trailblazer] Exception tracing"
+      puts "#{fmt(exception.inspect, :bold)}"
+      puts "    #{exception.backtrace[0]}"
+      puts "    #{exception.backtrace[1]}"
+      puts
+      puts Trailblazer::Activity::Trace::Present.(stack, closest_task: closest_task, renderer: method(:exception_renderer))
+    end
+
+
+
+    def fmt(line, style)
+      String.send(style, line)
+    end
+
+    # Stolen from https://stackoverflow.com/questions/1489183/colorized-ruby-output
+    #
+    # TODO: this is just prototyping
+    module String
+      module_function
+      def black(str);          "\e[30m#{str}\e[0m" end
+      def red(str);            "\e[31m#{str}\e[0m" end
+      def green(str);          "\e[32m#{str}\e[0m" end
+      def brown(str);          "\e[33m#{str}\e[0m" end
+      def blue(str);           "\e[34m#{str}\e[0m" end
+      def magenta(str);        "\e[35m#{str}\e[0m" end
+      def cyan(str);           "\e[36m#{str}\e[0m" end
+      def gray(str);           "\e[37m#{str}\e[0m" end
+
+      def bg_black(str);       "\e[40m#{str}\e[0m" end
+      def bg_red(str);         "\e[41m#{str}\e[0m" end
+      def bg_green(str);       "\e[42m#{str}\e[0m" end
+      def bg_brown(str);       "\e[43m#{str}\e[0m" end
+      def bg_blue(str);        "\e[44m#{str}\e[0m" end
+      def bg_magenta(str);     "\e[45m#{str}\e[0m" end
+      def bg_cyan(str);        "\e[46m#{str}\e[0m" end
+      def bg_gray(str);        "\e[47m#{str}\e[0m" end
+
+      def bold(str);           "\e[1m#{str}\e[22m" end
+      def italic(str);         "\e[3m#{str}\e[23m" end
+      def underline(str);      "\e[4m#{str}\e[24m" end
+      def blink(str);          "\e[5m#{str}\e[25m" end
+      def reverse_color(str);  "\e[7m#{str}\e[27m" end
+    end
+  end
+end

data/lib/trailblazer/diagram/bpmn.rb

@@ -0,0 +1,338 @@
+require "representable"
+require "representable/xml"
+
+require "trailblazer/developer/activity"
+
+module Trailblazer
+  module Diagram
+    module BPMN # rubocop:disable Metrics/ModuleLength
+      Plane  = Struct.new(:element, :shapes, :edges)
+      Shape  = Struct.new(:id, :element, :bounds)
+      Edge   = Struct.new(:id, :element, :waypoints)
+      Bounds = Struct.new(:x, :y, :width, :height)
+      Waypoint = Struct.new(:x, :y)
+
+      require "tsort"
+      # Helps sorting the tasks in a process "topologically", which is basically what the
+      # Sequence does for us, but this works for any kind of process.
+      # DISCUSS: should we work on the Model or Graph interface?
+      def self.topological_sort(model)
+        edges = {}
+        model.end_events.each { |task| edges[task.id] = {} }
+        model.sequence_flow.each do |edge|
+          edges[edge.sourceRef] ||= []
+          edges[edge.sourceRef] << edge.targetRef
+        end
+
+        # g = {1=>[2, 3], 2=>[4], 3=>[2, 4], 4=>[]}
+        each_node = ->(&b) { edges.each_key(&b) }
+        each_child = ->(n, &b) { edges[n].each(&b) }
+        TSort.tsort(each_node, each_child).reverse #=> [4, 2, 3, 1]
+      end
+
+      # FIXME: this should be called "linear layouter or something"
+      # Render an `Activity`'s circuit to a BPMN 2.0 XML `<process>` structure.
+      # @param activity Activity
+      # @param linear_task_ids [String] A list of task IDs that should be layouted sequentially in the provided order.
+      def self.to_xml(activity, linear_task_ids = nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        model = Trailblazer::Developer::Activity::Graph.to_model(activity.graph)
+
+        linear_task_ids ||= topological_sort(model)
+
+        # this layouter doesn't want End events in the linear part, we arrange them manually.
+        linear_task_ids -= model.end_events.map(&:id)
+        linear_task_ids -= model.start_events.map(&:id)
+        linear_tasks = linear_task_ids.collect do |id|
+          model.task.find { |task| task.id == id } || raise("task #{id} is not in model!")
+        end
+
+        start_x = 200
+        y_right = 200
+        y_left  = 300
+
+        event_width = 54
+
+        shape_width  = 81
+        shape_height = 54
+        shape_to_shape = 45
+
+        current = start_x
+        shapes = []
+
+        # add start.
+        shapes << Shape.new(
+          "Shape_#{model.start_events[0][:id]}",
+          model.start_events[0][:id],
+          Bounds.new(current, y_right, event_width, event_width)
+        )
+        current += event_width + shape_to_shape
+
+        # add tasks.
+        linear_tasks.each do |task|
+          is_right = %i[pass step].include?(task.options[:created_by])
+
+          shapes << Shape.new(
+            "Shape_#{task[:id]}",
+            task[:id],
+            Bounds.new(current, is_right ? y_right : y_left, shape_width, shape_height)
+          )
+          current += shape_width + shape_to_shape
+        end
+
+        # add ends.
+        horizontal_end_offset = 90
+
+        defaults = {
+          "End.success" => {y: y_right},
+          "End.failure" => {y: y_left},
+          "End.pass_fast" => {y: y_right - 90},
+          "End.fail_fast" => {y: y_left + 90}
+        }
+
+        success_end_events = []
+        failure_end_events = [] # rubocop:disable Lint/UselessAssignment
+
+        model.end_events.each do |evt|
+          id = evt[:id]
+          y  = defaults[id] ? defaults[id][:y] : success_end_events.last + horizontal_end_offset
+
+          success_end_events << y
+
+          shapes << Shape.new("Shape_#{id}", id, Bounds.new(current, y, event_width, event_width))
+        end
+
+        edges = []
+        model.sequence_flow.each do |flow|
+          source = shapes.find { |shape| shape.id == "Shape_#{flow.sourceRef}" }.bounds
+          target = shapes.find { |shape| shape.id == "Shape_#{flow.targetRef}" }.bounds
+
+          edges << Edge.new("SequenceFlow_#{flow[:id]}", flow[:id], Path(source, target, target.x != current))
+        end
+
+        diagram = Struct.new(:plane).new(Plane.new(model.id, shapes, edges))
+
+        # render XML.
+        Representer::Definitions.new(Definitions.new(model, diagram)).to_xml
+      end
+
+      def self.Path(source, target, do_straight_line) # rubocop:disable Metrics/AbcSize
+        if source.y == target.y # --->
+          [Waypoint.new(*fromRight(source)), Waypoint.new(*toLeft(target))]
+        elsif do_straight_line
+          [Waypoint.new(*fromBottom(source)), Waypoint.new(*toLeft(target))]
+        elsif target.y > source.y # target below source.
+          [
+            l = Waypoint.new(*fromBottom(source)),
+            r = Waypoint.new(l.x, target.y + target.height / 2),
+            Waypoint.new(target.x, r.y)
+          ]
+        else # target above source.
+          [l = Waypoint.new(*fromTop(source)), r = Waypoint.new(l.x, target.y + target.height / 2), Waypoint.new(target.x, r.y)]
+        end
+      end
+
+      def self.fromRight(left)
+        [left.x + left.width, left.y + left.height / 2]
+      end
+
+      def self.toLeft(bounds)
+        [bounds.x, bounds.y + bounds.height / 2]
+      end
+
+      def self.fromBottom(bounds)
+        [bounds.x + bounds.width / 2, bounds.y + bounds.height]
+      end
+
+      def self.fromTop(bounds)
+        [bounds.x + bounds.width / 2, bounds.y]
+      end
+
+      Definitions = Struct.new(:process, :diagram)
+
+      # Representers for BPMN XML.
+      module Representer
+        class Task < Representable::Decorator
+          include Representable::XML
+          include Representable::XML::Namespace
+          namespace "http://www.omg.org/spec/BPMN/20100524/MODEL"
+
+          self.representation_wrap = :task # overridden via :as.
+
+          property :id,   attribute: true
+          property :name, attribute: true
+
+          collection :outgoing, exec_context: :decorator
+          collection :incoming, exec_context: :decorator
+
+          def outgoing
+            represented.outgoing.collect { |edge| edge[:id] }
+          end
+
+          def incoming
+            represented.incoming.collect { |edge| edge[:id] }
+          end
+        end
+
+        class SequenceFlow < Representable::Decorator
+          include Representable::XML
+          include Representable::XML::Namespace
+          self.representation_wrap = :sequenceFlow
+          namespace "http://www.omg.org/spec/BPMN/20100524/MODEL"
+
+          property :id, attribute: true
+          property :sourceRef, attribute: true, exec_context: :decorator
+          property :targetRef, attribute: true, exec_context: :decorator
+          property :direction, as: :conditionExpression
+
+          def sourceRef
+            represented.sourceRef
+          end
+
+          def targetRef
+            represented.targetRef
+          end
+        end
+
+        class Process < Representable::Decorator
+          include Representable::XML
+          include Representable::XML::Namespace
+          self.representation_wrap = :process
+
+          namespace "http://www.omg.org/spec/BPMN/20100524/MODEL"
+
+          property :id, attribute: true
+
+          collection :start_events, as: :startEvent, decorator: Task
+          collection :end_events, as: :endEvent, decorator: Task
+          collection :task, decorator: Task
+          collection :sequence_flow, decorator: SequenceFlow, as: :sequenceFlow
+        end
+
+        module Diagram
+          class Bounds < Representable::Decorator
+            include Representable::XML
+            include Representable::XML::Namespace
+            self.representation_wrap = :Bounds
+
+            namespace "http://www.omg.org/spec/DD/20100524/DC"
+
+            property :x,      attribute: true
+            property :y,      attribute: true
+            property :width,  attribute: true
+            property :height, attribute: true
+          end
+
+          class Diagram < Representable::Decorator
+            feature Representable::XML
+            feature Representable::XML::Namespace
+            self.representation_wrap = :BPMNDiagram
+
+            namespace "http://www.omg.org/spec/BPMN/20100524/DI"
+
+            property :plane, as: "BPMNPlane" do
+              self.representation_wrap = :plane
+
+              property :element, as: :bpmnElement, attribute: true
+
+              namespace "http://www.omg.org/spec/BPMN/20100524/DI"
+
+              collection :shapes, as: "BPMNShape" do
+                self.representation_wrap = :BPMNShape
+                namespace "http://www.omg.org/spec/BPMN/20100524/DI"
+
+                property :id,                        attribute: true
+                property :element, as: :bpmnElement, attribute: true
+
+                property :bounds, as: "Bounds", decorator: Bounds
+              end
+
+              collection :edges, as: "BPMNEdge" do
+                self.representation_wrap = :BPMNEdge
+                namespace "http://www.omg.org/spec/BPMN/20100524/DI"
+
+                property :id,                        attribute: true
+                property :element, as: :bpmnElement, attribute: true
+
+                # <di:waypoint xsi:type="dc:Point" x="136" y="118" />
+                collection :waypoints, as: :waypoint do
+                  namespace "http://www.omg.org/spec/DD/20100524/DI"
+
+                  property :type, as: "xsi:type", exec_context: :decorator, attribute: true
+                  property :x, attribute: true
+                  property :y, attribute: true
+
+                  def type
+                    "dc:Point"
+                  end
+                end
+              end
+            end
+
+            # namespace "http://www.w3.org/2001/XMLSchema-instance" # xsi
+          end
+        end
+
+        class Definitions < Representable::Decorator
+          include Representable::XML
+          include Representable::XML::Namespace
+          self.representation_wrap = :definitions
+
+          namespace "http://www.omg.org/spec/BPMN/20100524/MODEL"
+          namespace_def bpmn: "http://www.omg.org/spec/BPMN/20100524/MODEL"
+          namespace_def bpmndi: "http://www.omg.org/spec/BPMN/20100524/DI"
+          namespace_def di: "http://www.omg.org/spec/DD/20100524/DI"
+
+          namespace_def dc: "http://www.omg.org/spec/DD/20100524/DC" # <cd:Bounds>
+          namespace_def xsi: "http://www.w3.org/2001/XMLSchema-instance" # used in waypoint.
+
+          property :process, decorator: Process
+          property :diagram, decorator: Diagram::Diagram, as: :BPMNDiagram
+        end
+      end
+    end
+  end
+end
+
+# <bpmndi:BPMNDiagram id="BPMNDiagram_1">
+#   <bpmndi:BPMNPlane id="BPMNPlane_1">
+#      <bpmndi:BPMNShape id="_BPMNShape_Task_2" bpmnElement="Task_2">
+#         <dc:Bounds x="100" y="100" width="36" height="36" />
+#      </bpmndi:BPMNShape>
+#      <bpmndi:BPMNShape id="_BPMNShape_Task_3" bpmnElement="Task_3">
+#         <dc:Bounds x="236" y="78" width="100" height="80" />
+#      </bpmndi:BPMNShape>
+#      <bpmndi:BPMNEdge id="_BPMNConnection_Flow_4" bpmnElement="Flow_4">
+#         <di:waypoint xsi:type="dc:Point" x="136" y="118" />
+#         <di:waypoint xsi:type="dc:Point" x="236" y="118" />
+#      </bpmndi:BPMNEdge>
+#      <bpmndi:BPMNShape id="_BPMNShape_Task_5" bpmnElement="Task_5">
+#         <dc:Bounds x="436" y="78" width="100" height="80" />
+#      </bpmndi:BPMNShape>
+#      <bpmndi:BPMNEdge id="_BPMNConnection_Flow_6" bpmnElement="Flow_6">
+#         <di:waypoint xsi:type="dc:Point" x="336" y="118" />
+#         <di:waypoint xsi:type="dc:Point" x="436" y="118" />
+#      </bpmndi:BPMNEdge>
+#      <bpmndi:BPMNShape id="_BPMNShape_Task_1" bpmnElement="Task_1">
+#         <dc:Bounds x="636" y="100" width="36" height="36" />
+#      </bpmndi:BPMNShape>
+#      <bpmndi:BPMNShape id="_BPMNShape_Task_8" bpmnElement="Task_8">
+#         <dc:Bounds x="636" y="266" width="100" height="80" />
+#      </bpmndi:BPMNShape>
+#      <bpmndi:BPMNEdge id="_BPMNConnection_Flow_7" bpmnElement="Flow_7">
+#         <di:waypoint xsi:type="dc:Point" x="536" y="118" />
+#         <di:waypoint xsi:type="dc:Point" x="636" y="118" />
+#      </bpmndi:BPMNEdge>
+#      <bpmndi:BPMNEdge id="_BPMNConnection_Flow_9" bpmnElement="Flow_9">
+#         <di:waypoint xsi:type="dc:Point" x="536" y="118" />
+#         <di:waypoint xsi:type="dc:Point" x="586" y="118" />
+#         <di:waypoint xsi:type="dc:Point" x="586" y="306" />
+#         <di:waypoint xsi:type="dc:Point" x="636" y="306" />
+#      </bpmndi:BPMNEdge>
+#      <bpmndi:BPMNEdge id="_BPMNConnection_Flow_10" bpmnElement="Flow_10">
+#         <di:waypoint xsi:type="dc:Point" x="686" y="266" />
+#         <di:waypoint xsi:type="dc:Point" x="686" y="201" />
+#         <di:waypoint xsi:type="dc:Point" x="654" y="201" />
+#         <di:waypoint xsi:type="dc:Point" x="654" y="136" />
+#      </bpmndi:BPMNEdge>
+#   </bpmndi:BPMNPlane>
+# </bpmndi:BPMNDiagram>

data/trailblazer-developer.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "trailblazer/developer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "trailblazer-developer"
+  spec.version       = Trailblazer::Developer::VERSION
+  spec.authors       = ["Nick Sutterer"]
+  spec.email         = ["apotonick@gmail.com"]
+
+  spec.summary       = "Developer tools for Trailblazer."
+  spec.description   = "Developer tools for Trailblazer: debugger, tracing, visual editor integration."
+  spec.homepage      = "http://trailblazer.to/gems/trailblazer/developer.html"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
+
+  spec.add_dependency "trailblazer-activity", "~> 0.8"
+  spec.add_dependency "representable"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: trailblazer-developer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nick Sutterer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rubocop
+  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: trailblazer-activity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: representable
+  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: 'Developer tools for Trailblazer: debugger, tracing, visual editor integration.'
+email:
+- apotonick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop-https---raw-githubusercontent-com-trailblazer-meta-master-rubocop-yml"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/trailblazer/developer.rb
+- lib/trailblazer/developer/activity.rb
+- lib/trailblazer/developer/client.rb
+- lib/trailblazer/developer/generate.rb
+- lib/trailblazer/developer/render/circuit.rb
+- lib/trailblazer/developer/version.rb
+- lib/trailblazer/developer/wtf.rb
+- lib/trailblazer/diagram/bpmn.rb
+- trailblazer-developer.gemspec
+homepage: http://trailblazer.to/gems/trailblazer/developer.html
+licenses: []
+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.7.3
+signing_key: 
+specification_version: 4
+summary: Developer tools for Trailblazer.
+test_files: []