trestle 0.8.4 → 0.8.11

data/lib/trestle/resource/controller.rb

@@ -1,69 +1,78 @@
 module Trestle
   class Resource
     class Controller < Admin::Controller
-      def index
-        self.collection = admin.prepare_collection(params)
+      before_action :load_collection, only: [:index]
+      before_action :load_instance, only: [:show, :edit, :update, :destroy]
 
+      def index
         respond_to do |format|
           format.html
           format.json { render json: collection }
+          format.js
         end
       end
 
       def new
-        self.instance = admin.build_instance({}, params)
+        self.instance = admin.build_instance(params.key?(admin.parameter_name) ? admin.permitted_params(params) : {}, params)
 
         respond_to do |format|
           format.html
           format.json { render json: instance }
+          format.js
         end
       end
 
       def create
         self.instance = admin.build_instance(admin.permitted_params(params), params)
 
-        if admin.save_instance(instance)
+        if admin.save_instance(instance, params)
           respond_to do |format|
             format.html do
-              flash[:message] = flash_message("success.create", default: "The %{model_name} was successfully created.")
-              redirect_to action: :show, id: admin.to_param(instance)
+              flash[:message] = flash_message("create.success", title: "Success!", message: "The %{lowercase_model_name} was successfully created.")
+              redirect_to_return_location(:create, instance, default: admin.instance_path(instance))
             end
-            format.json { render json: instance, status: :created, location: { action: :show, id: admin.to_param(instance) } }
+            format.json { render json: instance, status: :created, location: admin.instance_path(instance) }
             format.js
           end
         else
           respond_to do |format|
             format.html do
-              flash.now[:error] = flash_message("failure.create", default: "Please correct the errors below.")
-              render "new"
+              flash.now[:error] = flash_message("create.failure", title: "Warning!", message: "Please correct the errors below.")
+              render "new", status: :unprocessable_entity
             end
             format.json { render json: instance.errors, status: :unprocessable_entity }
+            format.js
           end
         end
       end
 
       def show
-        self.instance = admin.find_instance(params)
-
-        respond_to do |format|
-          format.html
-          format.json { render json: instance }
+        if admin.singular? && instance.nil?
+          respond_to do |format|
+            format.html { redirect_to action: :new }
+            format.json { head :not_found }
+            format.js
+          end
+        else
+          respond_to do |format|
+            format.html
+            format.json { render json: instance }
+            format.js
+          end
         end
       end
 
       def edit
-        self.instance = admin.find_instance(params)
       end
 
       def update
-        self.instance = admin.find_instance(params)
         admin.update_instance(instance, admin.permitted_params(params), params)
 
-        if admin.save_instance(instance)
+        if admin.save_instance(instance, params)
           respond_to do |format|
             format.html do
-              flash[:message] = flash_message("success.update", default: "The %{model_name} was successfully updated.")
-              redirect_to action: :show, id: admin.to_param(instance)
+              flash[:message] = flash_message("update.success", title: "Success!", message: "The %{lowercase_model_name} was successfully updated.")
+              redirect_to_return_location(:update, instance, default: admin.instance_path(instance))
             end
             format.json { render json: instance, status: :ok }
             format.js
@@ -71,27 +80,32 @@ module Trestle
         else
           respond_to do |format|
             format.html do
-              flash.now[:error] = flash_message("failure.update", default: "Please correct the errors below.")
-              render "show"
+              flash.now[:error] = flash_message("update.failure", title: "Warning!", message: "Please correct the errors below.")
+              render "show", status: :unprocessable_entity
             end
             format.json { render json: instance.errors, status: :unprocessable_entity }
+            format.js
           end
         end
       end
 
       def destroy
-        self.instance = admin.find_instance(params)
-        success = admin.delete_instance(instance)
+        success = admin.delete_instance(instance, params)
 
         respond_to do |format|
           format.html do
             if success
-              flash[:message] = flash_message("success.destroy", default: "The %{model_name} was successfully deleted.")
+              flash[:message] = flash_message("destroy.success", title: "Success!", message: "The %{lowercase_model_name} was successfully deleted.")
+              redirect_to_return_location(:destroy, instance, default: admin.path(:index))
             else
-              flash[:message] = flash_message("failure.destroy", default: "Could not delete %{model_name}.")
-            end
+              flash[:error] = flash_message("destroy.failure", title: "Warning!", message: "Could not delete %{lowercase_model_name}.")
 
