effective_resources 1.6.0 → 1.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2318bd8d0a93c63c8287583dd80a6b6e067bb5677f330b930d58588677d2cb55
-  data.tar.gz: 82af0a3fdbb5c27bd2498bf82017c398485b755d729674e8963796b5b72f85c9
+  metadata.gz: 638c0fd7b0f6e8ad8cbcdfe19a1d10e3824a2767734371e7ee744687181eb773
+  data.tar.gz: 25bf07d2126c62e65092cbeb4113a8df0017188fd5f17108b425cf8aa4ff09b0
 SHA512:
-  metadata.gz: 5bd4c614b11beea8c848996a541b2e729092164543d9b69727ae346b6146783b0024c8ebeb428615c5806c87107146b10a7055800cf7ad0a7f42a80fea0f54bf
-  data.tar.gz: d942166674ede76968161547a5eef54c1f3e9db015c2878d67ebaaa930117ad53f19beeaeea5632e4d69d39282cadf848c0da5c2cf151b3079d6288d4daeadab
+  metadata.gz: 86e11947ca25724dfb6255bd77129b92b87780f8199257634ebdd6841406165ba952d4ddad329608d15685102c5e216b9afeae6cffc51052c05b9564881ec749
+  data.tar.gz: 70608699672fe60a576f96987224accdddeffeef6248d775c2f6f4481ef1b69c42edddc14e20cb953025098e041d9e354fdb354dfa0a6b99a25a18218f9a5d81

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

@@ -71,6 +71,10 @@ module Effective
       effective_resource.name
     end
 
+    def resource_name_id
+      (effective_resource.name + '_id').to_sym
+    end
+
     def resource_klass # Thing
       effective_resource.klass
     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/permitted_params.rb

@@ -96,7 +96,7 @@ module Effective
 
           if (nested_params = permitted_params_for(nested.klass, namespaces)).present?
             nested_params.insert(nested_params.rindex { |obj| !obj.kind_of?(Hash)} + 1, :_destroy)
-            permitted_params << { "#{nested.resource_name}_attributes".to_sym => nested_params }
+            permitted_params << { "#{nested.name}_attributes".to_sym => nested_params }
           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,65 @@
+module Effective
+  module WizardController
+    extend ActiveSupport::Concern
+
+    unless defined?(Wicked)
+      raise("please install gem 'wicked' to use Effective::WizardController")
+    end
+
+    include Wicked::Wizard
+    include Effective::CrudController
+
+    include Effective::WizardController::Actions
+    include Effective::WizardController::BeforeActions
+    include Effective::WizardController::Save
+
+    included do
+      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
+
+    def resource_wizard_path(resource, step)
+      path_helper = effective_resource.action_path_helper(:show).to_s.sub('_path', '_build_path')
+      public_send(path_helper, resource, step)
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+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))
+
+        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 urrent 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/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,103 @@
+# 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 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/resources/actions.rb

@@ -30,7 +30,7 @@ module Effective
               ['effective', namespace, name].compact.join('/')
             ]
 
-            Rails::Engine.subclasses.each do |engine|
+            (Rails::Engine.subclasses.reverse + [Rails.application]).each do |engine|
               routes = engine.routes.routes.select do |route|
                 (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
               end
@@ -85,13 +85,15 @@ module Effective
                 h[part] = target.public_send(part)
               end
             end
-          else
+          elsif target.respond_to?(:to_param) || target.respond_to?(:id)
             target
+          else
+            {id: target}
           end
         end
 
         # Generate the path
-        path = routes[action].format(formattable || EMPTY_HASH)
+        path = (routes[action].format(formattable || EMPTY_HASH) rescue nil)
 
         if path.present? && opts.present?
           uri = URI.parse(path)

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

@@ -9,10 +9,11 @@ module Effective
       def datatable_klass
         if defined?(EffectiveDatatables)
           "#{namespaced_class_name.pluralize}Datatable".safe_constantize ||
-          "#{class_name.pluralize.camelize}Datatable".safe_constantize ||
-          "#{name.pluralize.camelize}Datatable".safe_constantize ||
+          "#{namespaced_module_name.pluralize}Datatable".safe_constantize ||
           "#{namespaced_class_name.pluralize.gsub('::', '')}Datatable".safe_constantize ||
+          "#{class_name.pluralize.camelize}Datatable".safe_constantize ||
           "#{class_name.pluralize.camelize.gsub('::', '')}Datatable".safe_constantize ||
+          "#{name.pluralize.camelize}Datatable".safe_constantize ||
           "#{name.pluralize.camelize.gsub('::', '')}Datatable".safe_constantize ||
           "Effective::Datatables::#{namespaced_class_name.pluralize}".safe_constantize ||
           "Effective::Datatables::#{class_name.pluralize.camelize}".safe_constantize ||

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

@@ -31,6 +31,10 @@ module Effective
         (Array(namespaces).map { |name| name.to_s.classify } + [class_name]) * '::'
       end
 
+      def namespaced_module_name # 'Admin::EffectivePosts'
+        Array(namespaces).map { |name| name.to_s.classify }.join('::') + '::' + class_name.gsub('::', '')
+      end
+
       def namespace # 'admin/things'
         (namespaces.join('/') if namespaces.present?)
       end

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
@@ -50,7 +51,9 @@ module EffectiveResources
     # Register the acts_as_archived routes concern
     # resources :things, concerns: :acts_as_archived
     initializer 'effective_resources.routes_concern' do |app|
-      ActionDispatch::Routing::Mapper.include(ActsAsArchived::RoutesConcern)
+      ActiveSupport.on_load :action_controller_base do
+        ActionDispatch::Routing::Mapper.include(ActsAsArchived::RoutesConcern)
+      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.0'.freeze
+  VERSION = '1.6.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.5
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2020-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: effective_datatables
+  name: effective_bootstrap
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: effective_developer
+  name: effective_datatables
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -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,18 @@ 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/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