third-prestige-rolify 3.3.0.rc5

data/Rakefile

@@ -0,0 +1,34 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'coveralls/rake/task'
+
+Bundler::GemHelper.install_tasks
+
+Coveralls::RakeTask.new
+
+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, 'coveralls:push' ]
+
+desc "Run all specs"
+task "spec" do
+  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

@@ -0,0 +1,44 @@
+= Upgrade instructions for Rolify library
+
+== From a previous rolify installation (1.x or 2.x)
+
+The easiest way is to re-run the generator using <tt>rails g Rolify:Role</tt> command, and overwrite the initializer file. Both the migration file and the <tt>role.rb</tt> haven't changed.
+In the <tt>config/initializers/rolify.rb</tt> file, here are the deprecated settings:
+* <tt>role_cname</tt>
+* <tt>user_cname</tt>
+By default, these settings were commented out, so you can safely remove them. 
+If you changed them, you can remove them in the initializer file too. <tt>user_cname</tt> is no longer used in 3.x, you don't need it anymore.
+Add your custom <tt>role_cname</tt> setting as argument of the rolify method you use in your User class. 
+For instance, if you use <tt>Privilege</tt> as <tt>Role</tt> class, you should add this to your whatever your <tt>User</tt> class is, let's say <tt>Client</tt> for the sake of example: 
+   class Client < ActiveRecord::Base
+     rolify :role_cname => "Privilege"
+   end
+If you use the default <tt>Role</tt> class name, you don't have to specify the <tt>:role_cname</tt> argument.
+
+If you use <i>dynamic methods</i> (<tt>user.is_admin?</tt> like methods), you should turn it on using <tt>use_dynamic_shortcuts</tt> method starting from rolify 3.0:
+   Rolify.configure do |c|
+      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,21 @@
+source "https://rubygems.org"
+
+case ENV["ADAPTER"]
+when nil, "active_record"
+  group :test do
+    gem "activerecord-jdbcsqlite3-adapter", ">= 1.3.0.rc", :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
+
+group :test do
+  gem 'coveralls', :require => false
+end
+
+gemspec :path => '../'

data/gemfiles/Gemfile.rails-4.0

@@ -0,0 +1,27 @@
+source "https://rubygems.org"
+
+case ENV["ADAPTER"]
+when nil, "active_record"
+  gem "activerecord", "~> 4.0.0.rc", :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.rc"
+  gem "ammeter"
+  gem "rake"
+  gem "rspec"
+  gem "rspec-rails"
+  gem "fuubar"
+  gem "bundler"
+  
+  gem "activerecord-jdbcsqlite3-adapter", "~> 1.3.0.beta", :platform => "jruby"
+  gem "sqlite3", :platform => "ruby"
+  gem "activerecord", "~> 4.0.0.rc", :require => "active_record"
+  gem "mongoid", :git => "git://github.com/mongoid/mongoid.git"
+  gem 'coveralls', :require => false
+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/README

@@ -0,0 +1,8 @@
+Now, you just have to run the migration using rake command:
+
+   rake db:migrate
+
+and you will be able to add the resourcify method inside all models you want 
+scoped by a role.
+
+===============================================================================

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.collection_name }
+      end
+    end
+  end
+end

data/lib/generators/mongoid/templates/README-mongoid

@@ -0,0 +1,4 @@
+Now, you are able to add the resourcify method inside all models you want 
+scoped by a role.
+
+===============================================================================

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/templates/README

@@ -0,0 +1,13 @@
+===============================================================================
+
+An initializer file has been created here: config/initializers/rolify.rb, you 
+can change rolify settings to match your needs. 
+Defaults values are commented out.
+
+A Role class has been created in app/models (with the name you gave as 
+argument otherwise the default is role.rb), you can add your own business logic 
+inside.
+
+Inside your User class (or the name you gave as argument otherwise the default 
+is user.rb), rolify method has been inserted to provide rolify methods.
+

data/lib/generators/rolify/templates/initializer.rb

@@ -0,0 +1,8 @@
+Rolify.configure<%= "(\"#{class_name.camelize.to_s}\")" if class_name != "Role" %> do |config|
+  # By default ORM adapter is ActiveRecord. uncomment to 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
+  # config.use_dynamic_shortcuts
+end

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/templates/role-mongoid.rb

@@ -0,0 +1,17 @@
+class <%= role_cname.camelize %>
+  include Mongoid::Document
+  
+  has_and_belongs_to_many :<%= user_cname.tableize %>
+  belongs_to :resource, :polymorphic => true
+  
+  field :name, :type => String
+
+  index({
+    :name => 1,
+    :resource_type => 1,
+    :resource_id => 1
+  },
+  { :unique => 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.rb

@@ -0,0 +1,57 @@
+require 'rolify/railtie' if defined?(Rails)
+require 'rolify/utils'
+require 'rolify/role'
+require 'rolify/configure'
+require 'rolify/dynamic'
+require 'rolify/resource'
+require 'rolify/adapters/base'
+
+module Rolify
+  extend Configure
+
+  attr_accessor :role_cname, :adapter, :role_join_table_name, :role_table_name
+
+  def rolify(options = {})
+    include Role
+    extend Dynamic if Rolify.dynamic_shortcuts
+
+    options.reverse_merge!({:role_cname => 'Role'})
+    self.role_cname = options[:role_cname]
+    self.role_table_name = self.role_cname.tableize.gsub(/\//, "_")
+
+    default_join_table = "#{self.to_s.tableize.gsub(/\//, "_")}_#{self.role_table_name}"
+    options.reverse_merge!({:role_join_table_name => default_join_table})
+    self.role_join_table_name = options[:role_join_table_name]
+
+    rolify_options = { :class_name => options[:role_cname].camelize }
+    rolify_options.merge!({ :join_table => self.role_join_table_name }) 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
+
+    self.adapter = Rolify::Adapter::Base.create("role_adapter", self.role_cname, self.name)
+    load_dynamic_methods if Rolify.dynamic_shortcuts
+  end
+
+  def resourcify(association_name = :roles, options = {})
+    include Resource
+
+    options.reverse_merge!({ :role_cname => 'Role', :dependent => :destroy })
+    resourcify_options = { :class_name => options[:role_cname].camelize, :as => :resource, :dependent => options[:dependent] }
+    self.role_cname = options[:role_cname]
+    self.role_table_name = self.role_cname.tableize.gsub(/\//, "_")
+
+    has_many association_name, resourcify_options
+
+    self.adapter = Rolify::Adapter::Base.create("resource_adapter", self.role_cname, self.name)
+  end
+
+  def scopify
+    require "rolify/adapters/#{Rolify.orm}/scopes.rb"
+    extend Rolify::Adapter::Scopes
+  end
+
+  def role_class
+    self.role_cname.constantize
+  end
+end