effective_resources 1.5.2 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbff7f74429b0acf21d35b75cb64e6fedcdb4b35c2e62080c530d7416dd1d05c
-  data.tar.gz: 392c8953a3cd59673d093c9fb8c8160951d54866c293e4f7f200d358503e0aab
+  metadata.gz: 8623ea704325f309e92ac90f7df48786d1cb44ce3f050628f094ac90a5a74590
+  data.tar.gz: 0c08de0bfeb8345152a89a68ab9031446ea455b3d6bcdb9cd39b5eb456be6baf
 SHA512:
-  metadata.gz: 24f6a3cc4b8ab73cfd180e79f45ab609fd6cb3af7ef76f24c07b272c82d6ee1087203e76e09f2113e217975f1d29cd550930a99cd82197ccd18985a5f1faa1b0
-  data.tar.gz: 1b3c4ef600b6aae43357764d6d908141f13453853fb7645ed11bf58f136dcb2265e16fadbaed9cfd627dd1a6d557fe4f14f1a24021e66491e072ad676e174a3e
+  metadata.gz: 467e9ca96fca55a286f6104ebb1bb5b32821d796fe31531726114fa723344cbad3cfa3371998759dbd5a75688f6cbffe08345b9053ef756aacf972436340019c
+  data.tar.gz: 97bb18a3ea794fe2be6696096b6636f37522a06d1e67a782e1b17794088f60d5132edb736506c50067fc3686502c9768a4e5a640e845cdd62d6c255b08f7505d

data/README.md

@@ -1,7 +1,7 @@
 # Effective Resources
 
 This gem looks at the current `routes.rb`, authorization `ability.rb`, `current_user` and controller context
-to metaprogram an effective CRUD website. 
+to metaprogram an effective CRUD website.
 
 It automates linking to resource edit, show, delete pages, as well as member and collection actions.
 
@@ -256,6 +256,14 @@ end
 
 and include Effective::CrudController in your resource controller.
 
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
 ## License
 
 MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
@@ -268,4 +276,3 @@ MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Bonus points for test coverage
 6. Create new Pull Request
-

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

@@ -118,7 +118,9 @@ module Effective
 
       return unless datatable_klass.present?
 
-      datatable_klass.new(resource_datatable_attributes)
+      datatable = datatable_klass.new(resource_datatable_attributes)
+      datatable.effective_resource = effective_resource if datatable.respond_to?(:effective_resource=)
+      datatable
     end
 
     def resource_params_method_name

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

@@ -80,7 +80,7 @@ module Effective
         raise 'expected a proc or block' unless (obj.respond_to?(:call) || block_given?)
 
         instance_exec do
-          prepend_before_action(opts) { @_effective_resource_scope ||= instance_exec(&(block_given? ? block : obj)) }
+          before_action(opts) { @_effective_resource_scope ||= instance_exec(&(block_given? ? block : obj)) }
         end
       end
 

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

@@ -5,7 +5,7 @@ module Effective
 
       # This is only available to models that use the effective_resource do ... end attributes block
       # It will be called last, and only for those resources
-      # params.require(effective_resource.name).permit!
+      # params.require(effective_resource.resource_name).permit!
       def resource_permitted_params
         raise 'expected resource class to have effective_resource do .. end' if effective_resource.model.blank?
 
@@ -13,10 +13,10 @@ module Effective
 
         if Rails.env.development?
           Rails.logger.info "Effective::CrudController#resource_permitted_params:"
-          Rails.logger.info "params.require(:#{effective_resource.name}).permit(#{permitted_params.to_s[1...-1]})"
+          Rails.logger.info "params.require(:#{effective_resource.resource_name}).permit(#{permitted_params.to_s[1...-1]})"
         end
 
-        params.require(effective_resource.name).permit(*permitted_params)
+        params.require(effective_resource.resource_name).permit(*permitted_params)
       end
 
       # If the resource is ActiveModel, just permit all
@@ -24,13 +24,13 @@ module Effective
       def resource_active_model_permitted_params
         if Rails.env.development?
           Rails.logger.info "Effective::CrudController#resource_permitted_params:"
-          Rails.logger.info "params.require(:#{effective_resource.name}).permit!"
+          Rails.logger.info "params.require(:#{effective_resource.resource_name}).permit!"
         end
 
