access-granted 0.1.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ada45684334e5433ed3504e66d2183464bcf4203
-  data.tar.gz: b0c59ba381cc29461dcb70d13a771dd72c268495
+  metadata.gz: 73df010b82397adef1ad1fbfdb345d0e5875ae86
+  data.tar.gz: f6db604ca6be5fc22d24225728b700df5ed4db5b
 SHA512:
-  metadata.gz: 2db7e6b39316cffabd20ef32e1b93af44f86812af6e93fc4153a03355326608b4727b99b78ac7843a47d3f8c85b3995cae01dd81335f692900f043feeb396c31
-  data.tar.gz: 0c19dd7e52f3ccf791a00ae436cd983df5e64377bf2cf3a6dd1511805f4e62b8cf429b974a3c20b22eca4cd4b564c2fe7d5af5bad1c88c98f5d0fea0d4ee2054
+  metadata.gz: 98ae394fea6d7a5e4695e76746dc6e0701da2be4c21f9145edc979644e22faa2e3f5149bea758ee6799c2914e833d13bb678c051e7a8df8e35a6c42decae21a4
+  data.tar.gz: 92f00c7b8668b51f25b4041022e26f095d65e302b79a5853aa500901dd851735b107336fa39e03899e4be723dd29fb78c7506a0e458737a89917e91fb1b831df

data/.travis.yml

@@ -1,10 +1,11 @@
 language: ruby
+sudo: false
 rvm:
   - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - rbx-2.1.1
-  - rbx-2.2.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - rbx-2
   - rbx
-  - jruby-1.7.6
+  - jruby-1
   - jruby

data/Gemfile

@@ -8,8 +8,10 @@ group :test, :development do
   gem 'simplecov', require: false
   gem 'rake'
   gem 'pry'
+  gem 'cancan'
+  gem 'benchmark-ips'
 end
 
 platforms :rbx do
-  gem 'rubysl', '~> 2.0'
+  gem 'rubysl', '~> 2.1'
 end

data/README.md

@@ -5,120 +5,78 @@
 
 Multi-role and whitelist based authorization gem for Rails. And it's lightweight (~300 lines of code)!
 
+
+## Installation
+
+    gem 'access-granted'
+
 ### Supported Ruby versions
 
-Guaranteed to work on MRI 1.9.3/2.0/2.1, Rubinius >= 2.1.1 and JRuby >= 1.7.6.
+Guaranteed to work on all major Ruby versions MRI 1.9.3-2.2, Rubinius >= 2.X and JRuby >= 1.7.
 
-# Summary
+## Summary
 
 AccessGranted is meant as a replacement for CanCan to solve three major problems:
 
