effective_resources 0.9.5 → 0.10.0

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

@@ -0,0 +1,66 @@
+module Effective
+  module CrudController
+    module PermittedParams
+      BLACKLIST = [:created_at, :updated_at]
+
+      # 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!
+      def resource_permitted_params
+        raise 'expected resource class to have effective_resource do .. end' if effective_resource.model.blank?
+
+        permitted_params = permitted_params_for(resource)
+
+        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]})"
+        end
+
+        params.require(effective_resource.name).permit(*permitted_params)
+      end
+
+      private
+
+      def permitted_params_for(resource)
+        effective_resource = if resource.kind_of?(Class)
+          resource.effective_resource if resource.respond_to?(:effective_resource)
+        else
+          resource.class.effective_resource if resource.class.respond_to?(:effective_resource)
+        end
+
+        # That class doesn't implement effective_resource do .. end block
+        return [] unless effective_resource.present?
+
+        # This is :id, all belongs_to ids, and model attributes
+        permitted_params = effective_resource.permitted_attributes.select do |name, (_, atts)|
+          if BLACKLIST.include?(name)
+            false
+          elsif atts.blank? || !atts.key?(:permitted)
+            true # Default is true
+          else
+            permitted = (atts[:permitted].respond_to?(:call) ? instance_exec(&atts[:permitted]) : atts[:permitted])
+
+            if permitted == true || permitted == false
+              permitted
+            elsif permitted == nil || permitted == :blank
+              effective_resource.namespaces.length == 0
+            else # A symbol, string, or array of, representing the namespace
+              (effective_resource.namespaces & Array(permitted).map(&:to_s)).present?
+            end
+          end
+        end.keys
+
+        # Recursively add any accepts_nested_resources
+        effective_resource.nested_resources.each do |nested|
+          if (nested_params = permitted_params_for(nested.klass)).present?
+            nested_params.insert(nested_params.rindex { |obj| !obj.kind_of?(Hash)} + 1, :_destroy)
+            permitted_params << { "#{nested.plural_name}_attributes".to_sym => nested_params }
+          end
+        end
+
+        permitted_params
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Effective
+  module CrudController
+    module Save
+
+      # Based on the incoming params[:commit] or passed action. Merges all options.
+      def commit_action(action = nil)
+        config = (['create', 'update'].include?(params[:action]) ? self.class.submits : self.class.buttons)
+
+        commit = if action.present?
+          config[action.to_s] || config.find { |_, v| v[:action] == action }.try(:last) || { action: action }
+        else
+          config[params[:commit].to_s] || config.find { |_, v| v[:action] == :save }.try(:last) || { action: :save }
+        end
+
+        commit.reverse_merge!(self.class.ons[commit[:action]]) if self.class.ons[commit[:action]]
+
+        commit
+      end
+
+      # This calls the appropriate member action, probably save!, on the resource.
+      def save_resource(resource, action = :save, &block)
+        raise "expected @#{resource_name} to respond to #{action}!" unless resource.respond_to?("#{action}!")
+
+        resource.current_user ||= current_user if resource.respond_to?(:current_user=)
+
+        ActiveRecord::Base.transaction do
+          begin
+            if resource.public_send("#{action}!") == false
+              raise("failed to #{action} #{resource}")
+            end
+
+            yield if block_given?
+
+            run_callbacks(:resource_save)
+            return true
+          rescue => e
+            Rails.logger.info "Failed to #{action}: #{e.message}" if Rails.env.development?
+
+            if resource.respond_to?(:restore_attributes) && resource.persisted?
+              resource.restore_attributes(['status', 'state'])
+            end
+
+            flash.delete(:success)
+            flash.now[:danger] = flash_danger(resource, action, e: e)
+            raise ActiveRecord::Rollback
+          end
+        end
+
+        run_callbacks(:resource_error)
+        false
+      end
+
+      def resource_flash(status, resource, action)
+        submit = commit_action(action)
+        message = submit[status].respond_to?(:call) ? instance_exec(&submit[status]) : submit[status]
+        return message if message.present?
+
+        case status
+        when :success then flash_success(resource, action)
+        when :danger then flash_danger(resource, action)
+        else
+          raise "unknown resource flash status: #{status}"
+        end
+      end
+
+      def reload_resource
+        self.resource.reload if resource.respond_to?(:reload)
+      end
+
+      # Should return a new resource based on the passed one
+      def duplicate_resource(resource)
+        resource.dup
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module Effective
+  module CrudController
+    module Submits
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # { 'Save' => { action: save, ...}}
+        def submits
+          @_effective_submits ||= effective_resource.submits
+        end
+
+        # { 'Approve' => { action: approve, ...}}
+        def buttons
+          @_effective_buttons ||= effective_resource.buttons
+        end
+
+        # { :approve => { redirect: .. }}
+        def ons
+          @_effective_ons ||= effective_resource.ons
+        end
+
+        # :only, :except, :if, :unless, :redirect, :success, :danger, :class
+        def _insert_submit(action, label = nil, args = {})
+          raise 'expected args to be a Hash or false' unless args.kind_of?(Hash) || args == false
+
+          if label == false
+            submits.delete_if { |label, args| args[:action] == action }; return
+          end
+
+          if args == false
+            submits.delete(label); return
+          end
+
+          if label # Overwrite the default member action when given a custom submit
+            submits.delete_if { |label, args| args[:default] && args[:action] == action }
+          end
+
+          if args.key?(:if) && args[:if].respond_to?(:call) == false
+            raise "expected if: to be callable. Try submit :approve, 'Save and Approve', if: -> { finished? }"
+          end
+
+          if args.key?(:unless) && args[:unless].respond_to?(:call) == false
+            raise "expected unless: to be callable. Try submit :approve, 'Save and Approve', unless: -> { declined? }"
+          end
+
+          if args.key?(:only)
+            args[:only] = Array(args[:only])
+            raise "expected only: to be a symbol or array of symbols. Try submit :approve, 'Save and Approve', only: [:edit]" unless args[:only].all? { |v| v.kind_of?(Symbol) }
+          end
+
+          if args.key?(:except)
+            args[:except] = Array(args[:except])
+            raise "expected except: to be a symbol or array of symbols. Try submit :approve, 'Save and Approve', except: [:edit]" unless args[:except].all? { |v| v.kind_of?(Symbol) }
+          end
+
+          if args.key?(:redirect_to) # Normalize this option to redirect
+            args[:redirect] = args.delete(:redirect_to)
+          end
+
+          args[:action] = action
+
+          (submits[label] ||= {}).merge!(args)
+        end
+
+        def _insert_button(action, label = nil, args = {})
+          raise 'expected args to be a Hash or false' unless args.kind_of?(Hash) || args == false
+
+          if label == false
+            buttons.delete_if { |label, args| args[:action] == action }; return
+          end
+
+          if args == false
+            buttons.delete(label); return
+          end
+
+          if label # Overwrite the default member action when given a custom label
+            buttons.delete_if { |label, args| args[:default] && args[:action] == action }
+          end
+
+          if args.key?(:if) && args[:if].respond_to?(:call) == false
+            raise "expected if: to be callable. Try button :approve, 'Approve', if: -> { finished? }"
+          end
+
+          if args.key?(:unless) && args[:unless].respond_to?(:call) == false
+            raise "expected unless: to be callable. Try button :approve, 'Approve', unless: -> { declined? }"
+          end
+
+          if args.key?(:only)
+            args[:only] = Array(args[:only])
+            raise "expected only: to be a symbol or array of symbols. Try button :approve, 'Save and Approve', only: [:edit]" unless args[:only].all? { |v| v.kind_of?(Symbol) }
+          end
+
+          if args.key?(:except)
+            args[:except] = Array(args[:except])
+            raise "expected except: to be a symbol or array of symbols. Try button :approve, 'Save and Approve', except: [:edit]" unless args[:except].all? { |v| v.kind_of?(Symbol) }
+          end
+
+          if args.key?(:redirect_to) # Normalize this option to redirect
+            args[:redirect] = args.delete(:redirect_to)
+          end
+
+          args[:action] = action
+
+          (buttons[label] ||= {}).merge!(args)
+        end
+
+        def _insert_on(action, args = {})
+          raise 'expected args to be a Hash' unless args.kind_of?(Hash)
+
+          if args.key?(:redirect_to) # Normalize this option to redirect
+            args[:redirect] = args.delete(:redirect_to)
+          end
+
+          args[:action] = action
+
+          (ons[action] ||= {}).merge!(args)
+        end
+      end
+
+    end
+  end
+end