-        if params[effective_resource.name].present?
-          params.require(effective_resource.name).permit!
+        if params[effective_resource.resource_name].present?
+          params.require(effective_resource.resource_name).permit!
         else
-          params.require((effective_resource.namespaces + [effective_resource.name]).join('_')).permit!
+          params.require((effective_resource.namespaces + [effective_resource.resource_name]).join('_')).permit!
         end
       end
 
@@ -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.name}_attributes".to_sym => nested_params }
+            permitted_params << { "#{nested.resource_name}_attributes".to_sym => nested_params }
           end
         end
 

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

@@ -64,10 +64,14 @@ module Effective
           else
             if template_present?(action)
               format.html { render(action, locals: { action: action }) }
+            elsif request.referer.to_s.end_with?('/edit')
+              format.html { render :edit }
+            elsif request.referer.to_s.end_with?('/new')
+              format.html { render :new }
             else
               format.html do
                 redirect_flash
-                redirect_to(from_path.presence || resource_redirect_path(action))
+                redirect_to(resource_redirect_path(action))
               end
             end
           end

data/app/helpers/effective_resources_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EffectiveResourcesHelper
 
   # effective_bootstrap
@@ -74,18 +76,22 @@ module EffectiveResourcesHelper
     namespace ||= (effective_resource.namespace.to_sym if effective_resource.namespace)
 
     # Assign actions
-    actions = if atts.key?(:actions) # We filter out any actions passed to us that aren't supported
-      available = effective_resource.actions + atts[:actions].map { |k, v| v[:action] if v[:path] }.compact
-      atts[:actions].inject({}) { |h, (commit, opts)| h[commit] = opts if available.include?(opts[:action]); h }
+    # We filter out any actions passed to us that aren't supported
+    actions = if atts.key?(:actions)
+      {}.tap do |actions|
+        atts[:actions].each do |commit, opts|
+          actions[commit] = opts if (effective_resource.actions.include?(opts[:action]) || opts[:path]).present?
+        end
+      end
     else
       (resource.kind_of?(Class) ? effective_resource.resource_klass_actions : effective_resource.resource_actions)
     end
 
     # Consider only, except, false and proc false
-    only = Array(atts[:only]).compact
-    except = Array(atts[:except]).compact
+    only = Array(atts[:only]) if atts[:only].present?
+    except = Array(atts[:except]) if atts[:except].present?
 
-    actions = actions.select do |_, opts|
+    actions.select! do |_, opts|
       action = opts[:action]
 
       if only.present? && !only.include?(action)
@@ -100,8 +106,11 @@ module EffectiveResourcesHelper
     end
 
     # Select Partial
