canard 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+pkg/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in canard.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    canard (0.0.1)
+      cancan
+      role_model
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.0)
+      activesupport (= 3.1.0)
+      bcrypt-ruby (~> 3.0.0)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.0)
+      activemodel (= 3.1.0)
+      activesupport (= 3.1.0)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.0)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    bcrypt-ruby (3.0.0)
+    builder (3.0.0)
+    cancan (1.6.5)
+    i18n (0.6.0)
+    minitest (2.5.1)
+    multi_json (1.0.3)
+    role_model (0.7.0)
+    sqlite3 (1.3.4)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  canard!
+  minitest (~> 2)
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,128 @@
+= Canard
+
+Canard brings CanCan and RoleModel together to make role based authorization in Rails easy. Your ability 
+definitions gain their own folder and a little structure. The easiest way to get started is with the 
+Canard generator. Canard progressively enhances the abilities of the model by applying role abilities on
+top of the models base abilities.
+
+A User model with :admin and :manger roles would be defined:
+
+    class User < ActiveRecord::Base
+    
+      acts_as_user :roles => :admin, :manager
+      
+    end
+    
+Lets generate some abilities for the User.
+
+    $ rails g canard:ability user can:[read,create]:[account,statement] cannot:destroy:account
+    create  abilities/users.rb
+    invoke  rspec
+    create    spec/abilities/user_spec.rb
+
+Generates an ability folder in Rails root and an associated spec;
+
+    abilities/
+      users.rb
+    spec/abilities/
+      users_spec.rb
+
+The resulting abilities/users.rb will look something like this;
+
+    abilities_for(:user) do
+    
+      can     [:read, :create], Account
+      cannot  [:destroy], Account
+      can     [:read, :create], Statement
+    
+    end
+    
+And it's associated test spec/abilities/users_spec.rb;
+
+    require_relative '../spec_helper'
+    require "cancan/matchers"
+
+    describe Ability, "for :user" do
+
+      before do
+        @user = Factory.create(:user_user)
+      end
+
+      subject { Ability.new(@user) }
+
+      describe 'on Account' do
+
+        before do
+          @account = Factory.create(:account)
+        end
+
+        it { should be_able_to( :read,      @account ) }
+        it { should be_able_to( :create,    @account ) }
+        it { should_not be_able_to( :destroy,   @account ) }
+
+      end
+      # on Account
+
+      describe 'on Statement' do
+
+        before do
+          @statement = Factory.create(:statement)
+        end
+
+        it { should be_able_to( :read,      @statement ) }
+        it { should be_able_to( :create,    @statement ) }
+
+      end
+      # on Statement
+
+    end
+
+Now lets generate some abilities for the manager and admin.
+
+    $ rails g canard:ability admin can:manage:[account,statement]
+    $ rails g canard:ability manager can:edit:statement
+
+Will give us two new sets of abilities in the abilities folder. Canard will apply these abilities by first
+loading the ability for the User model and then apply the abilities for each role the current user has.
+
+Canard also creates a guest ability by default so:
+
+    $ rails g canard:ability guest can:create:user
+    
+Would generate an ability for a not logged in user to signup.
+
+Obviously the generators are just a starting point and should not be used only to get you going. I strongly 
+suggest that every new model you create you add to the abilities as the specs are so easy to write and CanCan
+definitions are so clear and simple.
+
+== Installation
+
+=== Rails 3.x
+
+Add the canard gem to your Gemfile. In Gemfile:
+
+    gem "canard"
+
+That's it!
+
+=== Rails 2.x
+
+Sorry you are out of luck with Rails 2.x Canard has only been written and tested with Rails 3.x. I'll be happy 
+to accept pull requests for tested Rails 2.x updates if anybody is game.
+
+== Note on Patches/Pull Request
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it (when I have some). This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but
+  bump version in a commit by itself I can ignore it when I pull)
+* Send me a pull request.  Bonus points for topic branches.
+
+== Credits
+
+Thanks to Ryan Bates for creating the awesome CanCan (http://wiki.github.com/ryanb/cancan/role-based-authorization) 
+and Martin Rehfeld for implementing Role Based Authorization in the form of RoleModel (http://github.com/martinrehfeld/role_model).
+
+== Copyright
+Copyright (c) 2011 James McCarthy, released under the MIT license

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+ t.libs << 'lib' << "test"
+ t.pattern = 'test/*_test.rb'
+ t.verbose = true
+end

data/TODO

@@ -0,0 +1,5 @@
+* create ability generator for a new model e.g. rails g canard:abilitiy user:manage
+* Test the ability class.
+* Test the generators.
+* Test the railtie
+* Add scopes by default and :scopes => false to acts_as_user

data/canard.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "canard/version"
+
+Gem::Specification.new do |s|
+  s.name        = "canard"
+  s.version     = Canard::VERSION
+  s.authors     = ["James McCarthy"]
+  s.email       = ["james2mccarthy@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Adds RoleModel roles to CanCan.}
+  s.description = %q{Wraps CanCan and RoleModel up with some scopes}
+
+  s.rubyforge_project = "canard"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "minitest", "~> 2"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "activerecord"
+  s.add_runtime_dependency "cancan"
+  s.add_runtime_dependency "role_model"
+end

data/lib/ability.rb

@@ -0,0 +1,41 @@
+class Ability
+
+  include CanCan::Ability
+
+  def initialize(object=nil)
+    
+    # If a user was passed set the user from it.
+    @user = object.is_a?(Account) ? object.user : object
+    
+    if @user
+      # Add the base user abilities.
+      load_abilities @user.class.name.underscore.to_sym
+    else
+      # If user not set then lets create a guest
+      @user = Object.new
+      load_abilities :guest
+    end
+    
+    # If user has roles get those abilities
+    if @user.respond_to?(:roles)
+      # Add roles on top of the base user abilities
+      @user.roles.each { |role| load_abilities(role) }
+    end
+  
+  end
+  
+  private
+  
+  def user
+    @user
+  end
+  
+  def ability_definitions
+    Canard.ability_definitions
+  end
+  
+  def load_abilities(role)
+    instance_eval(&ability_definitions[role]) if ability_definitions.has_key?(role)
+  end
+
+end

data/lib/canard.rb

@@ -0,0 +1,12 @@
+require 'cancan'
+require 'role_model'
+require "canard/version"
+require "canard/find_abilities"
+require "ability"
+
+module Canard
+  autoload :UserModel, 'canard/user_model'
+end
+
+require 'canard/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+

data/lib/canard/find_abilities.rb

@@ -0,0 +1,31 @@
+module Canard
+
+  class << self
+    # A string specifying the location that should be searched for ability
+    # definitions. By default, Canard will attempt to load abilities from
+    # Rails.root + /abilities/.
+    attr_accessor :abilities_path
+    
+    def ability_definitions
+      @ability_definitions ||= {}
+    end
+    
+    def abilities_for(role, &block)
+      ability_definitions[role] = block
+    end
+    
+  end
+
+  def self.find_abilities #:nodoc:
+    
+    absolute_abilities_path = File.expand_path(abilities_path)
+
+    if File.directory? absolute_abilities_path
+      Dir[File.join(absolute_abilities_path, '**', '*.rb')].sort.each do |file|
+        self.class_eval File.read(file)
+      end
+    end
+
+  end
+  
+end

data/lib/canard/railtie.rb

@@ -0,0 +1,20 @@
+require 'canard'
+require 'rails'
+
+module Canard
+  class Railtie < Rails::Railtie
+    
+    initializer "canard.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        extend Canard::UserModel
+        Canard.abilities_path ||= File.expand_path('abilities', Rails.root)
+        Canard.find_abilities
+      end
+    end
+    
+    initializer "canard.abilities_reloading", :after => "action_dispatch.configure" do |app|
+      ActionDispatch::Reloader.to_prepare { Canard.find_abilities }
+    end
+    
+  end
+end

data/lib/canard/user_model.rb

@@ -0,0 +1,15 @@
+module Canard
+
+  module UserModel
+    
+    def acts_as_user(*args)
+      include RoleModel
+
+      options = args.extract_options!.symbolize_keys
+
+      roles options[:roles] if options.has_key?(:roles) && column_names.include?(roles_attribute_name.to_s)
+    end
+
+  end
+
+end

data/lib/canard/version.rb

@@ -0,0 +1,3 @@
+module Canard
+  VERSION = "0.1.0"
+end

data/lib/generators/ability_definition.rb

@@ -0,0 +1,43 @@
+require 'active_support/inflector'
+
+class AbilityDefinition
+  
+  attr_accessor :cans, :cannots
+  
+  def self.parse(definitions)
+    @@ability_definitions ||= {}
+    limitation, ability_names, model_names = *definitions.split(':')
+    abilities, models = extract(ability_names), extract(model_names)
+    models.each do |model|
+      definition = @@ability_definitions[model] || AbilityDefinition.new
+      definition.merge(limitation.pluralize, abilities)
+      @@ability_definitions[model] = definition
+    end
+  end
+  
+  def self.extract(string)
+    return *string.gsub(/[\[\]\s]/, '').split(',')
+  end
+    
+  def self.models
+    @@ability_definitions
+  end
+  
+  def initialize
+    @cans, @cannots = [], []
+  end
+  
+  def merge(limitation, abilities)
+    combined_abilities = instance_variable_get("@#{limitation}") | abilities
+    instance_variable_set("@#{limitation}", combined_abilities)
+  end
+  
+  def can
+    @cans
+  end
+  
+  def cannot
+    @cannots
+  end
+      
+end

data/lib/generators/canard/ability/USAGE

@@ -0,0 +1,3 @@
+Description:
+  The canard:ability generator creates an Ability definition in the abilities
+  directory. It also creates the shell of a spec for testing those abilities.

data/lib/generators/canard/ability/ability_generator.rb

@@ -0,0 +1,27 @@
+require_relative '../../ability_definition'
+
+module Canard
+  module Generators
+    class AbilityGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      argument :ability_definitions, :type => :array, :default => [], :banner => "can:[read,update]:[user,account] cannot:[create,destroy]:user"
+
+      def generate_ability
+        template "abilities.rb.erb", Canard.abilities_path + "/#{file_name.pluralize}.rb"
+      end
+    
+      hook_for :test_framework, :as => 'ability'
+    
+      private
+      
+      def definitions(&block)
+        ability_definitions.each { |definition| AbilityDefinition.parse(definition) }
+        
+        AbilityDefinition.models.sort.each do |model, definition|
+          yield model, definition
+        end
+      end
+      
+    end
+  end
+end

data/lib/generators/canard/ability/templates/abilities.rb.erb

@@ -0,0 +1,32 @@
+abilities_for(<%= ":#{name}" -%>) do
+
+<% if ability_definitions.empty? -%>
+  # Define abilities for the user role here. For example:
+  #
+  #   if user.admin?
+  #     can :manage, :all
+  #   else
+  #     can :read, :all
+  #   end
+  #
+  # The first argument to `can` is the action you are giving the user permission to do.
+  # If you pass :manage it will apply to every action. Other common actions here are
+  # :read, :create, :update and :destroy.
+  #
+  # The second argument is the resource the user can perform the action on. If you pass
+  # :all it will apply to every resource. Otherwise pass a Ruby class of the resource.
+  #
+  # The third argument is an optional hash of conditions to further filter the objects.
+  # For example, here the user can only update published articles.
+  #
+  #   can :update, Article, :published => true
+  #
+  # See the wiki for details: https://github.com/ryanb/cancan/wiki/Defining-Abilities
+<% else -%>
+<% definitions do |model, definition| -%>
+  <%= "can".ljust(8, ' ') + "#{definition.cans.map(&:to_sym)}, #{model.classify}" unless definition.cans.empty? %>
+  <%= "cannot".ljust(8, ' ') + "#{definition.cannots.map(&:to_sym)}, #{model.classify}" unless definition.cannots.empty? %>
+<% end -%>
+<% end -%>
+
+end

data/lib/generators/rspec/ability/ability_generator.rb

@@ -0,0 +1,31 @@
+require 'generators/rspec'
+require_relative '../../ability_definition'
+
+module Rspec
+  module Generators
+    class AbilityGenerator < Base
+      @_rspec_source_root = File.expand_path('../templates', __FILE__)
+      argument :ability_definitions, :type => :array, :default => [], :banner => "can:abilities:models cannot:abilities:models"
+
+      def generate_ability_spec
+        template "abilities_spec.rb.erb", "spec/abilities/#{file_name}_spec.rb"
+      end
+      
+      private
+      
+      def add_new_abilities
+        gsub_file "spec/abilities/#{file_name}_spec.rb", /^(\s*end\s*\Z)/, 'wibble' + '\1'
+      end
+      
+      def definitions(&block)
+        ability_definitions.each { |definition| AbilityDefinition.parse(definition) }
+        
+        AbilityDefinition.models.sort.each do |model, definition|
+          yield model, definition
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/generators/rspec/ability/templates/abilities_spec.rb.erb

@@ -0,0 +1,55 @@
+require_relative '../spec_helper'
+
+require "cancan/matchers"
+
+describe Ability, "for :<%= name %>" do
+
+  before do
+    @<%= name %> = Factory.create(:<%= name %>_user)
+  end
+  
+  subject { Ability.new(@<%= name -%>) }
+  
+<% if ability_definitions.empty? -%>
+# Define your ability tests thus;
+#
+#  describe 'on Activity' do
+#
+#    before do
+#      @activity = Factory.create(:activity)
+#    end
+#
+#    it { should be_able_to( :index,    Activity  ) }
+#    it { should be_able_to( :show,     @activity ) }
+#    it { should be_able_to( :read,     @activity ) }
+#    it { should be_able_to( :new,      @activity ) }
+#    it { should be_able_to( :create,   @activity ) }
+#    it { should be_able_to( :edit,     @activity ) }
+#    it { should be_able_to( :update,   @activity ) }
+#    it { should be_able_to( :destroy,  @activity ) }
+#
+#  end
+#  # on Activity
+<% else -%>
+<% definitions do |model, definition| -%>
+  
+  describe 'on <%= model.camelize -%>' do
+
+    before do
+      @<%= model -%> = Factory.create(:<%= model -%>)
+    end
+    
+<% definition.cans.each do |can| -%>
+    it { should be_able_to( <%= ":#{can},".ljust(12, ' ') + (can == 'index' ? model.camelize : "@#{model}") -%> ) }
+<% end -%>
+<%- definition.cannots.each do |cannot| -%>
+    it { should_not be_able_to( <%= ":#{cannot},".ljust(12, ' ') + (cannot == 'index' ? model.camelize : "@#{model}") -%> ) }
+<% end -%>
+
+  end
+  # on <%= model.camelize %>
+  <% end -%>
+  
+<% end -%>  
+end
+  

data/test/abilities/admins.rb

@@ -0,0 +1,9 @@
+abilities_for(:admin) do
+    
+  can :manage, [Activity, User, Variation, Year]
+  
+  cannot :destroy, User do |u|
+    (user == u)
+  end
+    
+end

data/test/canard_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require_relative '../lib/canard.rb'
+
+describe Canard do
+  
+  before do
+    class User < ActiveRecord::Base
+    end
+  
+    Canard.abilities_path = File.expand_path('../abilities', __FILE__)
+  end
+  
+  # Sanity test
+  it "must be an user" do
+    user = User.new
+    user.must_be_instance_of User
+  end
+  
+  describe "abilities_path" do
+    
+    it "should be mutable" do
+      Canard.abilities_path = 'app/abilities'
+      Canard.abilities_path.must_equal 'app/abilities'
+    end
+
+  end
+  
+  describe "ability_definitions" do
+    
+    it "should be an accessor" do
+      Canard.must_respond_to(:ability_definitions)
+    end
+    
+    it "should be a hash" do
+      Canard.ability_definitions.must_be_instance_of Hash
+    end
+    
+  end  
+  
+  describe "find_abilities" do
+    
+    it "should load the abilities into ability_definitions" do
+      Canard.find_abilities
+
+      Canard.ability_definitions.keys.must_include :admin
+    end
+    
+  end
+  
+end

data/test/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  extend Canard::UserModel
+  acts_as_user :roles => [:admin, :author, :viewer]
+end

data/test/models/user_without_role.rb

@@ -0,0 +1,5 @@
+class UserWithoutRole < ActiveRecord::Base
+  extend Canard::UserModel
+  acts_as_user 
+end
+

data/test/models/user_without_role_mask.rb

@@ -0,0 +1,4 @@
+class UserWithoutRoleMask < ActiveRecord::Base
+  extend Canard::UserModel
+  acts_as_user 
+end

data/test/test_helper.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+gem     'minitest'
+require 'active_record'
+require 'minitest/autorun'
+
+module MiniTestWithHooks
+  class Unit < MiniTest::Unit
+    def before_suites
+    end
+
+    def after_suites
+    end
+
+    def _run_suites(suites, type)
+      begin
+        before_suites
+        super(suites, type)
+      ensure
+        after_suites
+      end
+    end
+  end
+end
+
+module MiniTestWithActiveRecord
+  class Unit < MiniTestWithHooks::Unit
+
+    def before_suites
+      super
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+      ActiveRecord::Migration.verbose = false
+      
+      @migration  = Class.new(ActiveRecord::Migration) do
+
+        def change
+          create_table :users, :force => true do |t|
+            t.string     :roles_mask
+          end
+          create_table :user_without_roles, :force => true do |t|
+            t.string     :roles_mask
+          end
+          create_table :user_without_role_masks, :force => true do |t|
+          end
+        end
+
+      end
+      
+      @migration.new.migrate(:up)
+    end
+
+    def after_suites
+      @migration.new.migrate(:down)
+      super
+    end
+  end
+end
+
+MiniTest::Unit.runner = MiniTestWithActiveRecord::Unit.new

data/test/user_model_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+require 'canard'
+
+describe Canard::UserModel do
+  
+  before do
+    Canard.abilities_path = 'abilities'
+    require 'models/user'
+    require 'models/user_without_role'
+    require 'models/user_without_role_mask'
+  end
+  
+  # Sanity test
+  it "must be an user" do
+    user = User.new
+    user.must_be_instance_of User
+    user = UserWithoutRole.new
+    user.must_be_instance_of UserWithoutRole
+    user = UserWithoutRoleMask.new
+    user.must_be_instance_of UserWithoutRoleMask
+  end
+  
+  describe 'acts_as_user' do
+    
+    it 'should add role_model to this model' do
+      User.included_modules.must_include RoleModel
+      User.must_respond_to :roles
+    end
+    
+    describe 'on a model with a role mask' do
+      
+      describe 'and :roles => [] specified' do
+      
+        it 'should set the valid_roles for the class' do
+          User.valid_roles.must_equal [:admin, :author, :viewer]
+        end
+        
+      end
+      
+      describe 'with no :roles => [] specified' do
+        
+        it 'should not set any roles' do
+          UserWithoutRole.valid_roles.must_equal []
+        end
+      end
+      
+    end
+      
+    describe 'with no roles_mask' do
+      
+      it 'should not set any roles' do
+        UserWithoutRole.valid_roles.must_equal []
+      end
+    end
+    
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: canard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- James McCarthy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2153074000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *2153074000
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2153073580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153073580
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2153073120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153073120
+- !ruby/object:Gem::Dependency
+  name: cancan
+  requirement: &2153072700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153072700
+- !ruby/object:Gem::Dependency
+  name: role_model
+  requirement: &2153072280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153072280
+description: Wraps CanCan and RoleModel up with some scopes
+email:
+- james2mccarthy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- canard.gemspec
+- lib/ability.rb
+- lib/canard.rb
+- lib/canard/find_abilities.rb
+- lib/canard/railtie.rb
+- lib/canard/user_model.rb
+- lib/canard/version.rb
+- lib/generators/ability_definition.rb
+- lib/generators/canard/ability/USAGE
+- lib/generators/canard/ability/ability_generator.rb
+- lib/generators/canard/ability/templates/abilities.rb.erb
+- lib/generators/rspec/ability/ability_generator.rb
+- lib/generators/rspec/ability/templates/abilities_spec.rb.erb
+- test/abilities/admins.rb
+- test/canard_test.rb
+- test/models/user.rb
+- test/models/user_without_role.rb
+- test/models/user_without_role_mask.rb
+- test/test_helper.rb
+- test/user_model_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: canard
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Adds RoleModel roles to CanCan.
+test_files:
+- test/abilities/admins.rb
+- test/canard_test.rb
+- test/models/user.rb
+- test/models/user_without_role.rb
+- test/models/user_without_role_mask.rb
+- test/test_helper.rb
+- test/user_model_test.rb