alembic 0.1.0 → 0.3.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,8 @@ module Alembic
       helper KeystoneUiHelper
       helper KeystoneUi::React::MountHelper
       helper KsBlocks::ContentHelper
+      helper Alembic::PagesHelper
+      helper Alembic::ResultBlocksHelper
     end
   end
 end

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

@@ -1,54 +1,22 @@
 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
+        summaries = Flow::Summaries.new(@flow)
+        @summary = summaries.text
+        @summary_page = summaries.summary_page
+        @published_pages = Page.where(id: Page::Version.live.select(:page_id)).order(:name)
       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
+        details = params.require(:flow)
+        summaries = Flow::Summaries.new(flow_host.flows.find(params[:id]))
+        summaries.describe(details[:summary]) unless details[:summary].nil?
+        summaries.finish_on(Page.find_by(id: details[:summary_page_id])) unless details[:summary_page_id].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,59 @@
+module Alembic
+  module Summarizes
+    extend ActiveSupport::Concern
+
+    included do
+      layout -> { Alembic.layout }
+      helper ApplicationHelper
+      helper PagesHelper
+      helper ResultBlocksHelper
+      helper KsBlocks::LayoutHelper
+      helper_method :flow_summary, :first_step_path, :summary_values
+    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?
+      @summary_page = Flow::Summaries.new(run&.flow || flow).summary_page
+      render template: @summary_page&.live_version ? "alembic/flows/summary_page" : "alembic/flows/complete"
+    end
+
+    def summary_values
+      @outputs.to_h { |output| [ output.id, output.value ] }
+        .merge("slug" => @guide.slug, "note" => result_note, "answers" => answers_given)
+    end
+
+    def answers_given
+      @answered.map { |step, value| [ @guide.question_text(step), @guide.choice_label(step, value) ] }
+    end
+
+    def result_note
+      finished_flow = run&.flow || flow
+      return Alembic.lead_note.call(finished_flow.title, @outputs.to_h { |output| [ output.id, output.value ] }) if Alembic.lead_note
+
+      [ finished_flow.title, *@outputs.map { |output| "#{output.label}: #{helpers.alembic_output_lines(output.value).join(', ')}" } ]
+        .compact_blank.join(". ")
+    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/application_helper.rb

@@ -2,8 +2,8 @@ module Alembic
   module ApplicationHelper
     def alembic_output_lines(value)
       case value
-      when Hash then value.map { |name, share| "#{name}: #{share}" }
-      when Array then value
+      when Hash then value.key?("name") ? [ value["name"] ] : value.map { |name, share| "#{name}: #{share}" }
+      when Array then value.map { |item| item.is_a?(Hash) ? item["name"] : item }
       else [ value ]
       end
     end

data/app/helpers/alembic/pages_helper.rb

