alembic 0.1.0 → 0.2.0

data/app/controllers/alembic/flows_controller.rb

@@ -1,34 +1,14 @@
 module Alembic
-  class FlowsController < ApplicationController
-    helper_method :flow_start_path, :flow_step_path, :previewing?, :step_form, :carries_answers?
+  class FlowsController < EasyFlow::FlowsController
+    hosted_by FLOW_HOST
+    include Summarizes
 
-    def show
-      @diagnostic = flow
-    end
-
-    def start
-      redirect_to alembic.run_path(Flow::Run.start(flow))
-    end
-
-    def step
-      @guide = Runner.new(running_definition)
-      @progress = progress
-      @guide.run(@progress)
-      @answers = @progress.recorded
-      @question = @guide.next_step(@answers)
-      @drawing = @guide.drawing_at(@answers)
-      return render :step if @question
-
-      render_completion
-    end
+    private
 
-    def update
-      params[:back] ? progress.discard_last : record_submitted
-      redirect_to alembic.run_path(run)
+    def run_location(run)
+      alembic.run_path(run)
     end
 
-    private
-
     def flow_start_path(slug)
       alembic.flow_path(slug)
     end
@@ -36,69 +16,5 @@ module Alembic
     def flow_step_path(slug)
       alembic.flow_step_path(slug)
     end
-
-    def previewing?
-      false
-    end
-
-    def step_form
-      return { url: alembic.run_path(run), method: :patch } if run
-
-      { url: flow_step_path(@guide.slug), method: :get }
-    end
-
-    def carries_answers?
-      run.nil?
-    end
-
-    def render_completion
-      @answered = @guide.state_on_path(@answers)
-      @progress.finish(@answered)
-      @outputs = @progress.summary_of(@answered.transform_keys(&:to_s))
-      render :complete
-    end
-
-    def progress
-      return @progress ||= Flow::Progress.for(run.flow, run: run) if run
-
-      @progress ||= Flow::Progress.for(flow, answers: submitted_answers, definition: running_definition)
-    end
-
-    def running_definition
-      @running_definition ||= run ? run.pinned_definition : flowing_definition(flow)
-    end
-
-    def run
-      return unless params[:id]
-
-      @run ||= admitted_run
-    end
-
-    def admitted_run
-      found = Flow::Run.find(params[:id])
-
-      Flow::Admission.of_run(found, permitted: permitted?(found.flow))
-    end
-
-    def flow
-      @stored_flow ||= admit(Flow::Definition.find_by(slug: params[:slug]))
-    end
-
-    def flowing_definition(diagnostic)
-      diagnostic.live_definition
-    end
-
-    def submitted_answers
-      params.fetch(:answers, {}).permit(*@guide.steps.map(&:id)).to_h.symbolize_keys
-    end
-
-    def record_submitted
-      id, value = params.fetch(:answers, {}).permit(*asked).to_h.first
-      progress.record(id, value)
-    end
-
-    def asked
-      Runner.new(run.pinned_definition).steps.map(&:id)
-    end
   end
 end

data/app/controllers/alembic/manage/base_controller.rb

@@ -11,6 +11,7 @@ module Alembic
       helper KeystoneUiHelper
       helper KeystoneUi::React::MountHelper
       helper KsBlocks::ContentHelper
+      helper Alembic::PagesHelper
     end
   end
 end

data/app/controllers/alembic/manage/flows_controller.rb

@@ -1,54 +1,17 @@
 module Alembic
   module Manage
-    class FlowsController < BaseController
-      include DrawsCanvas
-      def index
-        @diagnostics = ordered_diagnostics
-      end
-
-      def create
-        @diagnostic = Flow::Definition.new(create_params)
-
-        if @diagnostic.save
-          redirect_to manage_flow_path(@diagnostic), notice: "Flow created."
-        else
-          @diagnostics = ordered_diagnostics
-          render :index, status: :unprocessable_entity
-        end
-      end
-
-      def show
-        @diagnostic = Flow::Definition.find(params[:id])
-        @canvas = canvas_payload(@diagnostic)
-      end
-
+    class FlowsController < EasyFlow::Manage::FlowsController
+      hosted_by FLOW_HOST
       def edit
-        @diagnostic = Flow::Definition.find(params[:id])
+        super
+        @summary = Flow::Summaries.new(@flow).text
       end
 
       def update
