tb_core 1.4.1 → 1.4.2

data/app/controllers/admin/application_controller.rb

@@ -1,4 +1,5 @@
-class Admin::ApplicationController < Spud::ApplicationController
+class Admin::ApplicationController < TbCore::ApplicationController
+  include TbCore::SortableParams
 
   before_action :require_admin_user
   add_breadcrumb 'Dashboard', :admin_root_path

data/app/controllers/admin/users_controller.rb

@@ -7,8 +7,12 @@ class Admin::UsersController < Admin::ApplicationController
   after_action :send_credentials_email, only: [:create, :update]
   respond_to :html, :csv
 
+  sortable_by :email, :current_login_at,
+              name: [:last_name, :first_name],
+              default: :email
+
   def index
-    @spud_users = SpudUser.ordered.paginate(page: params[:page], per_page: 15)
+    @spud_users = SpudUser.order(sortable_query).paginate(page: params[:page], per_page: 15)
     if params[:search]
       @spud_users = @spud_users.where_name_like(params[:search])
     end

data/app/controllers/concerns/tb_core/error_handling.rb

@@ -0,0 +1,49 @@
+module TbCore
+  module ErrorHandling
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from Spud::RequestError, with: :handle_request_error
+      rescue_from ActiveRecord::RecordNotFound, with: :handle_record_not_found
+      rescue_from ActionController::UnknownFormat, with: :handle_unknown_format_error
+    end
+
+    def handle_request_error(error)
+      error.request_url = request.original_url
+      error.template = template_for_request_error() if respond_to?(:template_for_request_error, true)
+
+      if error.is_a?(Spud::UnauthorizedError) && request.format.html?
+        redirect_to(login_path_for_require_user)
+        return false
+      end
+
+      do_error_response(error)
+    end
+
+    def do_error_response(error)
+      respond_to do |format|
+        format.json { render json: { errors: error.message }, status: error.code }
+        format.xml { render xml: { errors: error.message }, status: error.code }
+        format.all do
+          @error = error
+          render template: error.template,
+                 layout: nil,
+                 formats: [:html],
+                 status: error.code,
+                 content_type: 'text/html'
+        end
+      end
+    end
+
+    def handle_record_not_found(error)
+      error = Spud::NotFoundError.new('record')
+      handle_request_error(error)
+    end
+
+    def handle_unknown_format_error(error)
+      error = Spud::NotFoundError.new()
+      handle_request_error(error)
+    end
+
+  end
+end

data/app/controllers/concerns/tb_core/redirection.rb

@@ -0,0 +1,23 @@
+module TbCore
+  module Redirection
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :back_or_default
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(back_or_default(default))
+    end
+
+    def back_or_default(default = '/')
+      if params[:return_to]
+        uri = URI.parse(params[:return_to].to_s)
+        return "#{uri.path}?#{uri.query}" if uri.query
+        return uri.path
+      end
+      default
+    end
+
+  end
+end

data/app/controllers/concerns/tb_core/sortable_params.rb

