godmin 0.10.3 → 0.11.0

data/lib/godmin/authentication.rb

@@ -1,4 +1,4 @@
-require "godmin/authentication/sessions"
+require "godmin/authentication/sessions_controller"
 require "godmin/authentication/user"
 
 module Godmin

data/lib/godmin/authentication/{sessions.rb → sessions_controller.rb}

@@ -1,6 +1,6 @@
 module Godmin
   module Authentication
-    module Sessions
+    module SessionsController
       extend ActiveSupport::Concern
 
       included do

data/lib/godmin/authorization.rb

@@ -22,7 +22,7 @@ module Godmin
     end
 
     def policy(record)
-      policies[record] ||= PolicyFinder.find(record).constantize.new(admin_user, record)
+      policies[record] ||= PolicyFinder.find(record).new(admin_user, record)
     end
 
     def policies

data/lib/godmin/authorization/policy_finder.rb

@@ -3,6 +3,8 @@ module Godmin
     class PolicyFinder
       class << self
         def find(object)
+          return object.policy_class if object.respond_to?(:policy_class)
+          return object.class.policy_class if object.class.respond_to?(:policy_class)
           klass =
             if object.respond_to?(:model_name)
               object.model_name
@@ -20,7 +22,7 @@ module Godmin
             "#{Godmin.namespace.classify}::#{klass}Policy"
           else
             "#{klass}Policy"
-          end
+          end.constantize
         end
       end
     end

data/lib/godmin/helpers/application.rb

@@ -1,6 +1,16 @@
 module Godmin
   module Helpers
     module Application
+      # Renders the provided partial with locals if it exists, otherwise
+      # yields the given block.
+      def partial_override(partial, locals = {})
+        if lookup_context.exists?(partial, nil, true)
+          render partial: partial, locals: locals
+        else
+          yield
+        end
+      end
+
       # Wraps the policy helper so that it is always accessible, even when
       # authorization is not enabled. When that is the case, it returns a
       # policy that always returns true.

data/lib/godmin/helpers/batch_actions.rb

