consul 0.6.1 → 0.7.0

data/README.md

@@ -59,13 +59,6 @@ Here is how to do all of that:
     power.note?(Note.last) # => returns whether the given Note is in the Power#notes scope. Caches the result for subsequent queries.
     power.note!(Note.last) # => raises Consul::Powerless unless the given Note is in the Power#notes scope
 
-You can also write power checks like this:
-
-    power.include?(:notes)
-    power.include!(:notes)
-    power.include?(:notes, Note.last)
-    power.include!(:notes, Note.last)
-
 
 Boolean powers
 --------------
@@ -342,6 +335,113 @@ The `authorize_values_for` macro comes with many useful options and details best
     assignable_values_for :field, :through => lambda { Power.current }
 
 
+Dynamic power access
+--------------------
+
+Consul gives you a way to dynamically access and query powers for a given name, model class or record.
+A common use case for this are generic helper methods, e.g. a method to display an "edit" link for any given record
+if the user is authorized to change that record:
+
+    module CrudHelper
+
+      def edit_record_action(record)
+        if current_power.include_record?(:updatable, record)
+          link_to 'Edit', [:edit, record]
+        end
+      end
+
+    end
+
+You can find a full list of available dynamic calls below:
+
+| Dynamic call                                            | Equivalent                                 |
+|---------------------------------------------------------|--------------------------------------------|
+| `Power.current.send(:notes)`                            | `Power.current.notes`                      |
+| `Power.current.include?(:notes)`                        | `Power.current.notes?`                     |
+| `Power.current.include!(:notes)`                        | `Power.current.notes!`                     |
+| `Power.current.include?(:notes, Note.last)`             | `Power.current.note?(Note.last)`           |
+| `Power.current.include!(:notes, Note.last)`             | `Power.current.note!(Note.last)`           |
+| `Power.current.for_record(Note.last)`                   | `Power.current.notes`                      |
+| `Power.current.for_record(:updatable, Note.last)`       | `Power.current.updatable_notes`            |
+| `Power.current.for_model(Note)`                         | `Power.current.notes`                      |
+| `Power.current.for_model(:updatable, Note)`             | `Power.current.updatable_notes`            |
+| `Power.current.include_model?(Note)`                    | `Power.current.notes?`                     |
+| `Power.current.include_model?(:updatable, Note)`        | `Power.current.updatable_notes?`           |
+| `Power.current.include_model!(Note)`                    | `Power.current.notes!`                     |
+| `Power.current.include_model!(:updatable, Note)`        | `Power.current.updatable_notes!`           |
+| `Power.current.include_record?(Note.last)`              | `Power.current.note?(Note.last)`           |
+| `Power.current.include_record?(:updatable, Note.last)`  | `Power.current.updatable_note?(Note.last)` |
+| `Power.current.include_record!(Note.last)`              | `Power.current.note!(Note.last)`           |
+| `Power.current.include_record!(:updatable, Note.last)`  | `Power.current.updatable_note!(Note.last)` |
+| `Power.current.name_for_model(Note)`                    | `:notes`                                   |
+| `Power.current.name_for_model(:updatable, Note)`        | `:updatable_notes`                         |
+| `Power.current.name_for_record(Note.last)`              | `:notes`                                   |
+| `Power.current.name_for_record(:updatable, Note.last)`  | `:updatable_notes`                         |
+
+
+
+Querying a power that might be nil
+----------------------------------
+
+You will often want to access `Power.current` from another model, to e.g. iterate through the list of accessible users:
+
+    class UserReport
+
+      def data
+        Power.current.users.collect do |user|
+          [user.name, user.email, user.income]
+        end
+      end
+
+    end
+
+Good practice is for your model to not crash when `Power.current` is `nil`. This is the case when your model isn't
+called as part of processing a browser request, e.g. on the console, during tests and during batch processes.
+In such cases your model should simply skip authorization and assume that all users are accessible:
+
+    class UserReport
+
+      def data
+        accessible_users = Power.current.present? Power.current.users || User
+        accessible_users.collect do |user|
+          [user.name, user.email, user.income]
+        end
+      end
+
+    end
+
+Because this pattern is so common, the `Power` class comes with a number of class methods you can use to either query
+`Power.current` or, if it is not set, just assume that everything is accessible:
+
+    class UserReport
+
+      def data
+        Power.for_model(user).collect do |user|
+          [user.name, user.email, user.income]
+        end
+      end
+
+    end
+
+There is a long selection of class methods that behave neutrally in case `Power.current` is `nil`:
+
+| Call                                                     | Equivalent                                                          |
+|----------------------------------------------------------|---------------------------------------------------------------------|
+| `Power.for_model(Note)`                                  | `Power.current.present? ? Power.current.notes : Note`               |
+| `Power.for_model(:updatable, Note)`                      | `Power.current.present? ? Power.current.updatable_notes : Note`     |
+| `Power.include_model?(Note)`                             | `Power.current.present? ? Power.notes? : true`                      |
+| `Power.include_model?(:updatable, Note)`                 | `Power.current.present? ? Power.updatable_notes? : true`            |
+| `Power.include_model!(Note)`                             | `Power.notes! if Power.current.present?`                            |
+| `Power.include_model!(:updatable, Note)`                 | `Power.updatable_notes! if Power.current.present?`                  |
+| `Power.for_record(Note.last)`                            | `Power.current.present? ? Power.current.notes : Note`               |
+| `Power.for_record(:updatable, Note.last)`                | `Power.current.present? ? Power.current.updatable_notes : Note`     |
+| `Power.include_record?(Note.last)`                       | `Power.current.present? ? Power.note?(Note.last) : true`            |
+| `Power.include_record?(:updatable, Note.last)`           | `Power.current.present? ? Power.updatable_note?(Note.last?) : true` |
+| `Power.include_record!(Note.last)`                       | `Power.note!(Note.last) if Power.current.present?`                  |
+| `Power.include_record!(:updatable, Note.last)`           | `Power.updatable_note!(Note.last) if Power.current.present?`        |
+
+
+
 Testing
 -------
 
