wallaby 5.0.1 → 5.1.3

data/app/assets/stylesheets/wallaby/pages/_index.scss

@@ -0,0 +1,193 @@
+.index {
+  .resources__header {
+    > nav {
+      @include divider;
+      margin-left: 6px;
+    }
+  }
+
+  .resources {
+    section {
+      margin-bottom: 4px;
+    }
+
+    &__not-found {
+      font-size: 24px;
+      padding-left: 105px;
+      padding-top: 140px;
+      position: relative;
+      text-align: left;
+
+      img {
+        height: 80px;
+        margin-left: -90px;
+        margin-top: 12px;
+        position: absolute;
+      }
+    }
+
+    &__data, &__actions {
+      @extend .table;
+      border-collapse: separate;
+      margin-bottom: 0;
+
+      tbody td.resource__actions {
+        min-width: 85px;
+        text-align: right;
+
+        a {
+          @extend .fa, .fa-info;
+
+          background-color: $light-primary-color;
+          border-radius: 2px;
+          border: none;
+          color: $white;
+          display: inline-block;
+          height: 16px;
+          line-height: 16px;
+          margin-right: 3px;
+          text-align: center;
+          text-decoration: none;
+          width: 16px;
+
+          &:hover {
+            background-color: $default-primary-color;
+            color: $white;
+          }
+
+          &.resource__update {
+            @extend .fa-pencil;
+            background-color: $light-yellow-color;
+
+            &:hover {
+              background-color: $default-yellow-color;
+            }
+          }
+
+          &.resource__destroy {
+            @extend .fa-remove;
+            background-color: $light-red-color;
+
+            &:hover {
+              background-color: $default-red-color;
+            }
+          }
+
+          &:last-child {
+            margin-right: 0px;
+          }
+        }
+      }
+
+      thead tr th, tbody tr td {
+        background-color: white;
+        border: none;
+        border-bottom: 6px solid $background-color;
+        font-weight: normal;
+        height: 40px;
+        padding: 8px 12px;
+        white-space: nowrap;
+      }
+
+      thead tr th {
+        color: $light-grey-color;
+        font-weight: bold;
+        line-height: 20px;
+        position: relative;
+        text-transform: uppercase;
+
+        a {
+          border-bottom: none;
+          display: block;
+          padding-right: 11px;
+          position: relative;
+          transition: 0.5s;
+
+          &:before {
+            @extend .fa;
+            color: $light-primary-color;
+            margin-top: -6px;
+            position: absolute;
+            right: 0;
+            top: 50%;
+            transition: 0.5s;
+          }
+
+          &:hover {
+            color: $default-primary-color;
+            &:before {
+              color: $default-primary-color;
+              content: $fa-var-sort-asc;
+            }
+          }
+        }
+
+        &.asc {
+          a {
+            &:before {
+              content: $fa-var-sort-asc;
+            }
+            &:hover {
+              &:before {
+                content: $fa-var-sort-desc;
+              }
+            }
+          }
+        }
+
+        &.desc {
+          a {
+            &:before {
+              content: $fa-var-sort-desc;
+            }
+            &:hover {
+              &:before {
+                content: $fa-var-sort;
+              }
+            }
+          }
+        }
+      }
+
+      tbody tr {
+        td {
+          a {
+            display: inline-block;
+          }
+        }
+      }
+    }
+
+    &__actions {
+      position: absolute;
+      right: 0;
+      top: 0;
+      width: inherit;
+
+      thead tr th {
+        @extend .fa;
+        display: table-cell;
+        font-size: 14px;
+
+        &:before, &:after {
+          display: inline-block;
+          margin-top: -10px;
+          position: absolute;
+          top: 50%;
+        }
+
+        &.resources--forward:after {
+          content: $fa-var-angle-double-right;
+          right: 16px;
+        }
+
+        &.resources--backward:before {
+          content: $fa-var-angle-double-left;
+          left: 16px;
+        }
+      }
+    }
+  }
+}
+
+@import '_index_desktop';

data/app/assets/stylesheets/wallaby/pages/_index_desktop.scss

@@ -0,0 +1,22 @@
+@media (min-width: $screen-sm-min) {
+  body.index {
+    padding-top: 131px;
+
+    .resources__header {
+      padding-top: 15px;
+    }
+
+    .resources {
+      section {
+        margin-bottom: 24px;
+      }
+
+      &__not-found img {
+        margin-left: -95px;
+        margin-top: -21px;
+      }
+    }
+  }
+}
+
+

data/app/assets/stylesheets/wallaby/pages/_show.scss

@@ -0,0 +1,21 @@
+.show {
+  section {
+    dl {
+      margin: 0;
+      padding: 15px 20px;
+    }
+
+    dt {
+      border-bottom: 1px solid $background-color;
+      color: $default-primary-color;
+      font-style: italic;
+      font-weight: bold;
+      padding-bottom: 8px;
+      text-transform: uppercase;
+    }
+
+    dd {
+      padding-top: 8px;
+    }
+  }
+}