-            redirect_to action: :index
+              if self.instance = admin.find_instance(params)
+                redirect_to_return_location(:update, instance, default: admin.instance_path(instance))
+              else
+                redirect_to_return_location(:destroy, instance, default: admin.path(:index))
+              end
+            end
           end
           format.json { head :no_content }
           format.js
@@ -99,14 +113,37 @@ module Trestle
       end
 
     protected
-      attr_accessor :collection
-      helper_method :collection
+      def load_instance
+        self.instance = admin.find_instance(params)
+      end
 
-      attr_accessor :instance
-      helper_method :instance
+      def load_collection
+        self.collection = admin.prepare_collection(params)
+      end
+
+      attr_accessor :instance, :collection
+      helper_method :instance, :collection
+
+      def flash_message(type, title:, message:)
+        {
+          title:   admin.t("flash.#{type}.title", default: title),
+          message: admin.t("flash.#{type}.message", default: message)
+        }
+      end
 
-      def flash_message(type, options={})
-        t("trestle.flash.#{type}", options.merge(model_name: admin.model_name.underscore.humanize(capitalize: false)))
+      def redirect_to_return_location(action, instance, default:)
+        if admin.return_locations[action] && !dialog_request?
+          location = instance_exec(instance, &admin.return_locations[action])
+
+          case location
+          when :back
+            redirect_back fallback_location: default, turbolinks: false
+          else
+            redirect_to location, turbolinks: false
+          end
+        else
+          redirect_to default, turbolinks: false
+        end
       end
     end
   end

data/lib/trestle/resource.rb

@@ -2,110 +2,68 @@ module Trestle
   class Resource < Admin
     extend ActiveSupport::Autoload
 
+    autoload :AdapterMethods
     autoload :Builder
+    autoload :Collection
     autoload :Controller
 
-    class << self
-      def adapter
-        @adapter ||= Trestle.config.default_adapter.new(self)
-      end
-
-      def adapter=(klass)
-        @adapter = klass.new(self)
-      end
-
-      # Defines a method that can be overridden with a custom block,
-      # but is otherwise delegated to the adapter instance.
-      def self.adapter_method(name)
-        attr_writer name
-
-        define_method(name) do |*args|
-          if override = instance_variable_get("@#{name}")
-            instance_exec(*args, &override)
-          else
-            adapter.public_send(name, *args)
-          end
-        end
-      end
-
-      adapter_method :collection
-      adapter_method :find_instance
-      adapter_method :build_instance
-      adapter_method :update_instance
-      adapter_method :save_instance
-      adapter_method :delete_instance
-      adapter_method :to_param
-      adapter_method :permitted_params
-      adapter_method :decorate_collection
-      adapter_method :unscope
-      adapter_method :merge_scopes
-      adapter_method :count
-      adapter_method :sort
-      adapter_method :paginate
-      adapter_method :human_attribute_name
-      adapter_method :default_table_attributes
-      adapter_method :default_form_attributes
-
-      attr_accessor :decorator
-
-      def prepare_collection(params)
-        collection = initialize_collection(params)
-        collection = apply_scopes(collection, params)
-        collection = apply_sorting(collection, params)
-        collection = paginate(collection, params)
-        collection = decorate_collection(collection)
-        collection
-      end
+    include AdapterMethods
+
+    RESOURCE_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+    READONLY_ACTIONS = [:index, :show]
+
+    class_attribute :decorator
+
+    class_attribute :pagination_options
+    self.pagination_options = {}
+
+    # Collection-focused adapter methods
+    adapter_method :collection
+    adapter_method :merge_scopes
+    adapter_method :sort
+    adapter_method :paginate
+    adapter_method :finalize_collection
+    adapter_method :decorate_collection
+    adapter_method :count
+
+    # Instance-focused adapter methods
+    adapter_method :find_instance
+    adapter_method :build_instance
+    adapter_method :update_instance
+    adapter_method :save_instance
+    adapter_method :delete_instance
+    adapter_method :permitted_params
+
+    # Common adapter methods
+    adapter_method :to_param
+    adapter_method :human_attribute_name
+
+    # Automatic tables and forms adapter methods
+    adapter_method :default_table_attributes
+    adapter_method :default_form_attributes
+
+    # Prepares a collection for use in the resource controller's index action.
+    #
+    # Applies scopes, sorts, pagination, finalization and decorators according
+    # to the admin's adapter and any admin-specific adapter methods.
+    def prepare_collection(params, options={})
+      Collection.new(self, options).prepare(params)
+    end
 