@@ -0,0 +1,80 @@
+module TbCore
+  module SortableParams
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_accessor :default_sort_attribute
+      attr_accessor :sortable_mapping
+
+      # Define attributes you wish to sort by
+      #
+      # This optional configuration method tells the the sortable
+      # helpers how they should map attributes to queries. For
+      # example a "name" sort might need to sort on first and last
+      # name attributes
+      #
+      # The `default` argument, if passed, will determine the
+      # attribute used when no sort param has been passed
+      #
+      # Usage:
+      #
+      # sortable_by :email, name: [:last_name, :first_name]
+      #             default: :email,
+      #
+      #
+      def sortable_by(*attributes, **options)
+        @default_sort_attribute = options.delete(:default)
+        @sortable_mapping = options.merge(attributes.map { |att| [att, att] }.to_h)
+      end
+    end
+
+    # Return the current sort direction
+    #
+    # Defaults to :asc for all values other than "desc"
+    #
+    def sort_direction
+      if params[:dir].present? && params[:dir] == 'desc'
+        :desc
+      else
+        :asc
+      end
+    end
+
+    # Return the current sort param
+    #
+    def sort_attribute
+      params[:sort].try(:to_sym) || self.class.default_sort_attribute
+    end
+
+    # Return a hash that can be used in an ActiveRecord order query
+    #
+    # Example:
+    #   MyModel.where(...).order(sortable_query).paginate(...)
+    #
+    def sortable_query
+      return unless sort_attribute
+      normalize_sort_value(
+        sort_attribute,
+        sort_direction
+      )
+    end
+
+    # Translate the sort_by and direction into a sortable hash
+    #
+    def normalize_sort_value(sort_by, direction)
+      mapping = self.class.sortable_mapping[sort_by]
+      if mapping.is_a? Symbol
+        { mapping => sort_direction }
+      elsif mapping.is_a? String
+        mapping.gsub(':dir', sort_direction.to_s)
+      elsif mapping.is_a? Array
+        mapping.map { |att| [att, direction] }.to_h
+      elsif mapping.is_a? Proc
+        mapping.call(direction)
+      else
+        logger.debug("WARNING: Sort attribute '#{sort_by}' is not recognized. Did you mean to pass it to sortable_by?")
+        nil
+      end
+    end
+  end
+end

data/app/controllers/concerns/tb_core/user_authentication.rb

@@ -0,0 +1,57 @@
+module TbCore
+  module UserAuthentication
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_user_session, :current_user, :current_user_id
+      before_action :check_requires_password_change
+      around_action :set_time_zone
+    end
+
+    def current_user_session
+      return @current_user_session if defined?(@current_user_session)
+      @current_user_session = SpudUserSession.find
+    end
+
+    def current_user
+      return @current_user if defined?(@current_user)
+      @current_user = current_user_session && current_user_session.spud_user
+    end
+
+    def current_user_id
+      return 0 unless @current_user
+      @current_user.id
+    end
+
+    def require_user
+      raise Spud::UnauthorizedError.new unless current_user
+      true
+    end
+
+    def require_admin_user
+      raise Spud::UnauthorizedError.new unless current_user
+      raise Spud::AccessDeniedError.new unless current_user.has_admin_rights?
+      true
+    end
+
+    def check_requires_password_change
+      if current_user.present? && current_user.requires_password_change?
+        redirect_to(login_change_password_path(return_to: request.path))
+        return false
+      end
+    end
+
+    def set_time_zone
+      old_time_zone = Time.zone
+      Time.zone = current_user.time_zone if current_user && current_user.time_zone.present?
+      yield
+    ensure
+      Time.zone = old_time_zone
+    end
+
+    def login_path_for_require_user
+      login_path(return_to: request.fullpath)
+    end
+
+  end
+end

data/app/controllers/spud/application_controller.rb

@@ -1,138 +1,10 @@
-class Spud::ApplicationController < ActionController::Base
-
-  protect_from_forgery
-  helper_method :current_user_session, :current_user, :current_user_id, :back_or_default
-  before_action :check_requires_password_change
-  around_action :set_time_zone
-
-  include TbCore::ApplicationHelper
-  before_action :set_mailer_default_url
-
-  self.responder = TbCore::Responder
-
-  rescue_from Spud::RequestError, with: :handle_request_error
-  rescue_from ActiveRecord::RecordNotFound, with: :handle_record_not_found
-  rescue_from ActionController::UnknownFormat, with: :handle_unknown_format_error
-
-  def not_found
-    raise Spud::NotFoundError
+class Spud::ApplicationController < TbCore::ApplicationController
+  def initialize
+    ActiveSupport::Deprecation.warn(
+      'Spud::ApplicationController is deprecated and may be removed from future releases,
+      use TbCore::ApplicationController instead.',
+      caller
+    )
+    super
   end
