rolify 3.3.0.rc2 → 3.3.0.rc4

data/.gitignore

@@ -1,6 +1,7 @@
 *.gem
 .bundle
 Gemfile.lock
+gemfiles/*.lock
 pkg/*
 tmp/*
 log*/*

data/.travis.yml

@@ -1,16 +1,23 @@
 rvm:
-    - 1.9.3
-    - ruby-head
-    - rbx-19mode
-    - jruby-19mode
+  - 1.9.3
+  - 2.0.0 
+  - rbx-19mode
+  - jruby-19mode
+
+gemfile:
+  - gemfiles/Gemfile.rails-3.2
+  - gemfiles/Gemfile.rails-4.0
 
 env:
-    - ADAPTER=active_record
-    - ADAPTER=mongoid
+  - ADAPTER=active_record
+  - ADAPTER=mongoid
 
-before_install:
-  - gem update --system
-  - gem --version
-  - ruby -v
-  
 services: mongodb
+
+before_script: rails --version
+
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode
+    - rvm: jruby-19mode
+    - gemfile: gemfiles/Gemfile.rails-4.0

data/CHANGELOG.rdoc

@@ -1,3 +1,21 @@
+= 3.3 (not released yet)
+* <b>DEPRECATION NOTICE:</b>Rails 3.1 support dropped: if you use Rails 3.1, please stick to rolify 3.2
+* code cleanup in finders methods
+* generators rewritten entirely. now using ActiveRecord/Mongoid model generator to create Role model
+* added rspec matchers for detailed spec error messages (thanks to @delwyn)
+* clean up specs (thanks to @delwyn), removed subject and let declarations in before(:all) block
+* roles query needs 1 DB hit instead of 1 up to 3 (thanks to @terraplane)
+* remove nil entries from ResourceAdapter#resources_find when using Mongoid adapter (thanks to @daviscabral)
+* fixed a bug regarding redundant index for Mongoid Role model (thanks to  @rschultheis)
+* added support for rolify and resourcify methods on the same model class (specs by @amer)
+* added support for namespaced models (thanks to @intrica)
+* fixed compatibility issue with squeel when using symbols as role parameters (hint by @f3ndot)
+* now raises a warning in the initializer if migration has not been run
+* add support for primary key different than 'id' for resource Model (thanks to @rafaeldl)
+* Rails 4 (thanks to @adammathys) and ruby 2.0 compliant
+* configured travis-ci to run the specs on Rails 3.2/4.0 and Rubies 1.9.3/2.0/rbx/jruby
+* added code climate to check for code smell
+
 = 3.2 (Aug 7, 2012)
 * <b>DEPRECATION NOTICE:</b> Ruby 1.8 support dropped ! Mongoid 3.0 only supports MRI 1.9.3, and HEAD, and JRuby 1.6.0+ in 1.9 mode
 * removed <tt>dynamic_shortcuts</tt> arguments from the generator

data/Gemfile

@@ -1,4 +1,17 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in rolify.gemspec
-gemspec
+case ENV["ADAPTER"]
+when nil, "active_record"
+  group :test do
+    gem "activerecord-jdbcsqlite3-adapter", :platform => "jruby"
+    gem "sqlite3", :platform => "ruby"
+  end
+  gem "activerecord", ">= 3.2.0", :require => "active_record"
+when "mongoid"
+  gem "mongoid", ">= 3.1"
+  gem "bson_ext", :platform => "ruby"
+else
+  raise "Unknown model adapter: #{ENV["ADAPTER"]}"
+end
+
+gemspec

data/README.md

@@ -1,4 +1,4 @@
-# rolify [![Gem Version](https://badge.fury.io/rb/rolify.png)](http://badge.fury.io/rb/rolify) [![build status](https://secure.travis-ci.org/EppO/rolify.png?branch=master)](http://travis-ci.org/EppO/rolify) [![dependency status](https://gemnasium.com/EppO/rolify.png)](https://gemnasium.com/EppO/rolify) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/EppO/rolify)
+# rolify [![Gem Version](https://badge.fury.io/rb/rolify.png)](http://badge.fury.io/rb/rolify) [![build status](https://secure.travis-ci.org/EppO/rolify.png)](http://travis-ci.org/EppO/rolify) [![dependency status](https://gemnasium.com/EppO/rolify.png)](https://gemnasium.com/EppO/rolify) [![Code Climate](https://codeclimate.com/github/EppO/rolify.png)](https://codeclimate.com/github/EppO/rolify)
 
 Very simple Roles library without any authorization enforcement supporting scope on resource object.
 