data/app/helpers/effective_resources_helper.rb

@@ -1,41 +1,49 @@
 module EffectiveResourcesHelper
 
-  def effective_submit(form, options = {}, &block) # effective_bootstrap
-    resource = (controller.class.respond_to?(:effective_resource) ? controller.class.effective_resource : Effective::Resource.new(controller_path))
-    actions = resource.submits_for(form.object, controller: controller)
-    buttons = actions.map { |name, opts| form.save(name, opts) }.join.html_safe
+  # effective_bootstrap
+  def effective_submit(form, options = {}, &block)
+    actions = (controller.respond_to?(:effective_resource) ? controller.class : find_effective_resource).submits
+    actions = permitted_resource_actions(form.object, actions)
+
+    submits = actions.map { |name, opts| form.save(name, opts.except(:action, :title, 'data-method', 'data-confirm')) }.join.html_safe
 
     form.submit('', options) do
-      (block_given? ? capture(&block) : ''.html_safe) + buttons
+      (block_given? ? capture(&block) : ''.html_safe) + submits
     end
   end
 
   # effective_form_inputs
   def simple_form_submit(form, options = {}, &block)
-    resource = (controller.class.respond_to?(:effective_resource) ? controller.class.effective_resource : Effective::Resource.new(controller_path))
-    actions = resource.submits_for(form.object, controller: controller)
+    actions = (controller.respond_to?(:effective_resource) ? controller.class : find_effective_resource).submits
+    actions = permitted_resource_actions(form.object, actions)
 
