effective_resources 1.7.3 → 1.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a63a4abae27e2b70ac922d2f3eca07c701842b9ef2482677d200236f05a05dc8
-  data.tar.gz: 136206e80f42d5c019f9113d46c3260d19115f7f40ef58f0064f74b57283167f
+  metadata.gz: 7a4d2d6652da6f85e884ceb383ff012fda17863ad4b84c7cfaf5fec76a8632af
+  data.tar.gz: 155b5a31cc14908ea944978d940d550227bcb823e14bbc42e6f34108ece06c35
 SHA512:
-  metadata.gz: 2b08dd74cfa1605c8dcf8e8082612b078ff20b93f9bfbb931f41b8d58ec2795f4a6ca0ed13f837860df4b3166c2069136ab26e0b19a46fa812af2293674bb56a
-  data.tar.gz: a64adaf287722c737951827174f1074ad0580688540944551f406d66fb28dadf74ca7c845c57f008aea6036c355655674328c37c89cc90be36f40738753db436
+  metadata.gz: 4227d0379585019dafae032ac3300cc98ceed87f81bfcb45a35ab9b10c5e15f18dd7e6420b1973bef3e1567dd8ac71d78049b6ec6711153899568ed0d3398fc3
+  data.tar.gz: 700279f4126eefafe9b14d06b4dea16b9cf49c1f2b21fd472a17a80e3e2863d2f5d6318f481d3f862653d95f753960f5a0fbc79802301e3879422cec89866df8

data/README.md

@@ -362,7 +362,7 @@ rails test
 
 ## License
 
-MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+MIT License. Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 
 ## Contributing
 

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Effective
   module CrudController
     extend ActiveSupport::Concern
@@ -12,6 +13,7 @@ module Effective
     included do
       define_actions_from_routes
       define_callbacks :resource_render, :resource_before_save, :resource_after_save, :resource_after_commit, :resource_error
+      layout -> { resource_layout }
     end
 
     module ClassMethods
@@ -111,6 +113,11 @@ module Effective
       datatable
     end
 
+    def resource_layout
+      namespace = controller_path.include?('admin/') ? 'admin' : 'application'
+      defined?(Tenant) ? "#{Tenant.current}/#{namespace}" : namespace
+    end
+
     def resource_params_method_name
       ['permitted_params', "#{resource_name}_params", "#{resource_plural_name}_params"].each do |name|
         return name if respond_to?(name, true)

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

@@ -53,7 +53,7 @@ module Effective
 
         respond_to do |format|
           format.html { }
-          format.js { render('new.js') }
+          format.js { render('new', formats: :js) }
         end
       end
 
@@ -95,7 +95,7 @@ module Effective
 
         respond_to do |format|
           format.html { }
-          format.js { render('show.js') }
+          format.js { render('show', formats: :js) }
         end
 
       end
@@ -112,7 +112,7 @@ module Effective
 
         respond_to do |format|
           format.html { }
-          format.js { render('edit.js') }
+          format.js { render('edit', formats: :js) }
         end
 
       end
@@ -176,7 +176,10 @@ module Effective
 
           respond_to do |format|
             format.html { }
-            format.js { render(template_present?(action) ? action : 'member_action.js', locals: { action: action }) }
+            format.js do
+              template = template_present?(action) ? action : 'member_action'
+              render(template, formats: :js, locals: { action: action })
+            end
           end
 
           return

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

@@ -10,25 +10,28 @@ module Effective
         raise 'expected resource class to have effective_resource do .. end' if effective_resource.model.blank?
 
         permitted_params = permitted_params_for(resource, effective_resource.namespaces)
+        permitted_name = params.key?(effective_resource.name) ? effective_resource.name : effective_resource.resource_name
 
         if Rails.env.development?
           Rails.logger.info "Effective::CrudController#resource_permitted_params:"
-          Rails.logger.info "params.require(:#{effective_resource.resource_name}).permit(#{permitted_params.to_s[1...-1]})"
+          Rails.logger.info "params.require(:#{permitted_name}).permit(#{permitted_params.to_s[1...-1]})"
         end
 