-
-private
-
-  def set_mailer_default_url
-    ActionMailer::Base.default_url_options = {host: request.host_with_port}
-  end
-
-  def current_user_session
-    return @current_user_session if defined?(@current_user_session)
-    @current_user_session = SpudUserSession.find
-  end
-
-  def current_user
-    return @current_user if defined?(@current_user)
-    @current_user = current_user_session && current_user_session.spud_user
-  end
-
-  def current_user_id
-    if @current_user
-      return @current_user.id
-    else
-      0
-    end
-  end
-
-  def require_user
-    unless current_user
-      raise Spud::UnauthorizedError.new()
-    end
-    return true
-  end
-
-  # Override this in a controller to redifine where the login form is
-  #
-  def login_path_for_require_user
-    login_path(return_to: request.fullpath)
-  end
-
-  def require_admin_user
-    if current_user.blank?
-      raise Spud::UnauthorizedError.new()
-    elsif !current_user.has_admin_rights?
-      raise Spud::AccessDeniedError.new()
-    end
-  end
-
-  def redirect_back_or_default(default)
-    redirect_to(back_or_default(default))
-  end
-
-  def back_or_default(default='/')
-    if params[:return_to]
-      uri = URI.parse(params[:return_to].to_s)
-      return "#{uri.path}?#{uri.query}" if uri.query
-      return uri.path
-    else
-      return default
-    end
-  end
-
-  def check_requires_password_change
-    if current_user.present? && current_user.requires_password_change?
-      redirect_to(login_change_password_path(return_to: request.path))
-      return false
-    end
-  end
-
-  def set_time_zone
-    old_time_zone = Time.zone
-    Time.zone = current_user.time_zone if current_user and current_user.time_zone.blank? == false
-    yield
-  ensure
-    Time.zone = old_time_zone
-  end
-
-  def handle_request_error(error)
-    error.request_url = request.original_url
-    error.template = template_for_request_error() if respond_to?(:template_for_request_error, true)
-
-    if error.is_a?(Spud::UnauthorizedError)
-      if should_present_basic_auth?
-        headers['WWW-Authenticate'] = "Basic realm=\"#{Spud::Core.config.site_name}\""
-      elsif request.format.html?
-        redirect_to(login_path_for_require_user)
-        return false
-      end
-    end
-
-    do_error_response(error)
-  end
-
-  def do_error_response(error)
-    respond_to do |format|
-      format.json { render json: { errors: error.message }, status: error.code }
-      format.xml { render xml: { errors: error.message }, status: error.code }
-      format.all {
-        @error = error
-        render template: error.template, layout: nil, formats: [:html], status: error.code, content_type: 'text/html'
-      }
-    end
-  end
-
-  def should_present_basic_auth?
-    return request.headers['X-TWICE-BAKED-BASIC-AUTH'].present?
-  end
-
-  def handle_record_not_found(error)
-    error = Spud::NotFoundError.new('record')
-    handle_request_error(error)
-  end
-
-  def handle_unknown_format_error(error)
-    error = Spud::NotFoundError.new()
-    handle_request_error(error)
-  end
-
-  ActiveSupport.run_load_hooks(:spud_application_controller, self)
-
 end

data/app/controllers/tb_core/application_controller.rb

@@ -0,0 +1,16 @@
+module TbCore
+  class ApplicationController < ActionController::Base
+    protect_from_forgery
+
+    include TbCore::ErrorHandling
+    include TbCore::Redirection
+    include TbCore::UserAuthentication
+    self.responder = TbCore::Responder
+
+    def not_found
+      raise Spud::NotFoundError
+    end
+
+    ActiveSupport.run_load_hooks(:tb_core_application_controller, self)
+  end
+end

data/app/helpers/admin/application_helper.rb

@@ -35,7 +35,9 @@ module Admin::ApplicationHelper
     end
   end
 