-    buttons = actions.map { |action| form.button(:submit, *action) }
+    submits = actions.map { |name, opts| form.button(:submit, name, opts.except(:action, :title, 'data-method', 'data-confirm')) }.join(' ').html_safe
 
     # I think this is a bug. I can't override default button class when passing my own class: variable. it merges them.
-    if defined?(SimpleForm) && (btn_class = SimpleForm.button_class).present?
-      buttons = buttons.map { |button| button.sub(btn_class, '') }
+    if (btn_class = SimpleForm.button_class).present?
+      submits = submits.map { |submit| submit.sub(btn_class, '') }
     end
 
     wrapper_options = { class: 'form-actions' }.merge(options.delete(:wrapper_html) || {})
 
     content_tag(:div, wrapper_options) do
-      (block_given? ? capture(&block) : ''.html_safe) + buttons.join(' ').html_safe
+      (block_given? ? capture(&block) : ''.html_safe) + submits
     end
   end
 
-  def simple_form_save(form, label = 'Save', options = {}, &block)
-    wrapper_options = { class: 'form-actions' }.merge(options.delete(:wrapper_html) || {})
-    options = { class: 'btn btn-primary', data: { disable_with: 'Saving...'} }.merge(options)
+  def render_resource_buttons(resource, atts = {}, &block)
+    effective_resource = find_effective_resource
+    actions = (controller.respond_to?(:effective_resource) ? controller.class : effective_resource).buttons
 
-    content_tag(:div, wrapper_options) do
-      form.button(:submit, label, options) + (capture(&block) if block_given?)
+    actions = if resource.kind_of?(Class)
+      actions.select { |_, v| effective_resource.collection_get_actions.include?(v[:action]) }
+    elsif resource.respond_to?(:persisted?) && resource.persisted?
+      actions.select { |_, v| effective_resource.member_actions.include?(v[:action]) }
+    else
+      {}
     end