-        params.require(effective_resource.resource_name).permit(*permitted_params)
+        params.require(permitted_name).permit(*permitted_params)
       end
 
       # If the resource is ActiveModel, just permit all
       # This can still be overridden by a controller
       def resource_active_model_permitted_params
+        permitted_name = params.key?(effective_resource.name) ? effective_resource.name : effective_resource.resource_name
+
         if Rails.env.development?
           Rails.logger.info "Effective::CrudController#resource_permitted_params:"
-          Rails.logger.info "params.require(:#{effective_resource.resource_name}).permit!"
+          Rails.logger.info "params.require(:#{permitted_name}).permit!"
         end
 
-        if params[effective_resource.resource_name].present?
-          params.require(effective_resource.resource_name).permit!
+        if params[permitted_name].present?
+          params.require(permitted_name).permit!
         else
           params.require((effective_resource.namespaces + [effective_resource.resource_name]).join('_')).permit!
         end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module CrudController
     module Respond
@@ -94,7 +96,10 @@ module Effective
       end
 
       def template_present?(action)
-        lookup_context.template_exists?("#{action}.#{request.format.symbol.to_s.sub('json', 'js').presence || 'html'}", _prefixes)
+        #lookup_context.template_exists?("#{action}.#{request.format.symbol.to_s.sub('json', 'js').presence || 'html'}", _prefixes)
+
+        formats = [request.format.symbol.to_s.sub('json', 'js').presence || 'html']
+        lookup_context.template_exists?(action, _prefixes, formats: formats)
       end
 
     end

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

@@ -76,6 +76,7 @@ module Effective
       def resource_flash(status, resource, action, e: nil)
         submit = commit_action(action)
         message = submit[status].respond_to?(:call) ? instance_exec(&submit[status]) : submit[status]
+
         return message.gsub('@resource', resource.to_s) if message.present?
         return nil if message.blank? && submit.key?(status)
 
@@ -93,6 +94,9 @@ module Effective
 
       # Should return a new resource based on the passed one
       def duplicate_resource(resource)
+        return resource.duplicate if resource.respond_to?(:duplicate)
+        return resource.duplicate! if resource.respond_to?(:duplicate!)
+        return resource.deep_dup if resource.respond_to?(:deep_dup)
         resource.dup
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module FlashMessages
     extend ActiveSupport::Concern
@@ -6,7 +8,11 @@ module Effective
     def flash_success(resource, action = nil, name: nil)
       raise 'expected an ActiveRecord resource' unless (name || resource.class.respond_to?(:model_name))
 
-      "Successfully #{action_verb(action)} #{name || resource}".html_safe
+      name ||= begin
+        resource.destroyed? ? resource.class.model_name.to_s.downcase.split('::').last : resource.to_s.presence
+      end
+
+      "Successfully #{action_verb(action)} #{name || 'resource'}".html_safe
     end
 
     # flash.now[:danger] = flash_danger(@post)
@@ -18,7 +24,9 @@ module Effective
 
       messages = flash_errors(resource, e: e)
 
-      name ||= resource.to_s.presence
+      name ||= begin
+        resource.destroyed? ? resource.class.model_name.to_s.downcase.split('::').last : resource.to_s.presence
+      end
 
       ["Unable to #{action}", (" #{name}" if name), (": #{messages}" if messages)].compact.join.html_safe
     end
@@ -27,7 +35,10 @@ module Effective
     def flash_errors(resource, e: nil)
       raise 'expected an ActiveRecord resource' unless resource.respond_to?(:errors)
 
-      messages = resource.errors.map do |attribute, message|
+      messages = resource.errors.map do |error|
+        attribute = error.respond_to?(:attribute) ? error.attribute : error.first
+        message = error.respond_to?(:message) ? error.message : error.last
+
         if message[0] == message[0].upcase # If the error begins with a capital letter
           message
         elsif attribute == :base