-        @diagnostic = Flow::Definition.find(params[:id])
-        @diagnostic.update!(diagnostic_params)
-        redirect_to manage_flow_path(@diagnostic), notice: "Saved."
-      end
-
-      def destroy
-        Flow::Definition.find(params[:id]).destroy!
-        redirect_to manage_flows_path, notice: "Flow removed."
-      end
-
-      private
-
-      def ordered_diagnostics
-        Flow::Definition.order(:slug)
-      end
-
-      def create_params
-        params.require(:flow).permit(:slug, :kind)
-      end
+        summary = params.require(:flow)[:summary]
+        Flow::Summaries.new(flow_host.flows.find(params[:id])).describe(summary) unless summary.nil?
 
-      def diagnostic_params
-        params.require(:flow).permit(:title, :summary, :start_label, :persists)
+        super
       end
     end
   end

data/app/controllers/alembic/manage/pages_controller.rb

@@ -20,6 +20,13 @@ module Alembic
         redirect_to manage_page_path(page)
       end
 
+      def publish
+        page = Page.find(params[:id])
+        page.publish
+
+        redirect_to manage_page_path(page)
+      end
+
       private
 
       def payload(page)
@@ -31,7 +38,7 @@ module Alembic
       end
 
       def page_params
-        params.require(:page).permit(:name)
+        params.require(:page).permit(:name, :slug)
       end
     end
   end

data/app/controllers/alembic/manage/previews_controller.rb

@@ -1,10 +1,11 @@
 module Alembic
   module Manage
-    class PreviewsController < ::Alembic::FlowsController
-      include AuthenticatesAdmin
+    class PreviewsController < EasyFlow::Manage::PreviewsController
+      hosted_by FLOW_HOST
+      include Summarizes
 
       def show
-        @diagnostic = previewed
+        @flow = previewed
         render template: "alembic/flows/show"
       end
 
@@ -17,22 +18,6 @@ module Alembic
       def flow_step_path(_slug)
         alembic.step_manage_flow_preview_path(previewed)
       end
-
-      def previewing?
-        true
-      end
-
-      def flowing_definition(diagnostic)
-        diagnostic.document
-      end
-
-      def previewed
-        @previewed ||= Flow::Definition.find(params[:flow_id])
-      end
-
-      def admit(_diagnostic)
-        previewed
-      end
     end
   end
 end

data/app/controllers/alembic/pages_controller.rb

@@ -0,0 +1,19 @@
+module Alembic
+  class PagesController < ApplicationController
+    helper PagesHelper
+    helper KsBlocks::LayoutHelper
+
+    def show
+      @page = shown_page
+    end
+
+    private
+
+    def shown_page
+      page = Page.find_by(slug: params[:slug])
+      raise NotPublished if page.nil? || page.live_version.nil?
+
+      page
+    end
+  end
+end

data/app/controllers/concerns/alembic/summarizes.rb

@@ -0,0 +1,38 @@
+module Alembic
+  module Summarizes
+    extend ActiveSupport::Concern
+
+    included do
+      layout -> { Alembic.layout }
+      helper ApplicationHelper
+      helper_method :flow_summary, :first_step_path
+    end
+
+    private
+
+    def flow_summary(flow)
+      Flow::Summaries.new(flow).text
+    end
+
+    def first_step_path(slug)
+      flow_step_path(slug)
+    end
+
+    def start_run(flow)
+      super.tap { |run| Flow::Summaries.new(flow).pin(run) }
+    end
+
+    def finished(answers, finished_run)
+      @outputs = outputs_of(answers.transform_keys(&:to_s))
+      Flow::Summaries.new(flow).pin(finished_run) if finished_run && run.nil?
+      render template: "alembic/flows/complete"
+    end
+
+    def outputs_of(state)
+      return Flow::Summaries.new(run.flow).of_run(run, state) if run
+
+      summaries = Flow::Summaries.new(flow)
+      summaries.any? ? summaries.of(state) : []
+    end
+  end
+end

data/app/helpers/alembic/pages_helper.rb

