maybee 1.0.6 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3971315be229bbf7b4e265798d1aa944c7a49b39
-  data.tar.gz: 4bde684a5cb1766ba855254de8be10c16f76a8f5
+  metadata.gz: f29e6ee079046ec284b5a4f1c92c467e6f89b950
+  data.tar.gz: 701ddaee631e28e32b6b7c640e0d4d5b35a1a1f2
 SHA512:
-  metadata.gz: 21f149746d7726ebea52c65b2321e5221ce16638a9d72e52fd9c138dfb9ba08a6b9dc67ee90f29c2fae16ab883fe3fd052c36c1265da5fb124f4cf1f1c77da39
-  data.tar.gz: 35c35e6cdb0ebbc481a5f3c9f98894b130e57408eb5e13677298f5c93d93dfb7a7db0f78c5c93d474516f963dfc0be9cac0d2ad82f5e2f9d8e3beb1b22366700
+  metadata.gz: adc2dded1e8142e0fe2e0b877e1e3e00d76c2523fe50ea40b6d82dea8399bf2f1e05dec14405b2baf271f73f2b83d543e62e0d74c71349b419c72ce6278fae3c
+  data.tar.gz: 39d7f22f303ad19c9a17fc6ceee19e0f7d7a5396c1ea2b2fd8548bf1f505accd0722a69b08a226ef85b4d09567f7c0dac1ae917592b928dbad4870fbb1beb753

data/CHANGELOG

@@ -1,8 +1,17 @@
-* 1.0.5 (05 Jun 2014)*
+1.1.0 (16 Mar 2015)
+
+* Allow lambda literals in conditionals
+
+1.0.6 (16 Feb 2015)
+
+* Support Rails 4.2
+
+1.0.5 (05 Jun 2014)
 
 * Support Rails 4.1
 
-* 0.0.4 (09 Jul 2013)*
+
+0.0.4 (09 Jul 2013)
 
 * use ActiveSupport::Concern
 * add allows_crud DSL method

data/README.md

@@ -37,7 +37,7 @@ Access rules are defined inside models using a simple DSL and may be named as yo
 class Car < ActiveRecord::Base
   acts_as_authorization_object
   
-  allows :to => :drive
+  allows to: :drive
 end
 ```
 will have model instances respond `true` if asked
@@ -50,7 +50,7 @@ car.allow?(:drive, user)
 Usually, you will want to restrict access based on some internal state of the model (the authorization object) or the user (the subject). This can be accomplished using the options `:if`, `:unless`, `:if_subject` and `:unless_subject`:
 
 ```ruby
-allows :to => :drive, :if => :license_plate_valid?, :if_subject => :has_drivers_license?
+allows to: :drive, if: :license_plate_valid?, if_subject: :has_drivers_license?
 ```
 
 With this declaration, the car would allow any (ruby) object to drive, if the car has a valid license plate and the ruby object responds to `#has_drivers_license?` with a true value. 
@@ -72,7 +72,7 @@ end
 class Car < ActiveRecord::Base
   acts_as_authorization_object
   
-  allows :drivers, :to => :drive, :if_subject => :sober?
+  allows :drivers, to: :drive, if_subject: :sober?
 end
 ```
 This will allow sober drivers to drive, but will reject normal users and drunk drivers.
@@ -80,14 +80,14 @@ This will allow sober drivers to drive, but will reject normal users and drunk d
 If you do not care for the subject class, you may also write
 
 ```ruby
-allows_to :drive, :if => ...
+allows_to :drive, if: ...
 ```
-which is the same as `allows :to => ...`
+which is the same as `allows to: ...`
 
 Multiple access rights may be given in the same definition:
 
 ```ruby
-allows :drivers, :to => [:start, :drive], :if => ...
+allows :drivers, to: [:start, :drive], if: ...
 ```
 
 
@@ -96,7 +96,7 @@ allows :drivers, :to => [:start, :drive], :if => ...
 It is also possible to pass a proc to any of the conditional options:
 
 ```ruby
-allows :drivers, :to => :start, :if => lambda { |driver| gasoline_level > 0 }
+allows :drivers, to: :start, if: lambda { |driver| gasoline_level > 0 }
 ```
 
 Blocks passed to `:if` and `:unless` are evaluated inside the authorization object, while `:if_subject` and `:unless_subject` get evaluated inside the authorization subject (the user).
@@ -108,8 +108,8 @@ In most cases, you will want to restrict authorizations to authorized subjects o
 
 ```ruby
 class Image
-  allows :users, :to => :view, :if => :publicly_accessible?, :allow_nil => true
-  allows :users, :to => :view, :if_subject => lambda { |image| self.company_id == image.company_id }
+  allows :users, to: :view, if: :publicly_accessible?, allow_nil: true
+  allows :users, to: :view, if_subject: lambda { |image| self.company_id == image.company_id }
 
   def publicly_accessible?
     # implementation, or a simple attribute
@@ -126,7 +126,7 @@ There are three special accesses which limit creation, updating and destruction
 In the simplest form, the access to create, update and destroy would be granted regardless of the `authorization_subject`. This would be the default behaviour of ActiveRecord, where besides validations there is no restriction on these operations:
 
 ```ruby
-allows_to :create, :update, :destroy, :allow_nil => true
+allows_to :create, :update, :destroy, allow_nil: true
 ```
 
 Say you have models for users and roles, and you want normal users not to be able to assign roles, but only admins:
@@ -135,8 +135,8 @@ Say you have models for users and roles, and you want normal users not to be abl
 class User < ActiveRecord::Base
   acts_as_authorization_subject
   
-  has_many :user_roles, :dependent => :destroy
-  has_many :roles, :through => :user_roles
+  has_many :user_roles, dependent: :destroy
+  has_many :roles, through: :user_roles
 end
 
 
@@ -149,7 +149,7 @@ class UserRole < ActiveRecord::Base
   
   acts_as_authorization_object
   
-  allows :users, :to => [:create, :update, :destroy], :if_subject => :admin?
+  allows :users, to: [:create, :update, :destroy], if_subject: :admin?
 end
 ```
 
@@ -219,10 +219,10 @@ By default, access rules are inherited by subclasses of auth objects. Additional
 
 ```ruby
 class Foo < ActiveRecord::Base
-  allows_to :view, :if => :visible?
+  allows_to :view, if: :visible?
 end
 
 class SubFoo < Foo
-  allows_to :view, :exclusive => true
+  allows_to :view, exclusive: true
 end
 ```

data/lib/maybee/authorization.rb

@@ -23,7 +23,15 @@ module Maybee
         else
           receiver, argument = object, subject
         end
-        result = cond.is_a?(Proc) ? receiver.instance_exec(argument, &cond) : receiver.send(cond)
+        result = if cond.is_a?(Proc)
+          if cond.arity == 1
+            receiver.instance_exec(argument, &cond)
+          else
+            receiver.instance_exec(&cond)
+          end
+        else
+          receiver.send(cond)
+        end
         (:if_subject == clause || :if == clause) ? result : !result
       end
       false

data/lib/maybee/version.rb

@@ -1,3 +1,3 @@
 module Maybee
-  VERSION = '1.0.6'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maybee
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.2.0
 platform: ruby
 authors:
 - Matthias Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-16 00:00:00.000000000 Z
+date: 2015-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n