@@ -52,6 +63,8 @@ module Effective
         'deleted'
       elsif word == 'undo'
         'undid'
+      elsif word == 'run'
+        'ran'
       elsif word.end_with?('e')
         action.sub(word, word + 'd')
       elsif ['a', 'i', 'o', 'u'].include?(word[-1])

data/app/helpers/effective_resources_helper.rb

@@ -107,15 +107,16 @@ module EffectiveResourcesHelper
 
     # Select Partial
     partial = if partial.kind_of?(Symbol)
-      "effective/resource/actions_#{partial}.html"
+      "effective/resource/actions_#{partial}"
     else
-      "#{partial.presence || 'effective/resource/actions'}.html"
+      partial.presence || 'effective/resource/actions'
     end
 
     # Assign Locals
     locals = {
       resource: resource,
       effective_resource: effective_resource,
+      formats: [:html],
       format_block: (block if block_given?),
       namespace: namespace,
       actions: actions,
@@ -123,7 +124,14 @@ module EffectiveResourcesHelper
     }.compact.merge(locals)
 
     if resource.kind_of?(Array)
-      render(partial: partial, collection: resource, as: :resource, locals: locals.except(:resource), spacer_template: spacer_template)
+      render(
+        partial: partial,
+        formats: [:html],
+        collection: resource,
+        as: :resource,
+        locals: locals.except(:resource),
+        spacer_template: spacer_template
+      )
     else
       render(partial, locals)
     end
@@ -143,16 +151,24 @@ module EffectiveResourcesHelper
     atts = { :namespace => (effective_resource.namespace.to_sym if effective_resource.namespace), effective_resource.name.to_sym => resource }.compact.merge(atts)
 
     if lookup_context.template_exists?("form_#{action}", controller._prefixes, :partial)
-      render "form_#{action}", atts
-    elsif lookup_context.template_exists?('form', controller._prefixes, :partial)
-      render 'form', atts
-    elsif lookup_context.template_exists?('form', effective_resource.plural_name, :partial)
-      render "#{effective_resource.plural_name}/form", atts
-    elsif lookup_context.template_exists?('form', effective_resource.name, :partial)
-      render "#{effective_resource.name}/form", atts
-    else
-      render 'form', atts  # Will raise the regular error
+      return render("form_#{action}", atts)
+    end
+
+    if lookup_context.template_exists?('form', controller._prefixes, :partial)
+      return render('form', atts)
+    end
+
+    effective_resource.view_paths.each do |view_path|
+      if lookup_context.template_exists?("form_#{action}", [view_path], :partial)
+        return render(view_path + '/' + "form_#{action}", atts)
+      end
+
+      if lookup_context.template_exists?('form', [view_path], :partial)
+        return render(view_path + '/' + 'form', atts)
+      end
     end
+
+    render('form', atts) # Will raise the regular error
   end
 
   # Similar to render_resource_form
@@ -169,14 +185,16 @@ module EffectiveResourcesHelper
     atts = { :namespace => (effective_resource.namespace.to_sym if effective_resource.namespace), effective_resource.name.to_sym => resource }.compact.merge(atts)
 
     if lookup_context.template_exists?(effective_resource.name, controller._prefixes, :partial)
-      render(effective_resource.name, atts)
-    elsif lookup_context.template_exists?(effective_resource.name, [effective_resource.plural_name], :partial)
-      render(effective_resource.plural_name + '/' + effective_resource.name, atts)
-    elsif lookup_context.template_exists?(effective_resource.name, [effective_resource.name], :partial)
-      render(effective_resource.name + '/' + effective_resource.name, atts)
-    else
-      render(resource, atts)  # Will raise the regular error
+      return render(effective_resource.name, atts)
     end
+
+    effective_resource.view_paths.each do |view_path|
+      if lookup_context.template_exists?(effective_resource.name, [view_path], :partial)
+        return render(view_path + '/' + effective_resource.name, atts)
+      end
+    end
+
+    render(resource, atts)  # Will raise the regular error
   end
 
   # Tableize attributes