data/app/controllers/wallaby/abstract_resources_controller.rb

@@ -0,0 +1,334 @@
+module Wallaby
+  # Generic CRUD controller
+  class AbstractResourcesController < ::Wallaby::BaseController
+    self.responder = ResourcesResponder
+    respond_to :html
+    respond_to :json
+    respond_to :csv, only: :index
+    helper ResourcesHelper
+    helper_method :resource_id, :resource, :collection,
+                  :current_model_decorator, :authorizer
+
+    # Fetch resources name from its class name
+    def self.resources_name
+      return unless self < ::Wallaby::ResourcesController
+      Map.resources_name_map name.gsub('Controller', EMPTY_STRING)
+    end
+
+    # Find model class from its resources name
+    def self.model_class
+      return unless self < ::Wallaby::ResourcesController
+      Map.model_class_map resources_name
+    end
+
+    # home page
+    def home
+      # do nothing
+    end
+
+    # Index page to list data
+    def index
+      authorize! :index, current_model_class
+      yield if block_given? # after_index
+      respond_with collection
+    end
+
+    # Form page for creation
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `new` is run
+    #
+    #     ```
+    #        def new
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `new`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def new
+    #          super do
+    #            # do something after new
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def new
+    #          # do something completely different
+    #        end
+    #     ```
+    def new
+      authorize! :new, resource
+      yield if block_given? # after_new
+      respond_with resource
+    end
+
+    # Data creation
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `new` is run
+    #
+    #     ```
+    #        def create
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `create`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def create
+    #          super do
+    #            # do something after create
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def create
+    #          # do something completely different
+    #        end
+    #     ```
+    def create
+      authorize! :create, resource
+      current_model_service.create resource, params
+      yield if block_given? # after_create
+      respond_with resource, location: helpers.show_path(resource)
+    end
+
+    # Show page for a single record
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `show` is run
+    #
+    #     ```
+    #        def show
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `show`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def show
+    #          super do
+    #            # do something after show
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def show
+    #          # do something completely different
+    #        end
+    #     ```
+    def show
+      authorize! :show, resource
+      yield if block_given? # after_show
+      respond_with resource
+    end
+
+    # Edit page for a single record
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `edit` is run
+    #
+    #     ```
+    #        def edit
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `edit`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def edit
+    #          super do
+    #            # do something after edit
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def edit
+    #          # do something completely different
+    #        end
+    #     ```
+    def edit
+      authorize! :edit, resource
+      yield if block_given? # after_edit
+      respond_with resource
+    end
+
+    # Date update
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `update` is run
+    #
+    #     ```
+    #        def update
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `update`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def update
+    #          super do
+    #            # do something after update
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def update
+    #          # do something completely different
+    #        end
+    #     ```
+    def update
+      authorize! :update, resource
+      current_model_service.update resource, params
+      yield if block_given? # after_update
+      respond_with resource, location: helpers.show_path(resource)
+    end
+
+    # Data deletion
+    # You could override this method in subclasses in the following ways:
+    # - To perform action before `destroy` is run
+    #
+    #     ```
+    #        def destroy
+    #          # do something beforehand
+    #          super
+    #        end
+    #     ```
+    #
+    # - To perform action after `destroy`, but before rendering.
+    #  The reason is that we use responder at the end of the action
+    #
+    #     ```
+    #        def destroy
+    #          super do
+    #            # do something after destroy
+    #          end
+    #        end
+    #     ```
+    #
+    # - To perform completely different action
+    #
+    #     ```
+    #        def destroy
+    #          # do something completely different
+    #        end
+    #     ```
+    def destroy
+      authorize! :destroy, resource
+      current_model_service.destroy resource, params
+      yield if block_given? # after_destroy
+      respond_with resource, location: helpers.index_path(current_model_class)
+    end
+
+    protected
+
+    # Override origin ActionView::ViewPaths::ClassMethods#_prefixes
+    # to add more paths so that it could look up partials in the following
+    # order:
+    # - mounted_path/resources_name/action_name (e.g. `admin/products/index)
+    # - mounted_path/resources_name (e.g. `admin/products)
+    # - full_path_of_custom_resources_controller/action_name
+    #  (e.g. `management/custom_products/index)
+    # - full_path_of_custom_resources_controller
+    #  (e.g. `management/custom_products)
+    # - wallaby_resources_controller_name/action_name
+    #  (e.g. `wallaby/resources/index)
+    # - wallaby_resources_controller_name
+    #  (e.g. `wallaby/resources)
+    def _prefixes
+      @_prefixes ||= PrefixesBuilder.new(
+        super, controller_path, current_resources_name, params
+      ).build
+    end
+
+    # A wrapped lookup content
+    # Its aim is to render string partial when given partial is not found
+    def lookup_context
+      @_lookup_context ||= LookupContextWrapper.new super
+    end
+
+    # Current model service to take care of all the CRUD actions
+    # For how to override model service, see (Wallaby::ModelServicer)
+    def current_model_service
+      @current_model_service ||= begin
+        model_class = current_model_class
+        Map.servicer_map(model_class).new model_class, authorizer
+      end
+    end
+
+    # To paginate the collection but only when either `page` or `per` param is
+    # given, or requesting HTML response
+    # @see Wallaby::ModelServicer#paginate
+    def paginate(query)
+      if params[:page] || params[:per] || request.format.symbol == :html
+        current_model_service.paginate(query, params)
+      else
+        query
+      end
+    end
+
+    # To whitelist the params for CRUD actions
+    # @see Wallaby::ModelServicer#permit
+    def resource_params
+      @resource_params ||= current_model_service.permit params
+    end
+
+    # Shorthand of params[:id]
+    def resource_id
+      params[:id]
+    end
+
+    # @return [#each] a collection of all the records
+    def collection
+      @collection ||= paginate current_model_service.collection params
+    end
+
+    # @return either persisted or unpersisted resource instance
+    def resource
+      @resource ||=
+        if resource_id.present?
+          current_model_service.find resource_id, resource_params
+        else
+          current_model_service.new resource_params
+        end
+    end
+
+    # Get current model decorator so that we could retrive metadata for given
+    # model class.
+    def current_model_decorator
+      @current_model_decorator ||= helpers.model_decorator current_model_class
+    end
+
+    # A wrapper method for authorizer
+    # @todo to add support to pundit in the future
+    def authorizer
+      current_ability
+    end
+  end
+end

