wallaby 5.1.5 → 5.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d350fea3b2b5c2c80941c75875aa66a6a660efaa
-  data.tar.gz: ff4f3f8a4edeafa44eb548e6e89a3a1a26a74602
+  metadata.gz: ad9fb3be960036fe7cb2726cd9fd30a9ee111aaa
+  data.tar.gz: f49cb2db9f22cfb9022624b30f0a718fabd2e93e
 SHA512:
-  metadata.gz: 630a3c2632aca7189885132b805c6bf6cffd71497ff1562e844040eeab96af18048871c841a359a41fddf6044f8ece6880a185085a9fb0afc118f7b26438a323
-  data.tar.gz: f9f092cc627eb09b631c0ac0bb4394019a5b9ac5c56ebb970c752a8b8845e0819bb9efc4b32875790ea16ff0392b359dd8f0b8859236cc245df5564c5cdc1a14
+  metadata.gz: 54a406b351d36c99269a644db761d88198379204832ab17aef026353d5b0f06d6ec0f3ca63290f23cb5fda5e1d68adca32ee9a63c146db5b1bfcef3d8ed28cf2
+  data.tar.gz: 0c5011125fc765c9a1d1a8b064cc1cf9665f220df1130232f6b8ee6cad3cbb928ecbedeff1ded060943a144421ec6aaf222d60b8b7ce12335f5c0703cddaaa39

data/Rakefile

@@ -14,7 +14,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 load 'rails/tasks/statistics.rake'
 

data/app/controllers/wallaby/abstract_resources_controller.rb

@@ -1,6 +1,7 @@
 module Wallaby
   # Generic CRUD controller
   class AbstractResourcesController < ::Wallaby::BaseController
+    include ResourcesHelperMethods
     self.responder = ResourcesResponder
     respond_to :html
     respond_to :json
@@ -9,94 +10,118 @@ module Wallaby
     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
+    class << self
+      # @return [String] resources name for controller
+      def resources_name
+        return unless self < configuration.mapping.resources_controller
+        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
+      # @return [Class] model class for controller
+      def model_class
+        return unless self < configuration.mapping.resources_controller
+        Map.model_class_map resources_name
+      end
     end
 
-    # home page
+    # Home page
+    #
+    # You can completely override this action:
+    #
+    #    def home
+    #      # do something differently
+    #    end
     def home
       # do nothing
     end
 
-    # Index page to list data
+    # Resourceful action to list paginated records.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
+    # - To perform action before `index` is run
+    #
+    #    def index
+    #      # do something beforehand
+    #      super
+    #    end
+    #
+    # - To perform action after `index`, but before rendering.
+    # The reason is that we use responder at the end of the action
+    #
+    #    def index
+    #      super do
+    #        # do something afterwards
+    #      end
+    #    end
+    #
+    # - To perform completely different action
+    #
+    #     def index
+    #       # do something completely different
+    #     end
     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:
+    # Resourceful new action to show a form for creating a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `new` is run
     #
-    #     ```
-    #        def new
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #    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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def new
-    #          super do
-    #            # do something after new
-    #          end
-    #        end
-    #     ```
+    #    def new
+    #      super do
+    #        # do something afterwards
+    #      end
+    #    end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def new
-    #          # do something completely different
-    #        end
-    #     ```
+    #     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:
+    # Resourceful create action to create a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `new` is run
     #
-    #     ```
-    #        def create
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #     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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def create
-    #          super do
-    #            # do something after create
-    #          end
-    #        end
-    #     ```
+    #     def create
+    #       super do
+    #         # do something afterwards
+    #       end
+    #     end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def create
-    #          # do something completely different
-    #        end
-    #     ```
+    #     def create
+    #       # do something completely different
+    #     end
     def create
       authorize! :create, resource
       current_model_service.create resource, params
@@ -104,105 +129,93 @@ module Wallaby
       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:
+    # Resourceful show action to display values for a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `show` is run
     #
-    #     ```
-    #        def show
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #     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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def show
-    #          super do
-    #            # do something after show
-    #          end
-    #        end
-    #     ```
+    #     def show
+    #       super do
+    #         # do something afterwards
+    #       end
+    #     end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def show
-    #          # do something completely different
-    #        end
-    #     ```
+    #     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:
+    # Resourceful edit action to show a form for editing a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `edit` is run
     #