data/app/models/concerns/acts_as_slugged.rb

@@ -16,7 +16,9 @@ module ActsAsSlugged
   included do
     extend FinderMethods
 
-    before_validation { self.slug ||= build_slug }
+    before_validation do
+      assign_attributes(slug: build_slug) if slug.blank?
+    end
 
     validates :slug,
       presence: true, uniqueness: true, exclusion: { in: excluded_slugs }, length: { maximum: 255 },
@@ -44,7 +46,7 @@ module ActsAsSlugged
 
   # Instance Methods
   def build_slug
-    slug = self.to_s.parameterize.downcase[0, 250]
+    slug = to_s.parameterize.downcase[0, 250]
 
     if self.class.excluded_slugs.include?(slug)
       slug = "#{slug}-#{self.class.name.demodulize.parameterize}"

data/app/models/concerns/effective_devise_user.rb

@@ -0,0 +1,167 @@
+# EffectiveDeviseUsr
+#
+# Mark your user model with devise_for then effective_devise_user
+
+module EffectiveDeviseUser
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_devise_user
+      include ::EffectiveDeviseUser
+    end
+  end
+
+  included do
+    effective_resource do
+      encrypted_password      :string
+      reset_password_token    :string
+      reset_password_sent_at  :datetime
+      remember_created_at     :datetime
+      sign_in_count           :integer
+      current_sign_in_at      :datetime
+      last_sign_in_at         :datetime
+      current_sign_in_ip      :inet
+      last_sign_in_ip         :inet
+
+      # Devise invitable attributes
+      invitation_token        :string
+      invitation_created_at   :datetime
+      invitation_sent_at      :datetime
+      invitation_accepted_at  :datetime
+      invitation_limit        :integer
+      invited_by_type         :string
+      invited_by_id           :integer
+      invitations_count       :integer
+
+      # Omniauth
+      uid                     :string
+      provider                :string
+
+      access_token            :string
+      refresh_token           :string
+      token_expires_at        :datetime
+
+      name                    :string
+      avatar_url              :string
+    end
+
+    # Devise invitable ignores model validations, so we manually check for duplicate email addresses.
+    before_save(if: -> { new_record? && invitation_sent_at.present? }) do
+      if email.blank?
+        self.errors.add(:email, "can't be blank")
+        raise("email can't be blank")
+      end
+
+      if self.class.where(email: email.downcase.strip).exists?
+        self.errors.add(:email, 'has already been taken')
+        raise("email has already been taken")
+      end
+    end
+
+    # Clear the provider if an oauth signed in user resets password
+    before_save(if: -> { persisted? && encrypted_password_changed? }) do
+      assign_attributes(provider: nil, access_token: nil, refresh_token: nil, token_expires_at: nil)
+    end
+  end
+
+  module ClassMethods
+    def permitted_sign_up_params # Should contain all fields as per views/users/_sign_up_fields
+      [:email, :password, :password_confirmation, :first_name, :last_name, :name, :login]
+    end
+
+    def from_omniauth(auth, params)
+      invitation_token = (params.presence || {})['invitation_token']
+
+      email = (auth.info.email.presence || "#{auth.uid}@#{auth.provider}.none").downcase
+      image = auth.info.image
+      name = auth.info.name || auth.dig(:extra, :raw_info, :login)
+
+      user = if invitation_token
+        find_by_invitation_token(invitation_token, false) || raise(ActiveRecord::RecordNotFound)
+      else
+        where(uid: auth.uid).or(where(email: email)).first || self.new()
+      end
+
+      user.assign_attributes(
+        uid: auth.uid,
+        provider: auth.provider,
+        email: email,
+        avatar_url: image,
+        name: name,
+        first_name: (auth.info.first_name.presence || name.split(' ').first.presence || 'First'),
+        last_name: (auth.info.last_name.presence || name.split(' ').last.presence || 'Last')
+      )
+
+      if auth.respond_to?(:credentials)
+        user.assign_attributes(
+          access_token: auth.credentials.token,
+          refresh_token: auth.credentials.refresh_token,
+          token_expires_at: Time.zone.at(auth.credentials.expires_at), # We are given integer datetime e.g. '1549394077'
+        )
+      end
+
+      # Make a password
+      user.password = Devise.friendly_token[0, 20] if user.encrypted_password.blank?
+
+      # Devise Invitable
+      invitation_token ? user.accept_invitation! : user.save!
+
+      # Devise Confirmable
+      user.confirm if user.respond_to?(:confirm)
+
+      user
+    end
+
+    # https://github.com/heartcombo/devise/blob/master/lib/devise/models/recoverable.rb#L134
+    def send_reset_password_instructions(attributes = {})
+      recoverable = find_or_initialize_with_errors(reset_password_keys, attributes, :not_found)
+      return recoverable unless recoverable.persisted?
+
+      # Add custom errors and require a confirmation if previous sign in was provider
+      if recoverable.provider.present? && attributes[:confirm_new_password].blank?
+        recoverable.errors.add(:email, "previous sign in was with #{recoverable.provider}")
+        recoverable.errors.add(:confirm_new_password, 'please confirm to proceed')
+      end
+
+      recoverable.send_reset_password_instructions if recoverable.errors.blank?
+      recoverable
+    end
+
+  end
+
+  # EffectiveDeviseUser Instance Methods
+
+  def reinvite!
+    invite!
+  end
+
+  def active_for_authentication?
+    super && (respond_to?(:archived?) ? !archived? : true)
+  end
+
+  def inactive_message
+    (respond_to?(:archived?) && archived?) ? :archived : super
+  end
+
+  # Any password will work in development or mode
+  def valid_password?(password)
+    Rails.env.development? || Rails.env.staging? || super
+  end
+
+  # Send devise & devise_invitable emails via active job
+  def send_devise_notification(notification, *args)
+    raise('expected args Hash') unless args.respond_to?(:last) && args.last.kind_of?(Hash)
+
+
+
+    if defined?(Tenant)
+      tenant = Tenant.current || raise('expected a current tenant')
+      args.last[:tenant] ||= tenant
+    end
+
+    wait = (5 if notification == :invitation_instructions && !Rails.env.test?)
+
+    devise_mailer.send(notification, self, *args).deliver_later(wait: wait)
+  end
+
+end