@@ -0,0 +1,39 @@
+require "ks_blocks/layout_helper"
+
+module Alembic
+  module PagesHelper
+    UNDRAWABLE = "This block cannot be drawn until its fields are filled in.".freeze
+
+    def drawn_page(page, being_edited: false)
+      blocks = being_edited ? page.blocks : page.live_version&.blocks.to_a
+      drawn = blocks.to_h { |block| [ block["id"], drawn_block(block) ] }.compact
+
+      block_layout(blocks.select { |block| drawn.key?(block["id"]) }, kind: :pages) do |block|
+        drawn.fetch(block["id"])
+      end
+    end
+
+    def drawn_block(block)
+      component = Page::Drawing.of(block["type"])
+      return unless component
+
+      body = Page::Options.body_for(block)
+      body.nil? ? send(component, **Page::Options.for(block)) : send(component, **Page::Options.for(block)) { body }
+    rescue StandardError => undrawable
+      Rails.logger.error("Alembic could not draw the #{block['type']} block: #{undrawable.message}")
+      nil
+    end
+
+    def shown_block(block)
+      drawn_block(block) || undrawn_block(block)
+    end
+
+    private
+
+    def undrawn_block(block)
+      return UNDRAWABLE if Page::Drawing.of(block["type"])
+
+      KsBlocks.registry.block_types(kind: :pages).find { |type| type.key.to_s == block["type"] }&.name
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Alembic
+  module Flow
+    class DefinitionSummary < ApplicationRecord
+      self.table_name = "alembic_flow_definition_summaries"
+
+      belongs_to :flow, class_name: "EasyFlow::Definition"
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Alembic
+  module Flow
+    class RunSummary < ApplicationRecord
+      self.table_name = "alembic_flow_run_summaries"
+
+      belongs_to :run, class_name: "EasyFlow::Run"
+      belongs_to :summary_version
+    end
+  end
+end

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

@@ -10,12 +10,12 @@ module Alembic
       end
 
       def current_version
-        @flow.summary_versions.find_by(number: cursor)
+        versions.find_by(number: cursor)
       end
 
       def record(payload)
-        @flow.summary_versions.create!(number: next_number, summary: payload)
-          .tap { |version| @flow.update!(summary_cursor: version.number) }
+        versions.create!(number: next_number, summary: payload)
+          .tap { |version| details.update!(summary_cursor: version.number) }
       end
 
       def any?
@@ -26,18 +26,49 @@ module Alembic
         Summary::Report.new(document).results(Summary::Run.new(state: state, steps: steps_by_id))
       end
 
+      def text
+        details.summary
+      end
+
+      def describe(text)
+        details.update!(summary: text)
+      end
+
+      def pin(run)
+        RunSummary.create!(run: run, summary_version: current_version) if current_version
+      end
+
+      def pinned_to(run)
+        RunSummary.find_by(run: run)&.summary_version
+      end
+
+      def of_run(run, state)
+        pinned = pinned_to(run)&.summary
+        return [] if pinned.blank?
+
+        Summary::Report.new(pinned).results(Summary::Run.new(state: state, steps: run.pinned_steps))
+      end
+
       private
 
+      def versions
+        SummaryVersion.where(flow: @flow)
+      end
+
+      def details
+        @details ||= DefinitionSummary.find_or_initialize_by(flow: @flow)
+      end
+
       def steps_by_id
         Array(@flow.definition.to_h["nodes"]).index_by { |node| node["id"] }
       end
 
       def cursor
-        @flow.summary_cursor || @flow.summary_versions.pluck(:number).max
+        details.summary_cursor || versions.maximum(:number)
       end
 
       def next_number
-        (@flow.summary_versions.maximum(:number) || 0) + 1
+        (versions.maximum(:number) || 0) + 1
       end
     end
   end

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

@@ -3,7 +3,7 @@ module Alembic
     class SummaryVersion < ApplicationRecord
       self.table_name = "alembic_flow_summaries"
 
-      belongs_to :flow, class_name: "Alembic::Flow::Definition"
+      belongs_to :flow, class_name: "EasyFlow::Definition"
 
       validates :number, uniqueness: { scope: :flow_id }
 

data/app/models/alembic/outputs/grouped.rb

@@ -13,7 +13,7 @@ module Alembic
       end
 
       def self.bucket(step, marker)
-        marker ? step[marker] : Steps::Question.category_of(step)
+        marker ? step[marker] : EasyFlow::Steps::Question.category_of(step)
       end
 
       def self.shares(run, marker)

data/app/models/alembic/outputs/percentage.rb

@@ -24,7 +24,7 @@ module Alembic
       end
 
       def self.most(step)
-        Steps::Question.answers_of(step).filter_map { |option| option["weight"].to_i if option.is_a?(Hash) }.max.to_i
+        EasyFlow::Steps::Question.answers_of(step).filter_map { |option| option["weight"].to_i if option.is_a?(Hash) }.max.to_i
       end
     end
   end

data/app/models/alembic/outputs/weighted_sum.rb

@@ -17,7 +17,7 @@ module Alembic
       end
 
       def self.weight_of(step, value)
