multi_model_wizard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a50b7f01a93c84a15b78ce62f4b6f9269c44424f6d72b893c51145ad50cde5b0
+  data.tar.gz: d567b88c92d7b6fcf8d1e1dc45ab546a151c65d52ae3fb1bf62688cefae62f34
+SHA512:
+  metadata.gz: 40eed0735fade293059f9501b35b1567da14bd953f27acef37a370a0bccd8bae5c135c32774c80332359b04ad1038cca127739ed26b1a8e11fe79cf1637882ea
+  data.tar.gz: b7644a0d5f212951ce1019d838463cd1dbe852c506a7e2a85433ccfaef6e440279190286891fd25647af5680138cf53050fe42a270ff94bbe1d29fdc4b8345b8

data/.rspec

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

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-02-14
+
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"

data/README.md

@@ -0,0 +1,160 @@
+# MultiModelWizard
+
+MultiModelWizard is a way to create and update multiple ActiveRecord models using one form object. Creates a smart object for your wizards or forms. Create one form and form object that can update multiple models with ease.
+
+## Install
+
+Add this to your Gemfile
+```
+  $ gem install multi_model_wizard
+```
+
+Then run `bundle install` and you're ready to start
+
+## Use
+
+Initialize the gem by creating an initializer file and then configuring your settings:
+```
+  # config/initializers/multi_model_wizard.rb
+  #
+  MultiModelWizard.configure do |config|
+    config.store = { location: :redis, redis_instance: Redis.current }
+    config.form_key = 'custom_car_wizard'
+  end
+```
+The above code snippet is an example configuration. You only need to specify an initializer if you want to change the form key 
+or if you want to use Redis as the storage location.
+
+Note: If your form is going to be over 4kb then you will have to use Redis. Data larger than 4kb can not be stored in cookies (which is the default configuration).
+
+Create a new form object that inherits from the base class. Make sure to override the `form_steps`, `create`, and `update`.
+```
+  # form_objects/custom_vehicle_form.rb
+  #
+  class CustomVehicleForm < FormObject::Base
+    cattr_accessor :form_steps do
+      %i[
+        basic_configuration
+        body
+        engine
+        review
+      ].freeze
+    end
+
+    def create
+      created = false
+      begin
+          ActiveRecord::Base.transaction do
+          car = Car.new(attributes_for(Car))
+          car.parts = car_parts
+          car.save!
+          end
+          created = true
+      rescue StandardError => err
+          return created       
+      end
+      created
+    end
+
+    def update
+      updated = false
+      begin
+        ActiveRecord::Base.transaction do
+          car = Car.find(car_id)
+          car.attributes = attributes_for(Car)
+          car.parts = car_parts
+          car.save!
+        end
+        updated = true
+      rescue StandardError => err
+        return updated       
+      end
+      updated
+    end
+  end
+```
+
+Use form in your controller:
+
+```
+  # controllers/vehicle_wizard_controller.rb
+  #
+  def set_vehicle_form
+    @form ||= Wizards::FormObjects::CarForm.create_form do |form|
+                form.add_model Manufacturer
+                form.add_model Dealer
+                form.add_multiple_instance_model model: Part, instances: parts
+                form.add_dynamic_model prefix: 'vehicle', model: Vehicle
+                form.add_extra_attributes prefix: 'vehicle', attributes: %i[leather_origin], model: Vehicle
+              end
+  end
+
+  before_action :set_form_id
+
+  def set_form_id
+    @form_id = params[:vehicle_id]
+  end
+```
+
+Setting form_id will allow the gem to differ between a new wizard from (creating new data) and an existing form (editing existing models)
+Note: The `@form_id` should be set equal to whatever model id you are using in your form route.  
+
+You can now pass `@form` to your form views and start interacting with user input. The attributes of the form are the model attributes prefixed with the model name. Example:
+```
+  dealer = Dealer.new
+
+  dealer.name
+  # => nil
+
+  @form.dealer_name
+  # => nil
+```
+
+In the above example you might have `dealer_name` as an open text field in your form. That attribute would be mapped to the `Dealer` model and get validated using those validations.
+```
+  # views/vehicle_wizard/basic_configuration.rb
+  #
+  <%= form_for @form, url: my_wizard_path, method: :put do |f| %>
+    <%=  f.text_field :dealer_name  %>
+
+    <%= link_to 'Back', previous_wizard_path, class: 'btn btn-secondary' %>
+    <%= f.submit 'Next', value: 'Next: Configuration', class: 'btn btn-primary'%>
+  <% end %>
+```
+
+Models added with `add_multi_model_instance_model` are different. The form attribute to access these will be the pluralized version of the model name.
+```
+  @form.parts
+  #=> [{ name: nil, type: nil, size: nil}, { name: nil, type: nil, size: nil}]
+```
+
+These will also be mapped to the model and validated using its validators.
+
+`add_dynamic_model` models initialized with the dynamic attribute method will be referenced using whatever you set as the prefix and then the attribute name.
+```
+  @form.vehicle_type
+  #=> nil
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+### Content
+
+* Write articles
+* Recording screencasts
+* Submit presentations
+
+Pull requests are welcome! Feel free to submit bugs as well.
+
+1. Fork it! ( https://github.com/schneems/wicked/fork )
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Create a new Pull Request :D

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/form_object/base.rb

@@ -0,0 +1,497 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'multi_model_wizard/dynamic_validation'
+
+module FormObject
+  class AttributeNameError < StandardError; end
+  class Base
+    include MultiModelWizard::DynamicValidation
+    include ActiveModel::Model
+    include ActiveModel::AttributeAssignment
+
+    class << self
+      # Creates a new instance of the form object with all models and configuration
+      # @note This is how all forms should be instantiated
+      # @param block [Block] this yields to a block with an instance of its self
+      # @return form object [FormObjects::Base]
+      def create_form
+        instance = new
+        yield(instance)
+        instance.send(:init_attributes)
+        instance
+      end
+
+      # Needs to be overridden by child class.
+      # @note This method needs to be overridden with an array of symbols
+      # @return array [Array]
+      def form_steps
+        raise NotImplementedError
+      end
+    end
+
+    # These are the default atrributes for all form objects
+    ATTRIBUTES = %i[
+      current_step
+      new_form
+    ]
+
+    attr_reader :extra_attributes, :models, :dynamic_models, :multiple_instance_models
+
+    # WARNING: Light meta programming
+    # We will create an attr_accessor for all atributes
+    # @note This ATTRIBUTES can be overriden in child classes
+    ATTRIBUTES.each { |attribute| attr_accessor attribute }
+
+    alias new_form? new_form 
+
+    def initialize
+      @models = []
+      @dynamic_models = []
+      @multiple_instance_models = []
+      @extra_attributes = []
+      @new_form = true
+    end
+
+    # Checks if the form and its attributes are valid
+    # @note This method is here because the Wicked gem automagically runs this methdo to move to the next step
+    # @note This method needs return a boolean after attempting to create the records 
+    # @return boolean [Boolean]
+    def save
+      valid?
+    end
+
+    # Add a custom error message and makes the object invalid
+    #
+    def invalidate!(error_msg = nil)
+      errors.add(:associated_model, error_msg) unless error_msg.nil?
+      errors.add(:associated_model, 'could not be properly save')
+    end
+
+    # Boolean method returns if the object is on the first step or not
+    # @return boolean [Boolean]
+    def first_step?
+      return false if current_step.nil?
+      return true unless current_step.to_sym
+
+      form_steps.first == current_step.to_sym
+    end
+
+    # Gets all of the form objects present attributes and returns them in a hash
+    # @note This method will only return a key value pair for attributes that are not nil
+    # @note It ignores the models arrays, errors, etc. 
+    # @return hash [ActiveSupport::HashWithIndifferentAccess]
+    def attributes
+      hash = ActiveSupport::HashWithIndifferentAccess.new
+      instance_variables.each_with_object(hash) do |attribute, object|
+        next if %i[@errors @validation_context 
+                  @models @dynamic_models
+                  @multiple_instance_models
+                  @extra_attributes].include?(attribute)
+
+        key = attribute.to_s.gsub('@','').to_sym
+        object[key] = self.instance_variable_get(attribute)
+      end
+    end
+
+    # Returns an list of all attribute names as symbols 
+    # @return array [Array] of symbol attribute names
+    def attribute_keys
+      ATTRIBUTES
+    end
+
+    # Returns all of the attributes for a model
+    # @note If you dont pass a model to extra attributes they will not show up here
+    # @note attributes for model does not work for multiple_instance_models
+    # @param model class [ActiveRecord]
+    # @return hash [Hash]
+    def attributes_for(model)
+      model_is_activerecord?(model)
+
+      hash = ActiveSupport::HashWithIndifferentAccess.new
+      
+      attribute_lookup.each_with_object(hash) do |value, object|
+        lookup = value[1]
+        form_attribute = value[0]
+        object[lookup[:original_method]] = attributes[form_attribute] if lookup[:model] == model.name
+      end
+    end
+
+    # Takes a hash of key value pairs and assigns those attributes values to its
+    # corresponding methods/instance variables
+    # @note If you give it a key that is not a defined method of the class it will simply move on to the next
+    # @param hash [Hash]
+    # @return self [FormObject] the return value is the instance of the form object with its updated values
+    def set_attributes(attributes_hash)
+      attributes_hash.each do |pair|
+        key = "#{pair[0].to_s}="
+        value = pair[1]
+        self.send(key, value)
+      rescue NoMethodError
+        next 
+      end
+      self
+    end
+
+
+    # Given n number of atrribute names this method will iterate over each attribute and validate that attribute
+    # using the model that the attribute orignated from to validate it
+    # @note this method uses a special method #validate_attribute_with_message this method comes from
+    # the an DynamicValidation module and is not built in with ActiveRecord
+    # @note this method will add the model errors to your object instance and invalidate it. 
+    # The model errors are using the original attribute names
+    # @param symbol names of instance methods [Symbol]
+    # @return boolean [Boolean] this method will return true if all attributes are valid and false if not
+    def validate_attributes(*attributes)
+      raise ArgumentError, 'Attributes must be a Symbol' unless attributes.all? { |x| x.is_a?(Symbol) }
+
+      attributes.map do |single_attr|
+        unless respond_to?(single_attr)
+          raise FormObject::AttributeNameError, "#{single_attr.to_s} is not a valid attribute of this form object"
+        end
+
+        original_attribute = attribute_lookup.dig(single_attr.to_sym, :original_method)
+        attribute_hash = { "#{original_attribute}": send(single_attr) }
+        instance = attribute_lookup.dig(single_attr.to_sym, :model)&.constantize&.new
+        instance&.send("#{original_attribute}=", send(single_attr))
+        next if instance.nil?
+
+        validation = validate_attribute_with_message(attribute_hash, model_instance: instance)
+        if validation.valid.eql?(false)
+          validation.messages.each { |err| errors.add(single_attr.to_sym, err) }
+        end
+
+        validation.valid
+      end.compact.all?(true)
+    end
+
+    # Much like #validate_attributes this method will validate the attributes 
+    # of a instance model using the original model
+    # @note this method uses a special method #validate_attribute_with_message this method comes from
+    # the an DynamicValidation module and is not built in with ActiveRecord
+    # @note this method will add the model errors to your object instance and invalidate it. 
+    # The model errors are using the original attribute names
+    # @param symbol name of instance method [Symbol]
+    # @return boolean [Boolean] this method will return true if all attributes are valid and false if not
+    def validate_multiple_instance_model(attribute)
+      raise ArgumentError, 'Attribute must be a Symbol' unless attribute.is_a?(Symbol)
+      unless respond_to?(attribute)
+        raise FormObject::AttributeNameError, "#{attribute.to_s} is not a valid attribute of this form object"
+      end
+
+      model_instance = attribute_lookup.dig(attribute.to_sym, :model)&.constantize&.new
+      return nil if model_instance.nil?
+
+      send(attribute).map do |hash_instance|
+        hash_instance.map do |key, value|
+          model_instance&.send("#{key}=", value)
+
+          validation = validate_attribute_with_message({ "#{key}": value }, model_instance: model_instance )
+          if validation.valid.eql?(false)
+            validation.messages.each { |err| errors.add(attribute.to_sym, err) }
+          end
+          validation.valid
+        end
+      end.compact.all?(true)
+    end
+
+    # This method should be used when instantiating a new object. It is used to add extra attributes to the
+    # form object that may not be accessible from the models passed in.
+    # @note to have these attributes validated using the #validate_attributes method you must pass in a model
+    # @note model can be an instance or the class
+    # @note attributes should be an array of symbols
+    # @param prefix is a string that you want to hcae in front of all your extra attributes [String]
+    # @param attributes should be an array of symbols [Array]
+    # @param model class or model instance  [ActiveRecord] this is the class that you want these extra attributes to be related to
+    # @return array of all the extra attributes [Array]
+    def add_extra_attributes(prefix: nil, attributes:, model: nil )
+      if prefix.present?
+        raise ArgumentError, 'Prefix must be a String' unless prefix.is_a?(String)
+      end
+      raise ArgumentError, 'All attributes must be Symbols' unless attributes.all? { |x| x.is_a?(Symbol) }
+      model_is_activerecord?(model)
+
+      hash = { 
+              prefix: prefix || model_prefix(model), 
+              attributes: attributes,
+              model: model 
+            } 
+      extra_attributes << hash
+    end
+
+    # This method should be used when instantiating a new object. It is used to add dynamic models to the
+    # form object.
+    # Dynamic models are models that share a base class and are of the same family but can vary depending on child class
+    # Example: A Truck model, Racecar model, and a Semi model who all have a base class of Vehicle
+    # This method allows your form to recieve any of these models and keep the UI and method calls the same.
+    # @note model can be an instance or the class
+    # @param prefix is a string that you want to hcae in front of all your extra attributes [String]
+    # @param model class or model instance  [ActiveRecord] this is the class that you want these extra attributes to be related to
+    # @return array of all the dynamic models [Array]
+    def add_dynamic_model(prefix:, model:)
+      raise ArgumentError, 'Prefix must be a String' unless prefix.is_a?(String)
+      model_is_activerecord?(model)
+
+      @dynamic_models << { prefix: prefix, model: instance_of_model(model) }
+    end
+
+    # The add_multiple_instance_model is an instance method that is used for adding ActiveRecord models
+    # multiple instance models are models that would be child models in a has_many belongs_to relationship
+    # EXAMPLE: Car has_many parts
+    # In this example the multiple instance would be parts because a car can have an infinte number of parts
+    # @param name of the form object atrribute to retrieve these multiple instances of a model [String]
+    # @param model class or instance [ActiveRecord] this is the same model that the instances should be
+    # @param instances is an array of ActiveRecord models [Array] these are usually the has_many relation instances
+    # @return array of all the multiple instance models models [Array]
+    def add_multiple_instance_model(attribute_name: nil, model:, instances: [])
+      if attribute_name.present? 
+        raise ArgumentError, 'Attribute name must be a String' unless attribute_name.is_a?(String)
+      end
+      model_is_activerecord?(model)
+
+      attribute_name = attribute_name || model_prefix(model, pluralize: true)
+      hash = { attribute_name: attribute_name, model: instance_of_model(model), instances: instances }
+
+      @multiple_instance_models << hash
+    end
+
+    # The add_model is an instance method that is used for adding ActiveRecord models
+    # @param prefix is optional and is used to change the prefix of the models attributes [String] the prefix defaults to the model name
+    # @param model class or instance [ActiveRecord] this is the same model that the instances should be
+    # @return array of all the models [Array]
+    def add_model(model, prefix: nil)
+      if prefix.present?
+        raise ArgumentError, 'Prefix must be a String' unless prefix.is_a?(String)
+      end
+      model_is_activerecord?(model)
+
+      hash = { prefix: prefix || model_prefix(model), model: instance_of_model(model) }
+
+      @models << hash
+    end
+
+    # This method is used to turn the attributes of the form into a stringified object that resembles json
+    # @return form atttrubytes as a strigified hash [Hash]
+    def as_json
+      instance_variables.each_with_object({}) do |var, obj|
+          obj[var.to_s.gsub('@','')] = instance_variable_get(var)
+      end.stringify_keys
+    end
+
+    # This method is used to help validate the form object. Use required for step to do step contional validations of attributes
+    # @param step is used to compare the current step [Symbol]
+    # @return a true or false value if the step give is equal to or smaller in the form_steps [Boolean]
+    def required_for_step?(step)
+      # note: this line is specific if using the wicked gem
+      return true if current_step == 'wicked_finish' || current_step.nil?
+
+      form_steps.index(step.to_sym) <= form_steps.index(current_step.to_sym)
+    end
+
+    # Persist is used to update or create all of the models from the form object
+    # @note the create method and update method that this method use will have to manually implemented by the child class
+    # @note the create and update need to return a boolean based on their success or failure to udpate
+    # @return the output of the create or update method [Sybmbol]
+    def persist!
+      new_form ? create : update
+    end
+
+    # Create all of the models from the form object and their realations
+    # @note this should be done in an ActiveRecord transaction block
+    # @return returns true if the transaction was successfule and false if not[Boolean]
+    # EXAMPLE:
+    # def create
+    #   created = false
+    #   begin
+    #     ActiveRecord::Base.transaction do
+    #       car = Car.new(attributes_for(Car))
+    #       car.parts = car_parts
+    #       car.save!
+    #     end
+    #     created = true
+    #   rescue StandardError => err
+    #     return created       
+    #   end
+    #   created
+    # end
+    def create
+      true
+    end
+
+    # Update all of the models from the form object and their realations
+    # @note this should be done in an ActiveRecord transaction block
+    # @return returns true if the transaction was successfule and false if not [Boolean]
+    # EXAMPLE:
+    # def update
+    #   updated = false
+    #   begin
+    #     ActiveRecord::Base.transaction do
+    #       car = Car.find(car_id)
+    #       car.attributes = attributes_for(Car)
+    #       car.parts = car_parts
+    #       car.save!
+    #     end
+    #     updated = true
+    #   rescue StandardError => err
+    #     return updated       
+    #   end
+    #   updated
+    # end
+    def update
+      true
+    end
+
+    private
+
+    # WARNING: Light meta programming
+    # Used to add attributes to the ATTRIBUTES array and also create an attr_accessor for those attributes
+    # This is used to add model attributes to the form object
+    # @param attribute name [Symbol]
+    # @return method name [Sybmbol]
+    def add_attribute(attribute_name)
+      ATTRIBUTES << attribute_name
+      self.class.send(:attr_accessor, attribute_name)
+    end
+
+    # Used on the last step of a form wizard
+    # @note this model will invalidate the form object is the persist! method does not return true
+    # @return if all models were saved than true will be returned [Boolean]
+    def models_persisted?
+      persist! ? true : errors.add(:associated_model, 'could not be properly save')
+    end
+
+    # Returns all types of models including, dynamic models, multi instance models, etc
+    # @return all models [Array]
+    def all_models
+      @all_models = (models + dynamic_models + multiple_instance_models).uniq
+    end
+
+    # This method is used to make sure the form object has an attr_accessor for all of the models that
+    # were provided. This method is used during the initialization of a new form object instance.
+    def init_attributes
+      # get all model attributes and prefix them 
+      all_models.each do |hash|
+        prefix = hash[:prefix]
+        hash[:model].attributes.keys.each do |key|
+          ATTRIBUTES << "#{prefix}_#{key}".to_sym
+
+          # set attribute history
+          set_attribute_history(prefix, key, hash[:model])
+        end
+      end
+
+      # add extra attributes
+      init_extra_attributes
+
+      init_multiple_instance_attributes
+
+      # set attr_accessor
+      ATTRIBUTES.uniq.each do |attribute|
+        self.class.send(:attr_accessor, attribute)
+      end
+
+      # set any values from the class
+      all_models.each do |hash|
+        prefix = hash[:prefix] || model_prefix(hash[:model])
+        hash[:model].attributes.each do |key, value|
+          self.instance_variable_set("@#{prefix}_#{key}", value)
+        end
+      end
+      @models = []
+      @extra_attributes = []
+    end
+
+    # This method is used to make sure the form object has an attr_accessor for all of the multiple instance attributes 
+    # This method is used during the initialization of a new form object instance.
+    def init_multiple_instance_attributes
+      multiple_instance_models.each do |model_hash|
+        add_attribute(model_hash[:attribute_name].to_sym)
+        attribute_lookup.merge!(
+          "#{model_hash[:attribute_name]}": { original_method: nil, model: instance_of_model(model_hash[:model]).class.name }
+        )
+
+        instances = model_hash[:instances].map { |x| ActiveSupport::HashWithIndifferentAccess.new(x.attributes) }
+        self.send("#{model_hash[:attribute_name].to_s}=", instances)
+      end
+    end
+
+    # This method is used to make sure the form object has an attr_accessor for all of the extra attributes 
+    # This method is used during the initialization of a new form object instance.
+    def init_extra_attributes
+      @extra_attribute_keys = []
+      extra_attributes.each do |attr_object|
+        attr_object[:attributes].each do |x|
+          if attr_object[:prefix]
+            ATTRIBUTES << "#{attr_object[:prefix].to_s}_#{x.to_s}".to_sym
+            @extra_attribute_keys << "#{attr_object[:prefix].to_s}_#{x.to_s}".to_sym
+          else
+            ATTRIBUTES << x.to_sym
+            @extra_attribute_keys << x.to_sym
+          end
+
+          if attr_object[:model]
+            set_attribute_history(attr_object[:prefix], x.to_s, attr_object[:model])
+          end
+
+          # try to set value for extra atrributes
+          self.instance_variable_set("@#{@extra_attribute_keys.last}", attr_object[:model].try(x.to_s))
+        end
+      end
+    end
+
+    # Set attribute history updates the attrube_lookup object
+    # @param prefix is the attribute prefix [String] the prefix the form_object gave this attribute
+    # @param key is name of the original method from the model [String]
+    # @param model ActiveRecord class of the method [ActiveRecord]
+    def set_attribute_history(prefix=nil, key, model)
+      if prefix
+        attribute_lookup.merge!("#{prefix}_#{key}": { original_method: key, model: instance_of_model(model).class.name })
+      else
+        attribute_lookup.merge!("#{key}": { original_method: key, model: instance_of_model(model).class.name })
+      end 
+    end
+
+    # This method is reponsible for taking an ActiveRecord class and turning it into snake cased prefix
+    # @param pluralize determines if the prefix is going to be plural or not [Boolean]
+    # @param model ActiveRecord class [ActiveRecord]
+    def model_prefix(model, pluralize: false)
+      if pluralize
+        instance_of_model(model).class.name.pluralize.gsub('::','_').underscore
+      else
+        instance_of_model(model).class.name.gsub('::','_').underscore
+      end
+    end
+
+    # Instance of model gives the DSL the flexibility to have an instance of an ActiveRecord class or the class it self.
+    # This method will take an argument of either an ActiveRecord class instance or class definiton and return the an instance
+    # @param model ActiveRecord class or instance [ActiveRecord]
+    # @return ActiveRecord model instance [ActiveRecord]
+    def instance_of_model(model)
+      model.respond_to?(:new) ? model.new : model
+    end
+
+    def class_for(model)
+      model.respond_to?(:new) ? model : model.class
+    end
+
+    def model_is_activerecord?(model)
+      return if model.nil?
+
+      class_ancestors = class_for(model).ancestors
+      unless class_ancestors.include?(ActiveRecord::Base) || class_ancestors.include?(ActiveRecord::Base)
+        raise ArgumentError, 'Model must be an ActiveRecord descendant'
+      end
+    end
+
+    # The attribute lookup method is a hash that has the form object attribute as a key and the history of that atrribute as the value
+    # EXAMPLE:
+    # {
+    #   car_color: { original_method: 'color', model: 'Car' }
+    # }
+    # 
+    # @return hash [Hash]
+    def attribute_lookup
+      @attribute_lookup ||= {}
+    end
+  end
+end

data/lib/multi_model_wizard/config.rb

@@ -0,0 +1,46 @@
+module MultiModelWizard
+  class Config
+    # The form key is what is used a the key in the session cookies
+    # This can be changed in the intitializer file.
+    # This key is also what is used as part of the redis key value pair 
+    # if redis is configured.
+    FORM_KEY = 'multi_model_wizard_form'.freeze
+
+    attr_accessor :store, :form_key
+
+    def initialize
+      @store = { location: :cookies, redis_instance: nil }
+      @form_key = FORM_KEY
+    end
+
+    # The configured redis instance. This is should be set in the initializer.
+    # A redis instance is only needed if you are going to use redis to store.
+    # Redis is great to use when you have a bigger/longer wizard form. 
+    # Session cookies max size is 4k, so if the size is over that, consider
+    # switching to redis store
+    #
+    #
+    # Session cookies are still used even when using redis as the store location 
+    # A key and a uuid is stored on the browser session cookie
+    # That uuid is used as the key in redis to retrieve the form data to the controller
+    def redis_instance
+      store[:redis_instance]
+    end
+
+    # Location tells the gem where to put your form data between form steps
+    # The default is session cookies in the browser
+    def location
+      store[:location]
+    end
+
+    # Logical methods to determine where the gem should store form data
+    def store_in_redis?
+      store[:location] == :redis
+    end
+
+    # Logical methods to determine where the gem should store form data
+    def store_in_cookies?
+      store[:location] =! :redis
+    end
+  end
+end

data/lib/multi_model_wizard/cookie_store.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/numeric/time'
+
+module MultiModelWizard
+  module CookieStore
+    extend ActiveSupport::Concern
+
+    EXPIRATION = 1.hour
+
+    # This method is used to set the session cookie on the browser
+    # EXAMPLE:
+    # set_signed_cookie(key: 'multi_model_wizard_form', value: { hello: 'world' })
+    def set_signed_cookie(attributes)
+      cookies.signed[attributes[:key]&.to_sym] = {
+        value: attributes[:value],
+        expires: attributes[:expires] || EXPIRATION.from_now,
+        same_site: attributes[:same_site] || 'None',
+        secure: attributes[:secure] || true,
+        httponly: attributes[:httponly] || true
+      }
+    end
+
+    # This method is used to retrieve the session cookie from the browser
+    def get_signed_cookie(key)
+      cookies.signed[key.to_sym]
+    end
+
+    # This method is used to delete the session cookie from the browser
+    def delete_cookie(key)
+      cookies.delete(key.to_sym)
+    end
+  end
+end

data/lib/multi_model_wizard/dynamic_validation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MultiModelWizard
+  module DynamicValidation
+    # Validates attributes using the original model and returns boolean for the given attributes
+    # @params attributes are the names of the form objects methods [Symbol]
+    # @params model_instance is the original model that the form object got the attributes from [ActiveRecord]
+    # @returns returns boolean if the model has no errors [Boolean]
+    def valid_attribute?(*attributes, model_instance:)
+      model_instance.errors.clear
+
+      attributes.flatten!
+      attributes = attributes.first if attributes.first.is_a?(Hash)
+
+      attributes.each do |attribute, validator_types|
+        validators = model_instance.class.validators_on(attribute)
+
+        if validator_types.present?
+          validator_types = Array(validator_types)
+          validators.select! { |validator| validator.kind.in?(validator_types) }
+        end
+
+        validators.each { |validator| validator.validate(model_instance) }
+      end
+
+      model_instance.errors.empty?
+    end
+
+    # Validates attributes using the original model and returns a boolean and a message for the given attributes
+    # @params attributes are the names of the form objects methods [Symbol]
+    # @params model_instance is the original model that the form object got the attributes from [ActiveRecord]
+    # @returns returns an object with the valid and messages attributes [OpenStruct]
+    def validate_attribute_with_message( *attributes, model_instance:)
+      model_instance.errors.clear
+
+      attributes.flatten!
+      attributes = attributes.first if attributes.first.is_a?(Hash)
+
+      attributes.each do |attribute, value|
+        validators = model_instance.class.ancestors.map { |x| x.try(:validators_on, attribute) }.compact.flatten
+
+        validators.each { |validator| validator.validate(model_instance) }
+      end
+
+      OpenStruct.new(valid: model_instance.errors.empty?, messages: model_instance.errors.full_messages.uniq )
+    end
+  end
+end

data/lib/multi_model_wizard/redis_cookie_store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'multi_model_wizard/cookie_store'
+require 'multi_model_wizard/config'
+
+require 'active_support'
+require 'active_support/core_ext/numeric/time'
+
+module MultiModelWizard
+  module RedisCookieStore
+    include ::MultiModelWizard::CookieStore
+
+    # This method is used to set the form data in redis
+    # @note the key of this method is the congifured form key and the uuid for that form session
+    # EXAMPLE:
+    # set_redis_cache('multi_model_wizard:d5be032f-4863-44e7-87c8-0ec86c85263d', { hello: 'world' })
+    def set_redis_cache(key, data, expire: ::MultiModelWizard::CookieStore::EXPIRATION)
+      wizard_redis_instance.set(key, data, ex: expire)
+    end
+
+    # This method is used to delete the form data from redis
+    def clear_redis_cache(key)
+      wizard_redis_instance.del(key)
+    end
+    
+    # This method is used to retrieve the form data from redis
+    def fetch_redis_cache(key)
+      wizard_redis_instance.get(key)
+    end
+
+    private
+
+    # Reference the redis instance that was passed in from the initializer
+    def wizard_redis_instance
+      ::MultiModelWizard.configuration.redis_instance
+    end
+  end
+end

data/lib/multi_model_wizard/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiModelWizard
+  VERSION = '0.1.0'
+end

data/lib/multi_model_wizard/wizard.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Modules
+require 'multi_model_wizard/redis_cookie_store'
+require 'multi_model_wizard/dynamic_validation'
+require 'multi_model_wizard/cookie_store'
+require 'multi_model_wizard/version'
+require 'multi_model_wizard/config'
+require 'multi_model_wizard'
+require 'form_object/base'
+
+# Third party gems
+require 'json'
+require 'securerandom'
+require 'active_support'
+
+module MultiModelWizard
+  module Wizard
+    extend ActiveSupport::Concern
+
+    include ::MultiModelWizard::CookieStore
+    include ::MultiModelWizard::RedisCookieStore
+
+    attr_reader :form_id
+
+    # This gets the form data from the session cookie or redis depending on whats configured
+    def session_params
+      store_in_redis? ? redis_session_params : cookie_session_params
+    end
+  
+    # This clears the form data from the session cookie or redis depending on whats configured
+    def clear_session_params
+      store_in_redis? ? clear_redis_session_params : clear_cookie_session_params
+    end
+
+    # This sets the form data in the session cookie or redis depending on whats configured
+    def set_session_params(value)
+      store_in_redis? ? set_redis_session_params(value) : set_cookie_session_params(value)
+    end
+  
+    # Wizard form uuid will attempt to get the uuid from the browser session cookie
+    # If one is not there it will set a new session cookie with the uuid as teh value
+    def wizard_form_uuid
+      return get_signed_cookie(wizard_form_key) if get_signed_cookie(wizard_form_key).present?
+
+      @uuid ||= SecureRandom.uuid
+      set_signed_cookie(key: wizard_form_key, value: @uuid)
+      @uuid
+    end
+
+    # Reference the form key that was passed in from the initializer
+    def multi_model_wizard_form_key
+      ::MultiModelWizard.configuration.form_key
+    end
+
+    private
+
+    def wizard_form_key
+      if form_id
+        "#{multi_model_wizard_form_key}#{form_id}".to_sym
+      else
+        multi_model_wizard_form_key.to_sym
+      end
+    end
+
+    # Logical methods to determine where the gem should store form data
+    def store_in_redis?
+      ::MultiModelWizard.configuration.store_in_redis?
+    end
+
+    # This method is used to retrieve the form data from redis
+    def redis_session_params
+      JSON.parse(fetch_redis_cache("#{wizard_form_key.to_s}:#{wizard_form_uuid}"))
+    rescue TypeError
+      {}
+    end
+
+    def clear_redis_session_params
+      clear_redis_cache("#{wizard_form_key.to_s}:#{wizard_form_uuid}")
+      delete_cookie(wizard_form_key.to_sym)
+    end
+
+    def set_redis_session_params(value)
+      set_redis_cache(
+        "#{wizard_form_key.to_s}:#{wizard_form_uuid}", 
+        value,
+      )
+    end
+
+    def cookie_session_params
+      get_signed_cookie(wizard_form_key.to_s)
+    end
+
+    def clear_cookie_session_params
+      delete_cookie(wizard_form_key)
+    end
+
+    def set_cookie_session_params(attributes)
+      set_signed_cookie(attributes.merge(key: wizard_form_key.to_s))
+    end
+  end
+end

data/lib/multi_model_wizard.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'multi_model_wizard/dynamic_validation'
+require_relative 'multi_model_wizard/redis_cookie_store'
+require_relative 'multi_model_wizard/cookie_store'
+require_relative 'multi_model_wizard/version'
+require_relative 'multi_model_wizard/wizard'
+require_relative 'multi_model_wizard/config'
+require_relative 'form_object/base'
+
+
+module MultiModelWizard
+  class << self
+    def configuration
+      @configuration ||= ::MultiModelWizard::Config.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def version
+      ::MultiModelWizard::VERSION
+    end
+  end
+end

data/multi_model_wizard.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/multi_model_wizard/version"
+
+Gem::Specification.new do |spec|
+  spec.name = 'multi_model_wizard'
+  spec.version = MultiModelWizard::VERSION
+  spec.authors = ["micahbowie-pu"]
+  spec.authors = ["proctoru"]
+  spec.email = ["ruby-gems@meazurelearning.com "]
+
+  spec.summary = 'Creates a smart object for your wizards or forms. Create one form and form object that can update multiple models with ease.'
+  spec.description = 'MultiModelWizard is a way to create and update multiple ActiveRecord models using one form object.'
+  spec.homepage = 'https://github.com/ProctorU/multi_model_wizard'
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.metadata["allowed_push_host"] = 'https://rubygems.org/'
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activemodel', '>= 5.0'
+  spec.add_dependency 'activesupport', '>= 5.0'
+
+  spec.add_development_dependency 'activerecord', '>= 5.0'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'byebug'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: multi_model_wizard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- proctoru
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MultiModelWizard is a way to create and update multiple ActiveRecord
+  models using one form object.
+email:
+- ruby-gems@meazurelearning.com 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/form_object/base.rb
+- lib/multi_model_wizard.rb
+- lib/multi_model_wizard/config.rb
+- lib/multi_model_wizard/cookie_store.rb
+- lib/multi_model_wizard/dynamic_validation.rb
+- lib/multi_model_wizard/redis_cookie_store.rb
+- lib/multi_model_wizard/version.rb
+- lib/multi_model_wizard/wizard.rb
+- multi_model_wizard.gemspec
+homepage: https://github.com/ProctorU/multi_model_wizard
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/ProctorU/multi_model_wizard
+  source_code_uri: https://github.com/ProctorU/multi_model_wizard
+  changelog_uri: https://github.com/ProctorU/multi_model_wizard
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Creates a smart object for your wizards or forms. Create one form and form
+  object that can update multiple models with ease.
+test_files: []