effective_resources 1.6.3 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8f4f8a61fe16b9a92f77b57d2c296375b1a9173de4d6d3e210ca08531911d61
-  data.tar.gz: 467d2e1778f6fe676653f5fee538c5960eaeb971f1503b455fd785b00f0ccb31
+  metadata.gz: 907d2532f74c1cb4ef84e6266ded04a2574c9c0e9ccecd26416f39f360ef24bf
+  data.tar.gz: 33375d7283775217fb4ffb1d10f6e88032f80c1cebd33341fad3b00ed3d44000
 SHA512:
-  metadata.gz: 06baf45541024e1990157d58aeb88915ce6399534e01dc7d6ca4b430e0d473b3d294c15de8bbd4fe67f065a50ed4f2bc193c6c73b06892b13beb244400a122ec
-  data.tar.gz: 12cdb59f706b3c3fe1d03f0df1f19b2bc758e61e28b256a894fa880d736c03d28fc0067ab84dafe51fc88a00d599232b93033c1555d7d85e21371d1a4baa6f88
+  metadata.gz: 7f1d9b72921bd70f50ed839edbdb7f1be5787f43ecfcefdfd24fc7903dfeac0a886486ebea6e7c9e2d832bd17c62137b765d0a64d6619e22e3a22bff113b36e4
+  data.tar.gz: 8ff7a999b54f1b0c1f52728c57cd7a7ed8eeae1ad82aecb435ae004bb6dbf84444df410bd52d8d8470b5bdf8ef863e467283232f9d012a68f50ef8cf1f6b03c7

data/README.md

@@ -256,6 +256,102 @@ end
 
 and include Effective::CrudController in your resource controller.
 
