easy_flow 0.16.0 → 0.18.0

data/app/models/easy_flow/run.rb

@@ -15,11 +15,15 @@ module EasyFlow
     end
 
     def record(step_id, value)
-      update!(recorded: recorded.merge(step_id => value))
+      update!(recorded: visits.merge(step_id.to_s => { "value" => value, "completed_at" => Time.current.utc.iso8601 }))
     end
 
     def recorded
-      super.to_h.symbolize_keys
+      visits.to_h { |step_id, visit| [ step_id.to_sym, visit["value"] ] }
+    end
+
+    def completed_at
+      visits.select { |_step_id, visit| visit["completed_at"] }.to_h { |step_id, visit| [ step_id.to_sym, Time.zone.parse(visit["completed_at"]) ] }
     end
 
     def advance
@@ -31,11 +35,16 @@ module EasyFlow
     end
 
     def next_step(state)
-      digest.next_step(state.transform_keys(&:to_s))
+      digest.next_step(state.transform_keys(&:to_s), completed_at.transform_keys(&:to_s))
     end
 
     def output
-      digest.output(recorded.transform_keys(&:to_s))
+      digest.output(recorded.transform_keys(&:to_s), completed_at.transform_keys(&:to_s))
+    end
+
+    def held_until
+      stopped_at = next_step(recorded)
+      Wait.held_until(digest.step(stopped_at.id), CompletedAt.latest(completed_at)) if stopped_at&.type == "wait"
     end
 
     def waiting_on
@@ -44,7 +53,7 @@ module EasyFlow
     end
 
     def walked(state)
-      digest.state_on_path(state.transform_keys(&:to_s))
+      digest.state_on_path(state.transform_keys(&:to_s), completed_at.transform_keys(&:to_s))
     end
 
     def digest
@@ -53,7 +62,7 @@ module EasyFlow
 
     def discard_last
       last = walked(recorded).keys.map(&:to_sym).last
-      update!(recorded: recorded.except(last)) if last
+      update!(recorded: visits.except(last.to_s)) if last
     end
 
     def pinned_steps
@@ -62,6 +71,10 @@ module EasyFlow
 
     private
 
+    def visits
+      read_attribute(:recorded).to_h
+    end
+
     def started_on_a_published_version
       errors.add(:definition_version, "must be a published version of the flow") unless definition_version&.flow_id == flow_id && (definition_version.live? || definition_version.superseded?)
     end

data/app/models/easy_flow/runner.rb

@@ -23,13 +23,13 @@ module EasyFlow
       @digest.step(id.to_s)
     end
 
-    def next_step(state, run: nil)
-      node = @digest.next_step(named(state))
+    def next_step(state, run: nil, times: {})
+      node = @digest.next_step(named(state), named(times))
       narrowed(shown(node, run), node, state)
     end
 
     def run(progress)
-      while (node = @digest.next_step(named(progress.recorded))) && goes_on?(node, named(progress.recorded))
+      while (node = @digest.next_step(named(progress.recorded), named(progress.completed_at))) && goes_on?(node, named(progress.recorded), CompletedAt.latest(named(progress.completed_at)))
         progress.record(node.id, result_of(@digest.step(node.id), named(progress.recorded)))
       end
       progress.start_inner(node) if node && starts_a_flow?(node)
@@ -41,12 +41,12 @@ module EasyFlow
       node.present? && decided?(node, state)
     end
 
-    def drawing_at(state)
-      Drawing.of(@digest.next_step(named(state)), @registry)
+    def drawing_at(state, times: {})
+      Drawing.of(@digest.next_step(named(state), named(times)), @registry)
     end
 
-    def state_on_path(state)
-      @digest.state_on_path(named(state)).symbolize_keys
+    def state_on_path(state, times: {})
+      @digest.state_on_path(named(state), named(times)).symbolize_keys
     end
 
     def questions_left(state)
@@ -67,8 +67,8 @@ module EasyFlow
       @registry.registered?(node.type) && @registry.fetch(node.type).acts?
     end
 
