alembic 0.1.0 → 0.3.0

data/app/javascript/alembic/canvas/rows.js

@@ -1,2 +0,0 @@
-export const amended = (rows, index, name, next) =>
-  rows.map((row, at) => (at === index ? { ...row, [name]: next } : row))

data/app/javascript/alembic/canvas/styles.js

@@ -1,3 +0,0 @@
-export const CARD = 240
-export const GAP_X = 40
-export const GAP_Y = 64

data/app/javascript/alembic/canvas/useConnectors.js

@@ -1,75 +0,0 @@
-import { useLayoutEffect, useState } from "react"
-
-export const anchor = (box, side, frame, surface) => {
-  const left = box.left - frame.left + surface.scrollLeft
-  const top = box.top - frame.top + surface.scrollTop
-
-  if (side === "left") return { x: left, y: top + box.height / 2 }
-  if (side === "right") return { x: left + box.width, y: top + box.height / 2 }
-  if (side === "top") return { x: left + box.width / 2, y: top }
-  return { x: left + box.width / 2, y: top + box.height }
-}
-
-export const shy = (point, side) => {
-  if (side === "top") return { x: point.x, y: point.y - 3 }
-  if (side === "left") return { x: point.x - 3, y: point.y }
-  if (side === "right") return { x: point.x + 3, y: point.y }
-  return { x: point.x, y: point.y + 3 }
-}
-
-export const drawn = (edge, a, b, lane, detour) => {
-  const path = {
-    straight: `M ${a.x} ${a.y} L ${b.x} ${b.y}`,
-    turn: `M ${a.x} ${a.y} H ${b.x} V ${b.y}`,
-    lane: `M ${a.x} ${a.y} V ${lane} H ${b.x} V ${b.y}`,
-    detour: `M ${a.x} ${a.y} H ${detour} V ${b.y} H ${b.x}`
-  }[edge.route]
-
-  return {
-    ...edge, path,
-    midX: edge.route === "detour" ? detour : (a.x + b.x) / 2,
-    midY: edge.route === "lane" ? lane : (a.y + b.y) / 2
-  }
-}
-
-const useConnectors = (flow, surface, cards, watching) => {
-  const [ links, setLinks ] = useState([])
-  const [ extent, setExtent ] = useState({ width: "100%", height: "100%" })
-
-  useLayoutEffect(() => {
-    const measure = () => {
-      const frame = surface.current?.getBoundingClientRect()
-      if (!frame) return
-
-      setExtent({ width: surface.current.scrollWidth, height: surface.current.scrollHeight })
-
-      setLinks(flow.edges.flatMap((edge) => {
-        const fromBox = cards.current[edge.source]?.getBoundingClientRect()
-        const toBox = cards.current[edge.target]?.getBoundingClientRect()
-        if (!fromBox || !toBox) return []
-
-        const a = anchor(fromBox, edge.leaves, frame, surface.current)
-        const b = shy(anchor(toBox, edge.enters, frame, surface.current), edge.enters)
-        const lane = (anchor(fromBox, "bottom", frame, surface.current).y + anchor(toBox, "top", frame, surface.current).y) / 2
-        const detour = edge.leaves === "left" ? Math.min(a.x, b.x) - 28 : Math.max(a.x, b.x) + 28
-
-        return [ drawn(edge, a, b, lane, detour) ]
-      }))
-    }
-
-    measure()
-    window.addEventListener("resize", measure)
-
-    const watcher = new ResizeObserver(measure)
-    if (surface.current) watcher.observe(surface.current)
-
-    return () => {
-      window.removeEventListener("resize", measure)
-      watcher.disconnect()
-    }
-  }, watching)
-
-  return { links, extent }
-}
-
-export default useConnectors

data/app/javascript/alembic/canvas/useFlow.js

@@ -1,17 +0,0 @@
-import { useMemo, useState } from "react"
-import { createFlowSender } from "./flowSender"
-
-const useFlow = (base, token, initial) => {
-  const [ flow, setFlow ] = useState(initial)
-  const [ error, setError ] = useState(null)
-  const [ notice, setNotice ] = useState(null)
-
-  const send = useMemo(
-    () => createFlowSender({ base, token, fetch: (...request) => window.fetch(...request), onFlow: setFlow, onError: setError, onNotice: setNotice }),
-    [ base, token ]
-  )
-
-  return { flow, error, notice, send }
-}
-
-export default useFlow