data/app/models/effective/attribute.rb

@@ -27,6 +27,7 @@ module Effective
       @type ||= (
         case obj
         when :boolean     ; :boolean
+        when :config      ; :config
         when :currency    ; :currency
         when :date        ; :date
         when :datetime    ; :datetime
@@ -73,6 +74,9 @@ module Effective
       case type
       when :boolean
         [true, 'true', 't', '1'].include?(value)
+      when :config
+        raise('expected an ActiveSupport::OrderedOptions') unless value.kind_of?(ActiveSupport::OrderedOptions)
+        parse_ordered_options(value)
       when :date, :datetime
         if (digits = value.to_s.scan(/(\d+)/).flatten).present?
           date = if digits.first.length == 4  # 2017-01-10
@@ -169,5 +173,14 @@ module Effective
       name == other.name && type == other.type
     end
 
+    # This returns a nested ActiveSupport::OrderedOptions.new config
+    def parse_ordered_options(obj)
+      return obj unless obj.kind_of?(Hash)
+
+      ActiveSupport::OrderedOptions.new.tap do |config|
+        obj.each { |key, value| config[key] = parse_ordered_options(value) }
+      end
+    end
+
   end
 end

data/app/models/effective/resource.rb

@@ -14,10 +14,18 @@ module Effective
     include Effective::Resources::Relation
     include Effective::Resources::Sql
 
+
+    # In practice, this is initialized two ways
+    # With a klass and a namespace from effective_datatables
+    # Or with a controller_path from crud controller
+
     # post, Post, Admin::Post, admin::Post, admin/posts, admin/post, admin/effective::post
     def initialize(input, namespace: nil, relation: nil, &block)
       _initialize_input(input, namespace: namespace, relation: relation)
+
+      # This is an effective_resource do ... end block
       _initialize_model(&block) if block_given?
+
       self
     end
 

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

@@ -7,60 +7,43 @@ module Effective
       POST_VERBS = ['POST', 'PUT', 'PATCH']
       CRUD_ACTIONS = %i(index new create show edit update destroy)
 
-      # This was written for the Edit actions fallback templates and Datatables
-      # Effective::Resource.new('admin/posts').routes[:index]
+      # This will have been set by init from crud_controller, or from a class and namespace
+      def controller_path
+        @controller_path ||= route_name #[namespace, plural_name].compact * '/')
+      end
+
       def routes
-        @routes ||= (
-          matches = [
-            [namespace, route_name.pluralize].compact.join('/'),
-            [namespace, route_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
+        @routes ||= begin
+          routes = nil
+          engines = [Rails.application] + Rails::Engine.subclasses.reverse
+
+          # Check from controller_path. This is generally correct.
+          engines.each do |engine|
+            routes = engine.routes.routes.select do |route|
+              controller_path == route.defaults[:controller] && !(route.name || '').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')
+            if routes.present?
+              @routes_app = engine; break
             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('/'),
-              ['effective', namespace, name].compact.join('/')
-            ]
-
-            (Rails::Engine.subclasses.reverse + [Rails.application]).each do |engine|
+            matches = route_name_fallbacks()
+
+            engines.each do |engine|
               routes = engine.routes.routes.select do |route|
-                (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
+                (matches & [route.defaults[:controller]]).present? && !(route.name || '').end_with?('root')
               end
 
               if routes.present?
-                @routes_app = engine
-                break
+                @routes_app = engine; break
               end
-
             end
           end
 
           Array(routes).inject({}) { |h, route| h[route.defaults[:action].to_sym] = route; h }
-        )
+        end
       end
 
       def routes_app
@@ -137,58 +120,39 @@ module Effective
       end
 
       def crud_actions
-        @crud_actions ||= (actions & CRUD_ACTIONS)
+        (actions & CRUD_ACTIONS)
       end
 
       # GET actions
       def collection_actions
-        @collection_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) } - [nil]
       end
 
       def collection_get_actions
-        @collection_get_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_get_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_get_route?(route) } - [nil]
       end
 
       def collection_post_actions