-    #     ```
-    #        def edit
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #     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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def edit
-    #          super do
-    #            # do something after edit
-    #          end
-    #        end
-    #     ```
+    #     def edit
+    #       super do
+    #         # do something afterwards
+    #       end
+    #     end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def edit
-    #          # do something completely different
-    #        end
-    #     ```
+    #     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:
+    # Resourceful update action to update a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `update` is run
     #
-    #     ```
-    #        def update
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #     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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def update
-    #          super do
-    #            # do something after update
-    #          end
-    #        end
-    #     ```
+    #     def update
+    #       super do
+    #         # do something afterwards
+    #       end
+    #     end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def update
-    #          # do something completely different
-    #        end
-    #     ```
+    #     def update
+    #       # do something completely different
+    #     end
     def update
       authorize! :update, resource
       current_model_service.update resource, params
@@ -210,35 +223,31 @@ module Wallaby
       respond_with resource, location: helpers.show_path(resource)
     end
 
-    # Data deletion
-    # You could override this method in subclasses in the following ways:
+    # Resourceful destroy action to delete a record.
+    #
+    # You can override this method in subclasses in the following ways:
+    #
     # - To perform action before `destroy` is run
     #
-    #     ```
-    #        def destroy
-    #          # do something beforehand
-    #          super
-    #        end
-    #     ```
+    #     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
+    # The reason is that we use responder at the end of the action
     #
-    #     ```
-    #        def destroy
-    #          super do
-    #            # do something after destroy
-    #          end
-    #        end
-    #     ```
+    #     def destroy
+    #       super do
+    #         # do something afterwards
+    #       end
+    #     end
     #
     # - To perform completely different action
     #
-    #     ```
-    #        def destroy
-    #          # do something completely different
-    #        end
-    #     ```
+    #     def destroy
+    #       # do something completely different
+    #     end
     def destroy
       authorize! :destroy, resource
       current_model_service.destroy resource, params
@@ -246,6 +255,26 @@ module Wallaby
       respond_with resource, location: helpers.index_path(current_model_class)
     end
 
+    # Model servicer associated to current modal class.
+    #
+    # This model servicer will take care of all the CRUD operations
+    #
+    # For how to override model service, see (Wallaby::ModelServicer)
+    # @return [Wallaby::ModelServicer] a servicer
+    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 whitelist the params for CRUD actions
+    # @see Wallaby::ModelServicer#permit
+    # @return [ActionController::Parameters] whitelisted params
+    def resource_params
+      @resource_params ||= current_model_service.permit params
+    end
+
     protected
 
     # Override origin ActionView::ViewPaths::ClassMethods#_prefixes
@@ -261,6 +290,7 @@ module Wallaby
     #  (e.g. `wallaby/resources/index)
     # - wallaby_resources_controller_name
     #  (e.g. `wallaby/resources)
+    # @return [PrefixesBuilder]
     def _prefixes
       @_prefixes ||= PrefixesBuilder.new(
         super, controller_path, current_resources_name, params
@@ -269,66 +299,20 @@ module Wallaby
 
     # A wrapped lookup content
     # Its aim is to render string partial when given partial is not found
+    # @return [LookupContextWrapper]
     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
+      @_lookup_context ||= LookupContextWrapper.new super # rubocop:disable Naming/MemoizedInstanceVariableName, Metrics/LineLength
     end
 
     # To paginate the collection but only when either `page` or `per` param is
     # given, or requesting HTML response
     # @see Wallaby::ModelServicer#paginate
+    # @param query [#each]
+    # @return [#each]
     def paginate(query)
       paginatable =
         params[:page] || params[:per] || request.format.symbol == :html
       paginatable ? current_model_service.paginate(query, params) : query
     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 ||= begin
-        whitelisted = action_name.in?(SAVE_ACTIONS) ? resource_params : {}
-        if resource_id.present?
-          current_model_service.find resource_id, whitelisted
-        else
-          current_model_service.new whitelisted
-        end
-      end
-    end
-
-    # Get current model decorator so that we could retrieve 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