data/app/controllers/wallaby/application_controller.rb

@@ -1,21 +1,51 @@
-class Wallaby::ApplicationController < ::Wallaby.configuration.base_controller
-  helper Wallaby::ApplicationHelper
+module Wallaby
+  # Wallaby's application controller
+  # It defaults to inherit from ::ApplicationController, which can be configured
+  # via `Wallaby.configuration.base_controller`
+  # It only contains the error handling logics
+  class ApplicationController < configuration.base_controller
+    helper ApplicationHelper
 
-  rescue_from \
-    Wallaby::ResourceNotFound,
-    Wallaby::ModelNotFound,
-    with: :not_found
-  rescue_from ActionController::ParameterMissing, with: :unprocessable_entity
+    ERROR_PATH = ERROR_LAYOUT = 'wallaby/error'.freeze
 
-  layout 'wallaby/application'
+    # NOTE: we want to see the error blown up in development environment
+    unless Rails.env.development?
+      rescue_from NotFound, with: :not_found
+      rescue_from ::ActionController::ParameterMissing, with: :bad_request
+      rescue_from ::ActiveRecord::StatementInvalid, with: :unprocessable_entity
+    end
 
-  def not_found(exception = nil)
-    @exception = exception
-    render 'wallaby/errors/not_found', status: 404
-  end
+    layout 'wallaby/application'
+
+    # Not found page
+    def not_found(exception = nil)
+      error_rendering(exception, __callee__)
+    end
+
+    # Bad request page
+    def bad_request(exception = nil)
+      error_rendering(exception, __callee__)
+    end
+
+    # Unprocessable entity page
+    def unprocessable_entity(exception = nil)
+      error_rendering(exception, __callee__)
+    end
+
+    protected
+
+    def configuration
+      ::Wallaby.configuration
+    end
+
+    # capture exceptions and display the error using error layout and view
+    def error_rendering(exception, symbol)
+      @exception = exception
+      @symbol = symbol
+      @code = Rack::Utils::SYMBOL_TO_STATUS_CODE[@symbol].to_i
 
-  def unprocessable_entity(exception)
-    @exception = exception
-    render 'wallaby/errors/unprocessable_entity', status: 422
+      Rails.logger.error @exception
+      render ERROR_PATH, layout: ERROR_LAYOUT, status: symbol
+    end
   end
 end

data/app/controllers/wallaby/base_controller.rb

@@ -0,0 +1,30 @@
+module Wallaby
+  # Base controller to provide basic helper methods for sub classes
+  class BaseController < ::Wallaby::SecureController
+    helper BaseHelper
+    helper_method \
+      :current_resources_name,
+      :current_model_class
+
+    before_action :authenticate_user!, except: [:status]
+
+    # health check
+    def healthy
+      render plain: 'healthy'
+    end
+
+    protected
+
+    # @return [String] the resources name coming from params
+    def current_resources_name
+      @current_resources_name ||= params[:resources]
+    end
+
+    # @return [Class] the model class that links to the resources name
+    def current_model_class
+      @current_model_class ||=
+        self.class.respond_to?(:model_class) && self.class.model_class \
+        || Map.model_class_map(current_resources_name)
+    end
+  end
+end