data/app/javascript/alembic/canvas.jsx

@@ -1,13 +0,0 @@
-import { createRoot } from "react-dom/client"
-import { register } from "keystone_ui-react/src/registry.js"
-import { startMounting } from "keystone_ui-react/src/mounting.js"
-import Canvas from "./canvas/Canvas"
-
-register("alembic/flow-editor", Canvas)
-
-document.addEventListener("alembic:flow-named", (event) => {
-  const heading = document.querySelector("[data-flow-heading]")
-  if (heading) heading.textContent = event.detail
-})
-
-startMounting(document, createRoot)

data/app/models/alembic/asked.rb

@@ -1,3 +0,0 @@
-module Alembic
-  Asked = Data.define(:id, :text, :choices)
-end

data/app/models/alembic/choice.rb

@@ -1,7 +0,0 @@
-module Alembic
-  Choice = Data.define(:value, :label, :hint) do
-    def initialize(value:, label: nil, hint: nil)
-      super(value: value, label: label.presence || value, hint: hint)
-    end
-  end
-end

data/app/models/alembic/flow/admission.rb

@@ -1,19 +0,0 @@
-module Alembic
-  module Flow
-    module Admission
-      def self.of(diagnostic, permitted:)
-        raise NotPublished if diagnostic.nil? || diagnostic.live_definition.blank?
-        raise NotPermitted unless permitted && diagnostic.available?
-
-        diagnostic
-      end
-
-      def self.of_run(run, permitted: true)
-        raise Withdrawn if run.definition_version.withdrawn?
-        raise NotPermitted unless permitted && run.flow.available?
-
-        run
-      end
-    end
-  end
-end

data/app/models/alembic/flow/canvas.rb