-      def initialize_collection(params)
-        collection(params)
+    class << self
+      # Deprecated: use instance method instead
+      def prepare_collection(params, options={})
+        Collection.new(self, options).prepare(params)
       end
 
       def scopes
         @scopes ||= {}
       end
 
-      def apply_scopes(collection, params)
-        unscoped = unscope(collection)
-
-        scopes_for(params).each do |scope|
-          collection = merge_scopes(collection, scope.apply(unscoped))
-        end
-
-        collection
-      end
-
-      def scopes_for(params)
-        result = []
-
-        if params[:scope] && scopes.has_key?(params[:scope].to_sym)
-          result << scopes[params[:scope].to_sym]
-        end
-
-        if result.empty? && default_scope = scopes.values.find(&:default?)
-          result << default_scope
-        end
-
-        result
-      end
-
       def column_sorts
         @column_sorts ||= {}
       end
 
-      def apply_sorting(collection, params)
-        return collection unless params[:sort]
-
-        field = params[:sort].to_sym
-        order = params[:order].to_s.downcase == "desc" ? :desc : :asc
-
-        if column_sorts.has_key?(field)
-          instance_exec(collection, order, &column_sorts[field])
-        else
-          sort(collection, field, order)
-        end
-      end
-
       def table
         super || Table::Automatic.new(self)
       end
@@ -119,29 +77,72 @@ module Trestle
       end
 
       def model_name
-        options[:as] || default_model_name
+        @model_name ||= Trestle::ModelName.new(model)
+      end
+
+      def actions
+        @actions ||= (readonly? ? READONLY_ACTIONS : RESOURCE_ACTIONS).dup
+      end
+
+      def root_action
+        singular? ? :show : :index
       end
 
       def readonly?
         options[:readonly]
       end
 
-      def breadcrumb
-        Breadcrumb.new(model_name.pluralize, path)
+      def singular?
+        options[:singular]
+      end
+
+      def translate(key, options={})
+        super(key, options.merge({
+          model_name:            model_name.titleize,
+          lowercase_model_name:  model_name.downcase,
+          pluralized_model_name: model_name.plural.titleize
+        }))
+      end
+      alias t translate
+
+      def instance_path(instance, options={})
+        action = options.fetch(:action) { :show }
+        options = options.merge(id: to_param(instance)) unless singular?
+
+        path(action, options)
       end
 
       def routes
         admin = self
 
+        resource_method  = singular? ? :resource : :resources
+        resource_name    = admin_name
+        resource_options = {
+          controller: controller_namespace,
+          as:         route_name,
+          path:       options[:path],
+          except:     (RESOURCE_ACTIONS - actions)
+        }
+
         Proc.new do
-          resources admin.admin_name, controller: admin.controller_namespace, as: admin.route_name, path: admin.options[:path], except: admin.disabled_routes do
+          public_send(resource_method, resource_name, resource_options) do
             instance_exec(&admin.additional_routes) if admin.additional_routes
           end
         end
       end
 
-      def disabled_routes
-        readonly? ? [:new, :create, :edit, :update, :destroy] : []
+      def return_locations
+        @return_locations ||= {}
+      end
+
+      def build(&block)
+        Resource::Builder.build(self, &block)
+      end
+
+      def validate!
+        if singular? && !adapter_methods.method_defined?(:find_instance)
+          raise NotImplementedError, "Singular resources must define an instance block."
+        end
       end
 
     private
@@ -150,15 +151,6 @@ module Trestle
       rescue NameError
         raise NameError, "Unable to find model #{admin_name.classify}. Specify a different model using Trestle.resource(:#{admin_name}, model: MyModel)"
       end
-
-      def default_model_name
-        if model.respond_to?(:model_name)
-          model_name = model.model_name
-          model_name.respond_to?(:human) ? model_name.human : model_name.to_s.titleize
-        else
-          model.name.titleize
-        end
-      end
     end
   end
 end

data/lib/trestle/scope.rb

@@ -20,18 +20,28 @@ module Trestle
 
     def apply(collection)
       if @block
-        @admin.instance_exec(&@block)
+        if @block.arity == 1
+          @admin.instance_exec(collection, &@block)
+        else
+          @admin.instance_exec(&@block)
+        end
       else
         collection.public_send(name)
       end
     end
 
     def count(collection)
-      @admin.count(@admin.merge_scopes(collection, apply(@admin.unscope(collection))))
+      @admin.count(@admin.merge_scopes(collection, apply(collection)))
     end
 
     def active?(params)
-      @admin.scopes_for(params).include?(self)
+      active_scopes = Array(params[:scope])
+
+      if active_scopes.any?
+        active_scopes.include?(to_param.to_s)
+      else
+        default?
+      end
     end
   end
 end

