wizard_steps 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8439cdcbed27763997d550c7f93720ce6af9e4d14e727f12f459e9363db8ffa2
+  data.tar.gz: 06ad68edfc684da3713bdb534a891400fd42958acd429ff1b038cab8f566ccac
+SHA512:
+  metadata.gz: 012110dd09c32f3c6f50e1b9bb1dcfbe9900435d96e5d374e94cc91e2ee007356b8a045a3cce4054143730bbce8e1838de24828f25ca63118a9f8c1ce0a3f255
+  data.tar.gz: c77b7ca3de33d643d4213bcb0b5afbd5be30672bd7244a26cca3b7cbb76baa0b6777b211d1fb31330930b463b68a7ef66bbb749e7e17b579c0be1b9ab2c60d8a

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+## 0.1.0 (10-Feb-21)
+* Initial release

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in wizard_steps.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem 'activesupport', '~> 6.1', '>= 6.1.2.1'
+gem 'activemodel', '~> 6.1', '>= 6.1.2.1'

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    wizard_steps (0.1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.2.1)
+      activesupport (= 6.1.2.1)
+    activesupport (6.1.2.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    i18n (1.8.8)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.3)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 6.1, >= 6.1.2.1)
+  activesupport (~> 6.1, >= 6.1.2.1)
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  wizard_steps!
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,427 @@
+# WizardSteps
+
+TODO: describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wizard_steps'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install wizard_steps
+
+## Usage
+
+Firstly, there is a pre-requisite of knowing what a multi-step form is if you don't already. A great resource is [this railscast](http://railscasts.com/episodes/217-multistep-forms).
+
+The gem is fits a typical MVC style (model-view-controller)
+
+## Model
+
+List your steps in a wizard.rb file, located at the base of your multi-step folder. Take the following file structure below as an example for a module to create a user:
+
+```
+|models
+|__user_creation
+|  |__steps
+|  |  |__name.rb
+|  |  |__date_of_birth.rb
+|  |  |__gender.rb
+|  |  |__review_answers.rb
+|  |__wizard.rb  <--- list your steps here
+|__user.rb
+```
+For the above example with a User class in user.rb, a user_creation folder with four steps, lets have a look at what the wizard.rb would look like:
+
+```
+# app/models/user_creation/wizard.rb
+
+module UserCreation
+  class Wizard < WizardSteps::Base
+    self.steps = [
+      Steps::Name,
+      Steps::DateOfBirth,
+      Steps::Gender,
+      Steps::ReviewAnswers
+    ].freeze
+
+  private
+
+    def do_complete
+      User.create!(
+        first_name: @store.data["first_name"],
+        last_name: @store.data["last_name"],
+        date_of_birth: @store.data["date_of_birth"],
+        gender: @store.data["gender"],
+      )
+    end
+  end
+end
+```
+
+You create a module to wrap the multi step form. Inside this module, create a new wizard which derives from WizardSteps::Base, and register the steps you plan on using in the correct order.
+
+The private method, `do_complete`, is what will be called **when the last step has been submitted**, in this example we are creating a User instance in the database. Note how `@store.data` is accessed.
+
+In this example, our multi step form is for the User model, so we require various attributes in each step, such as Name, Date Of Birth and Gender, store them, review the answers, and if all is good, we submit.
+
+Wait, but what does each step look like? Similarly to the above, it follows a modular pattern. Take the below as an example.
+
+```
+# app/models/user_creation/steps/name.rb
+
+module UserCreation
+  module Steps
+    class Name < WizardSteps::Step
+
+      attribute :first_name, :string
+      attribute :last_name, :string
+
+      validates :first_name, :last_name, presence: true
+
+      def reviewable_answers
+        {
+          "name" => "#{first_name} #{last_name}"
+        }
+      end
+    end
+  end
+end
+```
+The step name (`Name`) inherits from `WizardSteps::Step` which includes ActiveModel, so we can define and validate attributes in each class. The `reviewable_answers` method defines a hash that will be passed to the review_answers view.
+
+### Date attribute
+
+As the steps are ActiveModels, we need to include `ActiveRecord::AttributeAssignment` to simplify processing Rails date fields:
+
+```
+# models/user_creation/steps/date_of_birth.rb
+
+module UserCreation
+  module Steps
+    class DateOfBirth < ::Wizard::Step
+      include ActiveRecord::AttributeAssignment
+
+      attribute :date_of_birth, :date
+
+      validates :date_of_birth, presence: true
+
+      def reviewable_answers
+        {
+          "date_of_birth" => date_of_birth,
+        }
+      end
+    end
+  end
+end
+
+# views/user_creation/steps/_date_of_birth.html.erb
+
+<%= form_for current_step, url: step_path do |f| %>
+    <%= f.date_field, :date_of_birth %>
+<% end %>
+```
+## Review Answers
+
+Your review_answers will look like this:
+
+```
+# models/user_creation/steps/review_answers.rb
+
+module UserCreation
+  module Steps
+    class ReviewAnswers < WizardSteps::Step
+      def answers_by_step
+        @answers_by_step ||= @wizard.reviewable_answers_by_step
+      end
+    end
+  end
+end
+
+# views/user_creation/steps/_review_answers.html.erb
+
+<% f.object.answers_by_step.each do |step, answers| %>
+    <% answers.each do |answer| %>
+    # you have `step.key`, `answer.first`, `answer.last`
+    # and you can link back to a `(step)`
+    <% end %>
+<% end %>
+```
+
+## Lets move onto the controller.
+
+Your controller layout should follow:
+
+```
+|controllers
+|__user_creation
+|  |__steps_controller.rb
+```
+
+Yep, its that simple. And in the controller:
+
+```
+# app/controllers/user_creation/steps_controller.rb
+
+module UserCreation
+  class StepsController < ApplicationController
+    include WizardSteps
+    self.wizard_class = UserCreation::Wizard
+
+  private
+
+    def step_path(step = params[:id])
+      user_creation_step_path(step)
+    end
+
+    def wizard_store_key
+      :user_creation
+    end
+
+    def on_complete(user)
+      redirect_to(<your custom route>)
+    end
+  end
+end
+```
+
+Inside the module for your steps, you can see it follows a general controller layout deriving from ApplicationController.
+
+And the views;
+
+```
+|views
+|__user_creation
+|  |__steps
+|     |__ _form.html.erb
+|     |__ _name.html.erb
+|     |__ _date_of_birth.html.erb
+|     |__ _gender.html.erb
+|     |__ _review_answers.html.erb
+|     |__show.html.erb
+```
+
+```
+# app/views/user_creation/_name.html.erb
+
+<%= f.govuk_fieldset legend: { text: "Name" } do %>
+  <%= f.govuk_text_field :first_name, label: { text: 'First name' } %>
+  <%= f.govuk_text_field :last_name, label: { text: 'Last name' } %>
+<% end %>
+```
+
+```
+# app/views/user_creation/show.html.erb
+
+<%= render "form", current_step: current_step, wizard: wizard %>
+```
+The form partial can check for `wizard.previous_key` as a conditional for a back button, and `wizard.can_proceed?` for a continue/submit button.
+The other key lines are:
+```
+<%= form_for current_step, url: step_path do |f| %>
+    <%= render current_step.key, current_step: current_step, f: f %>
+<% end >
+```
+As an example:
+
+```
+# app/views/user_creation/steps/_form.html.erb
+
+<% if wizard.previous_key %>
+  <% content_for(:back_button) do %>
+  <%= back_link step_path(wizard.previous_key) %>
+  <% end %>
+<% end %>
+
+<div class="govuk-grid-row">
+  <div class="govuk-grid-column-two-thirds">
+    <%= form_for current_step, url: step_path do |f| %>
+      <%= f.govuk_error_summary %>
+
+      <%= render current_step.key, current_step: current_step, f: f %>
+
+      <% if wizard.can_proceed? %>
+        <%= f.govuk_submit("Continue") %>
+      <% end %>
+    <% end %>
+  </div>
+</div>
+```
+
+
+And finally, in your routes
+
+```
+namespace :children_creation do
+  resources :steps, only: %i[show update]
+end
+```
+
+## Context
+
+It is possible to include a `context` where a stepped model belongs_to another model, in order to pass the latter id (foreign_key) to the stepped model. As an example we have a DiaryEntry which belongs to a Placement:
+```
+# app/models/diary_entry.rb
+
+class DiaryEntry < ApplicationRecord
+  belongs_to :placement, optional: false, inverse_of: :diary_entries
+
+  validates :event, presence: true
+  validates :note, presence: true
+end
+
+# app/models/placement.rb
+
+class Placement < ApplicationRecord
+  has_many :diary_entries, inverse_of: :placement
+  ...
+end
+```
+
+The model structure follows:
+```
+|models
+|__diary
+|  |__steps
+|  |  |__note.rb
+|  |  |__event.rb
+|  |  |__review_answers.rb
+|  |__wizard.rb  <--- list your steps here
+|__diary_entry.rb
+|__placement.rb
+```
+
+In the controller we have a `placement_id` in `step_path` and `wizard_context`:
+```
+# app/controllers/diary/steps_controller.rb
+
+module Diary
+  class StepsController < ApplicationController
+    include WizardSteps
+    self.wizard_class = Diary::Wizard
+
+  private
+
+    def step_path(step = params[:id])
+      placement_diary_step_path(placement_id: params[:placement_id], id: step)
+    end
+
+    def wizard_store_key
+      :diary
+    end
+
+    def wizard_context
+      {
+        "placement_id" => params[:placement_id],
+      }
+    end
+
+    def set_page_title
+      @page_title = "#{@current_step.title.downcase} step"
+    end
+  end
+end
+```
+
+In our routes:
+```
+resources :placements, only: :create do
+    resources :diary_entries,
+              only: %i[index show] do
+    end
+    namespace :diary do
+      resources :steps,
+                only: %i[index show update] do
+        collection do
+          get :completed
+        end
+      end
+    end
+  end
+```
+
+The placement_id is now available in `@context["placement_id"]` in wizard.rb
+```
+# app/models/diary/wizard.rb
+
+module Diary
+  class Wizard < ::Wizard::Base
+    self.steps = [
+      Steps::SelectEvent,
+      Steps::Note,
+      Steps::ReviewAnswers,
+    ].freeze
+
+  private
+
+    def do_complete
+      DiaryEntry.create!(
+        placement_id: @context["placement_id"],
+        event: @store.data["event"],
+        note: @store.data["entry"],
+      )
+    end
+  end
+end
+```
+
+## Skipping Steps
+
+The order of the steps are linear however it is possible to create a branching flow by conditionally skipping any number of steps. Steps have a default `skipped?` status of false. This can be altered by defining `skipped?` in the individual step on some condition, ususally dependent on the contents of the `@store` hash derived from previous steps, e.g.
+```
+def skipped?
+  result = @store["some condition here is true"]
+
+  result
+end
+```
+
+A step with a `skipped?` status of true will not be shown in the form flow. In this manner it is possible to build quite complex branching forms, although the conditional logic can become convoluted!
+
+## Accessing the store data
+
+The `store` is a reflection of part of the session data, and can be accessed by placing a `<% byebug %>` in any step view. The session key is set from the `wizard_store_key` defined in relevent `steps_controller.rb`, e.g.
+```
+#app/controllers/children_creation/steps_controller.rb
+
+module ChildrenCreation
+  class StepsController < ApplicationController
+    include WizardSteps
+    self.wizard_class = ChildrenCreation::Wizard
+
+  private
+
+    def step_path(step = params[:id])
+      children_creation_step_path(step)
+    end
+
+    def wizard_store_key
+      :children_creation # KEY DEFINED HERE
+    end
+
+    def on_complete(child)
+      redirect_to(new_child_placement_need_path(child.id))
+    end
+  end
+end
+```
+
+With `byebug` activated in a step view, in the console all data collected up to that view will be available:
+
+```
+(byebug) session[:children_creation]
+{"first_name"=>"joe", "last_name"=>"bloggs", "date_of_birth"=>"2000-01-01"}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/goodviber/wizard_steps.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wizard_steps"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/wizard_steps/base.rb

@@ -0,0 +1,131 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module'
+
+module WizardSteps
+  class UnknownStep < RuntimeError; end
+
+  class Base
+    extend ActiveSupport::Concern
+    class_attribute :steps
+
+    class << self
+      def indexed_steps
+        @indexed_steps ||= steps.index_by(&:key)
+      end
+
+      def step(key)
+        indexed_steps[key] || raise(UnknownStep)
+      end
+
+      def key_index(key)
+        steps.index step(key)
+      end
+
+      def step_keys
+        indexed_steps.keys
+      end
+
+      def first_key
+        step_keys.first
+      end
+    end
+
+    delegate :step, :key_index, :indexed_steps, :step_keys, to: :class
+    delegate :can_proceed?, to: :find_current_step
+    attr_reader :current_key
+
+    def initialize(store, current_key, context: {})
+      raise(UnknownStep) unless step_keys.include?(current_key)
+
+      @store = store
+      @context = context
+      @current_key = current_key
+    end
+
+    def find(key)
+      step(key).new self, @store
+    end
+
+    def find_current_step
+      find current_key
+    end
+
+    def previous_key(key = current_key)
+      earlier_keys(key).reverse.find do |k|
+        !find(k).skipped?
+      end
+    end
+
+    def next_key(key = current_key)
+      later_keys(key).find do |k|
+        !find(k).skipped?
+      end
+    end
+
+    def first_step?
+      previous_key.nil?
+    end
+
+    def last_step?
+      next_key.nil?
+    end
+
+    def valid?
+      active_steps.all?(&:valid?)
+    end
+
+    def complete?
+      last_step? && valid?
+    end
+
+    def complete!
+      return unless complete?
+
+      do_complete.tap do |result|
+        @store.purge!
+        yield(result) if block_given?
+      end
+    end
+
+    def invalid_steps
+      active_steps.select(&:invalid?)
+    end
+
+    def first_invalid_step
+      active_steps.find(&:invalid?)
+    end
+
+    def later_keys(key = current_key)
+      steps[(key_index(key) + 1)..].to_a.map(&:key)
+    end
+
+    def earlier_keys(key = current_key)
+      index = key_index(key)
+      return [] unless index.positive?
+
+      steps[0..(index - 1)].map(&:key)
+    end
+
+    def export_data
+      all_steps.map(&:export).reduce({}, :merge)
+    end
+
+    def reviewable_answers_by_step
+      all_steps.reject(&:skipped?).each_with_object({}) do |step, hash|
+        hash[step.class] = step.reviewable_answers
+      end
+    end
+
+  private
+
+    def all_steps
+      step_keys.map(&method(:find))
+    end
+
+    def active_steps
+      all_steps.reject(&:skipped?)
+    end
+
+    def do_complete; end
+  end
+end

data/lib/wizard_steps/step.rb

@@ -0,0 +1,70 @@
+module WizardSteps
+  class Step
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations::Callbacks
+
+    class << self
+      def key
+        name.split("::").last.underscore
+      end
+
+      def contains_personal_details?
+        false
+      end
+
+      def title
+        key.humanize
+      end
+    end
+
+    delegate :key, :contains_personal_details?, to: :class
+    alias_method :id, :key
+
+    def initialize(wizard, store, attributes = {}, *args)
+      @wizard = wizard
+      @store = store
+      super(*args)
+      assign_attributes attributes_from_store
+      assign_attributes attributes
+    end
+
+    def save!
+      return false unless valid?
+
+      persist_to_store
+    end
+
+    def can_proceed?
+      true
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    def skipped?
+      false
+    end
+
+    def export
+      return {} if skipped?
+
+      Hash[attributes.keys.zip([])].merge attributes_from_store
+    end
+
+    def reviewable_answers
+      attributes
+    end
+
+  private
+
+    def attributes_from_store
+      @store.fetch attributes.keys
+    end
+
+    def persist_to_store
+      @store.persist attributes
+    end
+  end
+end

data/lib/wizard_steps/store.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/module'
+
+module WizardSteps
+  class Store
+    attr_reader :data
+    delegate :keys, to: :data
+
+    def initialize(data)
+      raise InvalidBackingStore unless data.respond_to?(:[]=)
+
+      @data = data
+    end
+
+    def [](key)
+      data[key.to_s]
+    end
+
+    def []=(key, value)
+      data[key.to_s] = value
+    end
+
+    def fetch(*keys)
+      data.slice(*Array.wrap(keys).flatten.map(&:to_s)).stringify_keys
+    end
+
+    def persist(attributes)
+      data.merge! attributes.stringify_keys
+
+      true
+    end
+
+    def purge!
+      data.clear
+    end
+
+    def to_camelized_hash
+      data.transform_keys { |k| k.camelize(:lower).to_sym }
+    end
+
+    class InvalidBackingStore < RuntimeError; end
+  end
+end

data/lib/wizard_steps/version.rb

@@ -0,0 +1,3 @@
+module WizardSteps
+  VERSION = "0.1.3"
+end

data/lib/wizard_steps.rb

@@ -0,0 +1,86 @@
+require "active_support/concern"
+Dir[File.join(__dir__, "wizard_steps", "*.rb")].each { |file| require file }
+
+module WizardSteps
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :wizard_class
+    helper_method :wizard, :current_step, :step_path
+  end
+
+  def index
+    redirect_to step_path(wizard_class.first_key)
+  end
+
+  def show; end
+
+  def update
+    current_step.assign_attributes step_params
+
+    if current_step.save!
+      if wizard.complete?
+        wizard.complete! { |result| on_complete(result) }
+      else
+        redirect_to(next_step_path)
+      end
+    else
+      render :show
+    end
+  end
+
+  def completed; end
+
+private
+
+  def wizard
+    @wizard ||= wizard_class.new(wizard_store, params[:id], context: wizard_context)
+  end
+
+  def current_step
+    @current_step ||= wizard.find_current_step
+  end
+
+  def next_step_path
+    if (next_key = wizard.next_key)
+      step_path next_key
+    elsif (invalid_step = wizard.first_invalid_step)
+      step_path invalid_step
+    end
+  end
+
+  def step_path(step = params[:id])
+    raise(NotImplementedError)
+  end
+
+  def step_params
+    return {} unless params.key?(step_param_key)
+
+    params.require(step_param_key).permit current_step.attributes.keys
+  end
+
+  def step_param_key
+    current_step.class.model_name.param_key
+  end
+
+  def wizard_store
+    ::WizardSteps::Store.new(session_store)
+  end
+
+  def session_store
+    session[wizard_store_key] ||= {}
+  end
+
+  def wizard_context
+    {}
+  end
+
+  def wizard_store_key
+    raise(NotImplementedError)
+  end
+
+  def on_complete(_result)
+    redirect_to(action: :completed)
+  end
+end
+

data/wizard_steps.gemspec

@@ -0,0 +1,27 @@
+require_relative 'lib/wizard_steps/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wizard_steps"
+  spec.version       = WizardSteps::VERSION
+  spec.author        = "Max Mills"
+  spec.email         = ["8balldigitalsolutions@gmail.com"]
+
+  spec.summary       = %q{ A helper module to create multi-step forms typical of gov.uk forms }
+  spec.description   = %q{ See README for full description }
+  spec.homepage      = "https://github.com/goodviber/wizard_steps"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: wizard_steps
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Max Mills
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-03-17 00:00:00.000000000 Z
+dependencies: []
+description: " See README for full description "
+email:
+- 8balldigitalsolutions@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/wizard_steps.rb
+- lib/wizard_steps/base.rb
+- lib/wizard_steps/step.rb
+- lib/wizard_steps/store.rb
+- lib/wizard_steps/version.rb
+- wizard_steps.gemspec
+homepage: https://github.com/goodviber/wizard_steps
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/goodviber/wizard_steps
+  source_code_uri: https://github.com/goodviber/wizard_steps
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: A helper module to create multi-step forms typical of gov.uk forms
+test_files: []