wallaby-core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54c8cdfb2441a930457233aa18eb94b203afba08731c9eff8574d3308bb979df
+  data.tar.gz: e738dbb089e23a0148e112b250a9aead31d40cc8147e4403c911038e5d1c7c08
+SHA512:
+  metadata.gz: 0453d5a5de52cf2b6888a01e97658ee40155796156e7d09595f9249917baf036bce45a53d7c7ae180c9a184bd89e98c76df7fd960f49b4542d814f4bd8a725a3
+  data.tar.gz: ffe831732748530de95c35e7ed4ff91e9d9c9710b483c80e99048186636d36d24b3e432811c713b7e04c452bf91a190768970d827a3c402fdc6b91b4c374fd78

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2019 Google LLC. http://angular.io/license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Wallaby::Core
+
+This gem contains the core interface that Wallaby is built upon.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wallaby-core'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install wallaby-core
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wallaby-rails/wallaby-core.
+
+## License
+
+This project is [MIT Licensed](LICENSE)

data/app/controllers/wallaby/application_controller.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Like ordinary Rails application, it's the base controller that
+  # other Wallaby controllers inherit from.
+  #
+  # However, the difference is that the controller class that {Wallaby::ApplicationController} inherits from
+  # can be configured via {Wallaby::Configuration#base_controller}
+  #
+  # Here, it provides the most basic functions e.g. error handling for common 4xx HTTP status, helpers method,
+  # and URL handling.
+  class ApplicationController < configuration.base_controller
+    extend Engineable::ClassMethods
+    include Engineable
+    include SharedHelpers
+    helper ApplicationHelper
+
+    rescue_from NotFound, with: :not_found
+    rescue_from ::ActionController::ParameterMissing, with: :bad_request
+    rescue_from ::ActiveRecord::StatementInvalid, with: :unprocessable_entity
+    rescue_from NotImplemented, with: :not_implemented
+    rescue_from UnprocessableEntity, with: :unprocessable_entity
+
+    delegate(*ConfigurationHelper.instance_methods(false), :url_for, to: :helpers)
+
+    # Health check page for e.g. NewRelic
+    def healthy
+      render plain: 'healthy'
+    end
+
+    # Not found page
+    # @param exception [Exception] comes from **rescue_from**
+    def not_found(exception = nil)
+      error_rendering exception, __callee__
+    end
+
+    # Bad request page
+    # @param exception [Exception] comes from **rescue_from**
+    def bad_request(exception = nil)
+      error_rendering exception, __callee__
+    end
+
+    # Unprocessable entity page
+    # @param exception [Exception] comes from **rescue_from**
+    def unprocessable_entity(exception = nil)
+      error_rendering exception, __callee__
+    end
+
+    # Internal server error page
+    # @param exception [Exception] comes from **rescue_from**
+    def internal_server_error(exception = nil)
+      error_rendering exception, __callee__
+    end
+
+    # Not implemented
+    # @param exception [Exception] comes from **rescue_from**
+    def not_implemented(exception = nil)
+      error_rendering exception, __callee__
+    end
+
+    # {https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers helpers}
+    # exists since Rails 5.0, need to mimic this to support Rails 4.2.
+    # @see https://api.rubyonrails.org/classes/ActionController/Helpers.html#method-i-helpers
+    #   ActionController::Helpers#helpers
+    # @see https://github.com/rails/rails/blob/5-0-stable/actionpack/lib/action_controller/metal/helpers.rb#L118
+    def helpers
+      @helpers ||= defined?(super) ? super : view_context
+    end
+
+    protected
+
+    # Capture exceptions and display the error using error template.
+    # @param exception [Exception]
+    # @param symbol [Symbol] http status symbol
+    def error_rendering(exception, symbol)
+      Rails.logger.error exception
+
+      @exception = exception
+      @symbol = symbol
+      @code = Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol].to_i
+      respond_with @exception, status: @code, template: ERROR_PATH, prefixes: _prefixes
+    end
+  end
+end