-        @collection_post_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_post_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_post_route?(route) } - [nil]
       end
 
       # All actions
       def member_actions
-        @member_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) } - [nil]
       end
 
       # GET actions
       def member_get_actions
-        @member_get_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_get_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_get_route?(route) } - [nil]
       end
 
       def member_delete_actions
-        @member_delete_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_delete_route?(route) }.tap(&:compact!)
-        )
+        routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_delete_route?(route) } - [nil]
       end
 
       # POST/PUT/PATCH actions
       def member_post_actions
-        @member_post_actions ||= (
-          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_post_route?(route) }.tap(&:compact!)
-        )
-      end
-
-      # Same as controller_path in the view
-      def controller_path
-        [namespace, plural_name].compact * '/'
+        routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_post_route?(route) } - [nil]
       end
 
       private

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

@@ -7,6 +7,7 @@ module Effective
         case (type || sql_type(name))
         when :belongs_to
           { as: :select }.merge(search_form_field_collection(belongs_to(name)))
+
         when :belongs_to_polymorphic
           constant_pluralized = name.to_s.upcase
           constant = name.to_s.pluralize.upcase
@@ -18,7 +19,7 @@ module Effective
             collection ||= (klass.const_get(constant_pluralized) rescue nil) if defined?("#{klass.name}::#{constant_pluralized}")
           end
 
