stepper_motor 0.1.7 → 0.1.8

data/sig/stepper_motor.rbs

@@ -1,4 +1,407 @@
+# StepperMotor is a module for building multi-step flows where steps are sequential and only
+# ever progress forward. The building block of StepperMotor is StepperMotor::Journey
 module StepperMotor
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end
+  VERSION: untyped
+
+  class Error < StandardError
+  end
+
+  class JourneyNotPersisted < StepperMotor::Error
+  end
+
+  class StepConfigurationError < ArgumentError
+  end
+
+  # Describes a step in a journey. These objects get stored inside the `step_definitions`
+  # array of the Journey subclass. When the step gets performed, the block passed to the
+  # constructor will be instance_exec'd with the Journey model being the context
+  class Step
+    # sord omit - no YARD type given for "seq:", using untyped
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    # Creates a new step definition
+    # 
+    # _@param_ `name` — the name of the Step
+    # 
+    # _@param_ `wait` — the amount of time to wait before entering the step
+    # 
+    # _@param_ `on_exception` — the action to take if an exception occurs when performing the step. The possible values are: * `:cancel!` - cancels the Journey and re-raises the exception. The Journey will be persisted before re-raising. * `:reattempt!` - reattempts the Journey and re-raises the exception. The Journey will be persisted before re-raising.
+    def initialize: (
+                      name: (String | Symbol),
+                      seq: untyped,
+                      on_exception: Symbol,
+                      ?wait: (Numeric | ActiveSupport::Duration)
+                    ) -> void
+
+    # Performs the step on the passed Journey, wrapping the step with the required context.
+    # 
+    # _@param_ `journey` — the journey to perform the step in. If a `step_block` is passed in, it is going to be executed in the context of the journey using `instance_exec`. If only the name of the step has been provided, an accordingly named public method on the journey will be called
+    # 
+    # _@return_ — void
+    def perform_in_context_of: (StepperMotor::Journey journey) -> untyped
+
+    # _@return_ — the name of the step or method to call on the Journey
+    attr_reader name: String
+
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    # _@return_ — how long to wait before performing the step
+    attr_reader wait: (Numeric | ActiveSupport::Duration)
+
+    # sord omit - no YARD type given for :seq, using untyped
+    attr_reader seq: untyped
+
+    class MissingDefinition < NoMethodError
+    end
+  end
+
+  # A Journey is the main building block of StepperMotor. You create a journey to guide a particular model
+  # ("hero") through a sequence of steps. Any of your model can be the hero and have multiple Journeys. To create
+  # your own Journey, subclass the `StepperMotor::Journey` class and define your steps. For example, a drip mail
+  # campaign can look like this:
+  # 
+  # 
+  #     class ResubscribeCampaign < StepperMotor::Journey
+  #       step do
+  #         ReinviteMailer.with(recipient: hero).deliver_later
+  #       end
+  # 
+  #       step wait: 3.days do
+  #         cancel! if hero.active?
+  #         ReinviteMailer.with(recipient: hero).deliver_later
+  #       end
+  # 
+  #       step wait: 3.days do
+  #         cancel! if hero.active?
+  #         ReinviteMailer.with(recipient: hero).deliver_later
+  #       end
+  # 
+  #       step wait: 3.days do
+  #         cancel! if hero.active?
+  #         hero.close_account!
+  #       end
+  #     end
+  # 
+  # Creating a record for the Journey (just using `create!`) will instantly send your hero on their way:
+  # 
+  #     ResubscribeCampaign.create!(hero: current_account)
+  # 
+  # To stop the journey forcibly, delete it from your database - or call `cancel!` within any of the steps.
+  class Journey < ActiveRecord::Base
+    include StepperMotor::Journey::FlowControl
+    include StepperMotor::Journey::Recovery
+    STATES: untyped
+
+    # sord omit - no YARD return type given, using untyped
+    # Alias for the class attribute, for brevity
+    # 
+    # _@see_ `Journey.step_definitions`
+    def step_definitions: () -> untyped
+
+    # sord duck - #to_f looks like a duck type, replacing with untyped
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    # sord duck - #to_f looks like a duck type, replacing with untyped
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    # Defines a step in the journey.
+    # Steps are stacked top to bottom and get performed in sequence.
+    # 
+    # _@param_ `name` — the name of the step. If none is provided, a name will be automatically generated based on the position of the step in the list of `step_definitions`. The name can also be used to call a method on the `Journey` instead of calling the provided block.
+    # 
+    # _@param_ `wait` — the amount of time this step should wait before getting performed. When the journey gets scheduled, the triggering job is going to be delayed by this amount of time, and the `next_step_to_be_performed_at` attribute will be set to the current time plus the wait duration. Mutually exclusive with `after:`
+    # 
+    # _@param_ `after` — the amount of time this step should wait before getting performed including all the previous waits. This allows you to set the wait time based on the time after the journey started, as opposed to when the previous step has completed. When the journey gets scheduled, the triggering job is going to be delayed by this amount of time _minus the `wait` values of the preceding steps, and the `next_step_to_be_performed_at` attribute will be set to the current time. The `after` value gets converted into the `wait` value and passed to the step definition. Mutually exclusive with `wait:`
+    # 
+    # _@param_ `on_exception` — See {StepperMotor::Step#on_exception}
+    # 
+    # _@param_ `additional_step_definition_options` — Any remaining options get passed to `StepperMotor::Step.new` as keyword arguments.
+    # 
+    # _@return_ — the step definition that has been created
+    def self.step: (
+                     ?String? name,
+                     ?wait: (Float | untyped | ActiveSupport::Duration)?,
+                     ?after: (Float | untyped | ActiveSupport::Duration)?,
+                     ?on_exception: Symbol,
+                     **untyped additional_step_definition_options
+                   ) -> StepperMotor::Step
+
+    # sord warn - "StepperMotor::Step?" does not appear to be a type
+    # Returns the `Step` object for a named step. This is used when performing a step, but can also
+    # be useful in other contexts.
+    # 
+    # _@param_ `by_step_name` — the name of the step to find
+    def self.lookup_step_definition: ((Symbol | String) by_step_name) -> SORD_ERROR_StepperMotorStep
+
+    # sord omit - no YARD type given for "by_step_name", using untyped
+    # sord omit - no YARD return type given, using untyped
+    # Alias for the class method, for brevity
+    # 
+    # _@see_ `Journey.lookup_step_definition`
+    def lookup_step_definition: (untyped by_step_name) -> untyped
+
+    # Performs the next step in the journey. Will check whether any other process has performed the step already
+    # and whether the record is unchanged, and will then lock it and set the state to 'performimg'.
+    # 
+    # After setting the state, it will determine the next step to perform, and perform it. Depending on the outcome of
+    # the step another `PerformStepJob` may get enqueued. If the journey ends here, the journey record will set its state
+    # to 'finished'.
+    # 
+    # _@param_ `idempotency_key` — If provided, the step will only be performed if the idempotency key matches the current idempotency key. This ensures that the only the triggering job that was scheduled for this step can trigger the step and not any other.
+    def perform_next_step!: (?idempotency_key: String?) -> void
+
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    def time_remaining_until_final_step: () -> ActiveSupport::Duration
+
+    # sord omit - no YARD type given for "next_step_definition", using untyped
+    # sord omit - no YARD type given for "wait:", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def set_next_step_and_enqueue: (untyped next_step_definition, ?wait: untyped) -> untyped
+
+    # sord omit - no YARD return type given, using untyped
+    def logger: () -> untyped
+
+    # sord omit - no YARD type given for "step_name", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def after_locking_for_step: (untyped step_name) -> untyped
+
+    # sord omit - no YARD type given for "step_name", using untyped
+    # sord omit - no YARD type given for "exception", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def after_performing_step_with_exception: (untyped step_name, untyped exception) -> untyped
+
+    # sord omit - no YARD type given for "step_name", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def before_step_starts: (untyped step_name) -> untyped
+
+    # sord omit - no YARD type given for "step_name", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def after_performing_step_without_exception: (untyped step_name) -> untyped
+
+    # sord omit - no YARD return type given, using untyped
+    def schedule!: () -> untyped
+
+    # sord omit - no YARD return type given, using untyped
+    def recover!: () -> untyped
+
+    # Is a convenient way to end a hero's journey. Imagine you enter a step where you are inviting a user
+    # to rejoin the platform, and are just about to send them an email - but they have already joined. You
+    # can therefore cancel their journey. Canceling bails you out of the `step`-defined block and sets the journey record to the `canceled` state.
+    # 
+    # Calling `cancel!` within a step will abort the execution of the current step.
+    # 
+    # _@return_ — void
+    def cancel!: () -> untyped
+
+    # sord omit - no YARD type given for "wait:", using untyped
+    # Inside a step it is possible to ask StepperMotor to retry to start the step at a later point in time. Maybe now is an inconvenient moment
+    # (are you about to send a push notification at 3AM perhaps?). The `wait:` parameter specifies how long to defer reattempting the step for.
+    # Reattempting will resume the step from the beginning, so the step should be idempotent.
+    # 
+    # `reattempt!` may only be called within a step.
+    # 
+    # _@return_ — void
+    def reattempt!: (?wait: untyped) -> untyped
+
+    # Is used to pause a Journey at any point. The "paused" state is similar to the "ready" state, except that "perform_next_step!" on the
+    # journey will do nothing - even if it is scheduled to be performed. Pausing a Journey can be useful in the following situations:
+    # 
+    # * The hero of the journey is in a compliance procedure, and their Journeys should not continue
+    # * The external resource a Journey will be calling is not available
+    # * There is a bug in the Journey implementation and you need some time to get it fixed without canceling or recreating existing Journeys
+    # 
+    # Calling `pause!` within a step will abort the execution of the current step.
+    # 
+    # _@return_ — void
+    def pause!: () -> untyped
+
+    # Is used to resume a paused Journey. It places the Journey into the `ready` state and schedules the job to perform that step.
+    # 
+    # Calling `resume!` is only permitted outside of a step
+    # 
+    # _@return_ — void
+    def resume!: () -> untyped
+
+    module Recovery
+      extend ActiveSupport::Concern
+
+      # sord omit - no YARD return type given, using untyped
+      def recover!: () -> untyped
+    end
+
+    module FlowControl
+      # Is a convenient way to end a hero's journey. Imagine you enter a step where you are inviting a user
+      # to rejoin the platform, and are just about to send them an email - but they have already joined. You
+      # can therefore cancel their journey. Canceling bails you out of the `step`-defined block and sets the journey record to the `canceled` state.
+      # 
+      # Calling `cancel!` within a step will abort the execution of the current step.
+      # 
+      # _@return_ — void
+      def cancel!: () -> untyped
+
+      # sord omit - no YARD type given for "wait:", using untyped
+      # Inside a step it is possible to ask StepperMotor to retry to start the step at a later point in time. Maybe now is an inconvenient moment
+      # (are you about to send a push notification at 3AM perhaps?). The `wait:` parameter specifies how long to defer reattempting the step for.
+      # Reattempting will resume the step from the beginning, so the step should be idempotent.
+      # 
+      # `reattempt!` may only be called within a step.
+      # 
+      # _@return_ — void
+      def reattempt!: (?wait: untyped) -> untyped
+
+      # Is used to pause a Journey at any point. The "paused" state is similar to the "ready" state, except that "perform_next_step!" on the
+      # journey will do nothing - even if it is scheduled to be performed. Pausing a Journey can be useful in the following situations:
+      # 
+      # * The hero of the journey is in a compliance procedure, and their Journeys should not continue
+      # * The external resource a Journey will be calling is not available
+      # * There is a bug in the Journey implementation and you need some time to get it fixed without canceling or recreating existing Journeys
+      # 
+      # Calling `pause!` within a step will abort the execution of the current step.
+      # 
+      # _@return_ — void
+      def pause!: () -> untyped
+
+      # Is used to resume a paused Journey. It places the Journey into the `ready` state and schedules the job to perform that step.
+      # 
+      # Calling `resume!` is only permitted outside of a step
+      # 
+      # _@return_ — void
+      def resume!: () -> untyped
+    end
+  end
+
+  class Railtie < Rails::Railtie
+  end
+
+  module TestHelper
+    # Allows running a given Journey to completion, skipping across the waiting periods.
+    # This is useful to evaluate all side effects of a Journey. The helper will ensure
+    # that the number of steps performed is equal to the number of steps defined - this way
+    # it will not enter into an endless loop. If, after completing all the steps, the journey
+    # has neither canceled nor finished, an exception will be raised.
+    # 
+    # _@param_ `journey` — the journey to speedrun
+    # 
+    # _@return_ — void
+    def speedrun_journey: (StepperMotor::Journey journey) -> untyped
+
+    # Performs the named step of the journey without waiting for the time to perform the step.
+    # 
+    # _@param_ `journey` — the journey to speedrun
+    # 
+    # _@param_ `step_name` — the name of the step to run
+    # 
+    # _@return_ — void
+    def immediately_perform_single_step: (StepperMotor::Journey journey, Symbol step_name) -> untyped
+  end
+
+  # The generator is used to install StepperMotor. It adds an example Journey, a configing
+  # initializer and the migration that creates tables.
+  # Run it with `bin/rails g stepper_motor:install` in your console.
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+    UUID_MESSAGE: untyped
+
+    # sord omit - no YARD return type given, using untyped
+    # Generates monolithic migration file that contains all database changes.
+    def create_migration_file: () -> untyped
+
+    # sord omit - no YARD return type given, using untyped
+    def create_initializer: () -> untyped
+
+    def uuid_fk?: () -> bool
+
+    # sord omit - no YARD return type given, using untyped
+    def migration_version: () -> untyped
+  end
+
+  # The cyclic scheduler is designed to be run regularly via a cron job. On every
+  # cycle, it is going to look for Journeys which are going to come up for step execution
+  # before the next cycle is supposed to run. Then it is going to enqueue jobs to perform
+  # steps on those journeys. Since the scheduler gets run at a discrete interval, but we
+  # still them to be processed on time, if we only picked up the journeys which have the
+  # step execution time set to now or earlier, we will always have delays. This is why
+  # this scheduler enqueues jobs for journeys whose time to run is between now and the
+  # next cycle.
+  # 
+  # Once the job gets created, it then gets enqueued and gets picked up by the ActiveJob
+  # worker normally. If you are using SQS, which has a limit of 900 seconds for the `wait:`
+  # value, you need to run the scheduler at least (!) every 900 seconds, and preferably
+  # more frequently (for example, once every 5 minutes). This scheduler is also going to be
+  # more gentle with ActiveJob adapters that may get slower with large queue depths, such as
+  # good_job. This scheduler is a good fit if you are using an ActiveJob adapter which:
+  # 
+  # * Does not allow easy introspection of jobs in the future (like Redis-based queues)
+  # * Limits the value of the `wait:` parameter
+  # 
+  # The scheduler needs to be configured in your cron table.
+  class CyclicScheduler < StepperMotor::ForwardScheduler
+    # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
+    # Creates a new scheduler. The scheduler needs to know how frequently it is going to be running -
+    # you define that frequency when you configure your cron job that calls `run_scheduling_cycle`. Journeys which
+    # have to perform their steps between the runs of the cycles will generate jobs. The more frequent the scheduling
+    # cycle, the fewer jobs are going to be created per cycle.
+    # 
+    # _@param_ `cycle_duration` — how frequently the scheduler runs
+    def initialize: (cycle_duration: ActiveSupport::Duration) -> void
+
+    # Run a scheduling cycle. This should be called from your ActiveJob that runs on a regular Cron cadence. Ideally you
+    # would call the instance of the scheduler configured for the whole StepperMotor (so that the `cycle_duration` gets
+    # correctly applied, as it is necessary to pick the journeys to step). Normally, you would do this:
+    def run_scheduling_cycle: () -> void
+
+    # sord omit - no YARD type given for "journey", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def schedule: (untyped journey) -> untyped
+
+    class RunSchedulingCycleJob < ActiveJob::Base
+      # sord omit - no YARD return type given, using untyped
+      def perform: () -> untyped
+    end
+  end
+
+  class PerformStepJob < ActiveJob::Base
+    # sord omit - no YARD type given for "journey_gid", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def perform: (untyped journey_gid) -> untyped
+  end
+
+  # The forward scheduler enqueues a job for every Journey that
+  # gets sent to the `#schedule`. The job is then stored in the queue
+  # and gets picked up by the ActiveJob worker normally. This is the simplest
+  # option if your ActiveJob adapter supports far-ahead scheduling. Some adapters,
+  # such as SQS, have limitations regarding the maximum delay after which a message
+  # will become visible. For SQS, the limit is 900 seconds. If the job is further in the future,
+  # it is likely going to fail to get enqueued. If you are working with a queue adapter that:
+  # 
+  # * Does not allow easy introspection of jobs in the future (like Redis-based queues)
+  # * Limits the value of the `wait:` parameter
+  # 
+  # this scheduler may not be a good fit for you, and you will need to use the {CyclicScheduler} instead.
+  # Note that this scheduler is also likely to populate your queue with a high number of "far out"
+  # jobs to be performed in the future. Different ActiveJob adapters are known to have varying
+  # performance depending on the number of jobs in the queue. For example, good_job is known to
+  # struggle a bit if the queue contains a large number of jobs (even if those jobs are not yet
+  # scheduled to be performed). For good_job the {CyclicScheduler} is also likely to be a better option.
+  class ForwardScheduler
+    # sord omit - no YARD type given for "journey", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def schedule: (untyped journey) -> untyped
+  end
+
+  class PerformStepJobV2 < ActiveJob::Base
+    # sord omit - no YARD type given for "journey_id:", using untyped
+    # sord omit - no YARD type given for "journey_class_name:", using untyped
+    # sord omit - no YARD type given for "idempotency_key:", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def perform: (journey_id: untyped, journey_class_name: untyped, ?idempotency_key: untyped) -> untyped
+  end
+
+  # The purpose of this job is to find journeys which have, for whatever reason, remained in the
+  # `performing` state for far longer than the journey is supposed to. At the moment it assumes
+  # any journey that stayed in `performing` for longer than 1 hour has hung. Add this job to your
+  # cron table and perform it regularly.
+  class RecoverStuckJourneysJobV1 < ActiveJob::Base
+    DEFAULT_STUCK_FOR: untyped
+
+    # sord omit - no YARD type given for "stuck_for:", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def perform: (?stuck_for: untyped) -> untyped
+  end
+end

