diagrammatron 0.1.1

data/bin/diagrammatron-render

@@ -0,0 +1,355 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require '../lib/common.rb'
+require 'optparse'
+require 'yaml'
+require 'erb'
+require 'pathname'
+require 'set'
+require 'base64'
+
+
+Coordinate = Struct.new(:object, :key, :direction) do
+  def <=>(c)
+    d = integer <=> c.integer
+    return d unless d.zero?
+    d = direction <=> c.direction
+    return d unless d.zero?
+    fraction <=> c.fraction
+  end
+
+  def integer
+    object[key].to_int
+  end
+
+  def fraction
+    object[key] - object[key].floor
+  end
+end
+
+def end_directions(end_point, neighbor)
+  if end_point['xo'] == neighbor['xo'] # Vertical
+    return [ 0, (end_point['yo'] < neighbor['yo']) ? 1 : -1 ]
+  end
+  [ (end_point['xo'] < neighbor['xo']) ? 1 : -1, 0 ]
+end
+
+def push_coords(xcoords, ycoords, ckd2count, object, xdirection, ydirection, node = false)
+  unless node || xdirection.zero?
+    k = [ object['xo'], object['yo'], 'xo', xdirection ]
+    ckd2count[k] = ckd2count[k] + 1
+  end
+  unless node || ydirection.zero?
+    k = [ object['xo'], object['yo'], 'yo', ydirection ]
+    ckd2count[k] = ckd2count[k] + 1
+  end
+  xcoords.push(Coordinate.new(object, 'xo', xdirection))
+  ycoords.push(Coordinate.new(object, 'yo', ydirection))
+end
+
+def separate_coordinates(doc)
+  xcoords = []
+  ycoords = []
+  ckd2count = Hash.new(0)
+  doc['nodes'].each do |node|
+    # All four sides.
+    push_coords(xcoords, ycoords, ckd2count, node, -1, -1, true)
+    push_coords(xcoords, ycoords, ckd2count, node.clone, 1, 1, true)
+  end
+  doc['edges'].each do |edge|
+    path = edge.fetch('path', nil)
+    next if path.nil?
+    xdirection, ydirection = end_directions(path[0], path[1])
+    push_coords(xcoords, ycoords, ckd2count, path[0], xdirection, ydirection)
+    (1...(path.size - 1)).each do |k|
+      push_coords(xcoords, ycoords, ckd2count, path[k], 0, 0)
+    end
+    xdirection, ydirection = end_directions(path.last, path[path.size - 2])
+    push_coords(xcoords, ycoords, ckd2count, path.last, xdirection, ydirection)
+  end
+  xcoords.sort!
+  ycoords.sort!
+  [ xcoords, ycoords, ckd2count ]
+end
+
+class FontInfo
+  attr_reader :descender, :max_ascend, :ascender, :cap_height, :line_spacing, :width, :size
+
+  def initialize(template)
+    font = template.fetch('defaults', {}).fetch('font', { 'font_size' => 16 })
+    @cap_height = font.fetch('cap_height', 0.8 * font.fetch('font_size', 16))
+    @ascender = font.fetch('ascender', @cap_height)
+    @max_ascend = [ @cap_height, @ascender ].max
+    @descender = font.fetch('descender', 0.25 * @max_ascend)
+    @size = font.fetch('font_size', @max_ascend + @descender)
+    @line_spacing = font.fetch('line_spacing', 0.2 * @max_ascend)
+    @width = font.fetch('width', 0.5 * @size)
+  end
+end
+
+class Defaults
+  attr_reader :width_key, :height_key, :width_margin, :height_margin, :edge_gap
+  attr_reader :font
+
+  def initialize(template)
+    defaults = template.fetch('defaults', {})
+    @width_key = defaults.fetch('width_key', 'w')
+    @height_key = defaults.fetch('height_key', 'h')
+    @width_margin = defaults.fetch('width_margin', 10)
+    @height_margin = defaults.fetch('height_margin', 10)
+    @edge_gap = defaults.fetch('edge_gap', 20)
+    @font = FontInfo.new(template)
+  end
+end
+
+class SizeEstimation
+  attr_accessor :node, :template, :ckd2count, :defaults
+
+  def initialize(template, ckd2count, defaults)
+    @node = nil
+    @template = template
+    @ckd2count = ckd2count
+    @defaults = defaults
+  end
+
+  def get_binding
+    binding
+  end
+
+  def get_default(key, default_value = nil)
+    @template.fetch('defaults', {}).fetch(key, default_value)
+  end
+
+  def max_edges(key, edge_gap)
+    c = [ @node['xo'], @node['yo'], key, -1 ]
+    count = @ckd2count[c]
+    c[3] = 1
+    count = [ count, @ckd2count[c] ].max
+    return 0 if count < 2
+    (count - 1) * (edge_gap || @defaults.edge_gap)
+  end
+
+  def default_size(width_scale = nil, height_scale = nil, line_spacing = nil,
+      width_margin = nil, height_margin = nil, edge_gap = nil)
+    lines = @node.fetch('label', '').split("\n")
+    w = 2 * (width_margin || @defaults.width_margin) +
+      (width_scale || @default.font.width) * (lines.map &(:size)).max
+    @node[@defaults.width_key] = [ w, max_edges('xo', edge_gap) ].max
+    h = 2 * (height_margin || @defaults.height_margin) +
+      (height_scale || @defaults.font.size) * lines.size +
+      (line_spacing || @defaults.font.line_spacing) * (lines.size - 1)
+    @node[@defaults.height_key] = [ h, max_edges('yo', edge_gap) ].max
+  end
+end
+
+def estimate_sizes(doc, template, ckd2count, defaults)
+  $render = SizeEstimation.new(template, ckd2count, defaults)
+  sizes = template.fetch('sizes', {})
+  defaults = template.fetch('defaults', {})
+  doc['nodes'].each do |node|
+    $render.node = node
+    style = node.fetch('style', 'default')
+    code = sizes.fetch(style, defaults.fetch('size', 
+      %(raise NotImplementedError, "No size estimator for style: #{style}")))
+    if sizes.key? code
+      code = sizes.fetch(code)
+    end
+    code = code.join("\n") if code.is_a? Array
+    begin
+      eval(code, $render.get_binding)
+    rescue StandardError => e
+      return aargh("Size estimate style #{style} node #{node.fetch('label', 'unnamed')} error #{e}", false)
+    end
+  end
+  $render = nil
+  true
+end
+
+def maxima(doc, defaults)
+  xmax = Hash.new(0)
+  ymax = Hash.new(0)
+  doc.fetch('nodes', []).each do |node|
+    xmax[node['xo']] = [ node[defaults.width_key], xmax[node['xo']] ].max
+    ymax[node['yo']] = [ node[defaults.height_key], ymax[node['yo']] ].max
+  end
+  [ xmax, ymax ]
+end
+
+def apply_maxima(doc, xmax, ymax, defaults)
+  doc.fetch('nodes', []).each do |node|
+    node[defaults.width_key] = xmax[node['xo']]
+    node[defaults.height_key] = ymax[node['yo']]
+  end
+end
+
+def parallel_edge_step_minima(coords)
+  c2m = Hash.new(1.0)
+  coords.each do |coord|
+    f = coord.fraction
+    next if f.zero?
+    ic = coord.integer
+    c2m[ic] = [ c2m[ic], f ].min
+  end
+  c2m
+end
+
+def remap_coordinates(coords, cmax, c2min, defaults)
+  c = defaults.edge_gap
+  gap = 0 # How much space all edge segments need.
+  zero_after_decrease = false
+  prev_dir = -2
+  coords.each do |coord|
+    zero_after_decrease = true if prev_dir == -1 && coord.direction.zero?
+    case coord.direction
+    when -1
+      c += gap if -1 < prev_dir
+      gap = defaults.edge_gap
+      coord.object[coord.key] = c
+    when 0
+      gap = defaults.edge_gap / c2min[coord.integer]
+      if zero_after_decrease
+        # Edge segment is at same range as nodes.
+        coord.object[coord.key] = c + coord.fraction * cmax[coord.integer]
+      else
+        coord.object[coord.key] =
+          c + defaults.edge_gap * coord.fraction / c2min[coord.integer]
+      end
+    when 1
+      gap = defaults.edge_gap
+      c += cmax[coord.integer] unless 1 == prev_dir
+      coord.object[coord.key] = c
+      zero_after_decrease = false
+    end
+    prev_dir = coord.direction
+  end
+end
+
+class Render
+  attr_accessor :doc, :template, :defaults
+
+  def initialize(doc, template, defaults)
+    @doc = doc
+    @template = template
+    @defaults = defaults
+  end
+
+  def get_binding
+    binding
+  end
+
+  def get_default(key, default_value = nil)
+    @template.fetch('defaults', {}).fetch(key, default_value)
+  end
+
+  def dimensions
+    w = 0
+    h = 0
+    @doc.fetch('nodes', []).each do |node|
+      w = [ w, node['xo'] + node[@defaults.width_key] ].max
+      h = [ h, node['yo'] + node[@defaults.height_key] ].max
+    end
+    @doc.fetch('edges', []).each do |edge|
+      path = edge.fetch('path', nil)
+      next if path.nil?
+      path.each do |p|
+        w = [ w, p['xo'] ].max
+        h = [ h, p['yo'] ].max
+      end
+    end
+    [ w.to_i, h.to_i ]
+  end
+end
+
+def apply(doc, template, defaults)
+  $render = Render.new(doc, template, defaults)
+  out = ERB.new(template.fetch('template', '')).result($render.get_binding)
+  $render = nil
+  out
+end
+
+def main
+  template = nil
+  input = nil
+  output = nil
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-render [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-t', '--template FILE', 'Template file name.') do |filename|
+      template = filename
+    end
+    opts.on('-i', '--input FILE', 'Input file name. Read from stdin if not given.') do |filename|
+      input = filename
+    end
+    opts.on('-o', '--output FILE', 'Output file name. Write to stdout if not given.') do |filename|
+      output = filename
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+Input YAML file is expected to be the output of diagrammatron-place.
+
+Output is the file produced by the erb-template.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  return aargh('Template must be given.', 2) if template.nil?
+  template = load_source(template)
+  return 2 if template.nil?
+  template.keys.sort.each do |key|
+    next unless key.start_with? 'base64'
+    nk = key.slice(6, key.size - 6)
+    begin
+      template[nk] = Base64.strict_decode64(template[key])
+      template.delete key
+    rescue StandardError
+      return aargh("Key #{key} base-64 decoding failed to key #{nk}", 2)
+    end
+  end
+  defaults = Defaults.new(template)
+
+  doc = load_source(input)
+  return 2 if doc.nil?
+
+  begin
+    xcoords, ycoords, ckd2count = separate_coordinates(doc)
+  rescue StandardError
+    return aargh('Error processing input.', 3)
+  end
+
+  return 4 unless estimate_sizes(doc, template, ckd2count, defaults)
+
+  # Make all rows the same height and all columns the same width.
+  xmax, ymax = maxima(doc, defaults)
+  apply_maxima(doc, xmax, ymax, defaults)
+
+  x2min = parallel_edge_step_minima(xcoords)
+  y2min = parallel_edge_step_minima(ycoords)
+  remap_coordinates(xcoords, xmax, x2min, defaults)
+  remap_coordinates(ycoords, ymax, y2min, defaults)
+
+  out = apply(doc, template, defaults)
+  begin
+    if output.nil?
+      $stdout.puts out
+    else
+      fp = Pathname.new output
+      fp.open('w') do |f|
+        f.puts out
+      end
+    end
+  rescue StandardError => e
+    return aargh([ e, "Failed to write output: #{output || 'stdout'}" ], 5)
+  end
+  0
+end
+
+exit(main) if (defined? $unit_test).nil?

data/bin/diagrammatron-template

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require '../lib/common.rb'
+require 'optparse'
+require 'yaml'
+require 'set'
+require 'pathname'
+require 'base64'
+
+
+def add_field(doc, field_name, content)
+  if field_name.start_with?('base64')
+    doc[field_name] = content
+  else
+    doc["base64#{field_name}"] = Base64.strict_encode64(content)
+  end
+end
+
+def missing(doc)
+  [ 'defaults', 'sizes', 'template' ].each do |key|
+    next if doc.key? key
+    next if doc.key? "base64#{key}"
+    return aargh("#{key} is missing", 4)
+  end
+  nil
+end
+
+def main
+  input = nil
+  output = nil
+  ENV['POSIXLY_CORRECT'] = '1' # Leaves patterns as they are.
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: diagrammatron-template [options] field-name content-file ...'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-r', '--root FILE', 'Starting point YAML file name.') do |filename|
+      input = filename
+    end
+    opts.on('-o', '--output FILE', 'Output file name. Write to stdout if not given.') do |filename|
+      output = filename
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+Pairs all parameter field-names with content-files contents, starting with
+either given root YAML file or with an empty root.
+
+Any field name either in root document or in parameters is trusted to be
+base-64 encoded without further checking.
+
+Outputs a YAML-file that case be used with diagrammatron-render as a template.
+All fields are base64-encoded for safety. diagrammatron-render will decode
+them and rename the fields by removing the base64 prefix.
+
+Presence of "defaults", "sizes", and "template" fields is checked for.
+Extra fields are not restricted in any manner.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  if ARGV.size.odd?
+    return aargh('Field-names and content-files count is odd.', 1)
+  end
+
+  doc = input.nil? ? {} : load_source_hash(input)
+  return 2 if doc.nil?
+
+  (0...ARGV.size).step(2) do |k|
+    fn = ARGV[k]
+    cfn = ARGV[k + 1]
+    begin
+      c = File.read(cfn)
+    rescue Errno::ENOENT
+      return aargh("Could not read #{cfn}", 3)
+    rescue StandardError => e
+      return aargh([ e, "Failed to read #{cfn}" ], 3)
+    end
+    add_field(doc, fn, c)
+  end
+
+  m = missing(doc)
+  return m unless m.nil?
+
+  begin
+    d = YAML.dump(doc, line_width: 1000000)
+    if output.nil?
+      $stdout.puts d
+    else
+      fp = Pathname.new output
+      fp.open('w') do |f|
+        f.puts d
+      end
+    end
+  rescue StandardError => e
+    return aargh([ e, "Failed to write output: #{output || 'stdout'}" ], 5)
+  end
+  0
+end
+
+exit(main) if (defined? $unit_test).nil?