-          { as: :select, polymorphic: true, collection: collection }.compact
+          { as: :select, polymorphic: true, collection: (collection || []) }.compact
         when :has_and_belongs_to_many
           { as: :select }.merge(search_form_field_collection(has_and_belongs_to_many(name)))
         when :has_many

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

@@ -8,6 +8,11 @@ module Effective
         @initialized_name = input
         @model_klass = (relation ? _klass_by_input(relation) : _klass_by_input(input))
 
+        # Consider controller_name
+        if @model_klass && input.kind_of?(String) && namespace.blank?
+          @controller_path = input
+        end
+
         # Consider namespaces
         if namespace
           @namespaces = (namespace.kind_of?(String) ? namespace.split('/') : Array(namespace))
@@ -62,30 +67,30 @@ module Effective
         end
       end
 
+
+      # 'acpa/admin/shirts'
       def _klass_by_name(input)
         input = input.to_s
         input = input[1..-1] if input.start_with?('/')
 
         names = input.split('/')
 
-        # Crazy classify
-        0.upto(names.length-1) do |index|
-          class_name = names[index..-1].map { |name| name.classify } * '::'
-          klass = class_name.safe_constantize
-
-          if klass.blank? && index > 0
-            class_name = (names[0..index-1].map { |name| name.classify.pluralize } + names[index..-1].map { |name| name.classify }) * '::'
-            klass = class_name.safe_constantize
-          end
-
-          if klass.present?
-            @namespaces ||= names[0...index]
-            @model_klass = klass
-            return klass
+        # Classify based on namespace
+        # acpa/admin/shirts
+        (names.length).downto(1).each do |n|
+          names.combination(n).to_a.each do |pieces|
+            klass_pieces = pieces.map { |piece| piece.classify } * '::'
+            klass = klass_pieces.safe_constantize
+
+            if klass.present? && klass.class != Module
+              @namespaces ||= (names - pieces)
+              @model_klass = klass
+              return klass
+            end
           end
         end
 
-        # Crazy engine
+        # Crazy effective engine.
         if names[0] == 'admin'
           class_name = (['effective'] + names[1..-1]).map { |name| name.classify } * '::'
           klass = class_name.safe_constantize

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

@@ -8,6 +8,8 @@ module Effective
 
       def datatable_klass
         if defined?(EffectiveDatatables)
+          "#{controller_path.classify.pluralize}Datatable".safe_constantize ||
+          "#{controller_path.classify}Datatable".safe_constantize ||
           "#{namespaced_class_name.pluralize}Datatable".safe_constantize ||
           "#{namespaced_module_name.pluralize}Datatable".safe_constantize ||
           "#{namespaced_class_name.pluralize.gsub('::', '')}Datatable".safe_constantize ||

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

@@ -19,8 +19,27 @@ module Effective
         @initialized_name
       end
 
+      # There could be a few, this is the best guess.
       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
+        names = class_name.split('::')
+
+        if names.length > 1
+          Array(names[0]) + namespaces + Array(names[1..-1])
+        else
+          namespaces + names
+        end.compact.map(&:downcase).join('/').pluralize
+      end
+
+      def route_name_fallbacks
+        mod = class_name.split('::').first.downcase
+
+        matches = [
+          route_name.singularize,
+          [*namespace, plural_name].join('/'),
+          [*namespace, name].join('/'),
+          [mod, *namespace, plural_name].join('/'),
+          [mod, *namespace, name].join('/')
+        ]
       end
 
       def class_name # 'Effective::Post'

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

@@ -22,6 +22,22 @@ module Effective
         File.join('app/views', plural_name, "#{'_' if partial}#{action}.html.haml")
       end
 
+      # Used by render_resource_partial and render_resource_form to guess the view path
+      def view_paths
+        mod = class_name.split('::').first.downcase
+
+        [
+          [mod, *namespace, plural_name].join('/'),
+          [mod, *namespace, name].join('/'),
+          [*namespace, mod, plural_name].join('/'),
+          [*namespace, mod, name].join('/'),
+          [mod, plural_name].join('/'),
+          [mod, name].join('/'),
+          [*namespace, plural_name].join('/'),
+          [*namespace, name].join('/')
+        ]
+      end
+
     end
   end
 end