-        chosen = Steps::Question.answers_of(step).find { |option| option.is_a?(Hash) && option["value"] == value }
+        chosen = EasyFlow::Steps::Question.answers_of(step).find { |option| option.is_a?(Hash) && option["value"] == value }
 
         chosen&.fetch("weight", nil).to_i
       end

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

@@ -0,0 +1,17 @@
+module Alembic
+  class Page < ApplicationRecord
+    module Drawing
+      def self.record(key, component)
+        components[key.to_sym] = component
+      end
+
+      def self.of(key)
+        components[key.to_sym]
+      end
+
+      def self.components
+        @components ||= {}
+      end
+    end
+  end
+end

data/app/models/alembic/page/options.rb

@@ -0,0 +1,46 @@
+module Alembic
+  class Page < ApplicationRecord
+    module Options
+      def self.declare(key, options, body: nil)
+        declared[key.to_sym] = options
+        bodies[key.to_sym] = body
+      end
+
+      def self.for(block)
+        named(filled(block).except(bodies[block["type"].to_sym]), declared.fetch(block["type"].to_sym, {}))
+      end
+
+      def self.body_for(block)
+        field = bodies[block["type"].to_sym]
+
+        filled(block)[field] if field
+      end
+
+      def self.bodies
+        @bodies ||= {}
+      end
+
+      def self.declared
+        @declared ||= {}
+      end
+
+      def self.filled(block)
+        block.fetch("content", {}).reject { |_key, value| value == "" }.symbolize_keys
+      end
+
+      def self.named(filled, options)
+        options.each_with_object(filled) do |(option, spec), built|
+          spec.is_a?(Hash) ? fill(built, option, spec) : built[option] = spec
+        end
+      end
+
+      def self.fill(built, option, spec)
+        value = built.delete(spec.fetch(:from, option))
+        built[option] = value.nil? ? spec[:default] : value
+        built.delete(option) if built[option].nil?
+      end
+
+      private_class_method :filled, :named, :fill
+    end
+  end
+end

data/app/models/alembic/page/version.rb

@@ -0,0 +1,13 @@
+module Alembic
+  class Page < ApplicationRecord
+    class Version < ApplicationRecord
+      self.table_name = "alembic_page_versions"
+
+      enum :status, { draft: "draft", live: "live", superseded: "superseded" }
+
+      belongs_to :page, class_name: "Alembic::Page"
+
+      validates :number, uniqueness: { scope: :page_id }
+    end
+  end
+end

data/app/models/alembic/page.rb

@@ -6,6 +6,38 @@ module Alembic
 
     block_layout :blocks, kind: :pages
 
+    has_many :versions, class_name: "Alembic::Page::Version", dependent: :destroy, inverse_of: :page
+
     validates :name, presence: true
+    validates :slug, uniqueness: true, allow_nil: true
+
+    def publish
+      transaction do
+        live_version&.update!(status: :superseded)
+        versions.create!(number: next_number, blocks: blocks, status: :live)
+      end
+    end
+
+    def live_version
+      versions.find_by(status: :live)
+    end
+
+    def next_number
+      (versions.maximum(:number) || 0) + 1
+    end
+
+    def self.block(key, drawn_by: nil, options: {}, body: nil, **block_type)
+      refuse_unknown(key, drawn_by)
+      Drawing.record(key, drawn_by)
+      Options.declare(key, options, body: body)
+      KsBlocks.block(key, kind: :pages, **block_type)
+    end
+
+    def self.refuse_unknown(key, component)
+      return if component.nil? || ApplicationController.helpers.respond_to?(component)
+
+      raise ArgumentError, "The #{key} page block names #{component}, which nothing draws"
+    end
+    private_class_method :refuse_unknown
   end
 end

data/app/views/alembic/flows/complete.html.erb

@@ -22,11 +22,11 @@
   <% end %>
 
   <%= ui_section(title: @outputs.any? ? "What you told us" : nil) do %>
-    <ul class="divide-y divide-gray-100 border-y border-gray-100">
+    <ul class="divide-y divide-(color:--ks-color-divider) border-y border-(color:--ks-color-divider) dark:divide-(color:--ks-color-divider-dark) dark:border-(color:--ks-color-divider-dark)">
       <% @answered.each do |step, value| %>
         <li data-answer="<%= step %>" class="flex items-baseline justify-between gap-6 py-3">
-          <span class="text-gray-600"><%= @guide.question_text(step) %></span>
-          <span class="shrink-0 font-medium text-gray-900"><%= @guide.choice_label(step, value) %></span>
+          <span class="ks-tone-muted"><%= @guide.question_text(step) %></span>
+          <span class="shrink-0 font-(weight:--ks-font-weight-medium) ks-tone-neutral"><%= @guide.choice_label(step, value) %></span>
         </li>
       <% end %>
     </ul>