-1. **built-in support for roles**
+1. Performance
+  On average AccessGranted is 50-60% faster in resolving identical dependencies and takes less memory.
+  See [benchmarks](https://github.com/chaps-io/access-granted/blob/master/benchmarks).
+
+2. Built-in support for user roles
 
   Easy to read access policy code where permissions are cleanly grouped into roles.
-  Additionally, permissions are forced to be unique in the scope of a role. This greatly simplifies the resolving
-  permissions while substantially reducing the code-base.
+  Additionally, permissions are forced to be unique in the scope of a role. This greatly simplifies resolving permissions and makes it faster.
 
-2. **white-list based**
+3. white-list based
 
-  This means that you define what a role **can** do, which results in clean, readable policies regardless of complexity.
+  This means that you define what the user **can** do, which results in clean, readable policies regardless of app complexity.
   You don't have to worry about juggling `can`s and `cannot`s in a very convoluted way!
 
   _Note_: `cannot` is still available, but has a very specifc use. See [Usage](#usage) below.
 
-3. **framework agnostic**
+4. framework agnostic
 
   Permissions can work on basically any object and AccessGranted is framework-agnostic,
-  But we offer extensions for your favourite frameworks as gems:
-  - Rails: [access-granted-rails](https://github.com/pokonski/access-granted-rails)
-  - ... more to come!
-
-See [Usage](#usage) for an example of a complete AccessPolicy file.
-
-## Compatibility with CanCan
-
-This gem was created as a replacement for CanCan and therefore it requires minimum work to switch.
-
-### Main differences
-
-1. AccessGranted does not extend ActiveRecord in any way, so it does not have the `accessible_by?`
-   method which could be used for querying objects available to current user.
-   This was very complex and only worked with permissions defined using hash conditions, so
-   I decided to not implement this functionality as it was mostly ignored by CanCan users.
-
-2. Both `can?`/`cannot?` and `authorize!` methods work in Rails controllers and views, just like in CanCan.
-   The only change you have to make is to replace all `can? :manage, Class` with the exact action to check against.
-   `can :manage` is still available for **defining** methods and serves as a shortcut for defining `:read`, `:create`, `:update`, `:destroy` all in one line.
-
-3. Syntax for defining permissions in AccessPolicy file (Ability in CanCan) is exactly the same,
-   with added roles on top. See [Usage](#usage) below.
-
-
-## Installation
-
-### Rails
-
-This includes Rails-specific integration (`can?`, `cannot?`, `current_policy` helpers and more):
-
-    gem 'access-granted-rails'
-
-### Others
-
-    gem 'access-granted'
+  but it has Rails support of out the box :)
+  It **does not depend on any libraries**, pure and clean Ruby code. Guaranteed to always work,
+  even when software around changes.
 
 ## Usage
 
 Roles are defined using blocks (or by passing custom classes to keep things tidy).
-Order of the roles is important, because they are being traversed in the top-to-bottom order. Generally at the top you will have
-an admin or other important role giving the user top permissions, and as you go down you define less-privileged roles.
 
-See full example:
+**Order of the roles is VERY important**, because they are being traversed in the top-to-bottom order.
+At the top you must have an admin or other important role giving the user top permissions, and as you go down you define less-privileged roles.
+
+### 1. Defining access policy
+
+Let's start with a complete example of what can be achieved:
 
 ```ruby
-class Policy
+# app/policies/access_policy.rb
+
+class AccessPolicy
   include AccessGranted::Policy
 
   def configure(user)
-    # The most important role prohibiting banned
-    # users from doing anything.
-    # (even if they are moderators or admins)
-    role :banned, { is_banned: true } do
-      cannot [:create, :update, :destroy], Post
-
-      # same as above, :manage is just a shortcut for
-      # `[:read, :create, :update, :destroy]`
-      cannot :manage, Comment
-    end
 
-    # Takes precedences over roles placed lower
-    # and explicitly lets admin manage everything.
+    # The most important admin role, gets checked first
+
     role :admin, { is_admin: true } do
       can :manage, Post
       can :manage, Comment
     end
 
-    # You can also use Procs to determine
-    # if the role should apply to a given user.
+    # Less privileged moderator role
     role :moderator, proc {|u| u.moderator? } do
-      # takes precedence over :update/:destroy
-      # permissions defined in member role below
-      # and lets moderators edit and delete all posts
       can [:update, :destroy], Post
-
-      # and a new permission which lets moderators
-      # modify user accounts
       can :update, User
     end
 
-    # The basic role.
-    # Applies to everyone logged in.
+    # The basic role. Applies to every user.
     role :member do
       can :create, Post
 
-      # For more advanced permissions
-      # you must use blocks. Hash
-      # conditions should be used for
-      # simple checks only.
       can [:update, :destroy], Post do |post|
         post.user_id == user.id && post.comments.empty?
       end
@@ -127,6 +85,192 @@ class Policy
 end
 ```
 
+#### Defining roles
+
+Each `role` method accepts the name of the role you're creating and an optional matcher.
+Matchers are used to check if user belongs to that role and if the permissions inside should be executed against him.
+
+The simplest role can be defined as follows:
+
+```ruby
+role :member do
+  can :read, Post
+  can :create, Post
+end
+```
+
+This role will allow everyone (since we didn't supply a matcher) to read and create posts.
+
+But now we want to let admins delete those posts (for example spam posts).
+In this case we create a new role above the `:member` to add more permissions for the admin:
+
+```ruby
+role :admin, { is_admin: true } do
+  can :destroy, Post
+end
+
+role :member do
+  can :read, Post
+  can :create, Post
+end
+```
+
+The `{ is_admin: true }` hash is compared with the user's attributes to see if the role should be applied to him.
+So, if the user has an attribute `is_admin` set to `true`, then the role will be applied to him.
+
+**Note:** you can use more keys in the hash to check many attributes at once.
+
+#### Hash conditions
+
+Hashes can be used as matchers as a check if action is permitted.
+For example, we may allow users to only see published posts, like this:
+
+```ruby
+role :member do
+  can :read, Post, { published: true }
+end
+```
+
+#### Block conditions
+
+"But wait! User should also be able to edit his posts, and only his posts!" you are wondering.
+This can be done using a block condition in `can` method, like this:
+
+```ruby
+role :member do
+  can :update, Post do |post|
+    post.author_id == user.id
+  end
+end
+```
+
+When the given block evaluates to `true`, the user is then given the permission to update the post.
+
+#### Roles in order of importance
+
+Additionally we can allow admins to update **all** posts despite them not being authors like this:
+
+
+```ruby
+role :admin, { is_admin: true } do
+  can :update, Post
+end
+
+role :member do
+  can :update, Post do |post|
+    post.author_id == user.id
+  end
+end
+```
+
+As stated before: **`:admin` role takes precedence over `:member`** role, so when AccessGranted sees that admin can update all posts, it stops looking at the less important roles.
+
+That way you can keep a tidy and readable policy file which is basically human readable.
+
+### Using in Rails
+
+AccessGranted comes with a set of helpers available in Ruby on Rails apps:
+
+#### Authorizing controller actions
+
+```ruby
+class PostsController
+  def show
+    @post = Post.find(params[:id])
+    authorize! :read, @post
+  end
+
+  def create
+    authorize! :create, Post
+    # (...)
+  end
+end
+```
+
+`authorize!` throws an exception when current user doesn't have a given permission.
+You can rescue from it using `rescue_from`:
+
+```ruby
+class ApplicationController < ActionController::Base
+  rescue_from "AccessGranted::AccessDenied" do |exception|
+    redirect_to root_path, alert: "You don't have permissions to access this page."
+  end
+end
+```
+
+#### Checking permissions in controllers
+
+To check if the user has a permission to perform an action, use `can?` and `cannot?` methods.
+
+**Example:**
+
+```ruby
+class UsersController
+  def update
+    # (...)
+
+    # only admins can elevate users to moderator status
+
+    if can? :make_moderator, @user
+      @user.moderator = params[:user][:moderator]
+    end
+
+    # (...)
+  end
+end
+
+#### Checking permissions in views
+
+Usually you don't want to show "Create" buttons for people who can't create something.
+You can hide any part of the page from users without permissions like this:
+
+```html
+# app/views/categories/index.html.erb
+
+<% if can? :create, Category %>
+  <%= link_to "Create new category", new_category_path %>
+<% end %>
+```
+
+#### Customizing policy
+
+By default AccessGranted adds this method to your controllers:
+
+```ruby
+  def current_policy
+    @current_policy ||= ::AccessPolicy.new(current_user)
+  end
+```
+
+If you have a different policy class or if your user is not stored in `current_user` variable, then you can override it in any controllers and modify the logic as you please.
+
+You can even have different policies for different controllers!
+
+### Using in pure Ruby
+
+Initialize the Policy class:
+
+```ruby
+
+policy = AccessPolicy.new(current_user)
+```
+
+Check the ability to do something:
+
+with `can?`:
+
+```ruby
+policy.can?(:create, Post) #=> true
+policy.can?(:update, @post) #=> false
+```
+
+or with `cannot?`:
+
+```ruby
+policy.cannot?(:create, Post) #=> false
+policy.cannot?(:update, @ost) #=> true
+```
+
 ## Common examples
 
 ### Extracting roles to separate files
@@ -165,6 +309,24 @@ class MemberRole < AccessGranted::Role
 end
 ```
 
+## Compatibility with CanCan
+
+This gem was created as a replacement for CanCan and therefore it requires minimum work to switch.
+
+### Main differences
+
+1. AccessGranted does not extend ActiveRecord in any way, so it does not have the `accessible_by?`
+   method which could be used for querying objects available to current user.
+   This was very complex and only worked with permissions defined using hash conditions, so
+   I decided to not implement this functionality as it was mostly ignored by CanCan users.
+
+2. Both `can?`/`cannot?` and `authorize!` methods work in Rails controllers and views, just like in CanCan.
+   The only change you have to make is to replace all `can? :manage, Class` with the exact action to check against.
+   `can :manage` is still available for **defining** methods and serves as a shortcut for defining `:read`, `:create`, `:update`, `:destroy` all in one line.
+
+3. Syntax for defining permissions in AccessPolicy file (Ability in CanCan) is exactly the same,
+   with added roles on top. See [Usage](#usage) below.
+
 
 ## Contributing
 

data/access-granted.gemspec

@@ -1,11 +1,10 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'access-granted/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "access-granted"
-  spec.version       = AccessGranted::VERSION
+  spec.version       = "0.2"
   spec.authors       = ["Piotrek Okoński"]
   spec.email         = ["piotrek@okonski.org"]
   spec.description   = %q{Role based authorization gem}
@@ -19,5 +18,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 3.0"
 end

data/benchmarks/README.md

@@ -0,0 +1,24 @@
+# Benchmark results
+
+Benchmarks ran on Ubuntu 15.10 64bit, i5 2500k @ 4.4Ghz, 16 GB RAM with Ruby 2.2.
+
+## permissions.rb
+
+This benchmark runs `can?` method for the 3 user roles for 20 seconds each, for both CanCan and AccessGranted.
+
+```
+Calculating -------------------------------------
+            ag-admin    21.361k i/100ms
+        cancan-admin    13.631k i/100ms
+        ag-moderator    22.328k i/100ms
+    cancan-moderator    11.679k i/100ms
+             ag-user    25.860k i/100ms
+         cancan-user    16.308k i/100ms
+-------------------------------------------------
+            ag-admin    283.174k (± 1.1%) i/s -      5.682M
+        cancan-admin    160.450k (± 1.0%) i/s -      3.217M
+        ag-moderator    301.290k (± 1.1%) i/s -      6.029M
+    cancan-moderator    134.591k (± 1.3%) i/s -      2.698M
+             ag-user    353.259k (± 0.9%) i/s -      7.086M
+         cancan-user    198.579k (± 1.6%) i/s -      3.979M
+```

data/benchmarks/config.rb

@@ -0,0 +1,36 @@
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    if user.is_admin == true
+      can :destroy, String
+    end
+
+    if user.is_moderator == true
+      can :update, String
+    end
+
+    can :read, String
+  end
+end
+
+class AccessPolicy
+  include AccessGranted::Policy
+
+  def configure(user)
+    role :administrator, { is_admin: true } do
+      can :destroy, String
+    end
+
+    role :moderator, { is_moderator: true } do
+      can :update, String
+    end
+
+    role :member do
+      can :read, String
+    end
+  end
+end
+
+class User < Struct.new(:is_admin, :is_moderator)
+end

data/benchmarks/permissions.rb

@@ -0,0 +1,45 @@
+require 'benchmark/ips'
+require 'access-granted'
+require 'cancan'
+require_relative './config'
+
+admin        = User.new(true, false)
+mod          = User.new(false, true)
+user         = User.new(false, false)
+
+user_policy  = AccessPolicy.new(user)
+admin_policy = AccessPolicy.new(admin)
+mod_policy   = AccessPolicy.new(mod)
+
+user_ability  = Ability.new(user)
+admin_ability = Ability.new(admin)
+mod_ability   = Ability.new(mod)
+
+Benchmark.ips do |x|
+  x.config(time: 20, warmup: 2)
+
+  x.report("ag-admin") do
+    admin_policy.can?(:read, String)
+  end
+
+  x.report("ag-moderator") do
+    mod_policy.can?(:read, String)
+  end
+
+  x.report("ag-user") do
+    user_policy.can?(:read, String)
+  end
+
+  x.report("cancan-admin") do
+    admin_ability.can?(:read, String)
+  end
+
+  x.report("cancan-moderator") do
+    mod_ability.can?(:read, String)
+  end
+
+  x.report("cancan-user") do
+    user_ability.can?(:read, String)
+  end
+
+end

data/lib/access-granted.rb

@@ -1,9 +1,15 @@
-require "access-granted/version"
 require "access-granted/exceptions"
 require "access-granted/policy"
 require "access-granted/permission"
 require "access-granted/role"
+require 'access-granted/rails/controller_methods'
 
 module AccessGranted
 
 end
+
+if defined? ActionController::Base
+  ActionController::Base.class_eval do
+    include AccessGranted::Rails::ControllerMethods
+  end
+end

data/lib/access-granted/policy.rb

@@ -26,7 +26,8 @@ module AccessGranted
     end
 
     def can?(action, subject)
-      matching_roles.each do |role|
+      roles.each do |role|
+        next unless role.applies_to?(@user)
         permission = role.find_permission(action, subject)
         return permission.granted if permission
       end
@@ -37,10 +38,6 @@ module AccessGranted
       !can?(*args)
     end
 
-    def matching_roles
-      roles.select { |role| role.applies_to?(@user) }
-    end
-
     def authorize!(action, subject)
       if cannot?(action, subject)
         raise AccessDenied

data/lib/access-granted/rails/controller_methods.rb

@@ -0,0 +1,25 @@
+module AccessGranted
+  module Rails
+    module ControllerMethods
+      def current_policy
+        @current_policy ||= ::AccessPolicy.new(current_user)
+      end
+
+      def self.included(base)
+        base.helper_method :can?, :cannot?, :current_policy
+      end
+
+      def can?(*args)
+        current_policy.can?(*args)
+      end
+
+      def cannot?(*args)
+        current_policy.cannot?(*args)
+      end
+
+      def authorize!(*args)
+        current_policy.authorize!(*args)
+      end
+    end
+  end
+end

data/lib/access-granted/role.rb

@@ -28,8 +28,8 @@ module AccessGranted
     end
 
     def find_permission(action, subject)
-      relevant_permissions(action, subject).detect do |permission|
-        permission.matches_conditions?(subject)
+      permissions_by_action(action).detect do |permission|
+        permission.matches_subject?(subject) && permission.matches_conditions?(subject)
       end
     end
 
@@ -44,12 +44,6 @@ module AccessGranted
       end
     end
 
-    def relevant_permissions(action, subject)
-      permissions_by_action(action).select do |perm|
-        perm.matches_subject?(subject)
-      end
-    end
-
     def matches_hash?(user, conditions = {})
       conditions.all? do |name, value|
         user.send(name) == value
@@ -58,7 +52,7 @@ module AccessGranted
 
     def add_permission(granted, action, subject, conditions, block)
       prepare_actions(action).each do |a|
-        raise DuplicatePermission if relevant_permissions(a, subject).any?
+        raise DuplicatePermission if permission_exists?(a, subject)
         @permissions << Permission.new(granted, a, subject, conditions, block)
         @permissions_by_action[a] ||= []
         @permissions_by_action[a]  << @permissions.size - 1
@@ -67,11 +61,17 @@ module AccessGranted
 
     private
 
+    def permission_exists?(action, subject)
+      permissions_by_action(action).any? do |permission|
+        permission.matches_subject?(subject)
+      end
+    end
+
     def prepare_actions(action)
       if action == :manage
         actions = [:read, :create, :update, :destroy]
       else
-        actions = [action].flatten
+        actions = Array(*[action])
       end
     end
 

data/spec/controller_methods_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe AccessGranted::Rails::ControllerMethods do
+  before(:each) do
+    @current_user = double("User")
+    @controller_class = Class.new
+    @controller = @controller_class.new
+    allow(@controller_class).to receive(:helper_method).with(:can?, :cannot?, :current_policy)
+    @controller_class.send(:include, AccessGranted::Rails::ControllerMethods)
+    allow(@controller).to receive(:current_user).and_return(@current_user)
+  end
+
+  it "should have current_policy method returning Policy instance" do
+    expect(@controller.current_policy).to be_kind_of(AccessGranted::Policy)
+  end
+
+  it "provides can? and cannot? method delegated to current_policy" do
+    expect(@controller.can?(:read, String)).to eq(false)
+    expect(@controller.cannot?(:read, String)).to eq(true)
+  end
+
+  describe "#authorize!" do
+    it "raises exception when authorization fails" do
+      expect { @controller.authorize!(:read, String) }.to raise_error(AccessGranted::AccessDenied)
+    end
+
+    it "returns subject if authorization succeeds" do
+      klass = Class.new do
+        include AccessGranted::Policy
+
+        def configure(user)
+          role :member, 1 do
+            can :read, String
+          end
+        end
+      end
+      policy = klass.new(@current_user)
+      allow(@controller).to receive(:current_policy).and_return(policy)
+      expect(@controller.authorize!(:read, String)).to eq(String)
+    end
+  end
+end

data/spec/role_spec.rb

@@ -4,22 +4,13 @@ describe AccessGranted::Role do
   subject { AccessGranted::Role }
 
   it "requires a role name" do
-    expect { subject.new }.to raise_error
+    expect { subject.new }.to raise_error(ArgumentError)
   end
 
   it "creates a default role without conditions" do
     expect(subject.new(:member).conditions).to be_nil
   end
 
-  describe "#relevant_permissions?" do
-    it "returns only matching permissions" do
-      role = subject.new(:member)
-      role.can :read, String
-      role.can :read, Hash
-      expect(role.relevant_permissions(:read, String)).to eq([AccessGranted::Permission.new(true, :read, String)])
-    end
-  end
-
   describe "#applies_to?" do
     it "matches user when no conditions given" do
       role = subject.new(:member)

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
+
 if ENV["COV"]
   require 'simplecov'
   SimpleCov.start
@@ -19,12 +20,13 @@ module ActionController
     end
   end
 end
+
 require 'access-granted'
 
 class FakePost < Struct.new(:user_id)
 end
 
-class Policy
+class AccessPolicy
   include AccessGranted::Policy
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: access-granted
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: '0.2'
 platform: ruby
 authors:
 - Piotrek Okoński
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-30 00:00:00.000000000 Z
+date: 2015-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,16 +28,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 description: Role based authorization gem
 email:
 - piotrek@okonski.org
@@ -53,12 +53,16 @@ files:
 - README.md
 - Rakefile
 - access-granted.gemspec
+- benchmarks/README.md
+- benchmarks/config.rb
+- benchmarks/permissions.rb
 - lib/access-granted.rb
 - lib/access-granted/exceptions.rb
 - lib/access-granted/permission.rb
 - lib/access-granted/policy.rb
+- lib/access-granted/rails/controller_methods.rb
 - lib/access-granted/role.rb
-- lib/access-granted/version.rb
+- spec/controller_methods_spec.rb
 - spec/permission_spec.rb
 - spec/policy_spec.rb
 - spec/role_spec.rb
@@ -89,6 +93,7 @@ specification_version: 4
 summary: Elegant whitelist and role based authorization with ability to prioritize
   roles.
 test_files:
+- spec/controller_methods_spec.rb
 - spec/permission_spec.rb
 - spec/policy_spec.rb
 - spec/role_spec.rb

data/lib/access-granted/version.rb

@@ -1,3 +0,0 @@
-module AccessGranted
-  VERSION = "0.1.1"
-end