alembic 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebd0ef51eea97e6370103e3a49348ada05fcc41807ed10328e441297e93bb3b2
-  data.tar.gz: 26e892bfe991ca206d5ef15747b3d57a1434fd714e6748f9811d3fb3fb685586
+  metadata.gz: b9fe70ef3945d5a70f24110f819a17db43ee9f54ebf70e81631e76e96fe4e7a2
+  data.tar.gz: eb5c70109254d9e121b2fbe5b8bbf6ce7988e53deaf322a9a904ee556c6ede6a
 SHA512:
-  metadata.gz: 651e4f43dac80bc3de140bbbbe92e728acb3ce0fc22423dc47ed7a89d7fb7cf8f0cf501f5ec96ec60fbb1926b3f73692a7e1b43a359afca8c3ff01beff9db6f6
-  data.tar.gz: 283bbbbc4909b992333b4cf71808338b6fd9849d1b01ec0945b89a893ca98c18ffc0c614fecb990b616cc45b01ac304ed42662551636b338351bed1f3cd851ec
+  metadata.gz: 98520320480c38a5a72a8d11b11f0510b70352c8a6a9765c732842dae8075a6f843c419f29fe9c3308a5b9b8230fe8a20840274d4e5b866aa741ea414b2cbab0
+  data.tar.gz: 131062d6d22160f9ab6b3688d33f43120b783410d9836c2c03d09d6617b8efe47c7656896eca9bb0537151bf801cf1971564b7543afc279994071b40965636d3

data/app/controllers/alembic/flows_controller.rb

@@ -48,6 +48,10 @@ module Alembic
       Alembic.start_over_address&.call(run&.flow || flow) || super
     end
 
+    def finish_link
+      Alembic.finish_link&.call(run&.flow || flow)
+    end
+
     def flow_step_path(slug)
       alembic.flow_step_path(slug)
     end

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

@@ -9,7 +9,8 @@ module Alembic
       helper ResultBlocksHelper
       helper ContentBlocksHelper
       helper KsBlocks::LayoutHelper
-      helper_method :flow_summary, :first_step_path, :summary_values, :intro_values, :start_over_path, :visited_flow_address
+      after_action :keep_ended_inner_run, only: :step
+      helper_method :flow_summary, :first_step_path, :summary_values, :intro_values, :start_over_path, :finish_link, :visited_flow_address
     end
 
     private
@@ -26,6 +27,8 @@ module Alembic
       flow_start_path(visited_flow_address)
     end
 
+    def finish_link; end
+
     def visited_flow_address
       flow_address((run&.flow || flow).slug)
     end
@@ -40,6 +43,16 @@ module Alembic
       super.tap { |run| Flow::Summaries.new(flow).pin(run) }
     end
 
+    def admitted_run
+      super.tap { |found| Flow::Summaries.new(found.flow).pin_inner(found) }
+    end
+
+    def keep_ended_inner_run
+      return unless run&.parent_run && run.ended_at_end?
+
+      Flow::Summaries.new(run.flow).keep(run, run.walked(run.recorded).transform_keys(&:to_s))
+    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?

data/app/helpers/alembic/application_helper.rb

@@ -15,6 +15,13 @@ module Alembic
         "steps_text" => Array(entry["steps"]).map { |step| "#{step['title']}\n#{step['code']}" }.join("\n---\n") }
     end
 
+    def alembic_question_upload_path(flow)
+      registration = defined?(Ixport) && Ixport.registrations.values.find { |found| found.importer == "Alembic::QuestionImporter" }
+      return unless registration && respond_to?(:ixport)
+
+      ixport.new_import_path(key: registration.key, target: flow.to_global_id)
+    end
+
     def alembic_output_lines(value)
       case value
       when Hash then value.key?("name") ? [ value["name"] ] : value.map { |name, share| "#{name}: #{share}" }

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

@@ -1,6 +1,8 @@
 module Alembic
   module Flow
     class Summaries
+      SCORES = %w[weighted_sum inner_total].freeze
+
       def initialize(flow)
         @flow = flow
       end