@@ -5,8 +5,11 @@ module Godmin
         return unless include_batch_action_link?(options)
 
         link_to(
-          translate_scoped("batch_actions.labels.#{name}", default: name.to_s.titleize), "#",
-          class: "btn btn-default hidden", data: {
+          translate_scoped("batch_actions.labels.#{name}", default: name.to_s.titleize),
+          @resource_class,
+          method: :patch,
+          class: "btn btn-default hidden",
+          data: {
             behavior: "batch-actions-action-link",
             confirm: options[:confirm] ? translate_scoped("batch_actions.confirm_message") : false,
             value: name
@@ -18,8 +21,8 @@ module Godmin
 
       def include_batch_action_link?(options)
         (options[:only].nil? && options[:except].nil?) ||
-          (options[:only] && options[:only].include?(params[:scope].to_sym)) ||
-          (options[:except] && !options[:except].include?(params[:scope].to_sym))
+          (options[:only] && options[:only].include?(@resource_service.scope.to_sym)) ||
+          (options[:except] && !options[:except].include?(@resource_service.scope.to_sym))
       end
     end
   end

data/lib/godmin/helpers/filters.rb

@@ -1,109 +1,108 @@
 module Godmin
   module Helpers
     module Filters
-      def filter_input_tag(name, options)
+      def filter_form(url: params)
+        bootstrap_form_tag url: url, method: :get, layout: :inline, builder: FormBuilders::FilterFormBuilder do |f|
+          yield(f)
+        end
+      end
+    end
+  end
+
+  module FormBuilders
+    class FilterFormBuilder < BootstrapForm::FormBuilder
+      def filter_field(name, options, html_options = {})
         case options[:as]
         when :string
-          filter_string_tag(name, options)
+          string_filter_field(name, options, html_options)
         when :select
-          filter_select_tag(name, options)
+          select_filter_field(name, options, html_options)
         when :multiselect
-          filter_multiselect_tag(name, options)
-        when :checkboxes
-          filter_checkbox_tags(name, options)
+          multiselect_filter_field(name, options, html_options)
         end
       end
 
-      private
-
-      def filter_string_tag(name, _options)
-        text_field_tag(
-          name,
-          default_filter_value(name),
-          name: "filter[#{name}]",
-          class: "form-control",
-          placeholder: translate_scoped("filters.labels.#{name}", default: name.to_s.titleize)
+      def string_filter_field(name, _options, html_options = {})
+        text_field(
+          name, {
+            name: "filter[#{name}]",
+            value: default_filter_value(name),
+            placeholder: @template.translate_scoped("filters.labels.#{name}", default: name.to_s.titleize),
+            wrapper_class: "filter"
+          }.deep_merge(html_options)
         )
       end
 
-      def filter_select_tag(name, options)
-        filter_select_tag_helper(
-          name,
-          options,
-          name: "filter[#{name}]",
-          include_blank: true,
-          class: "form-control",
-          data: {
-            behavior: "select-box",
-            placeholder: translate_scoped("filters.select.placeholder.one")
-          }
+      def select_filter_field(name, options, html_options = {})
+        filter_select(
+          name, options, {
+            name: "filter[#{name}]",
+            data: {
+              placeholder: @template.translate_scoped("filters.select.placeholder.one")
+            }
+          }.deep_merge(html_options)
         )
       end
 
-      def filter_multiselect_tag(name, options)
-        filter_select_tag_helper(
-          name,
-          options,
-          name: "filter[#{name}][]",
-          multiple: true,
-          class: "form-control",
-          data: {
-            behavior: "select-box",
-            placeholder: translate_scoped("filters.select.placeholder.many")
-          }
+      def multiselect_filter_field(name, options, html_options = {})
+        filter_select(
+          name, options, {
+            name: "filter[#{name}][]",
+            multiple: true,
+            data: {
+              placeholder: @template.translate_scoped("filters.select.placeholder.many")
+            }
+          }.deep_merge(html_options)
         )
       end
 
-      def filter_select_tag_helper(name, options, html_options)
-        unless options[:collection].is_a? Proc
-          raise "A collection proc must be specified for select filters"
-        end
-
-        collection = options[:collection].call
-
-        if collection.is_a? ActiveRecord::Relation
-          choices = options_from_collection_for_select(
-            collection,
-            options[:option_value],
-            options[:option_text],
-            selected: default_filter_value(name)
-          )
-        else
-          choices = options_for_select(
-            collection,
-            selected: default_filter_value(name)
-          )
-        end
+      def apply_filters_button
+        submit @template.translate_scoped("filters.buttons.apply")
+      end
 
-        select_tag(name, choices, html_options)
+      def clear_filters_button
+        @template.link_to(
+          @template.translate_scoped("filters.buttons.clear"),
+          @template.url_for(
+            @template.params.slice(:scope, :order)
+          ),
+          class: "btn btn-default"
+        )
       end
 
-      def filter_checkbox_tags(name, options)
+      private
+
+      def filter_select(name, options, html_options)
         unless options[:collection].is_a? Proc
-          raise "A collection proc must be specified for checkbox filters"
+          fail "A collection proc must be specified for select filters"
         end
 
         collection = options[:collection].call
 
-        collection.map do |item|
-          text, value = if !item.is_a?(String) && item.respond_to?(:first) && item.respond_to?(:last)
-            [item.first.to_s, item.last.to_s]
+        choices =
+          if collection.is_a? ActiveRecord::Relation
+            @template.options_from_collection_for_select(
+              collection,
+              options[:option_value],
+              options[:option_text],
+              selected: default_filter_value(name)
+            )
           else
-            [item.to_s, item.to_s]
+            @template.options_for_select(
+              collection,
+              selected: default_filter_value(name)
+            )
           end
 
-          is_checked = default_filter_value(name) ? default_filter_value(name).include?(value) : false
-
-          content_tag :div, class: "checkbox" do
-            label_tag("#{name}_#{value}") do
-              check_box_tag("filter[#{name}][]", value, is_checked, id: "#{name}_#{value}") << text
-            end
-          end
-        end.join("\n").html_safe
+        select(
+          name, choices, { include_blank: true, wrapper_class: "filter" }, {
+            data: { behavior: "select-box" }
+          }.deep_merge(html_options)
+        )
       end
 
       def default_filter_value(name)
-        params[:filter] ? params[:filter][name] : nil
+        @template.params[:filter] ? @template.params[:filter][name] : nil
       end
     end
   end

data/lib/godmin/helpers/tables.rb

@@ -20,9 +20,7 @@ module Godmin
       end
 
       def column_value(resource, attribute)
-        if lookup_context.exists?("columns/#{attribute}", nil, true)
-          render partial: "columns/#{attribute}", locals: { resource: resource }
-        else
+        partial_override "columns/#{attribute}", resource: resource do
           column_value = resource.send(attribute)
 
           if column_value.is_a?(Date) || column_value.is_a?(Time)

data/lib/godmin/paginator.rb

@@ -0,0 +1,47 @@
+module Godmin
+  class Paginator
+    WINDOW_SIZE = 7.freeze
+
+    attr_reader :per_page, :current_page
+
+    def initialize(resources, per_page: 25, current_page: nil)
+      @resources    = resources
+      @per_page     = per_page
+      @current_page = current_page ? current_page.to_i : 1
+    end
+
+    def paginate
+      @resources.limit(per_page).offset(offset)
+    end
+
+    def pages
+      @pages ||= begin
+        pages = (1..total_pages).to_a
+
+        return pages unless total_pages > WINDOW_SIZE
+
+        if current_page < WINDOW_SIZE
+          pages.slice(0, WINDOW_SIZE)
+        elsif current_page > (total_pages - WINDOW_SIZE)
+          pages.slice(-WINDOW_SIZE, WINDOW_SIZE)
+        else
+          pages.slice(pages.index(current_page) - (WINDOW_SIZE / 2), WINDOW_SIZE)
+        end
+      end
+    end
+
+    def total_pages
+      @total_pages ||= (total_resources.to_f / per_page).ceil
+    end
+
+    def total_resources
+      @total_resources ||= @resources.count
+    end
+
+    private
+
+    def offset
+      (current_page * per_page) - per_page
+    end
+  end
+end

data/lib/godmin/rails.rb

@@ -18,12 +18,7 @@ module ActionDispatch::Routing
           Godmin.resources << resources.first
         end
 
-        super(*resources) do
-          if block_given?
-            yield
-          end
-          post "batch_action", on: :collection
-        end
+        super
       end
 
       yield

data/lib/godmin/resolver.rb

@@ -36,15 +36,20 @@ module Godmin
   class EngineResolver < Resolver
     def initialize(controller_name)
       super [Godmin.namespace, "app/views"].compact.join("/")
-      self.namespace       = Godmin.namespace
+      self.namespace = Godmin.namespace
       self.controller_name = controller_name
     end
+
+    def template_paths(prefix, _partial)
+      return [] if prefix =~ /^godmin\//
+      super
+    end
   end
 
   class GodminResolver < Resolver
     def initialize(controller_name)
       super [Godmin::Engine.root, "app/views"].compact.join("/")
-      self.namespace       = "godmin"
+      self.namespace = "godmin"
       self.controller_name = controller_name
     end
   end

data/lib/godmin/resources/resource_controller.rb

@@ -0,0 +1,170 @@
+require "godmin/helpers/batch_actions"
+require "godmin/helpers/filters"
+require "godmin/helpers/tables"
+
+module Godmin
+  module Resources
+    module ResourceController
+      extend ActiveSupport::Concern
+
+      included do
+        helper Godmin::Helpers::BatchActions
+        helper Godmin::Helpers::Filters
+        helper Godmin::Helpers::Tables
+
+        before_action :set_resource_service
+        before_action :set_resource_class
+        before_action :set_resources, only: :index
+        before_action :set_resource, only: [:show, :new, :edit, :create, :destroy]
+      end
+
+      def index
+        respond_to do |format|
+          format.html
+          format.json { render json: @resources.to_json }
+        end
+      end
+
+      def show
+        respond_to do |format|
+          format.html
+          format.json { render json: @resource.to_json }
+        end
+      end
+
+      def new; end
+
+      def edit; end
+
+      def create
+        respond_to do |format|
+          if @resource_service.create_resource(@resource)
+            format.html { redirect_to redirect_after_create, notice: redirect_flash_message }
+            format.json { render :show, status: :created, location: @resource }
+          else
+            format.html { render :edit }
+            format.json { render json: @resource.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      def update
+        return if perform_batch_action
+
+        set_resource
+
+        respond_to do |format|
+          if @resource_service.update_resource(@resource, resource_params)
+            format.html { redirect_to redirect_after_update, notice: redirect_flash_message }
+            format.json { render :show, status: :ok, location: @resource }
+          else
+            format.html { render :edit }
+            format.json { render json: @resource.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      def destroy
+        @resource.destroy
+
+        respond_to do |format|
+          format.html { redirect_to redirect_after_destroy, notice: redirect_flash_message }
+          format.json { head :no_content }
+        end
+      end
+
+      protected
+
+      def set_resource_service
+        @resource_service = resource_service
+      end
+
+      def set_resource_class
+        @resource_class = resource_class
+      end
+
+      def set_resources
+        @resources = resources
+        authorize(@resources) if authorization_enabled?
+      end
+
+      def set_resource
+        @resource = resource
+        authorize(@resource) if authorization_enabled?
+      end
+
+      def resource_service_class
+        "#{controller_path.singularize}_service".classify.constantize
+      end
+
+      def resource_service
+        if authentication_enabled?
+          resource_service_class.new(admin_user: admin_user)
+        else
+          resource_service_class.new
+        end
+      end
+
+      def resource_class
+        @resource_service.resource_class
+      end
+
+      def resources
+        @resource_service.resources(params)
+      end
+
+      def resource
+        if params[:id]
+          @resource_service.find_resource(params[:id])
+        else
+          case action_name
+          when "create"
+            @resource_service.build_resource(resource_params)
+          when "new"
+            @resource_service.build_resource(nil)
+          end
+        end
+      end
+
+      def resource_params
+        params.require(resource_class.model_name.param_key.to_sym).permit(@resource_service.attrs_for_form)
+      end
+
+      def redirect_after_create
+        redirect_after_save
+      end
+
+      def redirect_after_update
+        redirect_after_save
+      end
+
+      def redirect_after_save
+        @resource
+      end
+
+      def redirect_after_destroy
+        resource_class.model_name.route_key.to_sym
+      end
+
+      def redirect_flash_message
+        translate_scoped("flash.#{action_name}", resource: @resource.class.model_name.human)
+      end
+
+      def perform_batch_action
+        return false unless params[:batch_action].present?
+
+        item_ids = params[:id].split(",").map(&:to_i)
+
+        if @resource_service.batch_action(params[:batch_action], item_ids)
+          flash[:updated_ids] = item_ids
+
+          if respond_to?("redirect_after_batch_action_#{params[:batch_action]}", true)
+            redirect_to send("redirect_after_batch_action_#{params[:batch_action]}") and return true
+          end
+        end
+
+        redirect_to :back and return true
+      end
+    end
+  end
+end