data/bin/dot_json2diagrammatron

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require '../lib/common.rb'
+require 'optparse'
+require 'yaml'
+require 'json'
+require 'pathname'
+
+'''
+def load_source
+  begin
+    if $INPUT.nil?
+      src = $stdin.read
+    else
+      src = File.read($INPUT)
+    end
+    src = JSON.parse(src)
+  rescue Errno::ENOENT
+    return aargh("Could not load #{$INPUT || 'stdin'}")
+  rescue StandardError => e
+    return aargh("#{e}\nFailed to read #{$INPUT || 'stdin'}")
+  end
+  src
+end
+'''
+
+def convert(src)
+  idx2label = {}
+  labels = {} # For label collisions.
+  compound = {} # For compound nodes to remove if no edges.
+  nodes = []
+  items = src.fetch('objects', [])
+  items.each_index do |k|
+    item = items[k]
+    idx = item.fetch('_gvid', nil)
+    name = item.fetch('name', item.fetch('label', "node #{k}"))
+    return aargh("Object #{name} missing _gvid") if idx.nil?
+    compound[idx] = k if item.fetch('compound', false)
+    if labels.key? name
+      labels[name] += 1
+      name = "#{name}.#{labels[name]}" # Could collide here as well.
+    else
+      labels[name] = 0
+    end
+    idx2label[idx] = name
+    item['label'] = name
+    nodes.push(item)
+  end
+  edges = []
+  items = src.fetch('edges', [])
+  items.each_index do |k|
+    item = items[k]
+    tail = item.fetch('tail', nil)
+    head = item.fetch('head', nil)
+    if tail.nil? || head.nil?
+      return aargh("Edge #{k} (_gvid #{item.fetch('_gvid', 'undefined')}) head or tail missing")
+    end
+    next if head == tail
+    if compound.key? head
+      compound.delete head
+    elsif compound.key? tail
+      compound.delete tail
+    end
+    head = idx2label.fetch(head, nil)
+    tail = idx2label.fetch(tail, nil)
+    if tail.nil? || head.nil?
+      return aargh("Edge #{k} (_gvid #{item.fetch('_gvid', 'undefined')}) head or tail refer to unseen object index")
+    end
+    item['between'] = [ tail, head ]
+    edges.push(item)
+  end
+  # All compound nodes that have no edges are removed.
+  compound.values.sort.reverse.each do |k|
+    nodes.delete_at k
+  end
+  { 'edges' => edges, 'nodes' => nodes }
+end
+
+$INPUT = nil
+$OUTPUT = nil
+
+def main
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 20
+    opts.banner = 'Usage: dot_json2diagrammatron [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-i', '--input FILE', 'Input file name. Read from stdin if not given.') do |filename|
+      $INPUT = filename
+    end
+    opts.on('-o', '--output FILE', 'Output file name. Write to stdout if not given.') do |filename|
+      $OUTPUT = filename
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts opts
+      $stdout.puts %(
+Output is a YAML file with "name" used as "label" and "shape" used as is
+for nodes. For edges "tail" and "head" are used as the first and second element
+of "between" with the "name" as the identifier. Compound objects are ignored.
+)
+      exit 0
+    end
+  end
+  parser.parse! ARGV
+
+  doc = load_source
+  exit(2) if doc.nil?
+
+  begin
+    out = convert(doc)
+  rescue StandardError
+    out = aargh('Error processing input.')
+  end
+  exit(3) if out.nil?
+
+  begin
+    if $OUTPUT.nil?
+      $stdout.puts YAML.dump(out)
+    else
+      fp = Pathname.new $OUTPUT
+      fp.open('w') do |f|
+        f.puts YAML.dump(out)
+      end
+    end
+  rescue StandardError => e
+    aargh("#{e}\nFailed to write output: #{$OUTPUT}")
+    exit 4
+  end
+end
+
+main if (defined? $unit_test).nil?