@@ -0,0 +1,40 @@
+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, values: {})
+      blocks = being_edited ? page.blocks : page.live_version&.blocks.to_a
+      drawn = blocks.to_h { |block| [ block["id"], drawn_block(block, values: values) ] }.compact
+
+      block_layout(blocks.select { |block| drawn.key?(block["id"]) }, kind: :pages) do |block|
+        drawn.fetch(block["id"])
+      end
+    end
+
+    def drawn_block(block, values: {})
+      component = Page::Drawing.of(block["type"])
+      return unless component
+
+      options = Page::Options.for(block, values: values)
+      body = Page::Options.body_for(block)
+      body.nil? ? send(component, **options) : send(component, **options) { 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/helpers/alembic/result_blocks_helper.rb

@@ -0,0 +1,45 @@
+module Alembic
+  module ResultBlocksHelper
+    def alembic_score_block(value: nil, caption: nil, kicker: "Your result")
+      render "alembic/blocks/score", value: value, caption: caption, kicker: kicker
+    end
+
+    def alembic_band_block(value: nil, score: nil)
+      render "alembic/blocks/band", band: value.to_h, tone: alembic_tone(score)
+    end
+
+    def alembic_categories_block(value: nil, heading: "Where you stand, area by area")
+      render "alembic/blocks/categories", shares: value.to_h, heading: heading
+    end
+
+    def alembic_weakest_block(value: nil, heading: "Your biggest blind spots", cost_label: "What it likely costs you:")
+      render "alembic/blocks/weakest", categories: Array(value), heading: heading, cost_label: cost_label
+    end
+
+    def alembic_answers_block(value: nil, heading: "What you told us")
+      render "alembic/blocks/answers", answers: Array(value), heading: heading
+    end
+
+    def alembic_lead_block(slug:, note: nil, heading: "The next step", blurb: nil, button: "Send", placeholder: "you@example.com")
+      render "alembic/blocks/lead", address: Alembic.lead_address.call(slug), slug: slug, note: note,
+        heading: heading, blurb: blurb, button: button, placeholder: placeholder
+    end
+
+    def alembic_default_result(output, outputs = [])
+      case output.type
+      when "percentage" then alembic_score_block(value: output.value, caption: output.label)
+      when "band" then alembic_band_block(value: output.value, score: outputs.find { |other| other.type == "percentage" }&.value)
+      when "grouped" then alembic_categories_block(value: output.value)
+      when "lowest" then alembic_weakest_block(value: output.value)
+      else ui_stat_card(label: output.label, value: alembic_output_lines(output.value).join(" · "))
+      end
+    end
+
+    def alembic_tone(percentage)
+      return "bg-red-500" if percentage.to_i < 40
+      return "bg-amber-500" if percentage.to_i < 70
+
+      "bg-emerald-500"
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Alembic
+  module Flow
+    class DefinitionSummary < ApplicationRecord
+      self.table_name = "alembic_flow_definition_summaries"
+
+      belongs_to :flow, class_name: "EasyFlow::Definition"
+      belongs_to :summary_page, class_name: "Alembic::Page", optional: true
+    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,57 @@ 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 summary_page
+        details.summary_page
+      end
+
+      def finish_on(page)
+        details.update!(summary_page: page)
+      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/band.rb

@@ -15,7 +15,7 @@ module Alembic
       def self.covering(config, number)
         ordered = Array(config["bands"]).sort_by { |band| band["ceiling"] || Float::INFINITY }
 
-        ordered.find { |band| band["ceiling"].nil? || number < band["ceiling"] }&.fetch("name", nil)
+        ordered.find { |band| band["ceiling"].nil? || number < band["ceiling"] }&.slice("name", "description")
       end
     end
   end

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/lowest.rb

@@ -4,7 +4,7 @@ module Alembic
       def self.output_type
         Summary::OutputType.define(:lowest) do
           label "Weakest"
-          compute { |config, _run, so_far| Lowest.of(so_far[config["of"]], config["count"]) }
+          compute { |config, _run, so_far| Lowest.of(so_far[config["of"]], config["count"], config["copy"]) }
         end
       end
 
@@ -12,8 +12,10 @@ module Alembic
         registry.register(output_type)
       end
 
-      def self.of(shares, count)
-        shares.to_h.sort_by { |_name, share| share }.first(count.presence&.to_i || 1).map(&:first)
+      def self.of(shares, count, copy = nil)
+        weakest = shares.to_h.sort_by { |_name, share| share }.first(count.presence&.to_i || 1).map(&:first)
+
+        weakest.map { |name| { "name" => name, **copy.to_h.fetch(name, {}).slice("miss", "cost") } }
       end
     end
   end

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,53 @@
+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, values: {})
+        named(filled(block).except(bodies[block["type"].to_sym]), declared.fetch(block["type"].to_sym, {}), values)
+      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, values)
+        options.each_with_object(filled) do |(option, spec), built|
+          spec.is_a?(Hash) ? fill(built, option, spec, values) : built[option] = spec
+        end
+      end
+
+      def self.fill(built, option, spec, values)
+        value = handed(built, option, spec, values)
+        built[option] = value.nil? ? spec[:default] : value
+        built.delete(option) if built[option].nil?
+      end
+
+      def self.handed(built, option, spec, values)
+        return values[spec[:value]] if spec.key?(:value)
+        return values[built.delete(spec[:value_of]).to_s] if spec.key?(:value_of)
+
+        built.delete(spec.fetch(:from, option))
+      end
+
+      private_class_method :filled, :named, :fill, :handed
+    end
+  end
+end