data/lib/trestle/tab.rb

@@ -8,6 +8,10 @@ module Trestle
       @name, @options = name, options
     end
 
+    def id(tag=nil)
+      ["tab", tag, name].compact.join("-")
+    end
+
     def label
       safe_join([options[:label] || I18n.t("admin.tabs.#{name}", default: name.to_s.titleize), badge].compact, " ")
     end

data/lib/trestle/table/actions_column.rb

@@ -1,11 +1,17 @@
 module Trestle
   class Table
     class ActionsColumn
-      attr_reader :table, :block
+      attr_reader :table, :toolbar, :options
 
-      def initialize(table, &block)
-        @table = table
-        @block = block_given? ? block : default_actions
+      def initialize(table, options={}, &block)
+        @table, @options = table, options
+        @toolbar = Toolbar.new(ActionsBuilder)
+
+        if block_given?
+          @toolbar.append(&block)
+        else
+          @toolbar.append(&default_actions)
+        end
       end
 
       def renderer(template)
@@ -13,55 +19,59 @@ module Trestle
       end
 
       def default_actions
-        ->(action) do
-          action.delete
+        ->(toolbar, instance, admin) do
+          toolbar.delete if admin && admin.actions.include?(:destroy)
         end
       end
 
-      class ActionsBuilder
-        attr_reader :instance
+      class ActionsBuilder < Toolbar::Builder
+        attr_reader :instance, :admin
 
-        delegate :table, to: :@column
+        def initialize(template, instance, admin)
+          super(template)
+
+          @instance, @admin = instance, admin
+        end
 
-        def initialize(column, template, instance)
-          @column, @template, @instance = column, template, instance
+        def show
+          link(t("buttons.show", default: "Show"), instance, admin: admin, action: :show, icon: "fa fa-info", style: :info)
+        end
+
+        def edit
+          link(t("buttons.edit", default: "Edit"), instance, admin: admin, action: :edit, icon: "fa fa-pencil", style: :warning)
         end
 
         def delete
-          button(@template.icon("fa fa-trash"), @template.admin_url_for(instance, admin: table.options[:admin], action: :destroy), method: :delete, class: "btn-danger", data: { toggle: "confirm-delete", placement: "left" })
+          link(t("buttons.delete", default: "Delete"), instance, admin: admin, action: :destroy, method: :delete, icon: "fa fa-trash", style: :danger, data: { toggle: "confirm-delete", placement: "left" })
         end
 
-        def button(content, url, options={})
-          options[:class] = Array(options[:class])
-          options[:class] << "btn" unless options[:class].include?("btn")
+        builder_method :show, :edit, :delete
+
+        # Disallow button tags within the actions toolbar. Alias to link for backwards compatibility.
+        alias button link
 
-          @template.concat @template.link_to(content, url, options)
+      private
+        def translate(key, options={})
+          if admin
+            admin.translate(key, options)
+          else
+            I18n.t(:"admin.#{key}", options)
+          end
         end
-        alias_method :link, :button
+        alias t translate
       end
 
       class Renderer < Column::Renderer
         def header
+          options[:header]
         end
 
         def classes
-          "actions"
-        end
-
-        def options
-          {}
-        end
-
-        def data
-          {}
+          super + ["actions"]
         end
 
         def content(instance)
-          builder = ActionsBuilder.new(@column, @template, instance)
-
-          @template.with_output_buffer do
-            @template.instance_exec(builder, &@column.block)
-          end
+          @template.render_toolbar(@column.toolbar, instance, table.admin)
         end
       end
     end

data/lib/trestle/table/automatic.rb

@@ -3,7 +3,6 @@ module Trestle
     class Automatic < Table
       def initialize(admin)
         super(sortable: true, admin: admin)
-        @admin = admin
       end
 
       def columns
@@ -11,7 +10,7 @@ module Trestle
       end
 
       def content_columns
-        @admin.default_table_attributes.map.with_index do |attribute, index|
+        admin.default_table_attributes.map.with_index do |attribute, index|
           case attribute.type
           when :association
             Column.new(self, attribute.association_name, sort: false)

data/lib/trestle/table/builder.rb

@@ -25,8 +25,8 @@ module Trestle
         table.columns << Column.new(table, field, options, &(proc || block))
       end
 
-      def actions(&block)
-        table.columns << ActionsColumn.new(table, &block)
+      def actions(options={}, &block)
+        table.columns << ActionsColumn.new(table, options, &block)
       end
     end
   end