data/lib/common.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Copyright © 2021 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+def aargh(message, return_value = nil)
+  message = (message.map &(:to_s)).join("\n") if message.is_a? Array
+  $stderr.puts message
+  return_value
+end
+
+def load_source(input)
+  YAML.safe_load(input.nil? ? $stdin : File.read(input))
+rescue Errno::ENOENT
+  aargh "Could not load #{input || 'stdin'}"
+rescue StandardError => e
+  aargh "#{e}\nFailed to read #{input || 'stdin'}"
+end
+
+def load_source_hash(input)
+  src = load_source(input)
+  unless src.nil?
+    return aargh('Input is not a mapping.') unless src.is_a? Hash
+  end
+  src
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: diagrammatron
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ismo Kärkkäinen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-23 00:00:00.000000000 Z
+dependencies: []
+description: |2
+
+  Generates diagrams in SVG format from input material. Split into multiple
+  programs that each perform one stage.
+
+  Source: https://github.com/ismo-karkkainen/diagrammatron
+
+  Licensed under Universal Permissive License, see LICENSE.txt.
+email: ismokarkkainen@icloud.com
+executables:
+- diagrammatron-edges
+- diagrammatron-nodes
+- diagrammatron-place
+- diagrammatron-prune
+- diagrammatron-render
+- diagrammatron-template
+- dot_json2diagrammatron
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- bin/diagrammatron-edges
+- bin/diagrammatron-nodes
+- bin/diagrammatron-place
+- bin/diagrammatron-prune
+- bin/diagrammatron-render
+- bin/diagrammatron-template
+- bin/dot_json2diagrammatron
+- lib/common.rb
+homepage: http://xn--ismo-krkkinen-gfbd.fi/diagrammatron/index.html
+licenses:
+- UPL-1.0
+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: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Generates diagrams from input graph.
+test_files: []