data/lib/effective_resources.rb

@@ -1,25 +1,24 @@
 require 'effective_resources/engine'
 require 'effective_resources/version'
+require 'effective_resources/effective_gem'
 
 module EffectiveResources
 
-  # The following are all valid config keys
-  mattr_accessor :authorization_method
-  mattr_accessor :default_submits
-
-  def self.setup
-    yield self
+  def self.config_keys
+    [:authorization_method, :default_submits]
   end
 
+  include EffectiveGem
+
   def self.authorized?(controller, action, resource)
-    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
+    @exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
 
     return !!authorization_method unless authorization_method.respond_to?(:call)
     controller = controller.controller if controller.respond_to?(:controller)
 
     begin
       !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
-    rescue *@_exceptions
+    rescue *@exceptions
       false
     end
   end
@@ -29,9 +28,7 @@ module EffectiveResources
   end
 
   def self.default_submits
-    @_default_submits ||= begin
-      (['Save', 'Continue', 'Add New'] & Array(@@default_submits)).inject({}) { |h, v| h[v] = true; h }
-    end
+    (['Save', 'Continue', 'Add New'] & Array(config.default_submits)).inject({}) { |h, v| h[v] = true; h }
   end
 
 end

data/lib/effective_resources/effective_gem.rb

@@ -0,0 +1,42 @@
+# Effective Engine concern
+
+module EffectiveGem
+  extend ActiveSupport::Concern
+
+  included do
+    raise("expected self.config_keys method") unless respond_to?(:config_keys)
+
+    config_keys.each do |key|
+      self.class.define_method(key) { config()[key] }
+    end
+  end
+
+  module ClassMethods
+    def config(namespace = nil)
+      namespace ||= Tenant.current if defined?(Tenant)
+      @config.dig(namespace) || @config
+    end
+
+    def setup(namespace = nil, &block)
+      @config ||= ActiveSupport::OrderedOptions.new
+      namespace ||= Tenant.current if defined?(Tenant)
+
+      if namespace
+        @config[namespace] ||= ActiveSupport::OrderedOptions.new
+      end
+
+      yield(config(namespace))
+
+      if(unsupported = (config(namespace).keys - config_keys)).present?
+        if unsupported.include?(:authorization_method)
+          raise("config.authorization_method has been removed. This gem will call EffectiveResources.authorization_method instead. Please double check the config.authorization_method setting in config/initializers/effective_resources.rb and remove it from this file.")
+        end
+
+        raise("unsupported config keys: #{unsupported}\n supported keys: #{config_keys}")
+      end
+
+      true
+    end
+  end
+
+end

data/lib/effective_resources/engine.rb

@@ -27,6 +27,8 @@ module EffectiveResources
         ActiveRecord::Base.extend(ActsAsSlugged::Base)
         ActiveRecord::Base.extend(ActsAsStatused::Base)
         ActiveRecord::Base.extend(ActsAsWizard::Base)
+
+        ActiveRecord::Base.extend(EffectiveDeviseUser::Base)
         ActiveRecord::Base.extend(EffectiveResource::Base)
       end
     end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.7.3'.freeze
+  VERSION = '1.7.8'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.7.3
+  version: 1.7.8
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-02 00:00:00.000000000 Z
+date: 2021-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -141,6 +141,7 @@ files:
 - 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_devise_user.rb
 - app/models/concerns/effective_resource.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/action_failed.rb
@@ -179,6 +180,7 @@ files:
 - app/views/effective/resource/_actions_glyphicons.html.haml
 - config/effective_resources.rb
 - lib/effective_resources.rb
+- lib/effective_resources/effective_gem.rb
 - lib/effective_resources/engine.rb
 - lib/effective_resources/version.rb
 - lib/generators/effective_resources/install_generator.rb