data/stepper_motor.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "lib/stepper_motor/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "stepper_motor"
+  spec.version = StepperMotor::VERSION
+  spec.authors = ["Julik Tarkhanov"]
+  spec.email = ["me@julik.nl"]
+  spec.license = "LGPL"
+
+  spec.summary = "Effortless step workflows that embed nicely inside Rails"
+  spec.description = "Step workflows for Rails/ActiveRecord"
+  spec.homepage = "https://steppermotor.dev"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/stepper-motor/stepper_motor"
+  spec.metadata["changelog_uri"] = "https://github.com/stepper-motor/stepper_motor/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      File.basename(f).start_with?(".")
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 7"
+  spec.add_dependency "activejob"
+  spec.add_dependency "railties"
+  spec.add_dependency "globalid"
+
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rails", "~> 7.0"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "standard"
+  spec.add_development_dependency "magic_frozen_string_literal"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "redcarpet" # needed for the yard gem to enable Github Flavored Markdown
+  spec.add_development_dependency "sord"
+end

data/test/dummy/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1 @@
+/* Application styles */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ApplicationController < ActionController::Base
+  # Only allow modern browsers supporting webp images, web push, badges, import maps, CSS nesting, and CSS :has.
+  allow_browser versions: :modern
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ApplicationHelper
+end