@@ -389,6 +489,10 @@ A nice shortcut is that when you call `with_power` with an argument that is not
     end
 
 
+
+
+
+
 Installation
 ------------
 

data/consul.gemspec

@@ -17,12 +17,5 @@ Gem::Specification.new do |s|
 
   s.add_dependency('memoizer')
   s.add_dependency('rails')
-
-  ## s.add_development_dependency('assignable_values')
-  #s.add_development_dependency('assignable_values')
-  #s.add_development_dependency('rails', '~>2.3')
-  #s.add_development_dependency('rspec', '~>1.3')
-  #s.add_development_dependency('rspec-rails', '~>1.3')
-  #s.add_development_dependency('shoulda-matchers')
-  #s.add_development_dependency('sqlite3')
+  s.add_dependency('edge_rider')
 end

data/lib/consul.rb

@@ -1,4 +1,5 @@
 require 'memoizer'
+require 'edge_rider'
 require 'consul/util'
 require 'consul/power'
 require 'consul/errors'

data/lib/consul/power.rb

@@ -78,6 +78,10 @@ module Consul
       [TrueClass, FalseClass, NilClass].include?(value.class)
     end
 
+    def database_touched
+      # spy for tests
+    end
+
     module ClassMethods
 
       def power(*names, &block)
@@ -164,9 +168,8 @@ module Consul
         ids_method = power_ids_name(name)
         define_method(ids_method) do |*args|
           scope = send(name, *args)
-          scope = scope.scoped(:select => "`#{scope.table_name}`.`id`")
-          query = Util.scope_to_sql(scope)
-          ::ActiveRecord::Base.connection.select_values(query).collect(&:to_i)
+          database_touched
+          scope.collect_ids
         end
         memoize ids_method
         name

data/lib/consul/util.rb

@@ -2,17 +2,9 @@ module Consul
   module Util
     extend self
 
-    def scope_to_sql(scope)
-      if scope.respond_to?(:to_sql)
-        scope.to_sql
-      else
-        scope.send(:construct_finder_sql, {})
-      end
-    end
-
     def scope_selects_all_records?(scope)
       scope = scope.scoped({})
-      scope_sql = scope_to_sql(scope)
+      scope_sql = scope.to_sql
       quoted_table_name = Regexp.quote(scope.connection.quote_table_name(scope.table_name))
       all_sql_pattern = /\ASELECT (#{quoted_table_name}\.)?\* FROM #{quoted_table_name}\z/
       scope_sql.squish =~ all_sql_pattern

data/lib/consul/version.rb

@@ -1,3 +1,3 @@
 module Consul
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

data/spec/shared/consul/power_spec.rb

@@ -107,28 +107,28 @@ describe Consul::Power do
         end
 
         it 'should only trigger a single query for multiple checks on the same scope' do
-          ActiveRecord::Base.connection.should_receive(:select_values).once.and_return([]) #.and_return(double('connection').as_null_object)
+          @user.power.should_receive(:database_touched).once
           @user.power.client?(@client1)
           @user.power.client?(@deleted_client)
         end
 
-        it 'should trigger a query if the scope defines a condition' do
-          ActiveRecord::Base.connection.should_receive(:select_values).and_return([])
+        it 'should trigger a query only if the scope defines a condition' do
+          @user.power.should_receive(:database_touched).once
           @user.power.client?(@client1)
         end
 
         it 'should not trigger a query if the scope defines no conditions' do
-          ActiveRecord::Base.connection.should_not_receive(:select_values)
+          @user.power.should_not_receive(:database_touched)
           @user.power.all_client?(@client1)
         end
 
         it 'should always trigger a query if a returned model has a default scope, even if it defines no additional conditions' do
-          ActiveRecord::Base.connection.should_receive(:select_values).and_return([])
+          @user.power.should_receive(:database_touched).once
           @user.power.song?(Song.new)
         end
 
         it 'should trigger query if a returned model has a default scope and defines additional conditions' do
-          ActiveRecord::Base.connection.should_receive(:select_values).and_return([])
+          @user.power.should_receive(:database_touched).once
           @user.power.recent_song?(Song.new)
         end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: consul
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 1
-  version: 0.6.1
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Henning Koch
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-16 00:00:00 +01:00
+date: 2013-02-11 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,6 +46,20 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: edge_rider
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: A scope-based authorization solution for Ruby on Rails.
 email: henning.koch@makandra.de
 executables: []