@@ -1,167 +0,0 @@
-module Alembic
-  module Flow
-    class Canvas
-      def initialize(document, registry: Flow.registry)
-        @document = document
-        @registry = registry
-      end
-
-      def to_h
-        { "nodes" => nodes, "edges" => edges, "palette" => palette, "violations" => violations }
-      end
-
-      private
-
-      def nodes
-        @document.nodes.map { |node| drawn_step(node) } + waiting.map { |gap| drawn_placeholder(gap) }
-      end
-
-      def drawn_step(node)
-        { "id" => node.id, "type" => node.type, "label" => label_for(node),
-          "config" => node.config, "ports" => [], "ends_here" => ends_here?(node), "begins_here" => begins_here?(node),
-          "loose" => loose?(node), "choices" => choices_for(node), "placeholder" => false, **placed[node.id] }
-      end
-
-      def drawn_placeholder(gap)
-        { "id" => gap[:id], "type" => "placeholder", "label" => gap[:on], "config" => {}, "ports" => [],
-          "ends_here" => false, "begins_here" => false, "loose" => false, "choices" => {},
-          "placeholder" => true, "from" => gap[:from], "on" => gap[:on], **placed[gap[:id]] }
-      end
-
-      def edges
-        drawn.edges.each_with_index.map do |edge, index|
-          { "id" => "#{edge.from}-#{edge.to}-#{index}", "source" => edge.from, "target" => edge.to, "label" => edge.on&.to_s,
-            "placeholder" => waiting.any? { |gap| gap[:id] == edge.to } }.merge(routing(edge, placed))
-        end
-      end
-
-      def placed
-        @placed ||= Layout.new(drawn).positions
-      end
-
-      def drawn
-        @drawn ||= Document.new(@document.to_h.merge(
-          "nodes" => Array(@document.to_h["nodes"]) + waiting.map { |gap| { "id" => gap[:id], "type" => "placeholder" } },
-          "edges" => Array(@document.to_h["edges"]) + waiting.map { |gap| { "from" => gap[:from], "to" => gap[:id], "on" => gap[:on] } }
-        ), registry: @registry)
-      end
-
-      def waiting
-        @waiting ||= @document.nodes.flat_map { |node| gaps_after(node) }
-      end
-
-      def gaps_after(node)
-        wired = @document.edges_from(node.id).map { |edge| edge.on.to_s }
-        results = digest.routing_values(node.id)
-        return [ { id: "#{node.id}--", from: node.id, on: nil } ] if results.empty? && leads_nowhere?(node)
-
-        results.reject { |value| wired.include?(value) }
-          .map { |value| { id: "#{node.id}--#{value}", from: node.id, on: value } }
-      end
-
-      def leads_nowhere?(node)
-        !ends_here?(node) && !loose?(node) && @document.edges_from(node.id).none?
-      end
-
-      def routing(edge, placed)
-        from = placed[edge.from]
-        to = placed[edge.to]
-        return { "leaves" => "bottom", "enters" => "top", "route" => "straight" } unless from && to
-
-        return alongside_routing(from, to) unless to["row"] > from["row"]
-
-        { "leaves" => "bottom", "enters" => "top",
-          "route" => to["column"] == from["column"] ? "straight" : "lane" }
-      end
-
-      def alongside_routing(from, to)
-        leftward = to["column"] < from["column"]
-
-        { "leaves" => leftward ? "left" : "right", "enters" => leftward ? "right" : "left",
-          "route" => to["row"] == from["row"] ? "straight" : "detour" }
-      end
-
-      def palette
-        @registry.step_types.reject(&:begins_here?).map do |step_type|
-          { "type" => step_type.id.to_s, "label" => step_type.step_name,
-            "fields" => step_type.settings.fields.transform_keys(&:to_s).transform_values(&:to_s),
-            "labels" => step_type.settings.labels.transform_keys(&:to_s),
-            "choices" => step_type.settings.choices.transform_keys(&:to_s),
-            "records" => holdings_of(step_type),
-            "record_labels" => step_type.settings.record_labels.to_h { |name, held| [ name.to_s, held.transform_keys(&:to_s) ] },
-            "awaits_input" => step_type.awaits_input? }
-        end
-      end
-
-      def holdings_of(step_type)
-        step_type.settings.record_fields.to_h do |name, holds|
-          [ name.to_s, holds.transform_keys(&:to_s).transform_values(&:to_s) ]
-        end
-      end
-
-      def violations
-        Validator.new(@document, registry: @registry).violations.map do |violation|
-          { "node" => violation.node, "problem" => violation.problem.to_s, "detail" => violation.detail }
-        end
-      end
-
-      def label_for(node)
-        Name.of(node, @registry)
-      end
-
-      def choices_for(node)
-        naming_steps(node).index_with { earlier_than(node) }.merge(drawn_by(node)).merge(named_outputs_by(node))
-      end
-
-      def named_outputs_by(node)
-        step_type_for(node)&.settings&.outputs_of.to_h.to_h do |name, source|
-          [ name.to_s, digest.outputs_of(node.config[source.to_s]) ]
-        end
-      end
-
-      def drawn_by(node)
-        step_type_for(node)&.settings&.drawn_from.to_h.to_h do |name, source|
-          [ name.to_s, digest.values_of(step_named_by(node, source), node.config[source.to_s]) ]
-        end
-      end
-
-      def step_named_by(node, source)
-        node.config[step_type_for(node).settings.outputs_of[source].to_s]
-      end
-
-      def digest
-        Digest.new(@document, registry: @registry)
-      end
-
-      def naming_steps(node)
-        step_type_for(node)&.settings&.naming_steps.to_a.map(&:to_s)
-      end
-
-      def earlier_than(node)
-        digest.preceding(node.id).map do |id|
-          { "value" => id, "label" => label_for(@document.node(id)) }
-        end
-      end
-
-      def ends_here?(node)
-        step_type_for(node)&.ends_here? || false
-      end
-
-      def loose?(node)
-        @document.entry.present? && @document.reachable.exclude?(node.id)
-      end
-
-      def begins_here?(node)
-        step_type_for(node)&.begins_here? || false
-      end
-
-      def ports_for(node)
-        digest.routing_values(node.id)
-      end
-
-      def step_type_for(node)
-        @registry.fetch(node.type) if @registry.registered?(node.type)
-      end
-    end
-  end
-end

data/app/models/alembic/flow/change.rb

