alembic 0.1.0 → 0.2.0

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

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

@@ -1,131 +0,0 @@
-module Alembic
-  module Flow
-    class Document
-      def initialize(document, registry: Flow.registry)
-        @document = document
-        @registry = registry
-      end
-
-      def nodes
-        Array(@document["nodes"]).map { |node| Node.new(id: node["id"], type: node["type"], config: node.except("id", "type")) }
-      end
-
-      def edges
-        Array(@document["edges"]).map { |edge| Edge.new(from: edge["from"], to: edge["to"], on: edge["on"]) }
-      end
-
-      def entry
-        beginnings.first
-      end
-
-      def beginnings
-        nodes.select { |node| begins_here?(node) }.map(&:id)
-      end
-
-      def begins_here?(node)
-        @registry.registered?(node.type) && @registry.fetch(node.type).begins_here?
-      end
-
-      def node(id)
-        nodes.find { |node| node.id == id }
-      end
-
-      def edges_from(id)
-        edges.select { |edge| edge.from == id }
-      end
-
-      def reachable(without: nil)
-        found = []
-        frontier = [ entry ]
-
-        while (id = frontier.shift)
-          next if found.include?(id) || id == without
-
-          found << id
-          frontier.concat(edges_from(id).map(&:to))
-        end
-
-        found
-      end
-
-      def to_h
-        @document
-      end
-
-      def insert(node, on:, leaving: nil)
-        source, target = on
-        replaced = raw_edges.find { |edge| edge["from"] == source && edge["to"] == target }
-        bridged = [ { "from" => source, "to" => node["id"], "on" => replaced&.fetch("on", nil) }.compact,
-                    { "from" => node["id"], "to" => target, "on" => leaving }.compact ]
-
-        with(nodes: raw_nodes + [ node ], edges: (raw_edges - [ replaced ]) + bridged)
-      end
-
-      def add(node)
-        with(nodes: raw_nodes + [ node ], edges: raw_edges)
-      end
-
-      def connect(from:, to:, on: nil)
-        with(nodes: raw_nodes, edges: raw_edges + [ { "from" => from, "to" => to, "on" => on }.compact ])
-      end
-
-      def disconnect(from:, to:)
-        with(nodes: raw_nodes, edges: raw_edges.reject { |edge| edge["from"] == from && edge["to"] == to })
-      end
-
-      def move(id, on:, leaving: nil)
-        step = raw_nodes.find { |node| node["id"] == id }
-        return self unless step
-
-        remove(id).insert(step, on: on, leaving: leaving)
-      end
-
-      def configure(id, config)
-        reconfigured = raw_nodes.map do |node|
-          node["id"] == id ? node.slice("id", "type").merge(config) : node
-        end
-
-        with(nodes: reconfigured, edges: raw_edges)
-      end
-
-      def rewire(from:, to:, target:)
-        rewritten = raw_edges.map do |edge|
-          edge["from"] == from && edge["to"] == to ? edge.merge("to" => target) : edge
-        end
-
-        with(nodes: raw_nodes, edges: rewritten)
-      end
-
-      def remove(id)
-        incoming = raw_edges.select { |edge| edge["to"] == id }
-        outgoing = raw_edges.select { |edge| edge["from"] == id }
-
-        with(nodes: raw_nodes.reject { |node| node["id"] == id },
-             edges: (raw_edges - incoming - outgoing) + bridges(incoming, outgoing))
-      end
-
-      private
-
-      def bridges(incoming, outgoing)
-        incoming.product(outgoing).map do |arriving, leaving|
-          { "from" => arriving["from"], "to" => leaving["to"], "on" => arriving["on"] }.compact
-        end
-      end
-
-      def raw_nodes
-        Array(@document["nodes"])
-      end
-
-      def raw_edges
-        Array(@document["edges"])
-      end
-
-      def with(nodes:, edges:)
-        Document.new(@document.merge("nodes" => nodes, "edges" => edges), registry: @registry).tap do |edited|
-          broken = Validator.new(edited, registry: @registry).malformations
-          raise InvalidEdit, broken.map { |violation| "#{violation.node}: #{violation.problem}" }.join(", ") if broken.any?
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Alembic
-  module Flow
-    module Drawing
-      def self.of(node, registry = Flow.registry)
-        named(node, registry).presence || Flow.drawing
-      end
-
-      def self.named(node, registry)
-        return unless node && registry.registered?(node.type)
-
-        registry.fetch(node.type).drawn_by
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Alembic
-  module Flow
-    Edge = Data.define(:from, :to, :on) do
-      def initialize(from:, to:, on: nil)
-        super
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-module Alembic
-  module Flow
-    class EditHistory
-      def initialize(flow)
-        @flow = flow
-      end
-
-      def undoable?
-        undoable.any?
-      end
-
-      def redoable?
-        undone.any?
-      end
-
-      def undoable
-        @flow.undo_history.to_a + @flow.changes_since_version.to_a
-      end
-
-      def undo_change
-        undone_change = undoable.last
-        return unless undone_change
-
-        @flow.update!(document: undone_change["before"],
-          undone_changes: undone + [ undone_change.merge("after" => @flow.document) ],
-          undo_history: @flow.undo_history.to_a[0...-1],
-          changes_since_version: @flow.changes_since_version.to_a[0...-1])
-      end
-
-      def redo_change
-        redone = undone.last
-        return unless redone
-
-        @flow.update!(document: redone["after"], undone_changes: undone[0...-1],
-          changes_since_version: @flow.changes_since_version.to_a + [ redone.except("after") ])
-      end
-
-      def record(edited, action, steps, before)
-        @flow.update!(document: edited.to_h, undone_changes: [],
-          changes_since_version: with(edited, action, steps, before))
-      end
-
-      def edit_document(payload)
-        @flow.update!(document: payload, undone_changes: [],
-          changes_since_version: @flow.changes_since_version.to_a + [ edited_by_hand ])
-      end
-
-      private
-
-      def with(edited, action, steps, before)
-        return @flow.changes_since_version.to_a unless action
-
-        @flow.changes_since_version.to_a +
-          [ { "action" => action.to_s, "steps" => steps.map(&:to_s),
-              "named" => steps.map { |id| named(edited, id) }, "before" => before } ]
-      end
-
-      def named(edited, id)
-        Name.of(edited.node(id.to_s) || document.node(id.to_s))
-      end
-
-      def document
-        Document.new(@flow.document || @flow.definition || {})
-      end
-
-      def undone
-        @flow.undone_changes.to_a
-      end
-
-      def edited_by_hand
-        { "action" => "edited", "steps" => [], "named" => [ "the definition" ], "before" => @flow.document }
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-module Alembic
-  module Flow
-    class Layout
-      SPREAD = 2
-
-      def initialize(document)
-        @document = document
-      end
-
-      def positions
-        rows = depths
-        columns = columns_for(rows)
-
-        rows.to_h { |id, row| [ id, { "row" => row, "column" => columns[id] } ] }
-      end
-
-      private
-
-      def depths
-        walked = walk_from_entry
-
-        walked.merge(stranded(walked).index_with(next_row(walked)))
-      end
-
-      def walk_from_entry
-        seen = {}
-        frontier = starting_points.map { |id| [ id, 0 ] }
-
-        until frontier.empty?
-          id, depth = frontier.shift
-          next if seen.key?(id)
-
-          seen[id] = depth
-          @document.edges_from(id).each { |edge| frontier << [ edge.to, depth + 1 ] if known?(edge.to) }
-        end
-
-        seen
-      end
-
-      def starting_points
-        return [ @document.entry ] if known?(@document.entry)
-
-        arrived = @document.edges.map(&:to)
-        @document.nodes.map(&:id).reject { |id| arrived.include?(id) }
-      end
-
-      def columns_for(rows)
-        @columns = {}
-        @next_leaf = 0
-        rows.keys.each { |id| place(id, branches(rows)) }
-        @columns
-      end
-
-      def branches(rows)
-        claimed = {}
-
-        rows.keys.to_h do |id|
-          mine = @document.edges_from(id).map(&:to).uniq
-            .select { |child| rows[child] == rows[id] + 1 && !claimed.key?(child) }
-          mine.each { |child| claimed[child] = true }
-          [ id, mine ]
-        end
-      end
-
-      def place(id, branches)
-        return @columns[id] if @columns.key?(id)
-
-        mine = branches[id].to_a
-        return @columns[id] = (@next_leaf += SPREAD) - SPREAD if mine.empty?
-
-        spans = mine.map { |child| place(child, branches) }
-        @columns[id] = (spans.min + spans.max) / 2
-      end
-
-      def stranded(walked)
-        @document.nodes.map(&:id).uniq - walked.keys
-      end
-
-      def next_row(walked)
-        (walked.values.max || -1) + 1
-      end
-
-      def known?(id)
-        @document.node(id).present?
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Alembic
-  module Flow
-    module Name
-      def self.of(node, registry = Flow.registry)
-        return "" unless node
-
-        named(node, registry) || node.id
-      end
-
-      def self.named(node, registry)
-        registry.fetch(node.type).name_of(node) if registry.registered?(node.type)
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Alembic
-  module Flow
-    Node = Data.define(:id, :type, :config)
-  end
-end

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

