effective_resources 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75c86fb082f32358410e49243ea61b344d1e691a
-  data.tar.gz: 5a54eba2d20082b290fdd59fb80ed54f934cca40
+  metadata.gz: 64dfc3d7de672e57ba2ea0238a214acc4cef4a5e
+  data.tar.gz: 5c6e8b73c793b0dbfb1e9b38353621bc67193324
 SHA512:
-  metadata.gz: ae81d6db6a9a2ee2059ba36177a93d92bafbfb2a33842f28b4c718c3c478e0a454eb474459a14e072a566c09bfb436769fe7d6e7e797dce77da2ecfccf0ce9d7
-  data.tar.gz: c17da71ef1ba9a6e64f65d7a5bc256f0b8ab7a0e4d1b3e08d10c0b486970a236e62f553e50300cdbb32cd83fd772ce779a9d1861c8b2b0e17832b33ba6476c7d
+  metadata.gz: 4d737b31f4efc019d091a98712d3b4d56f6cd5a82ca18b59273ea838a1d4287f855294801b16351d7de54852d28cb383f9276ce16c721c9103df07477739158a
+  data.tar.gz: c07020c1c837060e43dfa69682da5a9027cd33113fc19d0af71bf86e82ec8ff601507433cd99b4e12921b1c4b21f5515a10ce8ec45ac5e0b2becca6c4a871d2a

data/README.md

@@ -1,8 +1,32 @@
 # Effective Resources
 
-Make your controller an effective resource controller.
+The goal of this gem is to reduce the amount of code that needs to be written when developing a ruby on rails website.
+
+It is ruby on rails, on effective rails.
+
+A rails developer will always need to maintain and write:
+
+- The `routes.rb` as it's the single most important file in an entire app.
+- The `ability.rb` or other authorization.
+- A normal active record model file for each model / form object / interaction / resource, whatever.
+- A corresponding form.
+- Any javascripts, etc, and unique resource actions.
+
+However, all other patterns and a lot of code can be automated.
+
+This gem replaces the following work a rails developer would normally do:
 
+- Controllers.
+- permitted params. This gem implements a model dsl to define and blacklist params. It's not the rails way.
+
+- Any file named index/edit/show/new.html. We use rails application templates and powerful defaults views so these files need never be written.
+- Figure out actions available to the `current_user` to each `resource` on the fly, based on controller namespace, the routes.rb and ability.rb
+- Powerful helpers to render the correct resource action links.
+- Collection of concern files.
+
+Make your controller an effective resource controller.
 Implements the 7 RESTful actions as a one-liner on any controller.
+Reads the `routes.rb` and serves collection and member actions.
 
 ## Getting Started
 
@@ -26,6 +50,45 @@ The generator will install an initializer which describes all configuration opti
 
 ## Usage
 