@@ -1,18 +0,0 @@
-module Alembic
-  module Flow
-    module Change
-      PHRASING = { "added" => "Added", "updated" => "Updated", "removed" => "Removed",
-                   "moved" => "Moved", "connected" => "Connected", "disconnected" => "Disconnected", "returned" => "Returned to" }.freeze
-
-      def self.phrase(change)
-        named = Array(change["named"]).compact_blank.map { |name| "“#{name}”" }
-        verb = PHRASING.fetch(change["action"], change["action"])
-
-        return "#{verb} #{named.join(' → ')}" if named.any?
-        return "#{verb} #{change['detail']}" if change["detail"].present?
-
-        verb
-      end
-    end
-  end
-end

data/app/models/alembic/flow/condition.rb

@@ -1,24 +0,0 @@
-module Alembic
-  module Flow
-    class Condition
-      include Step
-
-      step_name "Condition"
-
-      setting :step, type: :previous_step
-      setting :output, outputs_of: :step, required: true
-      setting :comparison, type: :select, options: [ "is", "is not" ], required: true
-      setting :answer, from: :output, required: true
-
-      output :result, type: :boolean, values: [ true, false ]
-
-      names_by { |node| node.config.values_at("step", "comparison", "answer").compact_blank.join(" ").presence }
-
-      def route(node, state)
-        matched = state[node.config["step"]] == node.config["answer"]
-
-        node.config["comparison"] == "is not" ? !matched : matched
-      end
-    end
-  end
-end

data/app/models/alembic/flow/definition.rb

@@ -1,132 +0,0 @@
-module Alembic
-  module Flow
-    class Definition < ApplicationRecord
-      self.table_name = "alembic_flows"
-
-      enum :status, { active: "active", hidden: "hidden", inactive: "inactive" }
-      enum :kind, { scored: "scored", guide: "guide" }
-      enum :persists, { unsaved: "unsaved", each_step: "each_step", on_finish: "on_finish" }
-
-      validates :slug, presence: true
-
-      after_initialize :begin_the_flow, if: :new_record?
-
-      scope :listable, -> { active }
-
-      # Declared before :definition_versions so responses clear first, otherwise
-      # destroying a diagnostic trips the responses -> definition_versions FK.
-      has_many :runs, class_name: "Alembic::Flow::Run", foreign_key: :flow_id, dependent: :destroy
-      has_many :definition_versions, class_name: "Alembic::Flow::Version", foreign_key: :flow_id, dependent: :destroy
-      has_many :summary_versions, class_name: "Alembic::Flow::SummaryVersion", foreign_key: :flow_id, dependent: :destroy
-
-      def self.upsert_definition(definition)
-        find_or_initialize_by(slug: definition["slug"]).tap do |diagnostic|
-          diagnostic.save!
-          diagnostic.record_definition(definition) unless diagnostic.definition == definition
-        end
-      end
-
-      def definition
-        current_definition_version&.definition
-      end
-
-      def current_definition_version
-        definition_versions.find_by(number: cursor)
-      end
-
-      def edit_history
-        @edit_history ||= EditHistory.new(self)
-      end
-
-      def summaries
-        @summaries ||= Summaries.new(self)
-      end
-
-      def publish
-        create_version
-
-        publish_version(current_definition_version)
-      end
-
-      def return_to(version)
-        raise ActiveRecord::RecordNotFound unless definition_versions.exists?(version.id)
-        raise OutOfService if version.out_of_service?
-
-        update!(document: version.definition, undone_changes: [],
-          changes_since_version: changes_since_version.to_a + [ returning_to(version) ])
-      end
-
-      def create_version
-        record_definition(document, changes_since_version.to_a) unless versioned?
-
-        update!(undo_history: edit_history.undoable, changes_since_version: [], undone_changes: [])
-      end
-
-      def returning_to(version)
-        { "action" => "returned", "steps" => [], "named" => [],
-          "detail" => "version #{version.number}", "before" => document }
-      end
-
-      def versioned?
-        document == definition
-      end
-
-      def record_definition(payload, captured = [])
-        definition_versions.create!(number: next_definition_number, definition: payload,
-          changes_captured: captured.map { |change| change.except("before") })
-          .tap { |version| update!(definition_cursor: version.number, document: payload) }
-      end
-
-      def publish_version(version)
-        raise OutOfService if version.out_of_service?
-        return if live_version == version
-
-        live_version&.update!(status: :superseded)
-        version.update!(status: :live)
-      end
-
-      def available?
-        !inactive?
-      end
-
-      def retire_version(version)
-        version.update!(status: :retired)
-      end
-
-      def withdraw_version(version)
-        version.update!(status: :withdrawn)
-      end
-
-      def live_version
-        definition_versions.find_by(status: :live)
-      end
-
-      def live_definition
-        live_version&.definition
-      end
-
-      def runner
-        Runner.new(live_definition)
-      end
-
-      private
-
-      def begin_the_flow
-        self.document ||= { "nodes" => [ { "id" => "start", "type" => "start" }, { "id" => "end", "type" => "terminal" } ],
-                            "edges" => [ { "from" => "start", "to" => "end" } ] }
-      end
-
-      def cursor
-        definition_cursor || recorded_numbers.max
-      end
-
-      def recorded_numbers
-        definition_versions.pluck(:number)
-      end
-
-      def next_definition_number
-        (definition_versions.maximum(:number) || 0) + 1
-      end
-    end
-  end
-end