+### acts_as_wizard
+
+Build up an object through a wizard.
+
+Works with the [wicked](https://github.com/zombocom/wicked) gem to create wizard quickly.
+
+Create a model and define `acts_as_wizard`:
+
+```ruby
+class Thing < ApplicationRecord
+  acts_as_wizard(
+    start: 'Start',
+    select: 'Select',
+    finish: 'Finish'
+  )
+
+  effective_resource do
+    title       :string
+    wizard_steps  :text, permitted: false
+  end
+
+  validates :title, presence: true
+
+  def to_s
+    title.presence || 'New Thing'
+  end
+
+  # If you define a bang method matching the name of a step
+  # it will be called when that step is submitted.
+  # Otherwise save! is called.
+  def select!
+    ApplicationMailer.selected(self).deliver_later
+    save!
+  end
+
+  # An array of steps that the controller will use
+  # Default value is just all of them. But you can customize here
+  # def required_steps
+  #   steps = WIZARD_STEPS.keys
+  #   selectable? ? steps : steps - [:select]
+  # end
+
+  # Control whether the user has permission to visit this step
+  #
+  # This is the default, can go forward or back:
+  #
+  # def can_visit_step?(step)
+  #   can_revisit_completed_steps(step)
+  # end
+  #
+  # Easy change if you only want to go forward:
+  #
+  # def can_visit_step?(step)
+  #   cannot_revisit_completed_steps(step)
+  # end
+  #
+  # or custom algorithm:
+  #
+  # def can_visit_step?(step)
+  #   return false unless has_completed_previous_step?(step)
+  #   return false if has_completed_step?(:finish) && step != :finish
+  # end
+end
+```
+
+In your routes:
+
+```ruby
+resources :things, only: [:index, :show, :new, :destroy] do
+  resources :build, controller: :things, only: [:show, :update]
+end
+```
+
+Make a controller:
+
+```ruby
+class ThingsController < ApplicationController
+  include Effective::WizardController
+end
+```
+
+And then create one view per step.
+
+Here's `views/things/start.html.haml`:
+
+```haml
+= render_wizard_sidebar(resource) do
+  %h1= @page_title
+
+  = effective_form_with(model: resource, url: wizard_path(step), method: :put) do |f|
+    = f.text_field :title
+    = f.submit 'Save and Continue'
+```
+
+You can also call `render_wizard_sidebar(resource)` without the block syntax.
+
 ## Testing
 
 Run tests by:

data/app/controllers/concerns/effective/crud_controller.rb

@@ -11,13 +11,14 @@ module Effective
 
     included do
       define_actions_from_routes
-      define_permitted_params_from_model
       define_callbacks :resource_render, :resource_before_save, :resource_after_save, :resource_after_commit, :resource_error
     end
 
     module ClassMethods
       include Effective::CrudController::Dsl
 
+      # This is used to define_actions_from_routes and for the buttons/submits/ons
+      # It doesn't really work with the resource_scope correctly but the routes are important here
       def effective_resource
         @_effective_resource ||= Effective::Resource.new(controller_path)
       end
@@ -32,17 +33,6 @@ module Effective
           define_method(action) { collection_action(action) }
         end
       end
-
-      def define_permitted_params_from_model
-        if effective_resource.model.present?
-          define_method(:effective_resource_permitted_params) { resource_permitted_params } # save.rb
-        end
-
-        if effective_resource.active_model?
-          define_method(:effective_resource_permitted_params) { resource_active_model_permitted_params } # save.rb
-        end
-      end
-
     end
 
     def resource # @thing
@@ -62,15 +52,37 @@ module Effective
     end
 
     def effective_resource
-      self.class.effective_resource
+      @_effective_resource ||= begin
+        relation = instance_exec(&resource_scope_relation) if respond_to?(:resource_scope_relation)
+
+        if respond_to?(:resource_scope_relation) && !relation.kind_of?(ActiveRecord::Relation)
+          raise('resource_scope must return an ActiveRecord::Relation')
+        end
+
+        resource = Effective::Resource.new(controller_path, relation: relation)
+
+        unless resource.relation.kind_of?(ActiveRecord::Relation) || effective_resource.active_model?
+          raise("unable to build resource_scope for #{resource.klass || 'unknown klass'}. Please name your controller to match an existing model, or manually define a resource_scope.")
+        end
+
+        resource
+      end
     end
 
     private
 
+    def resource_scope
+      effective_resource.relation
+    end
+
     def resource_name # 'thing'
       effective_resource.name
     end
 
+    def resource_name_id
+      (effective_resource.name + '_id').to_sym
+    end
+
     def resource_klass # Thing
       effective_resource.klass
     end
@@ -79,30 +91,6 @@ module Effective
       effective_resource.plural_name
     end
 
-    # Returns an ActiveRecord relation based on the computed value of `resource_scope` dsl method
-    def resource_scope # Thing
-      @_effective_resource_relation ||= (
-        relation = case @_effective_resource_scope  # If this was initialized by the resource_scope before_action
-        when ActiveRecord::Relation
-          @_effective_resource_scope
-        when Hash
-          effective_resource.klass.where(@_effective_resource_scope)
-        when Symbol
-          effective_resource.klass.send(@_effective_resource_scope)
-        when nil
-          effective_resource.klass.respond_to?(:all) ? effective_resource.klass.all : effective_resource.klass
-        else
-          raise "expected resource_scope method to return an ActiveRecord::Relation or Hash"
-        end
-
-        unless relation.kind_of?(ActiveRecord::Relation) || effective_resource.active_model?
-          raise("unable to build resource_scope for #{effective_resource.klass || 'unknown klass'}. Please name your controller to match an existing model, or manually define a resource_scope.")
-        end
-
-        relation
-      )
-    end
-
     def resource_datatable_attributes
       resource_scope.where_values_hash.symbolize_keys
     end
@@ -124,7 +112,16 @@ module Effective
     end
 
     def resource_params_method_name
-      ["#{resource_name}_params", "#{resource_plural_name}_params", 'permitted_params', 'effective_resource_permitted_params', ('resource_permitted_params' if effective_resource.model.present?)].compact.find { |name| respond_to?(name, true) } || 'params'
+      ['permitted_params', "#{resource_name}_params", "#{resource_plural_name}_params"].each do |name|
+        return name if respond_to?(name, true)
+      end
+
+      # Built in ones
+      return 'resource_permitted_params' if effective_resource.model.present?
+      return 'resource_active_model_permitted_params' if effective_resource.active_model?
+
+      # Fallback
+      'params'
     end
 
   end

data/app/controllers/concerns/effective/crud_controller/actions.rb

@@ -63,8 +63,13 @@ module Effective
         self.resource ||= resource_scope.new
         action = (commit_action[:action] == :save ? :create : commit_action[:action])
 
-        resource.current_user ||= current_user if resource.respond_to?(:current_user=)
-        resource.created_by ||= current_user if resource.respond_to?(:created_by=)
+        if respond_to?(:current_user) && resource.respond_to?(:current_user=)
+          resource.current_user ||= current_user
+        end
+
+        if respond_to?(:current_user) && resource.respond_to?(:created_by=)
+          resource.created_by ||= current_user
+        end
 
         resource.assign_attributes(send(resource_params_method_name))
 
@@ -121,8 +126,13 @@ module Effective
         EffectiveResources.authorize!(self, action, resource)
         @page_title ||= "Edit #{resource}"
 
-        resource.current_user ||= current_user if resource.respond_to?(:current_user=)
-        resource.updated_by ||= current_user if resource.respond_to?(:updated_by=)
+        if respond_to?(:current_user) && resource.respond_to?(:current_user=)
+          resource.current_user ||= current_user
+        end
+
+        if respond_to?(:current_user) && resource.respond_to?(:updated_by=)
+          resource.updated_by ||= current_user
+        end
 
         resource.assign_attributes(send(resource_params_method_name))
 

data/app/controllers/concerns/effective/crud_controller/dsl.rb

@@ -79,9 +79,12 @@ module Effective
       def resource_scope(obj = nil, opts = {}, &block)
         raise 'expected a proc or block' unless (obj.respond_to?(:call) || block_given?)
 
-        instance_exec do
-          before_action(opts) { @_effective_resource_scope ||= instance_exec(&(block_given? ? block : obj)) }
+        if block_given?
+          define_method(:resource_scope_relation) { return block }
+        else
+          define_method(:resource_scope_relation) { return obj }
         end
+
       end
 
     end

data/app/controllers/concerns/effective/crud_controller/save.rb

@@ -24,7 +24,9 @@ module Effective
         save_action = ([:create, :update].include?(action) ? :save : action)
         raise "expected @#{resource_name} to respond to #{save_action}!" unless resource.respond_to?("#{save_action}!")
 
-        resource.current_user ||= current_user if resource.respond_to?(:current_user=)
+        if respond_to?(:current_user) && resource.respond_to?(:current_user=)
+          resource.current_user ||= current_user
+        end
 
         success = false
 

data/app/controllers/concerns/effective/wizard_controller.rb

@@ -0,0 +1,66 @@
+module Effective
+  module WizardController
+    extend ActiveSupport::Concern
+
+    include Wicked::Wizard if defined?(Wicked)
+    include Effective::CrudController
+
+    include Effective::WizardController::Actions
+    include Effective::WizardController::BeforeActions
+    include Effective::WizardController::Save
+    include Effective::WizardController::WickedOverrides
+
+    included do
+      raise("please install gem 'wicked' to use Effective::WizardController") unless defined?(Wicked)
+
+      with_options(only: [:show, :update]) do
+        before_action :redirect_if_blank_step
+
+        before_action :assign_resource
+        before_action :authorize_resource
+        before_action :assign_required_steps
+        before_action :setup_wizard # Wicked
+
+        before_action :enforce_can_visit_step
+
+        before_action :assign_current_step
+        before_action :assign_page_title
+      end
+
+      helper_method :resource
+      helper_method :resource_wizard_step_title
+
+      helper EffectiveResourcesWizardHelper
+
+      rescue_from Wicked::Wizard::InvalidStepError do |exception|
+        flash[:danger] = "Unknown step. You have been moved to the #{resource_wizard_steps.first} step."
+        redirect_to wizard_path(resource_wizard_steps.first)
+      end
+    end
+
+    def find_wizard_resource
+      if params[resource_name_id] && params[resource_name_id] != 'new'
+        resource_scope.find(params[resource_name_id])
+      else
+        resource_scope.new
+      end
+    end
+
+    def resource_wizard_step_title(step)
+      return if step == 'wicked_finish'
+      effective_resource.klass.const_get(:WIZARD_STEPS).fetch(step)
+    end
+
+    def resource_wizard_steps
+      effective_resource.klass.const_get(:WIZARD_STEPS).keys
+    end
+
+    # It could be :new, :start
+    # Or resource, step
+    def resource_wizard_path(resource, step)
+      param = (resource.respond_to?(:to_param) ? resource.to_param : resource)
+      wizard_path(step, resource_name_id => param)
+    end
+
+  end
+end

data/app/controllers/concerns/effective/wizard_controller/actions.rb

@@ -0,0 +1,31 @@
+module Effective
+  module WizardController
+    module Actions
+
+      def new
+        Rails.logger.info 'Processed by Effective::WizardController#new'
+
+        self.resource ||= resource_scope.new
+        EffectiveResources.authorize!(self, :new, resource)
+
+        redirect_to resource_wizard_path(:new, resource_wizard_steps.first)
+      end
+
+      def show
+        Rails.logger.info 'Processed by Effective::WizardController#show'
+
+        render_wizard
+      end
+
+      def update
+        Rails.logger.info 'Processed by Effective::WizardController#update'
+
+        resource.assign_attributes(send(resource_params_method_name))
+        assign_current_step
+
+        save_wizard_resource(resource)
+      end
+
+    end
+  end
+end

data/app/controllers/concerns/effective/wizard_controller/before_actions.rb

@@ -0,0 +1,74 @@
+module Effective
+  module WizardController
+    module BeforeActions
+
+      # before_action :redirect_if_blank_step, only: [:show]
+      # When I visit /resources/1, redirect to /resources/1/build/step
+      def redirect_if_blank_step
+        if params[:id].present? && params[resource_name_id].blank?
+          params[resource_name_id] = params[:id]
+
+          assign_resource()
+
+          step = (resource.first_uncompleted_step || resource_wizard_steps.last)
+          redirect_to resource_wizard_path(resource, step)
+        end
+      end
+
+      # before_action :assign_resource, only: [:show, :update]
+      # Assigns the resource
+      def assign_resource
+        self.resource ||= find_wizard_resource
+      end
+
+      # before_action :authorize_resource, only: [:show, :update]
+      # Authorize the resource
+      def authorize_resource
+        EffectiveResources.authorize!(self, action_name.to_sym, resource)
+      end
+
+      # before_action :assign_required_steps, only: [:show, :update]
+      # Assign the required steps to Wickeds (dynamic steps)
+      def assign_required_steps
+        self.steps = resource.required_steps
+      end
+
+      # setup_wizard from Wicked called now
+
+      # before_action :enforce_can_visit_step, only: [:show, :update]
+      # Make sure I have permission for this step
+      def enforce_can_visit_step
+        return if step == 'wicked_finish'
+        return if resource.can_visit_step?(step)
+
+        next_step = wizard_steps.reverse.find { |step| resource.can_visit_step?(step) }
+        raise('There is no wizard step to visit. Make sure can_visit_step?(step) returns true for at least one step') unless next_step
+
+        if Rails.env.development?
+          Rails.logger.info "  \e[31m\e[1mFAILED\e[0m\e[22m" # bold red
+          Rails.logger.info "  Unable to visit step :#{step}. Last can_visit_step? is :#{next_step}. Change the acts_as_wizard model's can_visit_step?(step) function to change this."
+        end
+
+        flash[:success] = "You have been redirected to the #{resource_wizard_step_title(next_step)} step."
+        redirect_to wizard_path(next_step)
+      end
+
+      # before_action :assign_current_step, only: [:show, :update]
+      # Assign the current step to resource
+      def assign_current_step
+        if respond_to?(:current_user) && resource.respond_to?(:current_user=)
+          resource.current_user = current_user
+        end
+
+        resource.current_step = step.to_sym
+      end
+
+      # before_action :assign_page_title, only: [:show, :update]
+      # Assign page title
+      def assign_page_title
+        @page_title ||= resource_wizard_step_title(step)
+      end
+
+    end
+  end
+end

data/app/controllers/concerns/effective/wizard_controller/save.rb

@@ -0,0 +1,24 @@
+module Effective
+  module WizardController
+    module Save
+
+      def save_wizard_resource(resource, action = nil, options = {})
+        was_new_record = resource.new_record?
+        action ||= resource.respond_to?("#{step}!") ? step : :save
+
+        if save_resource(resource, action)
+          flash[:success] = options.delete(:success) || resource_flash(:success, resource, action)
+
+          @skip_to ||= next_step
+          @redirect_to ||= resource_wizard_path(resource, @skip_to) if was_new_record
+
+          redirect_to(@redirect_to || wizard_path(@skip_to))
+        else
+          flash.now[:danger] = options.delete(:error) || resource_flash(:danger, resource, action)
+          render_step(wizard_value(step), options)
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/concerns/effective/wizard_controller/wicked_overrides.rb

@@ -0,0 +1,23 @@
+module Effective
+  module WizardController
+    module WickedOverrides
+
+      # Changes made here to work inside an effective rails engine
+      #
+      # https://github.com/zombocom/wicked/blob/main/lib/wicked/controller/concerns/path.rb
+      # https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/routing/url_for.rb#L180
+      def wizard_path(goto_step = nil, options = {})
+        options = options.respond_to?(:to_h) ? options.to_h : options
+        options = { :controller => wicked_controller,
+                    :action     => 'show',
+                    :id         => goto_step || params[:id],
+                    :only_path  => true
+                   }.merge(options)
+
+        merged_url_options = options.reverse_merge!(url_options)
+        effective_resource.url_helpers.url_for(merged_url_options)
+      end
+
+    end
+  end
+end

data/app/helpers/effective_resources_wizard_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module EffectiveResourcesWizardHelper
+
+  def render_wizard_sidebar(resource, numbers: true, &block)
+    sidebar = content_tag(:div, class: 'nav list-group wizard-sidebar') do
+      resource.required_steps.map.with_index do |nav_step, index|
+        render_wizard_sidebar_item(resource, nav_step, (index + 1 if numbers))
+      end.join.html_safe
+    end
+
+    return sidebar unless block_given?
+
+    content_tag(:div, class: 'row') do
+      content_tag(:div, class: 'col-3') { sidebar } +
+      content_tag(:div, class: 'col-9') { yield }
+    end
+  end
+
+  def render_wizard_sidebar_item(resource, nav_step, index = nil)
+    # From Controller
+    current = (nav_step == step)
+    title = resource_wizard_step_title(nav_step)
+
+    # From Model
+    disabled = !resource.can_visit_step?(nav_step)
+
+    label = [index, title].compact.join('. ')
+    klass = ['list-group-item', ('active' if current), ('disabled' if disabled && !current)].compact.join(' ')
+
+    if (current || disabled)
+      content_tag(:li, label, class: klass)
+    else
+      link_to(label, wizard_path(nav_step), class: klass)
+    end
+  end
+
+end

data/app/models/concerns/acts_as_wizard.rb

@@ -0,0 +1,107 @@
+# ActsAsWizard
+# Works alongside wicked gem to build a wizard
+# https://github.com/zombocom/wicked
+
+# acts_as_wizard(start: 'Start Step', select: 'Select Step', finish: 'Finished')
+
+module ActsAsWizard
+  extend ActiveSupport::Concern
+
+  module Base
+    def acts_as_wizard(steps)
+      raise 'acts_as_wizard expected a Hash of steps' unless steps.kind_of?(Hash)
+
+      unless steps.all? { |k, v| k.kind_of?(Symbol) && v.kind_of?(String) }
+        raise 'acts_as_wizard expected a Hash of symbol => String steps'
+      end
+
+      @acts_as_wizard_options = {steps: steps}
+
+      include ::ActsAsWizard
+    end
+  end
+
+  included do
+    acts_as_wizard_options = @acts_as_wizard_options
+
+    attr_accessor :current_step
+    attr_accessor :current_user
+
+    if Rails.env.test? # So our tests can override the required_steps method
+      cattr_accessor :test_required_steps
+    end
+
+    const_set(:WIZARD_STEPS, acts_as_wizard_options[:steps])
+
+    effective_resource do
+      wizard_steps           :text, permitted: false
+    end
+
+    serialize :wizard_steps, Hash
+
+    before_save(if: -> { current_step.present? }) do
+      wizard_steps[current_step.to_sym] ||= Time.zone.now
+    end
+
+    def can_visit_step?(step)
+      can_revisit_completed_steps(step)
+    end
+
+    def required_steps
+      return self.class.test_required_steps if Rails.env.test? && self.class.test_required_steps.present?
+      self.class.const_get(:WIZARD_STEPS).keys
+    end
+
+    def first_completed_step
+      required_steps.find { |step| has_completed_step?(step) }
+    end
+
+    def last_completed_step
+      required_steps.reverse.find { |step| has_completed_step?(step) }
+    end
+
+    def first_uncompleted_step
+      required_steps.find { |step| has_completed_step?(step) == false }
+    end
+
+    def has_completed_step?(step)
+      wizard_steps[step].present?
+    end
+
+    def next_step
+      required_steps.reverse.find { |step| can_visit_step?(step) } || required_steps.first
+    end
+
+    def previous_step(step)
+      index = required_steps.index(step)
+      required_steps[index-1] unless index == 0 || index.nil?
+    end
+
+    def has_completed_previous_step?(step)
+      previous = previous_step(step)
+      previous.blank? || has_completed_step?(previous)
+    end
+
+    def has_completed_last_step?
+      has_completed_step?(required_steps.last)
+    end
+
+    private
+
+    def can_revisit_completed_steps(step)
+      return (step == required_steps.last) if has_completed_last_step?
+      has_completed_previous_step?(step)
+    end
+
+    def cannot_revisit_completed_steps(step)
+      return (step == required_steps.last) if has_completed_last_step?
+      has_completed_previous_step?(step) && !has_completed_step?(step)
+    end
+
+  end
+
+  module ClassMethods
+    def acts_as_wizard?; true; end
+  end
+
+end

data/app/models/effective/resource.rb

@@ -15,8 +15,8 @@ module Effective
     include Effective::Resources::Sql
 
     # post, Post, Admin::Post, admin::Post, admin/posts, admin/post, admin/effective::post
-    def initialize(input, namespace: nil, &block)
-      _initialize_input(input, namespace: namespace)
+    def initialize(input, namespace: nil, relation: nil, &block)
+      _initialize_input(input, namespace: namespace, relation: relation)
       _initialize_model(&block) if block_given?
       self
     end

data/app/models/effective/resources/actions.rb

@@ -12,8 +12,8 @@ module Effective
       def routes
         @routes ||= (
           matches = [
-            [namespace, plural_name].compact.join('/'),
-            [namespace, name].compact.join('/')
+            [namespace, route_name.pluralize].compact.join('/'),
+            [namespace, route_name].compact.join('/'),
           ]
 
           # Check main Rails app
@@ -21,9 +21,25 @@ module Effective
             (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
           end
 
+          if routes.blank?
+            matches = [
+              [namespace, plural_name].compact.join('/'),
+              [namespace, name].compact.join('/')
+            ]
+
+            # Check main Rails app
+            routes = Rails.application.routes.routes.select do |route|
+              (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
+            end
+          end
+
           # Check engine routes
           if routes.blank?
             matches = [
+              [namespace, route_name.pluralize].compact.join('/'),
+              [namespace, route_name].compact.join('/'),
+              ['effective', namespace, route_name.pluralize].compact.join('/'),
+              ['effective', namespace, route_name].compact.join('/'),
               [namespace, plural_name].compact.join('/'),
               [namespace, name].compact.join('/'),
               ['effective', namespace, plural_name].compact.join('/'),
@@ -35,7 +51,11 @@ module Effective
                 (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
               end
 
-              break if routes.present?
+              if routes.present?
+                @routes_app = engine
+                break
+              end
+
             end
           end
 
@@ -43,6 +63,14 @@ module Effective
         )
       end
 
+      def routes_app
+        @routes_app if routes.present?
+      end
+
+      def url_helpers
+        (routes_app || Rails.application).routes.url_helpers
+      end
+
       # Effective::Resource.new('admin/posts').action_path_helper(:edit) => 'edit_admin_posts_path'
       # This will return empty for create, update and destroy
       def action_path_helper(action)

data/app/models/effective/resources/init.rb

@@ -4,9 +4,9 @@ module Effective
 
       private
 
-      def _initialize_input(input, namespace: nil)
+      def _initialize_input(input, namespace: nil, relation: nil)
         @initialized_name = input
-        @model_klass = _klass_by_input(input)
+        @model_klass = (relation ? _klass_by_input(relation) : _klass_by_input(input))
 
         # Consider namespaces
         if namespace
@@ -18,20 +18,24 @@ module Effective
         end
 
         # Consider relation
+        if relation.kind_of?(ActiveRecord::Relation)
+          @relation ||= relation
+        end
+
         if input.kind_of?(ActiveRecord::Relation)
           @relation ||= input
         end
 
         if input.kind_of?(ActiveRecord::Reflection::MacroReflection) && input.scope
-          @relation ||= klass.where(nil).merge(input.scope)
+          @relation ||= @model_klass.where(nil).merge(input.scope)
         end
 
         # Consider instance
-        if klass && input.instance_of?(klass)
+        if @model_klass && input.instance_of?(@model_klass)
           @instance ||= input
         end
 
-        if klass && input.kind_of?(Array) && input.last.instance_of?(klass)
+        if @model_klass && input.kind_of?(Array) && input.last.instance_of?(@model_klass)
           @instance ||= input.last
         end
       end

data/app/models/effective/resources/naming.rb

@@ -19,6 +19,10 @@ module Effective
         @initialized_name
       end
 
+      def route_name # 'post' initialized from the controller_path/initialized_name and not the class
+        @route_name ||= (initialized_name.to_s.split(SPLIT).last || '').singularize.underscore
+      end
+
       def class_name # 'Effective::Post'
         @model_klass ? @model_klass.name : name.classify
       end
@@ -44,11 +48,11 @@ module Effective
       end
 
       def human_name
-        class_name.gsub('::', ' ').underscore.gsub('_', ' ')
+        name.gsub('::', ' ').underscore.gsub('_', ' ')
       end
 
       def human_plural_name
-        class_name.pluralize.gsub('::', ' ').underscore.gsub('_', ' ')
+        name.pluralize.gsub('::', ' ').underscore.gsub('_', ' ')
       end
 
     end

data/app/models/effective/resources/relation.rb

@@ -4,8 +4,10 @@ module Effective
       TARGET_LIST_LIMIT = 1500
       TARGET_KEYS_LIMIT = 30000
 
+      # This could be active_model? in which we just return the klass itself here
+      # This value ends up being crud_controller resource_scope()
       def relation
-        @relation ||= klass.where(nil)
+        @relation ||= (klass.respond_to?(:where) ? klass.where(nil) : klass)
       end
 
       # When Effective::Resource is initialized with an ActiveRecord relation, the following

data/lib/effective_resources/engine.rb

@@ -26,6 +26,7 @@ module EffectiveResources
         ActiveRecord::Base.extend(ActsAsTokened::Base)
         ActiveRecord::Base.extend(ActsAsSlugged::Base)
         ActiveRecord::Base.extend(ActsAsStatused::Base)
+        ActiveRecord::Base.extend(ActsAsWizard::Base)
         ActiveRecord::Base.extend(EffectiveResource::Base)
       end
     end
@@ -51,6 +52,10 @@ module EffectiveResources
     # resources :things, concerns: :acts_as_archived
     initializer 'effective_resources.routes_concern' do |app|
       ActionDispatch::Routing::Mapper.include(ActsAsArchived::RoutesConcern)
+
+      # Doesn't seem to work with the on_load in rails 6.0
+      #ActiveSupport.on_load :action_controller_base do
+      #end
     end
 
     # Register the flash_messages concern so that it can be called in ActionController

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.6.3'.freeze
+  VERSION = '1.7.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2021-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: wicked
+  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: Make any controller an effective resource controller.
 email:
 - info@codeandeffect.com
@@ -114,12 +128,19 @@ files:
 - app/controllers/concerns/effective/crud_controller/save.rb
 - app/controllers/concerns/effective/crud_controller/submits.rb
 - app/controllers/concerns/effective/flash_messages.rb
+- app/controllers/concerns/effective/wizard_controller.rb
+- app/controllers/concerns/effective/wizard_controller/actions.rb
+- app/controllers/concerns/effective/wizard_controller/before_actions.rb
+- app/controllers/concerns/effective/wizard_controller/save.rb
+- app/controllers/concerns/effective/wizard_controller/wicked_overrides.rb
 - app/helpers/effective_resources_helper.rb
 - app/helpers/effective_resources_private_helper.rb
+- app/helpers/effective_resources_wizard_helper.rb
 - app/models/concerns/acts_as_archived.rb
 - app/models/concerns/acts_as_slugged.rb
 - app/models/concerns/acts_as_statused.rb
 - app/models/concerns/acts_as_tokened.rb
+- app/models/concerns/acts_as_wizard.rb
 - app/models/concerns/effective_resource.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/action_failed.rb