data/app/controllers/wallaby/resources_controller.rb

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+module Wallaby
+  # Resources controller, superclass for all customization controllers.
+  # It contains CRUD template action methods (`index`/`new`/`create`/`edit`/`update`/`destroy`)
+  # that allow subclasses to override.
+  class ResourcesController < ::Wallaby::SecureController
+    extend Authorizable::ClassMethods
+    extend Baseable::ClassMethods
+    extend Decoratable::ClassMethods
+    extend Paginatable::ClassMethods
+    extend Resourcable::ClassMethods
+    extend Servicable::ClassMethods
+    extend Themeable::ClassMethods
+    include Authorizable
+    include Decoratable
+    include Defaultable
+    include Paginatable
+    include RailsOverriddenMethods
+    include Resourcable
+    include Servicable
+    include Themeable
+
+    self.responder = ResourcesResponder
+    respond_to :html
+    respond_to :json
+    respond_to :csv, only: :index
+    helper ResourcesHelper
+    before_action :authenticate_user!
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is an action for landing page display. It does nothing more than rendering `home` template.
+    #
+    # It can be replaced completely in subclasses as below:
+    #
+    # ```
+    # def home
+    #   generate_dashboard_report
+    # end
+    # ```
+    def home
+      # do nothing
+    end
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to list records that user can access.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # `WARN: Please keep in mind that Wallaby User Interface requires **index**
+    # action to respond to **csv** and **json** format as well.`
+    #
+    # ```
+    # def index
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   index!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # `WARN: Please keep in mind that Wallaby User Interface requires **index**
+    # action to respond to **csv** and **json** format as well.`
+    #
+    # ```
+    # def index
+    #   # NOTE: `@collection` will be used by the view, please ensure it is assigned, for example:
+    #   @collection = Product.all
+    #   respond_with @collection
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def index(options = {}, &block)
+      current_authorizer.authorize :index, current_model_class
+      respond_with collection, options, &block
+    end
+
+    alias index! index
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to show the form to create record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def new
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   new!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def new
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.new new_arrival: true
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def new(options = {}, &block)
+      current_authorizer.authorize :new, resource
+      respond_with resource, options, &block
+    end
+
+    alias new! new
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to create a record that user is allowed to.
+    #
+    # If record is created successfully, user will be navigated to the record show page.
+    # Otherwise, the form will be shown again with error messages.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def create
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   create!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def create
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.new resource_params.merge(new_arrival: true)
+    #   if @resource.save
+    #     redirect_to helper.index_path(current_model_class)
+    #   else
+    #     render :new
+    #   end
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to create the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def create(options = {}, &block)
+      set_defaults_for :create, options
+      current_authorizer.authorize :create, resource
+      current_servicer.create resource, options.delete(:params)
+      respond_with resource, options, &block
+    end
+
+    alias create! create
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to display the record details that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def show
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   show!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def show
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def show(options = {}, &block)
+      current_authorizer.authorize :show, resource
+      respond_with resource, options, &block
+    end
+
+    alias show! show
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to show the form to edit record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def edit
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   edit!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def edit
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def edit(options = {}, &block)
+      current_authorizer.authorize :edit, resource
+      respond_with resource, options, &block
+    end
+
+    alias edit! edit
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to update the record that user is allowed to.
+    #
+    # If record is updated successfully, user will be navigated to the record show page.
+    # Otherwise, the form will be shown again with error messages.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def update
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   update!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def update
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    #   @resource.assign_attributes resource_params.merge(new_arrival: true)
+    #   if @resource.save
+    #     redirect_to helper.index_path(current_model_class)
+    #   else
+    #     render :new
+    #   end
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to update the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def update(options = {}, &block)
+      set_defaults_for :update, options
+      current_authorizer.authorize :update, resource
+      current_servicer.update resource, options.delete(:params)
+      respond_with resource, options, &block
+    end
+
+    alias update! update
+
+    # @note This is a template method that can be overridden by subclasses.
+    # This is a resourceful action to delete the record that user is allowed to.
+    #
+    # It can be customized as below in subclasses:
+    #
+    # ```
+    # def destroy
+    #   # do something before the origin action
+    #   options = {} # NOTE: see `options` parameter for more details
+    #   destroy!(options) do |format| # NOTE: this is better than using `super`
+    #     # NOTE: this block is for `respond_with` which works similar to `respond_to`
+    #     # customize response behaviour, or do something before the request is rendered
+    #   end
+    # end
+    # ```
+    #
+    # Otherwise, it can be replaced completely in subclasses:
+    #
+    # ```
+    # def destroy
+    #   # NOTE: `@resource` will be used by the view, please ensure it is assigned, for example:
+    #   @resource = Product.find_by_slug params[:id]
+    #   @resource.destroy
+    #   redirect_to helper.index_path(current_model_class)
+    # end
+    # ```
+    # @param options [Hash] (since 5.2.0) options for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}. In addition, options `:params` is supported, see below
+    # @option options [ActionController::Parameters, Hash] :params
+    #   permitted parameters for servicer to destroy the record. _(defaults to: {#resource_params})_
+    # @yield [format] block for
+    #   {https://www.rubydoc.info/gems/responders/ActionController/RespondWith#respond_with-instance_method
+    #   respond_with}
+    #   to customize response behaviour.
+    # @raise [Wallaby::Forbidden] if user has no access
+    def destroy(options = {}, &block)
+      set_defaults_for :destroy, options
+      current_authorizer.authorize :destroy, resource
+      current_servicer.destroy resource, options.delete(:params)
+      respond_with resource, options, &block
+    end
+
+    alias destroy! destroy
+
+    # @note This is a template method that can be overridden by subclasses.
+    # To whitelist the params for {#create} and {#update} actions.
+    #
+    # If Wallaby cannot generate the correct strong parameters, it can be replaced, for example:
+    #
+    # ```
+    # def resource_params
+    #   params.fetch(:product, {}).permit(:name, :sku)
+    # end
+    # ```
+    # @return [ActionController::Parameters] whitelisted params
+    def resource_params
+      @resource_params ||= current_servicer.permit params, action_name
+    end
+
+    # @!method collection(options = {}, &block)
+    #   (see Wallaby::Resourcable#collection)
+    #   @see Wallaby::Resourcable#collection
+    alias collection! collection
+
+    # @!method resource(options = {}, &block)
+    #   (see Wallaby::Resourcable#resource)
+    #   @see Wallaby::Resourcable#resource
+    alias resource! resource
+  end
+end