-    def goes_on?(node, state)
-      acts?(node) || ready?(node, state) || decided?(node, state)
+    def goes_on?(node, state, times = {})
+      acts?(node) || ready?(node, state, times) || decided?(node, state)
     end
 
     def allowed(node, state)
@@ -87,8 +87,8 @@ module EasyFlow
       !choices.nil? && choices.size <= 1
     end
 
-    def ready?(node, state)
-      @registry.registered?(node.type) && @registry.fetch(node.type).waits? && @registry.fetch(node.type).ready?(node, state)
+    def ready?(node, state, times = {})
+      @registry.registered?(node.type) && @registry.fetch(node.type).waits? && @registry.fetch(node.type).ready?(node, state, times)
     end
 
     def result_of(node, state)

data/app/models/easy_flow/settings.rb

@@ -1,13 +1,16 @@
 module EasyFlow
   class Settings
-    attr_reader :fields, :labels, :record_fields, :record_labels, :drawn_from, :outputs_of
+    attr_reader :fields, :labels, :record_fields, :record_labels, :record_choices, :record_outputs_of, :record_required, :drawn_from, :outputs_of
 
-    def initialize(fields: {}, labels: {}, record_fields: {}, record_labels: {}, choices: {},
+    def initialize(fields: {}, labels: {}, record_fields: {}, record_labels: {}, record_choices: {}, record_outputs_of: {}, record_required: {}, choices: {},
       limits: {}, checks: {}, required: [], drawn_from: {}, outputs_of: {}, kept: {})
       @fields = fields
       @labels = labels
       @record_fields = record_fields
       @record_labels = record_labels
+      @record_choices = record_choices
+      @record_outputs_of = record_outputs_of
+      @record_required = record_required
       @choices = choices
       @limits = limits
       @checks = checks

data/app/models/easy_flow/step.rb

@@ -24,8 +24,12 @@ module EasyFlow
       end
 
       def behaviours
-        BEHAVIOURS.select { |word| method_defined?(word) }
-          .map { |word| [ word, [], {}, ->(node, state) { new.public_send(word, node, state) } ] }
+        BEHAVIOURS.select { |word| method_defined?(word) }.map { |word| [ word, [], {}, behaviour(word) ] }
+      end
+
+      def behaviour(word)
+        asks_for_times = instance_method(word).arity.abs >= 3
+        ->(node, state, times = {}) { asks_for_times ? new.public_send(word, node, state, times) : new.public_send(word, node, state) }
       end
 
       def register(registry = EasyFlow.registry)

data/app/models/easy_flow/step_type/declaration.rb

@@ -8,6 +8,9 @@ module EasyFlow
         @labels = {}
         @record_fields = {}
         @record_labels = {}
+        @record_choices = {}
+        @record_outputs_of = {}
+        @record_required = {}
         @choices = {}
         @limits = {}
         @checks = {}
@@ -26,6 +29,10 @@ module EasyFlow
         @declared_outputs += [ Output.new(name: name, type: type, label: label, values: values, from: from) ]
       end
 
+      def outputs_named_by(setting)
+        @outputs_named_by = setting
+      end
+
       def displays_by(&display)
         @display = display
       end
@@ -107,7 +114,7 @@ module EasyFlow
 
       protected
 
-      attr_reader :fields, :labels
+      attr_reader :fields, :labels, :choices, :outputs_of, :required
 
       private
 
@@ -122,6 +129,9 @@ module EasyFlow
         declared = Declaration.new(:entry).tap { |entry| entry.instance_eval(&entries) }
         @record_fields[name] = declared.fields
         @record_labels[name] = declared.labels
+        @record_choices[name] = declared.choices
+        @record_outputs_of[name] = declared.outputs_of
+        @record_required[name] = declared.required
       end
 
       public
@@ -130,12 +140,12 @@ module EasyFlow
         StepType.new(id: @id, step_name: @step_name, settings: settings, awaits_input: @awaits_input,
           ends_here: @ends_here, begins_here: @begins_here, starts_a_flow: @starts_a_flow, flow_chooser: @flow_chooser, run_chooser: @run_chooser, behaviour: @behaviour, routing: @routing,
           display: @display, drawn_by: @drawn_by, naming_field: @naming_field, naming: @naming,
-          outputs: @declared_outputs, answer_check: @answer_check, answer_labelling: @answer_labelling, readiness: @readiness)
+          outputs: @declared_outputs, outputs_named_by: @outputs_named_by, answer_check: @answer_check, answer_labelling: @answer_labelling, readiness: @readiness)
       end
 
       def settings
         Settings.new(fields: @fields, labels: @labels, record_fields: @record_fields,
-          record_labels: @record_labels, choices: @choices, limits: @limits, checks: @checks,
+          record_labels: @record_labels, record_choices: @record_choices, record_outputs_of: @record_outputs_of, record_required: @record_required, choices: @choices, limits: @limits, checks: @checks,
           required: @required, drawn_from: @drawn_from, outputs_of: @outputs_of, kept: @kept)
       end
     end