+Add to your `app/models/post.rb`:
+
+```ruby
+class Post < ApplicationRecord
+  belongs_to :author, class_name: 'User'
+
+  # The only thing this block is used for - right now - is permitted_params
+  # So yo
+  effective_resource do
+    category      :string
+    title         :string
+    body          :text
+
+    approved      :boolean, permitted: false   # You could write permitted: [:admin] to only permit this in the admin namespace
+
+    timestamps
+  end
+
+  # The approve! action will be called by Effective::CrudController when submitted on a create/update or member action
+  def approve!
+    raise 'already approved' if approved?
+    update!(approved: true)
+  end
+
+end
+```
+
+Add to your `routes.rb`:
+
+```ruby
+resources :posts, only: [:index, :show] do
+  get :approve, on: :member
+  post :approve, on: :member
+
+  get :approved, on: :collection
+  post :bulk_approve, on: :collection
+end
+```
+
 Add to your contoller:
 
 ```ruby
@@ -43,6 +106,9 @@ class PostsController < ApplicationController
     Post.active.where(user: current_user)
   end
 
+  # The following methods are discovered from the routes.rb and defined automatically.
+  # But you could also define them like this if you wanted.
+
   # When GET request, will render the approve page
   # When POST|PATCH|PUT request, will call @post.approve! and do the right thing
   member_action :approve
@@ -56,7 +122,9 @@ class PostsController < ApplicationController
 
   protected
 
-  # The permitted parameters for this post.  Other recognized method names are posts_params and permitted_params
+  # The post_params are discovered from the model effective_resource do ... end block.
+  # But you could also define them like this if you wanted.
+  # Other recognized method names are posts_params and permitted_params
   def post_params
     params.require(:post).permit(:id, :author_id, :category, :title, :body)
   end
@@ -190,6 +258,40 @@ This prevents enumeration of this resource.
 
 Make sure to create a string `token` field on your model, then just declare `acts_as_tokened`.  There are no options.
 
+### acts_as_archived
+
+Create an 'archived' boolean filed in your model, then declare `acts_as_archived`.
+
+Implements the dumb archived pattern.
+
+An archived object should not be displayed on index screens, or any related resource's #new pages
+
+effective_select (from the effective_bootstrap gem) is aware of this concern, and calls `.unarchived` and `.archived` appropriately when passed an ActiveRecord relation.
+
+Use the cascade argument to cascade archived changes to any has_manys
+
+```ruby
+class Thing < ApplicationRecord
+  has_many :comments
+  acts_as_archivable cascade: :comments
+end
+```
+
+Each controller needs its own archive and unarchive action.
+To simplify this, use the following route concern.
+
+In your routes.rb:
+
+```ruby
+Rails.application.routes.draw do
+  acts_as_archived
+
+  resource :things, concern: :acts_as_archived
+  resource :comments, concern: :acts_as_archived
+end
+```
+
+and include Effective::CrudController in your resource controller.
 
 ## License
 

data/app/controllers/concerns/effective/crud_controller/permitted_params.rb

@@ -53,7 +53,7 @@ module Effective
           elsif atts.blank? || !atts.key?(:permitted)
             true # Default is true
           else
-            permitted = (atts[:permitted].respond_to?(:call) ? instance_exec(&atts[:permitted]) : atts[:permitted])
+            permitted = (atts[:permitted].respond_to?(:call) ? Effective::ResourceExec.new(self, resource).instance_exec(&atts[:permitted]) : atts[:permitted])
 
             if permitted == true || permitted == false
               permitted

data/app/controllers/concerns/effective/crud_controller/submits.rb

@@ -36,11 +36,11 @@ module Effective
           end
 
           if args.key?(:if) && args[:if].respond_to?(:call) == false
-            raise "expected if: to be callable. Try submit :approve, 'Save and Approve', if: -> (resource) { resource.finished? }"
+            raise "expected if: to be callable. Try submit :approve, 'Save and Approve', if: -> { resource.finished? }"
           end
 
           if args.key?(:unless) && args[:unless].respond_to?(:call) == false
-            raise "expected unless: to be callable. Try submit :approve, 'Save and Approve', unless: -> (resource) { resource.declined? }"
+            raise "expected unless: to be callable. Try submit :approve, 'Save and Approve', unless: -> { resource.declined? }"
           end
 
           if args.key?(:only)
@@ -78,11 +78,11 @@ module Effective
           end
 
           if args.key?(:if) && args[:if].respond_to?(:call) == false
-            raise "expected if: to be callable. Try button :approve, 'Approve', if: -> (resource) { resource.finished? }"
+            raise "expected if: to be callable. Try button :approve, 'Approve', if: -> { resource.finished? }"
           end
 
           if args.key?(:unless) && args[:unless].respond_to?(:call) == false
-            raise "expected unless: to be callable. Try button :approve, 'Approve', unless: -> (resource) { resource.declined? }"
+            raise "expected unless: to be callable. Try button :approve, 'Approve', unless: -> { resource.declined? }"
           end
 
           if args.key?(:only)

data/app/helpers/effective_resources_helper.rb

@@ -77,7 +77,7 @@ module EffectiveResourcesHelper
     end
 
     # Filter out false and proc false
-    actions = actions.select { |_, v| atts[v[:action]].respond_to?(:call) ? instance_exec(&atts[v[:action]]) : (atts[v[:action]] != false) }
+    actions = actions.select { |_, v| atts[v[:action]].respond_to?(:call) ? Effective::ResourceExec.new(self, resource).instance_exec(&atts[v[:action]]) : (atts[v[:action]] != false) }
 
     # Select Partial
     partial = ['effective/resource/actions', partial.to_s].join('_') if partial.kind_of?(Symbol)

data/app/helpers/effective_resources_private_helper.rb

@@ -5,14 +5,15 @@ module EffectiveResourcesPrivateHelper
 
   def permitted_resource_actions(resource, actions)
     page_action = REPLACE_PAGE_ACTIONS[params[:action]] || params[:action]&.to_sym || :save
+    executor = Effective::ResourceExec.new(self, resource)
 
     actions.select do |commit, args|
       action = (args[:action] == :save ? (resource.new_record? ? :create : :update) : args[:action])
 
       (args.key?(:only) ? args[:only].include?(page_action) : true) &&
       (args.key?(:except) ? !args[:except].include?(page_action) : true) &&
-      (args.key?(:if) ? controller.instance_exec(resource, &args[:if]) : true) &&
-      (args.key?(:unless) ? !controller.instance_exec(resource, &args[:unless]) : true) &&
+      (args.key?(:if) ? executor.instance_exec(&args[:if]) : true) &&
+      (args.key?(:unless) ? !executor.instance_exec(&args[:unless]) : true) &&
       EffectiveResources.authorized?(controller, action, resource)
     end.inject({}) do |h, (commit, args)|
       opts = args.except(:default, :only, :except, :if, :unless, :redirect, :success, :danger)

data/app/models/concerns/acts_as_archived.rb

@@ -44,7 +44,7 @@ module ActsAsArchived
 
   module CanCan
     def acts_as_archived(klass)
-      raise "klass does not implement acts_as_archived" unless klass.acts_as_archived?
+      raise "klass does not implement acts_as_archived" unless klass.respond_to?(:acts_as_archived?)
 
       can(:archive, klass) { |obj| !obj.archived? }
       can(:unarchive, klass) { |obj| obj.archived? }

data/app/models/effective/resource_exec.rb

@@ -0,0 +1,19 @@
+# Makes sure resource in any instance_execs is the correct resource
+module Effective
+  class ResourceExec
+
+    def initialize(instance, resource)
+      @instance = instance
+      @resource = resource
+    end
+
+    def resource
+      @resource
+    end
+
+    def method_missing(method, *args, &block)
+      @instance.send(method, *args)
+    end
+
+  end
+end

data/app/models/effective/resources/controller.rb

@@ -13,11 +13,11 @@ module Effective
           end
 
           if actions.find { |a| a == :index }
-            submits['Continue'] = { action: :save, redirect: :index, default: true, unless: -> (resource) { params[:_datatable_id] } }
+            submits['Continue'] = { action: :save, redirect: :index, default: true, unless: -> { params[:_datatable_id].present? } }
           end
 
           if actions.find { |a| a == :new }
-            submits['Add New'] = { action: :save, redirect: :new, default: true, unless: -> (resource) { params[:_datatable_id] } }
+            submits['Add New'] = { action: :save, redirect: :new, default: true, unless: -> { params[:_datatable_id].present? } }
           end
         end
       end
@@ -31,9 +31,9 @@ module Effective
           (member_post_actions - crud_actions).each do |action| # default true means it will be overwritten by dsl methods
             buttons[action.to_s.titleize] = case action
             when :archive
-              { action: action, default: true, if: -> (resource) { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
+              { action: action, default: true, if: -> { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
             when :unarchive
-              { action: action, default: true, if: -> (resource) { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
             else
               { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
             end
@@ -79,9 +79,9 @@ module Effective
 
             actions[action.to_s.titleize] = case action
             when :archive
-              { action: action, default: true, if: -> (resource) { !resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
+              { action: action, default: true, if: -> { resource.archived? }, class: 'btn btn-danger', 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?"}
             when :unarchive
-              { action: action, default: true, if: -> (resource) { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
+              { action: action, default: true, if: -> { resource.archived? }, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
             else
               { action: action, default: true, 'data-method' => :post, 'data-confirm' => "Really #{action} @resource?" }
             end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '1.2.2'.freeze
+  VERSION = '1.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-07 00:00:00.000000000 Z
+date: 2019-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -57,6 +57,7 @@ files:
 - app/models/effective/code_reader.rb
 - app/models/effective/model_reader.rb
 - app/models/effective/resource.rb
+- app/models/effective/resource_exec.rb
 - app/models/effective/resources/actions.rb
 - app/models/effective/resources/associations.rb
 - app/models/effective/resources/attributes.rb