data/app/views/alembic/flows/show.html.erb

@@ -1,16 +1,16 @@
-<% content_for(:title, @diagnostic.title.presence || @diagnostic.slug) %>
+<% content_for(:title, @flow.title.presence || @flow.slug) %>
 
 <%= ui_page(max_width: :md) do %>
-  <%= ui_page_header(title: @diagnostic.title.presence || @diagnostic.slug, subtitle: @diagnostic.summary) %>
+  <%= ui_page_header(title: @flow.title.presence || @flow.slug, subtitle: flow_summary(@flow)) %>
 
   <%= ui_section do %>
     <div class="flex flex-wrap items-center gap-3">
-      <% if @diagnostic.each_step? && @diagnostic.definition.present? && !previewing? %>
-        <%= ui_form(action: alembic.flow_runs_path(@diagnostic.slug), method: :post) do %>
-          <%= ui_button(label: @diagnostic.start_label.presence || "Start", type: :submit) %>
+      <% if @flow.each_step? && @flow.definition.present? && !previewing? %>
+        <%= ui_form(action: alembic.flow_runs_path(@flow.slug), method: :post) do %>
+          <%= ui_button(label: @flow.start_label.presence || "Start", type: :submit) %>
         <% end %>
       <% else %>
-        <%= ui_button(label: @diagnostic.start_label.presence || "Start", href: flow_step_path(@diagnostic.slug)) %>
+        <%= ui_button(label: @flow.start_label.presence || "Start", href: first_step_path(@flow.slug)) %>
       <% end %>
     </div>
   <% end %>

data/app/views/alembic/manage/flows/edit.html.erb

@@ -1,24 +1,24 @@
 <%= ui_page(max_width: :lg) do %>
   <p class="mb-4">
-    <%= link_to "← Back to the flow", alembic.manage_flow_path(@diagnostic), class: "text-sm text-accent-600 hover:text-accent-700" %>
+    <%= link_to "← Back to the flow", easy_flow.manage_flow_path(@flow), class: "text-sm text-(color:--ks-color-link) hover:text-(color:--ks-color-link-hover) dark:text-(color:--ks-color-link-dark) dark:hover:text-(color:--ks-color-link-hover-dark)" %>
   </p>
 
-  <%= ui_form_page(title: "Edit details", back_url: alembic.manage_flow_path(@diagnostic)) %>
+  <%= ui_form_page(title: "Edit details", back_url: easy_flow.manage_flow_path(@flow)) %>
 
-  <%= ui_form(action: alembic.manage_flow_path(@diagnostic), method: :patch) do %>
+  <%= ui_form(action: easy_flow.manage_flow_path(@flow), method: :patch) do %>
     <%= ui_section(title: "How this is introduced") do %>
-      <label class="block text-sm font-medium mb-1">Title</label>
-      <%= ui_input(name: "flow[title]", value: @diagnostic.title) %>
+      <label class="ks-label mb-1">Title</label>
+      <%= ui_input(name: "flow[title]", value: @flow.title) %>
 
-      <label class="block text-sm font-medium mb-1 mt-4">Summary</label>
-      <%= ui_textarea(name: "flow[summary]", value: @diagnostic.summary, rows: 4) %>
+      <label class="ks-label mb-1 mt-4">Summary</label>
+      <%= ui_textarea(name: "flow[summary]", value: @summary, rows: 4) %>
 
-      <label class="block text-sm font-medium mb-1 mt-4">Start label</label>
-      <%= ui_input(name: "flow[start_label]", value: @diagnostic.start_label) %>
+      <label class="ks-label mb-1 mt-4">Start label</label>
+      <%= ui_input(name: "flow[start_label]", value: @flow.start_label) %>
     <% end %>
 
     <%= ui_section(title: "What this keeps of a run") do %>
-      <%= ui_select(name: "flow[persists]", selected: @diagnostic.persists,
+      <%= ui_select(name: "flow[persists]", selected: @flow.persists,
             options: [ [ "Nothing", "unsaved" ],
                        [ "Every answer as it is given", "each_step" ],
                        [ "The whole run once it finishes", "on_finish" ] ]) %>

data/app/views/alembic/manage/pages/_block_content.html.erb

@@ -1 +1 @@
-<%= KsBlocks.registry.block_types(kind: :pages).find { |type| type.key.to_s == block["type"] }&.name %>
+<%= shown_block(block) %>