alembic 0.1.0 → 0.3.0

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

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

@@ -1,43 +0,0 @@
-module Alembic
-  module Flow
-    module Progress
-      class Loose
-        def initialize(flow, answers, definition = nil)
-          @flow = flow
-          @answers = answers.to_h.symbolize_keys
-          @definition = definition
-        end
-
-        def definition
-          @definition || @flow.live_definition
-        end
-
-        def summary_of(state)
-          return [] unless @flow.summaries.any?
-
-          @flow.summaries.of(state)
-        end
-
-        def recorded
-          @answers
-        end
-
-        def record(id, value)
-          @answers = @answers.merge(id.to_sym => value)
-        end
-
-        def finish(state)
-          return unless @flow.on_finish?
-
-          Run.start(@flow).tap { |run| run.update!(recorded: state) }
-        end
-
-        def discard_last
-          last = Runner.new(@flow.live_definition).state_on_path(@answers).keys.last
-
-          @answers = @answers.except(last) if last
-        end
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Alembic
-  module Flow
-    module Progress
-      def self.for(flow, run: nil, answers: {}, definition: nil)
-        return Kept.new(run) if run
-
-        Loose.new(flow, answers, definition)
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Alembic
-  module Flow
-    class Registry
-      def initialize
-        @step_types = {}
-      end
-
-      def register(step_type)
-        @step_types[step_type.id.to_sym] = step_type
-      end
-
-      def fetch(id)
-        @step_types.fetch(id.to_sym) { raise UnknownStepType, "no step type registered as #{id}" }
-      end
-
-      def registered?(id)
-        id.present? && @step_types.key?(id.to_sym)
-      end
-
-      def step_types
-        @step_types.values
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module Alembic
-  module Flow
-    class Run < ApplicationRecord
-      self.table_name = "alembic_flow_runs"
-
-      belongs_to :flow, class_name: "Alembic::Flow::Definition"
-      belongs_to :definition_version, class_name: "Alembic::Flow::Version"
-      belongs_to :summary_version, class_name: "Alembic::Flow::SummaryVersion", optional: true
-      belongs_to :owner, polymorphic: true, optional: true
-
-      def self.start(flow)
-        create!(flow: flow, definition_version: flow.live_version,
-          summary_version: flow.summaries.current_version)
-      end
-
-      def record(step_id, value)
-        update!(recorded: recorded.merge(step_id => value))
-      end
-
-      def recorded
-        super.to_h.symbolize_keys
-      end
-
-      def pinned_definition
-        definition_version.definition.to_h
-      end
-
-      def pinned_summary
-        summary_version&.summary.to_h
-      end
-
-      def next_step(state)
-        digest.next_step(state.transform_keys(&:to_s))
-      end
-
-      def walked(state)
-        digest.state_on_path(state.transform_keys(&:to_s))
-      end
-
-      def digest
-        @digest ||= Digest.new(Document.new(pinned_definition))
-      end
-
-      def discard_last
-        last = walked(recorded).keys.map(&:to_sym).last
-        update!(recorded: recorded.except(last)) if last
-      end
-
-      def pinned_steps
-        Array(definition_version.definition.to_h["nodes"]).index_by { |node| node["id"] }
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module Alembic
-  module Flow
-    class Runner
-      def initialize(document, registry: Flow.registry)
-        @document = document.to_h
-        @registry = registry
-        @digest = Digest.new(Document.new(@document, registry: registry), registry: registry)
-      end
-
-      def slug
-        @document["slug"]
-      end
-
-      def headline
-        @document["headline"]
-      end
-
-      def steps
-        @digest.steps
-      end
-
-      def step(id)
-        @digest.step(id.to_s)
-      end
-
-      def next_step(state)
-        shown(@digest.next_step(named(state)))
-      end
-
-      def run(progress)
-        while (node = @digest.next_step(named(progress.recorded))) && acts?(node)
-          progress.record(node.id, @registry.fetch(node.type).process(node, named(progress.recorded)))
-        end
-      end
-
-      def drawing_at(state)
-        Drawing.of(@digest.next_step(named(state)), @registry)
-      end
-
-      def state_on_path(state)
-        @digest.state_on_path(named(state)).symbolize_keys
-      end
-
-      def steps_on_path(state)
-        state_on_path(state).keys.map { |id| shown(@digest.step(id.to_s)) }
-      end
-
-      private
-
-      def acts?(node)
-        @registry.registered?(node.type) && @registry.fetch(node.type).acts?
-      end
-
-      def shown(node)
-        return node unless node && @registry.registered?(node.type)
-
-        @registry.fetch(node.type).display_of(node) || node
-      end
-
-      def named(state)
-        state.transform_keys(&:to_s)
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-module Alembic
-  module Flow
-    class Settings
-      attr_reader :fields, :labels, :record_fields, :record_labels, :choices, :drawn_from, :outputs_of
-
-      def initialize(fields: {}, labels: {}, record_fields: {}, record_labels: {}, choices: {},
-        limits: {}, checks: {}, required: [], drawn_from: {}, outputs_of: {})
-        @fields = fields
-        @labels = labels
-        @record_fields = record_fields
-        @record_labels = record_labels
-        @choices = choices
-        @limits = limits
-        @checks = checks
-        @required = required
-        @drawn_from = drawn_from
-        @outputs_of = outputs_of
-      end
-
-      def naming_steps
-        fields.select { |_name, type| type == :previous_step }.keys
-      end
-
-      def required
-        fields.keys.select { |name| @required.include?(name) || naming_steps.include?(name) }
-      end
-
-      def requirements_for(config)
-        naming_steps.map { |name| config.to_h[name.to_s] }.compact_blank
-      end
-
-      def coerce(config)
-        config.to_h.to_h { |name, value| [ name, cast(fields[name.to_sym], value, record_fields[name.to_sym]) ] }
-      end
-
-      def objections(config)
-        config.to_h.flat_map { |name, value| objections_to(name.to_sym, value) }.compact
-      end
-
-      private
-
-      def objections_to(name, value)
-        [ unoffered(name, value), over_limit(name, value), refused(name, value) ]
-      end
-
-      def unoffered(name, value)
-        offered = choices[name]
-        return unless offered
-
-        stray = Array(value).find { |chosen| offered.exclude?(chosen) }
-        "#{labels[name]} does not offer #{stray}" if stray
-      end
-
-      def over_limit(name, value)
-        allowed = @limits[name]
-        return unless allowed && Array(value).size > allowed
-
-        "#{labels[name]} takes at most #{allowed}"
-      end
-
-      def refused(name, value)
-        @checks[name]&.call(value)
-      end
-
-      def cast(type, value, holds = nil)
-        case type
-        when :integer then Integer(value, exception: false)
-        when :float then Float(value, exception: false)
-        when :boolean then ActiveModel::Type::Boolean.new.cast(value).present?
-        when :list then Array(value).map { |entry| cast_entry(entry, holds.to_h) }
-        else value
-        end
-      end
-
-      def cast_entry(entry, holds)
-        entry.to_h.to_h { |name, value| [ name, cast(holds[name.to_sym], value) ] }
-      end
-    end
-  end
-end