-  WHITE_LIST_PARAMS = [:tab, :page, :sort, :direction, :search, :id].freeze
+  # The following params will automatically be white listed for tabbed navigation
+  #
+  WHITE_LIST_PARAMS = [:tab, :sort, :direction, :dir, :search, :id].freeze
 
   # Build a Bootstrap nav-tabs element
   #

data/app/helpers/tb_core/application_helper.rb

@@ -67,6 +67,38 @@ module TbCore::ApplicationHelper
     return content_tag :title, title
   end
 
+  # Build a table header for a model
+  #
+  # * path_helper: The helper method you want to use to generate URLs.
+  # * model: The class we should use for translations (optional)
+  # * permit: Array of request params that are forwarded to the sort links
+  #
+  # Example:
+  #
+  # <%= tb_table_header :admin_users_path, model: SpudUser do |t| %>
+  #   <%= t.sortable :name %>
+  #   <%= t.sortable :email %>
+  #   <%= t.header :last_login %>
+  #   <th></th>
+  # <% end %>
+  #
+  # Header labels will be pulled from en.yml. To provide a different
+  # label pass the label: option
+  #
+  # Example:
+  #
+  # <%= t.header :name, label: 'Full Name' %>
+  #
+  def tb_table_header(path_helper, model: nil, permit: [], &block)
+    header = TbCore::TableHeader.new(
+      path_helper: path_helper,
+      model: model,
+      params: params.permit(permit.concat([:sort, :dir, :search, :tab])),
+      context: self)
+    header.capture(block) if block
+    header.to_html
+  end
+
   def current_site_name
     return Spud::Core.config.site_name
   end

data/app/views/admin/users/index.html.erb

@@ -8,12 +8,12 @@
 <%= content_for :detail do %>
   <div class="table-responsive">
     <table class="table table-striped table-hover">
-      <thead>
-        <th>Name</th>
-        <th>Email</th>
-        <th>Last Login</th>
-        <th>&nbsp;</th>
-      </thead>
+      <%= tb_table_header :admin_users_path, model: SpudUser do |t| %>
+        <%= t.sortable :name %>
+        <%= t.sortable :email %>
+        <%= t.sortable :current_login_at %>
+        <th></th>
+      <% end %>
       <tbody>
         <% @spud_users.each do |spud_user| %>
           <tr>

data/config/locales/en.yml

@@ -20,6 +20,7 @@ en:
         spud_role_id: 'Role'
         password_confirmation: 'Confirm password'
         requires_password_change: 'Require change'
+        current_login_at: 'Logged in at'
   tb_core_mailer:
     forgot_password_notification:
       subject: 'Forgot Password Request from %{site_name}'

data/config/routes.rb

@@ -32,6 +32,6 @@ Rails.application.routes.draw do
   resources :password_resets, :only => [:index, :create, :show, :update], :path => 'login/forgot'
 
   get 'spud/admin' => 'admin/user_sessions#legacy_redirect'
-  get 'spud/not_found' => 'spud/application#not_found', :as => 'not_found'
+  get 'tb_core/not_found' => 'tb_core/application#not_found', as: 'not_found' unless Rails.env.production?
 
 end

data/lib/generators/spud/templates/application_controller.rb

@@ -1,3 +1,3 @@
-class ApplicationController < Spud::ApplicationController
+class ApplicationController < TbCore::ApplicationController
   protect_from_forgery
 end

data/lib/spud_core/engine.rb

@@ -1,6 +1,5 @@
 require 'responders'
 require 'jquery-rails'
-require 'jquery-ui-rails'
 require 'authlogic'
 require 'bootstrap-sass'
 require 'autoprefixer-rails'
@@ -18,6 +17,7 @@ module Spud
       require "#{root}/lib/spud_core/errors"
       require "#{root}/lib/spud_core/searchable"
       require "#{root}/lib/tb_core/form_builder"