@@ -15,10 +15,10 @@ This library can be easily integrated with any authentication gem ([devise](http
 
 ## Requirements
 
-* Rails >= 3.1
-* ActiveRecord >= 3.1 <b>or</b> Mongoid >= 3.0
-* supports ruby 1.9, JRuby 1.6.0+ (in 1.9 mode) and Rubinius 2.0.0dev (in 1.9 mode)
-* support of ruby 1.8 has been dropped due to Mongoid 3.0 that only supports 1.9 new hash syntax
+* Rails >= 3.2
+* ActiveRecord >= 3.2 <b>or</b> Mongoid >= 3.1
+* supports ruby 2.0/1.9.3, JRuby 1.6.0+ (in 1.9 mode) and Rubinius 2.0.0dev (in 1.9 mode)
+* support of ruby 1.8 has been dropped due to Mongoid >=3.0 that only supports 1.9 new hash syntax
 
 ## Installation
 
@@ -28,12 +28,6 @@ In <b>Rails 3</b>, add this to your Gemfile and run the +bundle+ command.
   gem "rolify"
 ```
 
-Alternatively, you can install it as a plugin.
-
-```
-  rails plugin install git://github.com/EppO/rolify.git
-```
-
 ## Getting Started
 
 ### 1. Generate Role Model
@@ -41,13 +35,13 @@ Alternatively, you can install it as a plugin.
 First, create your Role model and migration file using this generator:
 
 ```
-  rails g rolify:role Role User
+  rails g rolify Role User
 ```
 
 Role and User classes are the default. You can specify any Role class name you want. This is completly a new file so any name can do the job.
 For the User class name, you would probably use the one provided by your authentication solution. rolify just adds some class methods in an existing User class.
 
-If you want to use Mongoid instead of ActiveRecord, follow these [instructions](https://github.com/EppO/rolify/wiki/Configuration), and skip to step #3
+If you want to use Mongoid instead of ActiveRecord, just add `--orm=mongoid` argument, and skip to step #3
 
 ### 2. Run the migration (only required when using ActiveRecord)
 
@@ -59,26 +53,26 @@ Let's migrate !
 
 ### 3.1 Configure your user model
 
-This gem adds the `rolify` method to your User class. You can also specify optional callbacks* on the user for when roles are added or removed:
+This gem adds the `rolify` method to your User class. You can also specify optional callbacks on the User class for when roles are added or removed:
 
 ```ruby
   class User < ActiveRecord::Base
     rolify :before_add => :before_add_method
 
-    def :before_add_method(role)
+    def before_add_method(role)
       # do something before it gets added
     end
   end
 ```
 
-The `rolify` method accepts the following callback* options:
+The `rolify` method accepts the following callback options:
 
 - `before_add`
 - `after_add`
 - `before_remove`
 - `after_remove`
 
-*PLEASE NOTE: callbacks are currently only supported using ActiveRecord ORM. Mongoid will support association callbacks in its 3.1 release (Mongoid current version is 3.0.x)
+Mongoid callbacks are also supported and works the same way.
 
 ### 3.2 Configure your resource models
 
@@ -201,6 +195,12 @@ Starting from rolify 3.0, you can search roles on instance level or class level
   * [Using rolify with Devise and Authority](https://github.com/EppO/rolify/wiki/Using-rolify-with-Devise-and-Authority)
   * [Step-by-step tutorial](http://railsapps.github.com/tutorial-rails-bootstrap-devise-cancan.html) provided by [RailsApps](http://railsapps.github.com/)
 
+## Upgrade from previous versions
+
+Please read the [upgrade instructions](UPGRADE.rdoc).
+
 ## Questions or Problems?
 
 If you have any issue or feature request with/for rolify, please add an [issue on GitHub](https://github.com/EppO/rolify/issues) or fork the project and send a pull request.
+
+To get the specs running you should call `bundle` and then `rake`. See the spec/README for more information.

data/Rakefile

@@ -1,9 +1,31 @@
 require 'bundler'
+require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
 
+RSpec::Core::RakeTask.new(:generators) do |task|
+  task.pattern = "spec/generators/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:rolify) do |task|
+  task.pattern = "spec/rolify/**/*_spec.rb"
+end
+
 task :default => :spec
 
 desc "Run all specs"
 task "spec" do
-  exec "bundle exec rspec spec"
+  Rake::Task['generators'].invoke
+  return_code1 = $?.exitstatus
+  Rake::Task['rolify'].invoke
+  return_code2 = $?.exitstatus
+  fail if return_code1 != 0 || return_code2 != 0
 end
+
+desc "Run specs for all adapters"
+task :spec_all do
+  %w[active_record mongoid].each do |model_adapter|
+    puts "ADAPTER = #{model_adapter}"
+    system "ADAPTER=#{model_adapter} rake"
+  end
+end

data/UPGRADE.rdoc

@@ -20,3 +20,25 @@ If you use <i>dynamic methods</i> (<tt>user.is_admin?</tt> like methods), you sh
       c.use_dynamic_shortcuts
    end
 The old fashion way still works though, but won't work anymore if the setter method name is changed in a possible future. You've been warned :-)
+
+== From a rolify installation 3.x
+
+=== Dependencies: 
+
+Starting from 3.3 release, rolify supports Rails 3.2 and newer.
+
+Mongoid callbacks are supported if Mongoid 3.1 and newer is installed.
+
+=== Rails Generators
+
+Role model template when using Mongoid has been changed, you should re-run the generator.
+
+Rails generator has been renamed to: <tt>rails g rolify</tt> and arguments have been changed: 
+* Role class name is now mandatory, User class name remains optional and its default is still <tt>User</tt>
+* ORM optional argument is now <tt>-o</tt> or <tt>--orm=</tt>
+For instance, here is a new rolify generator command example: <tt>rails g rolify Role</tt>
+You can use <tt>rails g rolify --help</tt> to see all available options.
+
+=== Testing
+
+Starting from rolify 3.3, to run the specs you should run: <tt>rake spec</tt> or simply <tt>rake</tt>.

data/gemfiles/Gemfile.rails-3.2

@@ -0,0 +1,17 @@
+source "https://rubygems.org"
+
+case ENV["ADAPTER"]
+when nil, "active_record"
+  group :test do
+    gem "activerecord-jdbcsqlite3-adapter", :platform => "jruby"
+    gem "sqlite3", :platform => "ruby"
+  end
+  gem "activerecord", "~> 3.2.0", :require => "active_record"
+when "mongoid"
+  gem "mongoid", "~> 3.1"
+  gem "bson_ext", :platform => "ruby"
+else
+  raise "Unknown model adapter: #{ENV["ADAPTER"]}"
+end
+
+gemspec :path => '../'

data/gemfiles/Gemfile.rails-4.0

@@ -0,0 +1,26 @@
+source "https://rubygems.org"
+
+case ENV["ADAPTER"]
+when nil, "active_record"
+  gem "activerecord", "~> 4.0.0.beta1", :require => "active_record"
+when "mongoid"
+  gem "mongoid", :git => "git://github.com/mongoid/mongoid.git"
+  gem "bson_ext", :platform => "ruby"
+else
+  raise "Unknown model adapter: #{ENV["ADAPTER"]}"
+end
+
+group :test do
+  gem "rails", "~> 4.0.0.beta1"
+  gem "ammeter"
+  gem "rake"
+  gem "rspec"
+  gem "rspec-rails"
+  gem "fuubar"
+  gem "bundler"
+  
+  gem "activerecord-jdbcsqlite3-adapter", :platform => "jruby"
+  gem "sqlite3", :platform => "ruby"
+  gem "activerecord", "~> 4.0.0.beta1", :require => "active_record"
+  gem "mongoid", :git => "git://github.com/mongoid/mongoid.git"
+end

data/lib/generators/active_record/rolify_generator.rb

@@ -0,0 +1,50 @@
+require 'rails/generators/active_record'
+require 'active_support/core_ext'
+
+module ActiveRecord
+  module Generators
+    class RolifyGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+      
+      argument :user_cname, :type => :string, :default => "User", :banner => "User"
+      
+      def generate_model
+        invoke "active_record:model", [ name ], :migration => false
+      end
+      
+      def inject_role_class
+        inject_into_class(model_path, class_name, model_content)
+      end
+      
+      def copy_rolify_migration
+        migration_template "migration.rb", "db/migrate/rolify_create_#{table_name}"
+      end
+      
+      def join_table
+        user_cname.constantize.table_name + "_" + table_name
+      end
+      
+      def user_reference
+        user_cname.demodulize.underscore
+      end
+      
+      def role_reference
+        class_name.demodulize.underscore
+      end
+      
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+      
+      def model_content
+        content = <<RUBY
+  has_and_belongs_to_many :%{user_cname}, :join_table => :%{join_table}
+  belongs_to :resource, :polymorphic => true
+  
+  scopify
+RUBY
+        content % { :user_cname => user_cname.constantize.table_name, :join_table => "#{user_cname.constantize.table_name}_#{table_name}"}
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,19 @@
+class RolifyCreate<%= table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table(:<%= table_name %>) do |t|
+      t.string :name
+      t.references :resource, :polymorphic => true
+
+      t.timestamps
+    end
+
+    create_table(:<%= join_table %>, :id => false) do |t|
+      t.references :<%= user_reference %>
+      t.references :<%= role_reference %>
+    end
+
+    add_index(:<%= table_name %>, :name)
+    add_index(:<%= table_name %>, [ :name, :resource_type, :resource_id ])
+    add_index(:<%= join_table %>, [ :<%= user_reference %>_id, :<%= role_reference %>_id ])
+  end
+end

data/lib/generators/mongoid/rolify_generator.rb

@@ -0,0 +1,51 @@
+require 'rails/generators/mongoid_generator'
+require 'active_support/core_ext'
+
+module Mongoid
+  module Generators
+    class RolifyGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+      
+      argument :user_cname, :type => :string, :default => "User", :banner => "User"
+      
+      def generate_model
+        invoke "mongoid:model", [ name ]
+      end
+      
+      def inject_role_class
+        inject_into_file(model_path, model_contents, :after => "include Mongoid::Document\n")
+      end
+      
+      def user_reference
+        user_cname.demodulize.underscore
+      end
+      
+      def role_reference
+        class_name.demodulize.underscore
+      end
+      
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+      
+      def model_contents
+        content = <<RUBY
+  has_and_belongs_to_many :%{user_cname}
+  belongs_to :resource, :polymorphic => true
+  
+  field :name, :type => String
+
+  index({
+    :name => 1,
+    :resource_type => 1,
+    :resource_id => 1
+  },
+  { :unique => true})
+  
+  scopify
+RUBY
+        content % { :user_cname => user_cname.constantize.table_name }
+      end
+    end
+  end
+end

data/lib/generators/rolify/rolify_generator.rb

@@ -0,0 +1,35 @@
+module Rolify
+  module Generators
+    class RolifyGenerator < Rails::Generators::NamedBase
+      Rails::Generators::ResourceHelpers
+      
+      source_root File.expand_path('../templates', __FILE__)
+      argument :user_cname, :type => :string, :default => "User"
+
+      namespace :rolify
+      hook_for :orm, :required => true
+
+      desc "Generates a model with the given NAME and a migration file."
+
+      def self.start(args, config)
+        user_cname = args.size > 1 ? args[1] : "User"
+        args.insert(1, user_cname) # 0 being the view name
+        super
+      end
+      
+      def inject_user_class
+        invoke "rolify:user", [ user_cname, class_name ], :orm => options.orm
+      end
+        
+      def copy_initializer_file
+        template "initializer.rb", "config/initializers/rolify.rb"
+      end
+      
+      def show_readme
+        if behavior == :invoke
+          readme "README"
+        end
+      end
+    end
+  end
+end

data/lib/generators/rolify/{role/templates → templates}/initializer.rb

@@ -1,6 +1,6 @@
-Rolify.configure<%= "(\"#{role_cname.camelize.to_s}\")" if role_cname != "Role" %> do |config|
+Rolify.configure<%= "(\"#{class_name.camelize.to_s}\")" if class_name != "Role" %> do |config|
   # By default ORM adapter is ActiveRecord. uncomment to use mongoid
-  <%= "# " if orm_adapter == "active_record" %>config.use_mongoid
+  <%= "# " if options.orm == :active_record || !options.orm %>config.use_mongoid
   
   # Dynamic shortcuts for User class (user.is_admin? like methods). Default is: false
   # Enable this feature _after_ running rake db:migrate as it relies on the roles table

data/lib/generators/rolify/templates/role-active_record.rb

@@ -0,0 +1,11 @@
+class <%= role_cname.camelize %> < ActiveRecord::Base
+<% if need_table_prefix?(role_cname) %>
+  def self.table_name_prefix
+    <%= table_prefix(role_cname) %>_
+  end
+<% end %>
+  has_and_belongs_to_many :<%= user_cname.tableize %>, :join_table => :<%= "#{table_name(user_cname, true)}_#{table_name(role_cname, true)}" %>
+  belongs_to :resource, :polymorphic => true
+  
+  scopify
+end

data/lib/generators/rolify/user_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators/migration'
+require 'active_support/core_ext'
+
+module Rolify
+  module Generators
+    class UserGenerator < Rails::Generators::NamedBase
+      argument :role_cname, :type => :string, :default => "Role"
+      class_option :orm, :type => :string, :default => "active_record"
+      
+      desc "Inject rolify method in the User class."
+
+      def inject_user_content
+        inject_into_file(model_path, :after => inject_rolify_method) do
+          "  rolify#{role_association}\n"
+        end
+      end
+      
+      def inject_rolify_method
+        if options.orm == :active_record
+          /class #{class_name.camelize}\n|class #{class_name.camelize} .*\n|class #{class_name.demodulize.camelize}\n|class #{class_name.demodulize.camelize} .*\n/
+        else
+          /include Mongoid::Document\n|include Mongoid::Document .*\n/
+        end
+      end
+      
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+      
+      def role_association
+        if role_cname != "Role"
+          " :role_cname => '#{role_cname.camelize}'"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/rolify/adapters/active_record/resource_adapter.rb

@@ -1,25 +1,25 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter   
+  module Adapter
     class ResourceAdapter < ResourceAdapterBase
       def resources_find(roles_table, relation, role_name)
-        resources = relation.joins("INNER JOIN #{quote(roles_table)} ON #{quote(roles_table)}.resource_type = '#{relation.to_s}' AND 
-                                    (#{quote(roles_table)}.resource_id IS NULL OR #{quote(roles_table)}.resource_id = #{quote(relation.table_name)}.id)")
+        resources = relation.joins("INNER JOIN #{quote(roles_table)} ON #{quote(roles_table)}.resource_type = '#{relation.to_s}' AND
+                                    (#{quote(roles_table)}.resource_id IS NULL OR #{quote(roles_table)}.resource_id = #{quote(relation.table_name)}.#{relation.primary_key})")
         resources = resources.where("#{quote(roles_table)}.name IN (?) AND #{quote(roles_table)}.resource_type = ?", Array(role_name), relation.to_s)
         resources
       end
 
       def in(relation, user, role_names)
         roles = user.roles.where(:name => role_names)
-        relation.where("#{quote(role_class.table_name)}.id IN (?) AND ((resource_id = #{quote(relation.table_name)}.id) OR (resource_id IS NULL))", roles)
+        relation.where("#{quote(role_class.table_name)}.#{role_class.primary_key} IN (?) AND ((resource_id = #{quote(relation.table_name)}.#{relation.primary_key}) OR (resource_id IS NULL))", roles)
       end
-      
+
       private
-      
+
       def quote(column)
          ActiveRecord::Base.connection.quote_column_name column
       end
     end
   end
-end
+end

data/lib/rolify/adapters/active_record/role_adapter.rb

@@ -1,7 +1,7 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter   
+  module Adapter
     class RoleAdapter < RoleAdapterBase
       def where(relation, *args)
         conditions, values = build_conditions(relation, args)
@@ -9,7 +9,7 @@ module Rolify
       end
 
       def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
-        role_class.find_or_create_by_name_and_resource_type_and_resource_id(role_name, resource_type, resource_id)
+        role_class.where(:name => role_name, :resource_type => resource_type, :resource_id => resource_id).first_or_create
       end
 
       def add(relation, role)
@@ -23,8 +23,8 @@ module Rolify
         roles = relation.roles.where(cond)
         if roles
           relation.roles.delete(roles)
-          roles.each do |role| 
-            role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty? 
+          roles.each do |role|
+            role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?
           end
         end
         roles
@@ -33,7 +33,7 @@ module Rolify
       def exists?(relation, column)
         relation.where("#{column} IS NOT NULL")
       end
-      
+
       def scope(relation, conditions)
         query = relation.scoped
         query = query.joins(:roles)
@@ -67,10 +67,10 @@ module Rolify
         values = [ role ]
         if resource
           query.insert(0, "(")
-          query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id IS NULL))" 
+          query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id IS NULL))"
           values << role << (resource.is_a?(Class) ? resource.to_s : resource.class.name)
           if !resource.is_a? Class
-            query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id = ?))" 
+            query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id = ?))"
             values << role << resource.class.name << resource.id
           end
           query += ")"
@@ -79,4 +79,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/configure.rb

@@ -45,7 +45,7 @@ module Rolify
       role_cnames = [ "Role" ] if role_cnames.empty?
       role_cnames.each do |role_cname|
         role_class = role_cname.constantize
-        if role_class.superclass == ActiveRecord && !role_class.table_exists?
+        if role_class.superclass.to_s == "ActiveRecord" && !role_class.table_exists?
           warn "[WARN] table '#{role_cname}' doesn't exist. Did you run the migration ? Ignoring rolify config."
           return false
         end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "3.3.0.rc2"
+  VERSION = "3.3.0.rc4"
 end

data/lib/rolify.rb

@@ -22,7 +22,7 @@ module Rolify
     join_table = "#{self.to_s.tableize.gsub(/\//, "_")}_#{self.role_table_name}"
     rolify_options = { :class_name => options[:role_cname].camelize }
     rolify_options.merge!({ :join_table => join_table }) if Rolify.orm == "active_record"
-    rolify_options.merge!(options.reject{ |k,v| ![:before_add, :after_add, :before_remove, :after_remove].include? k.to_sym }) if Rolify.orm == "active_record"
+    rolify_options.merge!(options.reject{ |k,v| ![ :before_add, :after_add, :before_remove, :after_remove ].include? k.to_sym })
 
     has_and_belongs_to_many :roles, rolify_options
 

data/rolify.gemspec

@@ -15,23 +15,16 @@ Gem::Specification.new do |s|
   s.rubyforge_project = s.name
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-    s.add_development_dependency "activerecord-jdbcsqlite3-adapter"
-  else
-    s.add_development_dependency "sqlite3"
-    s.add_development_dependency "bson_ext" if RUBY_VERSION < "2.0.0"
-  end
-  s.add_development_dependency "activerecord", ">= 3.1.0"
-  s.add_development_dependency "mongoid", ">= 3.0"
   s.add_development_dependency "ammeter"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", ">= 2.0"
   s.add_development_dependency "rspec-rails", ">= 2.0"
-  s.add_development_dependency "mongoid-rspec", ">= 1.5"
-  s.add_development_dependency "bundler" 
-  s.add_development_dependency "fuubar"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "fuubar" 
+  s.add_development_dependency "activerecord", ">= 3.2.0"
+  s.add_development_dependency "mongoid", ">= 3.1"
 end