@@ -77,6 +79,10 @@ module Alembic
         RunSummary.create!(run: run, summary_version: current_version) if current_version
       end
 
+      def pin_inner(run)
+        pin(run) if run.parent_run && pinned_to(run).nil?
+      end
+
       def pinned_to(run)
         RunSummary.find_by(run: run)&.summary_version
       end
@@ -96,15 +102,15 @@ module Alembic
         pinned = pinned_to(run)&.summary
         return [] if pinned.blank?
 
-        Summary::Report.new(pinned).results(Summary::Run.new(state: state, steps: run.pinned_steps))
+        Summary::Report.new(pinned).results(Summary::Run.new(state: state, steps: run.pinned_steps, run: run))
       end
 
-      private
-
       def score_of(run, state)
-        of_run(run, state).find { |result| result.type == "weighted_sum" }&.value
+        of_run(run, state).find { |result| SCORES.include?(result.type) }&.value
       end
 
+      private
+
       def seconds_taken_by(run)
         return unless run.flow.each_step?
 

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

@@ -0,0 +1,87 @@
+module Alembic
+  module Flow
+    class UploadedQuestion
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attr_accessor :flow
+
+      attribute :type, :string
+      attribute :question, :string
+      attribute :category, :string
+      attribute :right_answer, :string
+      ANSWER_FIELDS = (1..6).map { |number| :"answer_#{number}" }
+      ANSWER_FIELDS.each { |field| attribute field, :string }
+
+      KINDS = %w[truefalse multiplechoice].freeze
+
+      validates :question, presence: true
+      validate :kind_is_offered
+      validate :choices_are_offered, if: -> { kind == "multiplechoice" }
+      validate :true_or_false_is_right, if: -> { kind == "truefalse" }
+
+      def save!
+        before = document.to_h
+        flow.edit_history.record(appended, :added, [ step["id"] ], before)
+      end
+
+      private
+
+      def choices_are_offered
+        errors.add(:answers, "must be at least two for a multiple choice question") if filled_answers.size < 2
+        errors.add(:right_answer, "must be the number of one of its answers") if answers.none? { |answer| answer["weight"] == 1 }
+      end
+
+      def true_or_false_is_right
+        errors.add(:right_answer, "must be true or false") if answers.none? { |answer| answer["weight"] == 1 }
+      end
+
+      def kind_is_offered
+        errors.add(:type, "must be true/false or multiple choice") unless KINDS.include?(kind)
+      end
+
+      def document
+        EasyFlow::Document.new(flow.document || flow.definition || {})
+      end
+
+      def appended
+        leaving = document.edges_from(last_question).first
+        return document.insert(step, on: [ last_question, leaving.to ]) if leaving
+
+        document.add(step).connect(from: last_question, to: step["id"])
+      end
+
+      def last_question
+        reached = document.reachable
+        reached.reverse.find { |id| document.node(id)&.type == "question" } || reached.last
+      end
+
+      def step
+        @step ||= { "id" => next_id, "type" => "question", "question" => question, "category" => category.presence, "answers" => answers }.compact
+      end
+
+      def answers
+        return true_false_answers if kind == "truefalse"
+
+        filled_answers.map { |number, text| { "value" => text, "weight" => number.to_s == right_answer.to_s.strip ? 1 : 0 } }
+      end
+
+      def true_false_answers
+        %w[True False].map { |text| { "value" => text, "weight" => text.casecmp?(right_answer.to_s.strip) ? 1 : 0 } }
+      end
+
+      def kind
+        type.to_s.downcase.gsub(/[^a-z]/, "")
+      end
+
+      def filled_answers
+        ANSWER_FIELDS.each_with_index.filter_map { |field, index| [ index + 1, public_send(field).strip ] if public_send(field).present? }
+      end
+
+      def next_id
+        taken = document.nodes.map(&:id)
+        (1..).lazy.map { |number| "question_#{number}" }.find { |id| !taken.include?(id) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Alembic
+  module Flow
+    class UploadedQuestions
+      def initialize(flow)
+        @flow = flow
+      end
+
+      def new(values)
+        UploadedQuestion.new(values.merge(flow: @flow))
+      end
+
+      def where(*)
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Alembic
+  module Outputs
+    module InnerTotal
+      def self.output_type
+        Summary::OutputType.define(:inner_total) do
+          label "Total score"
+          compute { |_config, run, _so_far| InnerTotal.total(run.run) }
+        end
+      end
+
+      def self.register(registry = Summary.registry)
+        registry.register(output_type)
+      end
+
+      def self.total(parent)
+        return 0 if parent.nil?
+
+        parent.inner_runs.select(&:ended_at_end?).sum { |inner| score_of(inner).to_i }
+      end
+
+      def self.score_of(inner)
+        Flow::Summaries.new(inner.flow).score_of(inner, inner.walked(inner.recorded).transform_keys(&:to_s))
+      end
+    end
+  end
+end

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

@@ -24,6 +24,9 @@ module Alembic
       end
 
       def self.most(step)
+        return 1 if step["type"] == "multiple_select"
+        return WeightedSum.weight_of(step, Array(step["accepted_answers"]).first&.dig("value")) if step["type"] == "fill_in_the_blank"
+
         EasyFlow::Steps::Question.answers_of(step).filter_map { |option| option["weight"].to_i if option.is_a?(Hash) }.max.to_i
       end
     end

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

@@ -17,10 +17,33 @@ module Alembic
       end
 
       def self.weight_of(step, value)
+        return picked_weight(step, value) if step["type"] == "multiple_select"
+        return typed_weight(step, value) if step["type"] == "fill_in_the_blank"
+
+        answer_weight(step, value)
+      end
+
+      def self.answer_weight(step, value)
         chosen = EasyFlow::Steps::Question.answers_of(step).find { |option| option.is_a?(Hash) && option["value"] == value }
 
         chosen&.fetch("weight", nil).to_i
       end
+
+      def self.picked_weight(step, values)
+        Array(values).sort == right_answers(step).sort ? 1 : 0
+      end
+
+      def self.typed_weight(step, text)
+        Array(step["accepted_answers"]).any? { |accepted| comparable(accepted["value"]) == comparable(text) } ? 1 : 0
+      end
+
+      def self.comparable(text)
+        text.to_s.strip.downcase
+      end
+
+      def self.right_answers(step)
+        EasyFlow::Steps::Question.answers_of(step).filter_map { |option| option["value"] if option["weight"].to_i.positive? }
+      end
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Alembic
   module Summary
-    Run = Data.define(:state, :steps) do
-      def initialize(state:, steps: {})
+    Run = Data.define(:state, :steps, :run) do
+      def initialize(state:, steps: {}, run: nil)
         super
       end
 

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

@@ -21,6 +21,12 @@
     <% end %>
   <% end %>
 
+  <% if (link = finish_link) %>
+    <%= ui_section do %>
+      <%= ui_button(label: link[:label], href: link[:url]) %>
+    <% end %>
+  <% end %>
+
   <% if Alembic.lead_address %>
     <%= ui_section do %>
       <%= alembic_lead_block(slug: summary_values["slug"], note: summary_values["note"]) %>

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

@@ -5,5 +5,10 @@
 <section class="py-20 md:py-28">
   <div class="max-w-2xl mx-auto px-6">
     <%= drawn_page(@summary_page, values: summary_values) %>
+    <% if (link = finish_link) %>
+      <div class="mt-10">
+        <%= ui_button(label: link[:label], href: link[:url]) %>
+      </div>
+    <% end %>
   </div>
 </section>

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

@@ -58,4 +58,10 @@
     <%= hidden_field_tag "#{field}[type]", "outcome", id: nil %>
     <%= ui_input(name: "#{field}[id]", placeholder: "The new outcome's id") %>
   </div>
+  <% field = "flow[outputs][#{outputs.size + 1}]" %>
+  <div data-new-inner-total class="mt-6">
+    <label class="ks-label mb-1">Add a total of every inner run's score</label>
+    <%= hidden_field_tag "#{field}[type]", "inner_total", id: nil %>
+    <%= ui_input(name: "#{field}[id]", placeholder: "The new total's id") %>
+  </div>
 <% end %>

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

@@ -5,6 +5,12 @@
 
   <%= ui_form_page(title: "Edit details", back_url: easy_flow.manage_flow_path(@flow)) %>
 
+  <% if (upload_path = alembic_question_upload_path(@flow)) %>
+    <%= ui_section(title: "Questions from a file") do %>
+      <%= link_to "Upload questions", upload_path, 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)" %>
+    <% end %>
+  <% end %>
+
   <%= ui_form(action: easy_flow.manage_flow_path(@flow), method: :patch) do %>
     <%= ui_section(title: "How this is introduced") do %>
       <label class="ks-label mb-1">Title</label>