data/test/dummy/app/jobs/application_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/test/dummy/app/mailers/application_mailer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/test/dummy/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= content_for(:title) || "Dummy" %></title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="mobile-web-app-capable" content="yes">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= yield :head %>
+
+    <%# Enable PWA manifest for installable apps (make sure to enable in config/routes.rb too!) %>
+    <%#= tag.link rel: "manifest", href: pwa_manifest_path(format: :json) %>
+
+    <link rel="icon" href="/icon.png" type="image/png">
+    <link rel="icon" href="/icon.svg" type="image/svg+xml">
+    <link rel="apple-touch-icon" href="/icon.png">
+
+    <%# Includes all stylesheet files in app/assets/stylesheets %>
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/test/dummy/app/views/layouts/mailer.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/test/dummy/app/views/layouts/mailer.text.erb

@@ -0,0 +1 @@
+<%= yield %>

data/test/dummy/app/views/pwa/manifest.json.erb

@@ -0,0 +1,22 @@
+{
+  "name": "Dummy",
+  "icons": [
+    {
+      "src": "/icon.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    },
+    {
+      "src": "/icon.png",
+      "type": "image/png",
+      "sizes": "512x512",
+      "purpose": "maskable"
+    }
+  ],
+  "start_url": "/",
+  "display": "standalone",
+  "scope": "/",
+  "description": "Dummy.",
+  "theme_color": "red",
+  "background_color": "red"
+}

data/test/dummy/app/views/pwa/service-worker.js

@@ -0,0 +1,26 @@
+// Add a service worker for processing Web Push notifications:
+//
+// self.addEventListener("push", async (event) => {
+//   const { title, options } = await event.data.json()
+//   event.waitUntil(self.registration.showNotification(title, options))
+// })
+//
+// self.addEventListener("notificationclick", function(event) {
+//   event.notification.close()
+//   event.waitUntil(
+//     clients.matchAll({ type: "window" }).then((clientList) => {
+//       for (let i = 0; i < clientList.length; i++) {
+//         let client = clientList[i]
+//         let clientPath = (new URL(client.url)).pathname
+//
+//         if (clientPath == event.notification.data.path && "focus" in client) {
+//           return client.focus()
+//         }
+//       }
+//
+//       if (clients.openWindow) {
+//         return clients.openWindow(event.notification.data.path)
+//       }
+//     })
+//   )
+// })

data/test/dummy/bin/dev

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+exec "./bin/rails", "server", *ARGV

data/test/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/test/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/test/dummy/bin/setup

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  unless ARGV.include?("--skip-server")
+    puts "\n== Starting development server =="
+    $stdout.flush # flush the output before exec(2) so that it displays
+    exec "bin/dev"
+  end
+end