@@ -1,23 +0,0 @@
-module Alembic
-  module Flow
-    Output = Data.define(:name, :label, :type, :values, :from) do
-      def initialize(name:, label: nil, type: :string, values: nil, from: nil)
-        raise UnknownOutputType, "#{type} is not one of #{OUTPUT_TYPES.join(', ')}" unless OUTPUT_TYPES.include?(type)
-
-        super(name: name, label: label.presence || name.to_s.humanize, type: type, values: values, from: from)
-      end
-
-      def values_for(node)
-        Array(values.respond_to?(:call) ? values.call(node) : values).map { |value| taken(value) }
-      end
-
-      private
-
-      def taken(value)
-        return value if value.is_a?(Hash)
-
-        { "value" => value, "label" => value.to_s }
-      end
-    end
-  end
-end

data/app/models/alembic/flow/progress/kept.rb

@@ -1,38 +0,0 @@
-module Alembic
-  module Flow
-    module Progress
-      class Kept
-        def initialize(run)
-          @run = run
-        end
-
-        def definition
-          @run.pinned_definition
-        end
-
-        def summary_of(state)
-          return [] if @run.pinned_summary.blank?
-
-          Summary::Report.new(@run.pinned_summary)
-            .results(Summary::Run.new(state: state, steps: @run.pinned_steps))
-        end
-
-        def recorded
-          @run.recorded
-        end
-
-        def record(id, value)
-          @run.record(id.to_sym, value)
-        end
-
-        def finish(_state)
-          @run
-        end
-
-        def discard_last
-          @run.discard_last
-        end
-      end
-    end
-  end
-end