data/app/models/easy_flow/step_type.rb

@@ -8,7 +8,7 @@ module EasyFlow
 
     def initialize(id:, step_name:, settings:, awaits_input:, behaviour:, routing:,
       ends_here: false, begins_here: false, starts_a_flow: false, flow_chooser: nil, run_chooser: nil, display: nil, drawn_by: nil,
-      naming_field: nil, naming: nil, outputs: [], answer_check: nil, answer_labelling: nil, readiness: nil)
+      naming_field: nil, naming: nil, outputs: [], outputs_named_by: nil, answer_check: nil, answer_labelling: nil, readiness: nil)
       @id = id
       @step_name = step_name
       @settings = settings
@@ -25,6 +25,7 @@ module EasyFlow
       @naming_field = naming_field
       @naming = naming
       @outputs = outputs
+      @outputs_named_by = outputs_named_by
       @answer_check = answer_check
       @answer_labelling = answer_labelling
       @readiness = readiness
@@ -40,8 +41,8 @@ module EasyFlow
       @behaviour&.call(node, state)
     end
 
-    def route(node, state)
-      @routing&.call(node, state)
+    def route(node, state, times = {})
+      @routing&.call(node, state, times)
     end
 
     def answer_problem(node, value)
@@ -56,8 +57,8 @@ module EasyFlow
       @readiness.present?
     end
 
-    def ready?(node, state)
-      @readiness.call(node, state)
+    def ready?(node, state, times = {})
+      @readiness.call(node, state, times)
     end
 
     def name_of(node)
@@ -72,6 +73,10 @@ module EasyFlow
       @routing.present?
     end
 
+    def outputs_for(node)
+      outputs + named_outputs(node)
+    end
+
     def values_of(name, node)
       outputs.find { |output| output.name.to_s == name.to_s }&.values_for(node).to_a
     end
@@ -108,5 +113,13 @@ module EasyFlow
       chosen = flow_chosen_by(node)
       ChosenFlow.worked_out(chosen).name if chosen
     end
+
+    private
+
+    def named_outputs(node)
+      return [] unless @outputs_named_by
+
+      Array(node.config[@outputs_named_by.to_s]).filter_map { |entry| entry["name"].presence }.map { |name| Output.new(name: name) }
+    end
   end
 end

data/app/models/easy_flow/validator.rb

@@ -176,7 +176,18 @@ module EasyFlow
     def missing_settings
       @document.nodes.flat_map do |node|
         required_of(node).reject { |name| node.config[name.to_s].present? }
-          .map { |name| Violation.new(node: node.id, problem: :missing_setting, detail: name.to_s) }
+          .map { |name| Violation.new(node: node.id, problem: :missing_setting, detail: name.to_s) } + missing_entry_settings(node)
+      end
+    end
+
+    def missing_entry_settings(node)
+      return [] unless @registry.registered?(node.type)
+
+      @registry.fetch(node.type).settings.record_required.flat_map do |list, required|
+        Array(node.config[list.to_s]).each_with_index.flat_map do |entry, index|
+          required.reject { |name| entry.to_h[name.to_s].present? }
+            .map { |name| Violation.new(node: node.id, problem: :missing_setting, detail: "#{list} #{index + 1} #{name}") }
+        end
       end
     end
 

data/app/models/easy_flow/wait.rb