+
+    render_resource_actions(resource, atts.merge(actions: actions), &block)
   end
 
   # Renders the effective/resource view partial for this resource
@@ -46,29 +54,34 @@ module EffectiveResourcesHelper
   # partial: :dropleft|:glyphicons|string
   # locals: {} render locals
   # you can also pass all action names and true/false such as edit: true, show: false
-  def render_resource_actions(resource, instance = nil, atts = {}, &block)
-    (atts = instance; instance = nil) if instance.kind_of?(Hash) && atts.blank?
-    raise 'expected first argument to be an Effective::Resource' unless resource.kind_of?(Effective::Resource)
+  def render_resource_actions(resource, atts = {}, &block)
+    raise 'expected first argument to be an ActiveRecord::Base object or Array of objects' unless resource.kind_of?(ActiveRecord::Base) || resource.kind_of?(Class) || resource.kind_of?(Array)
     raise 'expected attributes to be a Hash' unless atts.kind_of?(Hash)
 
     locals = atts.delete(:locals) || {}
-    namespace = atts.delete(:namespace) || (resource.namespace.to_sym if resource.namespace)
     partial = atts.delete(:partial)
     spacer_template = locals.delete(:spacer_template)
 
-    partial = ['effective/resource/actions', partial.to_s].join('_') if partial.kind_of?(Symbol)
-    partial = (partial.presence || 'effective/resource/actions') + '.html'
+    effective_resource = (atts.delete(:effective_resource) || find_effective_resource)
+    actions = atts.delete(:actions) || effective_resource.resource_actions
+    namespace = atts.delete(:namespace) || (effective_resource.namespace.to_sym if effective_resource.namespace)
 
-    actions = (instance ? (resource.member_get_actions + resource.member_delete_actions) : resource.collection_get_actions)
-    actions = (actions & resource.crud_actions) if atts.delete(:crud)
+    # Filter Actions
+    action_keys = actions.map { |_, v| v[:action] }
+    raise "unknown action for #{effective_resource.name}: #{(atts.keys - action_keys).join(' ')}." if (atts.keys - action_keys).present?
+    actions = actions.select { |_, v| atts[v[:action]].respond_to?(:call) ? instance_exec(&atts[v[:action]]) : (atts[v[:action]] != false) }
 
-    raise "unknown action for #{resource.name}: #{(atts.keys - actions).join(' ')}." if (atts.keys - actions).present?
-    actions = (actions - atts.reject { |_, v| v }.keys + atts.select { |_, v| v }.keys).uniq
+    # Select Partial
+    partial = ['effective/resource/actions', partial.to_s].join('_') if partial.kind_of?(Symbol)
+    partial = (partial.presence || 'effective/resource/actions') + '.html'
 
-    locals = { resource: instance, effective_resource: resource, namespace: namespace, actions: actions }.compact.merge(locals)
+    # Assign Locals
+    locals = { resource: resource, effective_resource: effective_resource, namespace: namespace, actions: actions }.compact.merge(locals)
 
-    if instance.kind_of?(Array)
-      render(partial: partial, collection: instance, as: :resource, locals: locals.except(:resource), spacer_template: spacer_template)
+    # Render
+    if resource.kind_of?(Array)
+      locals[:format_block] = block if block_given?
+      render(partial: partial, collection: resource, as: :resource, locals: locals.except(:resource), spacer_template: spacer_template)
     elsif block_given?
       render(partial, locals) { yield }
     else
@@ -77,43 +90,29 @@ module EffectiveResourcesHelper
   end
 
   # When called from /admin/things/new.html.haml this will render 'admin/things/form', or 'things/form', or 'thing/form'
-  def render_resource_form(resource, instance = nil, atts = {})
-    (atts = instance; instance = nil) if instance.kind_of?(Hash) && atts.blank?
-    raise 'expected first argument to be an Effective::Resource' unless resource.kind_of?(Effective::Resource)
+  def render_resource_form(resource, atts = {})
+    raise 'expected first argument to be an ActiveRecord::Base object' unless resource.kind_of?(ActiveRecord::Base)
     raise 'expected attributes to be a Hash' unless atts.kind_of?(Hash)
 