-    partial = ['effective/resource/actions', partial.to_s].join('_') if partial.kind_of?(Symbol)
-    partial = (partial.presence || 'effective/resource/actions') + '.html'
+    partial = if partial.kind_of?(Symbol)
+      "effective/resource/actions_#{partial}.html"
+    else
+      "#{partial.presence || 'effective/resource/actions'}.html"
+    end
 
     # Assign Locals
     locals = {

data/app/helpers/effective_resources_private_helper.rb

@@ -2,21 +2,27 @@
 
 module EffectiveResourcesPrivateHelper
   REPLACE_PAGE_ACTIONS = {'update' => :edit, 'create' => :new}
+  BLACKLIST = [:default, :only, :except, :if, :unless, :redirect, :success, :danger, :klass]
+
+  DATA_CONFIRM = 'data-confirm'
 
   def permitted_resource_actions(resource, actions)
     page_action = REPLACE_PAGE_ACTIONS[params[:action]] || params[:action].try(:to_sym) || :save
     executor = Effective::ResourceExec.new(self, resource)
 
-    actions.select do |commit, args|
+    actions.each_with_object({}) do |(commit, args), h|
       action = (args[:action] == :save ? (resource.new_record? ? :create : :update) : args[:action])
 
-      (args.key?(:only) ? args[:only].include?(page_action) : true) &&
-      (args.key?(:except) ? !args[:except].include?(page_action) : true) &&
-      (args.key?(:if) ? executor.instance_exec(&args[:if]) : true) &&
-      (args.key?(:unless) ? !executor.instance_exec(&args[:unless]) : true) &&
-      EffectiveResources.authorized?(controller, action, resource)
-    end.inject({}) do |h, (commit, args)|
+      permitted = (args.key?(:only) ? args[:only].include?(page_action) : true) &&
+        (args.key?(:except) ? !args[:except].include?(page_action) : true) &&
+        (args.key?(:if) ? executor.instance_exec(&args[:if]) : true) &&
+        (args.key?(:unless) ? !executor.instance_exec(&args[:unless]) : true) &&
+        EffectiveResources.authorized?(controller, action, resource)
+
+      next unless permitted
+
       opts = args.except(:default, :only, :except, :if, :unless, :redirect, :success, :danger, :klass)
+      resource_to_s = resource.to_s.presence || resource.class.name.underscore
 
       # Transform data: { ... } hash into 'data-' keys
       if opts.key?(:data)
@@ -32,34 +38,34 @@ module EffectiveResourcesPrivateHelper
       end
 
       # Replace resource name in any token strings
-      if opts.key?('data-confirm')
-        opts['data-confirm'] = opts['data-confirm'].gsub('@resource', (resource.to_s.presence || resource.class.name.gsub('::', ' ').underscore.gsub('_', ' ')).to_s)
+      if opts[DATA_CONFIRM].present? && opts[DATA_CONFIRM].include?('@resource'.freeze)
+        opts[DATA_CONFIRM] = opts[DATA_CONFIRM].gsub('@resource'.freeze, resource_to_s)
       end
 
       # Assign class
       opts[:class] ||= (
-        if opts['data-method'].to_s == 'delete'
-          'btn btn-danger'
+        if opts['data-method'.freeze] == 'delete'.freeze
+          'btn btn-danger'.freeze
         elsif h.length == 0
-          'btn btn-primary'
+          'btn btn-primary'.freeze
         elsif defined?(EffectiveBootstrap)
-          'btn btn-secondary'
+          'btn btn-secondary'.freeze
         else
-          'btn btn-default'
+          'btn btn-default'.freeze
         end
       )
 
       # Assign title
       opts[:title] ||= case opts[:action]
         when :save then commit
-        when :edit then "Edit #{resource}"
-        when :show then "#{resource}"
-        when :destroy then "Delete #{resource}"
+        when :edit then "Edit #{resource_to_s}"
+        when :show then "#{resource_to_s}"
+        when :destroy then "Delete #{resource_to_s}"
         when :index then "All #{resource.class.name.gsub('::', ' ').underscore.gsub('_', ' ').titleize.pluralize}"
-        else "#{opts[:action].to_s.titleize} #{resource}"
+        else "#{opts[:action].to_s.titleize} #{resource_to_s}"
       end
 
-      h[commit] = opts; h
+      h[commit] = opts
     end
   end
 

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

@@ -1,41 +1,60 @@
+# frozen_string_literal: true
+
 module Effective
   module Resources
     module Actions
+      EMPTY_HASH = {}
+      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]
       def routes
         @routes ||= (
-          matches = [[namespace, plural_name].compact.join('/'.freeze), [namespace, name].compact.join('/'.freeze)]
+          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
 
-          routes_engine.routes.routes.select do |route|
-            matches.any? { |match| match == route.defaults[:controller] } && !route.name.to_s.end_with?('root')
-          end.inject({}) do |h, route|
-            h[route.defaults[:action].to_sym] = route; h
+          # Check engine routes
+          if routes.blank?
+            matches = [
+              [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|
+              routes = engine.routes.routes.select do |route|
+                (matches & [route.defaults[:controller]]).present? && !route.name.to_s.end_with?('root')
+              end
+
+              break if routes.present?
+            end
           end
-        )
-      end
 
-      # Effective::Resource.new('effective/order', namespace: :admin)
-      def routes_engine
-        case class_name
-        when 'Effective::Order'.freeze
-          EffectiveOrders::Engine
-        else
-          Rails.application
-        end
+          Array(routes).inject({}) { |h, route| h[route.defaults[:action].to_sym] = route; h }
+        )
       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)
         return unless routes[action]