data/app/models/alembic/flow/digest.rb

@@ -1,116 +0,0 @@
-module Alembic
-  module Flow
-    class Digest
-      def initialize(document, registry: Flow.registry)
-        @document = document
-        @registry = registry
-      end
-
-      def entry
-        @document.node(@document.entry)
-      end
-
-      def step(id)
-        @document.node(id)
-      end
-
-      def steps
-        @document.nodes
-      end
-
-      def preceding(id)
-        return [] unless @document.reachable.include?(id)
-
-        @document.nodes.map(&:id).uniq
-          .reject { |other| other == id || @document.reachable(without: other).include?(id) }
-      end
-
-      def routing_values(id)
-        named = step(id)
-        return [] unless named && step_type(named)&.routes?
-
-        step_type(named).outputs.flat_map { |output| values_taken(output, named) }.map { |value| value["value"].to_s }
-      end
-
-      def values_taken(output, node)
-        return output.values_for(node) unless output.from
-
-        values_out_of(node.config[output.from.to_s])
-      end
-
-      def values_of(id, output_name)
-        named = step(id)
-        return [] unless named && output_name.present?
-
-        step_type(named)&.values_of(output_name, named).to_a
-      end
-
-      def outputs_of(id)
-        named = step(id)
-        return [] unless named
-
-        step_type(named)&.outputs.to_a.map { |output| { "value" => output.name.to_s, "label" => output.label } }
-      end
-
-      def values_out_of(id)
-        named = step(id)
-        return [] unless named
-
-        step_type(named)&.outputs.to_a.flat_map { |output| output.values_for(named) }
-      end
-
-      def requirements(id)
-        node = step(id)
-        step_type(node)&.settings&.requirements_for(node.config).to_a
-      end
-
-      def next_step(state)
-        walk(state).last
-      end
-
-      def state_on_path(state)
-        state.slice(*walk(state).first)
-      end
-
-      private
-
-      def walk(state)
-        recorded = []
-        visited = []
-        cursor = entry
-
-        while cursor && !visited.include?(cursor.id)
-          return [ recorded, cursor ] if pending?(cursor, state)
-
-          recorded << cursor.id if state.key?(cursor.id)
-          visited << cursor.id
-          cursor = successor(cursor, state)
-        end
-
-        [ recorded, nil ]
-      end
-
-      def pending?(node, state)
-        return false if state.key?(node.id)
-
-        step_type(node)&.awaits_input? || acts?(node)
-      end
-
-      def acts?(node)
-        step_type(node)&.acts? || false
-      end
-
-      def successor(node, state)
-        leaving = @document.edges_from(node.id)
-        port = step_type(node)&.route(node, state)
-        taken = port.nil? ? leaving.first : leaving.find { |edge| edge.on.to_s == port.to_s }
-
-        taken && @document.node(taken.to)
-      end
-
-      def step_type(node)
-        @registry.fetch(node.type) if node && @registry.registered?(node.type)
-      end
-    end
-  end
-end