data/lib/alembic/engine.rb

@@ -29,9 +29,14 @@ module Alembic
         Alembic::Outputs::Tally.register
         Alembic::Outputs::Band.register
         Alembic::Outputs::Outcome.register
+        Alembic::Outputs::InnerTotal.register
       end
     end
 
+    initializer "alembic.question_importer" do |app|
+      app.config.to_prepare { require "alembic/question_importer" if defined?(Ixport::Importer) }
+    end
+
     initializer "alembic.result_blocks" do |app|
       app.config.to_prepare do
         Alembic::Page::ContentBlocks.register

data/lib/alembic/question_importer.rb

@@ -0,0 +1,17 @@
+module Alembic
+  class QuestionImporter < Ixport::Importer
+    field :type, label: "Type"
+    field :question, label: "Question"
+    field :category, label: "Category"
+    Flow::UploadedQuestion::ANSWER_FIELDS.each.with_index(1) { |key, number| field key, label: "Answer #{number}" }
+    field :right_answer, label: "Right answer"
+
+    def records
+      Flow::UploadedQuestions.new(target)
+    end
+
+    def self.allows?(account, quiz)
+      quiz.is_a?(EasyFlow::Definition) && quiz.host == FLOW_HOST.to_s && (Alembic.owner_method.nil? || quiz.owner == account)
+    end
+  end
+end