-        return (routes[action].name + '_path'.freeze) if routes[action].name.present?
+        return (routes[action].name + '_path') if routes[action].name.present?
       end
 
       # Effective::Resource.new('admin/posts').action_path(:edit, Post.last) => '/admin/posts/3/edit'
       # Will work for any action. Returns the real path
-      def action_path(action, resource = nil, opts = {})
+      def action_path(action, resource = nil, opts = nil)
+        opts ||= EMPTY_HASH
+
         if klass.nil? && resource.present? && initialized_name.kind_of?(ActiveRecord::Reflection::BelongsToReflection)
           return Effective::Resource.new(resource, namespace: namespace).action_path(action, resource, opts)
         end
@@ -53,12 +72,26 @@ module Effective
           end
         end
 
-        # This generates the correct route when an object is overriding to_param
-        if (resource || instance).respond_to?(:attributes)
-          formattable = (resource || instance).attributes.symbolize_keys.merge(id: (resource || instance).to_param)
+        target = (resource || instance)
+
+        formattable = if routes[action].parts.include?(:id)
+          if target.respond_to?(:to_param) && target.respond_to?(:id) && (target.to_param != target.id.to_s)
+            routes[action].parts.each_with_object({}) do |part, h|
+              if part == :id
+                h[part] = target.to_param
+              elsif part == :format
+                # Nothing
+              elsif target.respond_to?(part)
+                h[part] = target.public_send(part)
+              end
+            end
+          else
+            target
+          end
         end
 
-        path = routes[action].format(formattable || {}).presence
+        # Generate the path
+        path = routes[action].format(formattable || EMPTY_HASH)
 
         if path.present? && opts.present?
           uri = URI.parse(path)
@@ -70,74 +103,85 @@ module Effective
       end
 
       def actions
-        routes.keys
+        @route_actions ||= routes.keys
       end
 
       def crud_actions
-        actions & %i(index new create show edit update destroy)
+        @crud_actions ||= (actions & CRUD_ACTIONS)
       end
 
       # GET actions
       def collection_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_collection_route?(route) }.compact
+        @collection_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) }.tap(&:compact!)
+        )
       end
 
       def collection_get_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_collection_route?(route) && is_get_route?(route) }.compact
+        @collection_get_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_get_route?(route) }.tap(&:compact!)
+        )
       end
 
       def collection_post_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_collection_route?(route) && is_post_route?(route) }.compact
+        @collection_post_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_collection_route?(route) && is_post_route?(route) }.tap(&:compact!)
+        )
       end
 
       # All actions
       def member_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_member_route?(route) }.compact
+        @member_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) }.tap(&:compact!)
+        )
       end
 
       # GET actions
       def member_get_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_member_route?(route) && is_get_route?(route) }.compact
+        @member_get_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_get_route?(route) }.tap(&:compact!)
+        )
       end
 
       def member_delete_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_member_route?(route) && is_delete_route?(route) }.compact
+        @member_delete_actions ||= (
+          routes.map { |_, route| route.defaults[:action].to_sym if is_member_route?(route) && is_delete_route?(route) }.tap(&:compact!)
+        )
       end
 
       # POST/PUT/PATCH actions
       def member_post_actions
-        routes.values.map { |route| route.defaults[:action].to_sym if is_member_route?(route) && is_post_route?(route) }.compact
+        @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 * '/'.freeze
+        [namespace, plural_name].compact * '/'
       end
 
       private
 
       def is_member_route?(route)
-        (route.path.required_names || []).include?('id'.freeze)
+        (route.path.required_names || []).include?('id')
       end
 
       def is_collection_route?(route)
-        (route.path.required_names || []).include?('id'.freeze) == false
+        (route.path.required_names || []).include?('id') == false
       end
 
       def is_get_route?(route)
-        route.verb.to_s.include?('GET'.freeze)
+        route.verb == 'GET'
       end
 
       def is_delete_route?(route)
-        route.verb.to_s.include?('DELETE'.freeze)
+        route.verb == 'DELETE'
       end
 
       def is_post_route?(route)
-        ['POST', 'PUT', 'PATCH'].freeze.any? { |verb| route.verb == verb }
+        POST_VERBS.include?(route.verb)
       end
     end
   end
 end
-
-
-

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