-    instance = instance || instance_variable_get('@' + resource.name) || resource.instance
-    raise "unable to find resource instance.  Either pass the instance as the second argument, or assign @#{resource.name}" unless instance
+    effective_resource = (atts.delete(:effective_resource) || find_effective_resource)
 
     action = atts.delete(:action)
-    atts = { :namespace => (resource.namespace.to_sym if resource.namespace), resource.name.to_sym => instance }.compact.merge(atts)
+    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', resource.plural_name, :partial)
-      render "#{resource.plural_name}/form", atts
-    elsif lookup_context.template_exists?('form', resource.name, :partial)
-      render "#{resource.name}/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
     end
   end
 
-  def number_to_duration(duration)
-    duration = duration.to_i
-    value = duration.abs
-
-    [
-      ('-' if duration < 0),
-      ("#{value / 60}h " if value >= 60),
-      ("#{'%0.2d' % (value % 60)}m" if value > 0),
-      ('0m' if value == 0),
-    ].compact.join
-  end
-
-  ### Tableize attributes
+  # Tableize attributes
   # This is used by effective_orders, effective_logging, effective_trash and effective_mergery
   def tableize_hash(obj, table: 'table', th: true, sub_table: 'table', sub_th: true, flatten: true)
     case obj

data/app/helpers/effective_resources_private_helper.rb

@@ -0,0 +1,69 @@
+module EffectiveResourcesPrivateHelper
+  REPLACE_PAGE_ACTIONS = {'update' => :edit, 'create' => :new}
+
+  def permitted_resource_actions(resource, actions, effective_resource = nil)
+    effective_resource ||= find_effective_resource
+
+    page_action = REPLACE_PAGE_ACTIONS[params[:action]] || params[:action]&.to_sym || :save
+
+    actions.select do |commit, args|
+      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) ? controller.instance_exec(&args[:if]) : true) &&
+      (args.key?(:unless) ? !controller.instance_exec(&args[:unless]) : true) &&
+      EffectiveResources.authorized?(controller, action, resource)
+    end.transform_values.with_index do |opts, index|
+      action = opts[:action]
+
+      # Transform data: { ... } hash into 'data-' keys
+      data.each { |k, v| opts["data-#{k}"] ||= v } if (data = opts.delete(:data))
+
+      # Assign data method and confirm
+      if effective_resource.member_post_actions.include?(action)
+        opts['data-method'] ||= :post
+        opts['data-confirm'] ||= "Really #{action} @resource?"
+      elsif effective_resource.member_delete_actions.include?(action)
+        opts['data-method'] ||= :delete
+        opts['data-confirm'] ||= "Really #{action == :destroy ? 'delete' : action.to_s.titleize} @resource?"
+      end
+
+      # Assign class
+      opts[:class] ||= (
+        if opts['data-method'] == :delete
+          'btn btn-danger'
+        elsif index == 0
+          'btn btn-primary'
+        elsif defined?(EffectiveBootstrap)
+          'btn btn-secondary'
+        else
+          'btn btn-default'
+        end
+      )
+
+      # Assign title
+      unless action == :save
+        opts[:title] ||= case action
+          when :edit then "Edit #{resource}"
+          when :show then "#{resource}"
+          when :destroy then "Delete #{resource}"
+          when :index then "All #{effective_resource.human_plural_name.titleize}"
+          else "#{action.to_s.titleize} #{resource}"
+        end
+      end
+
+      # Replace resource name in any token strings
+      if opts['data-confirm']
+        opts['data-confirm'].gsub!('@resource', (resource.to_s.presence || effective_resource.human_name))
+      end
+
+      opts.except(:default, :only, :except, :if, :unless, :redirect, :success, :danger)
+    end
+  end
+
+  def find_effective_resource
+    @_effective_resource ||= (controller.respond_to?(:effective_resource) ? controller.effective_resource : Effective::Resource.new(controller_path))
+  end
+
+end