data/lib/alembic/version.rb

@@ -1,3 +1,3 @@
 module Alembic
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/lib/alembic.rb

@@ -13,7 +13,7 @@ module Alembic
                           visitor_authorization_method refusal_method owner_method].freeze
 
   class << self
-    attr_accessor :lead_address, :lead_fields_partial, :lead_note, :start_over_address
+    attr_accessor :lead_address, :lead_fields_partial, :lead_note, :start_over_address, :finish_link
     attr_reader :admin_authentication_method, :visitor_authorization_method, :refusal_method, :owner_method
 
     FLOW_HOST_SETTINGS.each do |name|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alembic
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - tylercschneider
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.27'
 description: Alembic builds and runs data-driven interactive diagnostics — scored
   assessments and branching guides — that place a visitor on an outcome and capture
   the result. A runtime engine plus a UI builder.
@@ -107,8 +107,11 @@ files:
 - app/models/alembic/flow/run_summary.rb
 - app/models/alembic/flow/summaries.rb
 - app/models/alembic/flow/summary_version.rb
+- app/models/alembic/flow/uploaded_question.rb
+- app/models/alembic/flow/uploaded_questions.rb
 - app/models/alembic/outputs/band.rb
 - app/models/alembic/outputs/grouped.rb
+- app/models/alembic/outputs/inner_total.rb
 - app/models/alembic/outputs/lowest.rb
 - app/models/alembic/outputs/outcome.rb
 - app/models/alembic/outputs/percentage.rb
@@ -215,6 +218,7 @@ files:
 - lib/alembic.rb
 - lib/alembic/engine.rb
 - lib/alembic/leftover_stylesheet.rb
+- lib/alembic/question_importer.rb
 - lib/alembic/version.rb
 - lib/tasks/alembic_tasks.rake
 homepage: https://github.com/tylercschneider/alembic