@@ -0,0 +1,38 @@
+module EasyFlow
+  class Wait
+    include Step
+
+    step_name "Wait"
+
+    setting :step, type: :previous_step, label: "Counting from", required: true
+    setting :minutes, type: :integer, label: "Minutes after it"
+    setting :time_of_day, type: :string, label: "Next time of day after it, as HH:MM"
+    setting :date, type: :string, label: "Date, as YYYY-MM-DD"
+
+    names_by { |node| Wait.named(node.config) }
+
+    waits_until { |node, _state, times| Wait.held_until(node, times)&.then { |held| held <= Time.current } || false }
+
+    def self.named(config)
+      return config["date"] if config["date"].present?
+
+      waited = config["time_of_day"].presence || ("#{config["minutes"]} minutes" if config["minutes"].present?)
+      "#{waited} after #{config["step"]}" if waited
+    end
+
+    def self.held_until(node, times)
+      from = times[node.config["step"]]
+      return Time.zone.parse(node.config["date"]) if node.config["date"].present?
+      return if from.nil?
+      return next_time_of_day(from, node.config["time_of_day"]) if node.config["time_of_day"].present?
+
+      from + node.config["minutes"].to_i.minutes
+    end
+
+    def self.next_time_of_day(from, time_of_day)
+      hour, minute = time_of_day.split(":").map(&:to_i)
+      same_day = from.in_time_zone.change(hour: hour, min: minute)
+      same_day > from ? same_day : same_day.tomorrow
+    end
+  end
+end

data/app/views/easy_flow/flows/step.html.erb

@@ -13,6 +13,9 @@
 
   <% if @waiting %>
     <p class="ks-hint">Waiting for <%= @waiting %>.</p>
+    <% if carries_answers? %>
+      <div class="mt-4"><%= ui_button(label: "Check again", href: "#{flow_step_path(@guide.slug)}?#{{ answers: @answers, completed_at: @progress.completed_at.transform_values(&:iso8601) }.to_query}", variant: :secondary) %></div>
+    <% end %>
   <% else %>
     <%= form_with url: step_form[:url], method: step_form[:method], multipart: true, data: { turbo: false } do %>
       <%= hidden_field_tag :asked, @question.id %>
@@ -25,6 +28,9 @@
           <% else %>
             <%= hidden_field_tag "answers[#{key}]", value %>
           <% end %>
+          <% if (answered = @progress.completed_at[key]) %>
+            <%= hidden_field_tag "completed_at[#{key}]", answered.iso8601, id: nil %>
+          <% end %>
         <% end %>
       <% end %>
 

data/db/migrate/20261011130000_keep_step_visits_whole_in_easy_flow_runs.rb

@@ -0,0 +1,23 @@
+class KeepStepVisitsWholeInEasyFlowRuns < ActiveRecord::Migration[8.1]
+  class Run < ActiveRecord::Base
+    self.table_name = "easy_flow_runs"
+  end
+
+  def up
+    Run.find_each do |run|
+      run.update_columns(recorded: run.recorded.to_h.transform_values { |value| whole?(value) ? value : { "value" => value } })
+    end
+  end
+
+  def down
+    Run.find_each do |run|
+      run.update_columns(recorded: run.recorded.to_h.transform_values { |value| whole?(value) ? value["value"] : value })
+    end
+  end
+
+  private
+
+  def whole?(value)
+    value.is_a?(Hash) && value.key?("value") && (value.keys - %w[value completed_at]).empty?
+  end
+end

data/lib/easy_flow/engine.rb

@@ -24,6 +24,10 @@ module EasyFlow
         EasyFlow::Condition.register
         EasyFlow::Switch.register
         EasyFlow::Compare.register
+        EasyFlow::CompareTwoValues.register
+        EasyFlow::AllOrAny.register
+        EasyFlow::Count.register
+        EasyFlow::Wait.register
         EasyFlow::FlowStep.register
 
         EasyFlow.check(:unrouted_value)

data/lib/easy_flow/version.rb

@@ -1,3 +1,3 @@
 module EasyFlow
-  VERSION = "0.16.0"
+  VERSION = "0.18.0"
 end