+      require "#{root}/lib/tb_core/table_header"
 
       engine_name :tb_core
       config.autoload_paths << "#{root}/lib"

data/lib/spud_core/version.rb

@@ -1,5 +1,5 @@
 module Spud
   module Core
-    VERSION = '1.4.1'.freeze
+    VERSION = '1.4.2'.freeze
   end
 end

data/lib/tb_core/form_builder.rb

@@ -143,7 +143,7 @@ class TbCore::FormBuilder < ActionView::Helpers::FormBuilder
   # ie, container div + label + input + error message
   #
 
-  def tb_sub_title(text)
+  def tb_sub_title(text, options={})
     content_tag :div, options.merge(class: 'form-group') do
       content_tag :div, class: 'col-sm-offset-2 col-sm-10' do
         content_tag :h4, text, class: 'form-sub-title'

data/lib/tb_core/table_header.rb

@@ -0,0 +1,92 @@
+module TbCore
+  class TableHeader
+    attr_reader :context
+    attr_accessor :header_html
+
+    # Forward view helper methods to the view context
+    delegate :concat, :content_tag, :link_to, to: :context
+
+    def initialize(path_helper:, model: nil, params: {}, context:)
+      @path_helper = path_helper
+      @model = model
+      @params = params
+      @context = context
+    end
+
+    def capture(block)
+      @html = context.capture do
+        block.call(self)
+      end
+    end
+
+    def sortable(attribute, label: nil)
+      content_tag :th, class: classes_for_attribute(attribute) do
+        concat(link_to_for_attribute(attribute, label))
+        concat(sort_arrow_for_attribute(attribute))
+      end
+    end
+
+    def header(attribute, label: nil)
+      label ||= translated_attribute(attribute)
+      content_tag :th, label
+    end
+
+    def to_row
+      content_tag(:tr, @html)
+    end
+
+    def to_html
+      content_tag :thead, to_row, class: 'tb-table-header'
+    end
+
+    private
+
+    def translated_attribute(attribute)
+      if @model
+        @model.human_attribute_name(attribute)
+      else
+        context.t(attribute)
+      end
+    end
+
+    def current_direction
+      @params[:dir] || 'asc'
+    end
+
+    def inverted_direction
+      current_direction == 'asc' ? 'desc' : 'asc'
+    end
+
+    def determine_direction(attribute)
+      if @params[:sort].nil? || @params[:sort] != attribute.to_s
+        'asc'
+      else
+        inverted_direction
+      end
+    end
+
+    def classes_for_attribute(attribute)
+      classes = ['sortable']
+      if @params[:sort] == attribute.to_s
+        classes << 'sortable-active'
+        classes << "sortable-#{current_direction}"
+      end
+      classes.join(' ')
+    end
+
+    def link_to_for_attribute(attribute, label)
+      label ||= translated_attribute(attribute)
+      path = context.send(
+        @path_helper,
+        @params.merge(sort: attribute, dir: determine_direction(attribute))
+      )
+      link_to(label, path)
+    end
+
+    def sort_arrow_for_attribute(attribute)
+      return '' unless @params[:sort] == attribute.to_s
+      arrow_class = current_direction == 'asc' ? 'up' : 'down'
+      content_tag(:span, '', class: "glyphicon glyphicon-arrow-#{arrow_class}")
+    end
+  end
+end

data/spec/controllers/admin/application_controller_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Admin::ApplicationController, type: :controller do
       end
     end
     it 'should respond successfully if the current user is a super admin' do
-      @user.update_attribute(:super_admin, true)
+      @user.update_attributes(super_admin: true)
       get :index
       expect(response).to be_success
     end

data/spec/controllers/{spud → tb_core}/application_controller_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 require 'rspec/mocks'
 require 'rspec/mocks/standalone'
 
-describe Spud::ApplicationController, type: :controller do
+describe TbCore::ApplicationController, type: :controller do
 
   describe 'not_found' do
     it 'throws a 404 error' do