@@ -1,3 +1,5 @@
+# frozen_sting_literals: true
+
 module Effective
   module Resources
     module Controller
@@ -29,22 +31,26 @@ module Effective
           end
 
           (member_post_actions - crud_actions).each do |action| # default true means it will be overwritten by dsl methods
-            buttons[action.to_s.titleize] = case action
+            action_name = action.to_s.titleize
+
+            buttons[action_name] = case action
             when :archive
-              { action: action, default: true, if: -> { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
+              { action: action, default: true, if: -> { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?"}
             when :unarchive
-              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?" }
             else
-              { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
+              { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?"}
             end
           end
 
           member_delete_actions.each do |action|
+            action_name = action.to_s.titleize
+
             if action == :destroy
               next if buttons.values.find { |v| v[:action] == :archive }.present?
               buttons['Delete'] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really delete @resource?" }
             else
-              buttons[action.to_s.titleize] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really #{action} @resource?" }
+              buttons[action_name] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really #{action_name} @resource?" }
             end
           end
 
@@ -66,33 +72,39 @@ module Effective
       # It is used by datatables
       def resource_actions
         {}.tap do |actions|
-          (member_get_actions & crud_actions).reverse_each do |action|
+          member_get_actions.reverse_each do |action|
+            next unless crud_actions.include?(action)
             actions[action.to_s.titleize] = { action: action, default: true }
           end
 
-          (member_get_actions - crud_actions).each do |action|
+          member_get_actions.each do |action|
+            next if crud_actions.include?(action)
             actions[action.to_s.titleize] = { action: action, default: true }
           end
 
-          (member_post_actions - crud_actions).each do |action|
-            actions[action.to_s.titleize] = { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+          member_post_actions.each do |action|
+            next if crud_actions.include?(action)
 
-            actions[action.to_s.titleize] = case action
+            action_name = action.to_s.titleize
+
+            actions[action_name] = case action
             when :archive
-              { action: action, default: true, if: -> { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
+              { action: action, default: true, if: -> { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?"}
             when :unarchive
-              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?" }
             else
-              { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+              { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action_name} @resource?" }
             end
           end
 
           member_delete_actions.each do |action|
+            action_name = action.to_s.titleize
+
             if action == :destroy
-              next if actions.values.find { |v| v[:action] == :archive }.present?
+              next if actions.find { |_, v| v[:action] == :archive }.present?
               actions['Delete'] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really delete @resource?" }
             else
-              actions[action.to_s.titleize] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really #{action} @resource?" }
+              actions[action_name] = { action: action, default: true, 'data-method' => :delete, 'data-confirm' => "Really #{action_name} @resource?" }
             end
           end
         end

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

@@ -6,8 +6,40 @@ module Effective
 
       def _initialize_input(input, namespace: nil)
         @initialized_name = input
+        @model_klass = _klass_by_input(input)
 
-        @model_klass = case input
+        # Consider namespaces
+        if namespace
+          @namespaces = (namespace.kind_of?(String) ? namespace.split('/') : Array(namespace))
+        end
+
+        if input.kind_of?(Array) && @namespaces.blank?
+          @namespaces = input[0...-1].map { |input| input.to_s.presence }.compact
+        end
+
+        # Consider relation
+        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)
+        end
+
+        # Consider instance
+        if klass && input.instance_of?(klass)
+          @instance ||= input
+        end
+
+        if klass && input.kind_of?(Array) && input.last.instance_of?(klass)
+          @instance ||= input.last
+        end
+      end
+
+      def _klass_by_input(input)
+        case input
+        when Array
+          _klass_by_input(input.last)
         when String, Symbol
           _klass_by_name(input)
         when Class
@@ -24,22 +56,6 @@ module Effective
         when nil    ; raise 'expected a string or class'
         else        ; _klass_by_name(input.class.name)
         end
-
-        if namespace
-          @namespaces = (namespace.kind_of?(String) ? namespace.split('/') : Array(namespace))
-        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)
-        end
-
-        if klass && input.instance_of?(klass)
-          @instance = input
-        end
       end
 
       def _klass_by_name(input)
@@ -48,6 +64,7 @@ module Effective
 
         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
@@ -64,35 +81,19 @@ module Effective
           end
         end
 
-        nil
-      end
-
-      # Lazy initialized
-      def _initialize_written
-        @written_attributes = []
-        @written_belong_tos = []
-        @written_scopes = []
-
-        return unless File.exists?(model_file)
-
-        Effective::CodeReader.new(model_file) do |reader|
-          first = reader.index { |line| line == '# Attributes' }
-          last = reader.index(from: first) { |line| line.start_with?('#') == false && line.length > 0 } if first
-
-          if first && last
-            @written_attributes = reader.select(from: first+1, to: last-1).map do |line|
-              Effective::Attribute.parse_written(line).presence
-            end.compact
-          end
-
-          @written_belong_tos = reader.select { |line| line.start_with?('belongs_to ') }.map do |line|
-            line.scan(/belongs_to\s+:(\w+)/).flatten.first
-          end
+        # Crazy engine
+        if names[0] == 'admin'
+          class_name = (['effective'] + names[1..-1]).map { |name| name.classify } * '::'
+          klass = class_name.safe_constantize
 
-          @written_scopes = reader.select { |line| line.start_with?('scope ') }.map do |line|
-            line.scan(/scope\s+:(\w+)/).flatten.first
+          if klass.present?
+            @namespaces ||= names[0...-1]
+            @model_klass = klass
+            return klass
           end
         end
+
+        nil
       end
 
     end

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

@@ -9,8 +9,12 @@ module Effective
       def datatable_klass
         if defined?(EffectiveDatatables)
           "#{namespaced_class_name.pluralize}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 ||
           "Effective::Datatables::#{name.pluralize.camelize}".safe_constantize

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

@@ -11,6 +11,10 @@ module Effective
         name.pluralize
       end
 
+      def resource_name # 'effective_post' used by permitted params
+        @resource_name ||= ((klass.present? ? klass.name : initialized_name).to_s.split(SPLIT).join('_') || '').singularize.underscore
+      end
+
       def initialized_name
         @initialized_name
       end
@@ -27,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/app/views/effective/resource/_actions.html.haml

@@ -1,5 +1,6 @@
 - permitted_resource_actions(resource, actions).each do |label, opts|
-  = link_to(label, (effective_resource.action_path(opts[:action], resource) || '#'), opts.except(:action))
+  - action = opts.delete(:action)
+  = link_to(label, (effective_resource.action_path(action, resource) || '#'), opts)
 
 = instance_exec(resource, &format_block) if local_assigns[:format_block]
 = yield if block_given?

data/app/views/effective/resource/_actions_dropleft.html.haml

@@ -1,6 +1,9 @@
 = dropdown(variation: :dropleft, btn_class: btn_class) do
   - permitted_resource_actions(resource, actions).each do |label, opts|
-    = dropdown_link_to(label, (effective_resource.action_path(opts[:action], resource) || '#'), opts.except(:action, :class).merge(btn_class: btn_class))
+    - action = opts.delete(:action)
+    - opts.delete(:class)
+
+    = dropdown_link_to(label, (effective_resource.action_path(action, resource) || '#'), opts)
 
   = instance_exec(resource, &format_block) if local_assigns[:format_block]
   = yield(resource) if block_given?

data/app/views/effective/resource/_actions_glyphicons.html.haml

@@ -1,5 +1,8 @@
 - permitted_resource_actions(resource, actions).each do |label, opts|
-  = glyphicon_to(opts[:action], (effective_resource.action_path(opts[:action], resource) || '#'), opts.except(:action, :class))
+  - action = opts.delete(:action)
+  - opts.delete(:class)
+
+  = glyphicon_to(action, (effective_resource.action_path(action, resource) || '#'), opts)
 
 = instance_exec(resource, &format_block) if local_assigns[:format_block]
 = yield(resource) if block_given?

data/lib/effective_resources.rb

@@ -1,4 +1,5 @@
 require 'effective_resources/engine'
+require 'effective_resources/version'
 
 module EffectiveResources
 

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.5.2'.freeze
+  VERSION = '1.6.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.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: effective_bootstrap
+  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: effective_datatables
+  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: haml
+  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: pry-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: Make any controller an effective resource controller.
 email:
 - info@codeandeffect.com
@@ -113,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: Make any controller an effective resource controller.