roles_active_record 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/.rspec

@@ -0,0 +1 @@
+--format nested --color

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gem "active_record",  ">= 3.0.0.rc"
+gem "active_support", ">= 3.0.0.rc"
+gem "meta_where",     ">= 0.6.0"
+
+group :test do
+  gem "rspec", ">= 2.0.0.beta.19" 
+  gem "yaml"
+  gem "logger"
+  gem 'database_cleaner'
+  gem "generator_spec", '>= 0.4.5'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Kristian Mandrup
+
+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.markdown

@@ -0,0 +1,178 @@
+# Roles for Active Record
+
+An Active Record implementation of [roles generic](http://github.com/kristianmandrup/roles_generic)
+
+## Install
+
+<code>gem install roles_active_record</code>
+
+## Update!
+
+Now implements the [roles generic](http://github.com/kristianmandrup/roles_generic) Roles API
+It also implements the following Role strategies:
+
+* admin_flag
+* many_roles
+* one_role
+* roles_mask
+* role_string
+
+## Rails generator
+
+Needs some more refactoring (see notes below!)
+
+<code>$ rails g active_record:roles User --strategy admin_flag --roles admin guest</code>
+
+## Usage
+
+Example: admin_flag Role strategy - generate migrations and model files
+
+<code>$ rails g active_record:roles User admin_flag</code>
+
+Example: admin_flag Role strategy - generate migrations only
+
+<code>$ rails g active_record:roles_migration User admin_flag</code>
+
+## Role strategies
+
+The library comes with the following role strategies built-in:
+
+Single role:
+
+* admin_flag
+* role_string
+* one_role  
+
+Multi role:
+
+* many_roles
+* roles_mask
+
+
+### Admin flag
+
+Boolean *admin_flag* on User to indicate if user role is admin or normal user 
+
+### Role string
+
+String *role_string* on User that names the role
+
+### One role
+
+*role_id* relation to *id* of *Roles* table that contain all valid roles  
+
+### Many roles
+
+*role_id* relation to *UserRoles* table that is the join table that joins a user to multiple roles in the *Roles* tables.
+
+### Roles mask
+
+*roles_mask* integer that as a bitmask indicating which roles out of a set of valid roles that the user has.
+
+Note: The following examples use RSpec to demonstrate usage scenarios.
+
+## Example : admin_flag
+
+<pre>use_roles_strategy :admin_flag
+
+class User < ActiveRecord::Base    
+  include Roles::ActiveRecord 
+    
+  strategy :admin_flag, :default
+  valid_roles_are :admin, :guest
+end
+</pre>
+
+## Example : role_string
+
+<pre>use_roles_strategy :role_string
+
+class User < ActiveRecord::Base
+  include Roles::ActiveRecord 
+  
+  strategy :role_string, :default
+  valid_roles_are :admin, :guest   
+end
+</pre>
+
+## Example : one_role
+
+<pre>use_roles_strategy :one_role
+class User < ActiveRecord::Base
+  include Roles::ActiveRecord 
+
+  strategy :one_role, :default
+  role_class :role
+
+  valid_roles_are :admin, :guest
+end
+</pre>
+    
+## Example : many_roles
+
+<pre>use_roles_strategy :many_roles
+class User < ActiveRecord::Base    
+  include Roles::ActiveRecord
+
+  strategy :many_roles, :default
+  role_class :role
+
+  valid_roles_are :admin, :guest
+end
+</pre>
+
+## Example : roles_mask
+
+<pre>use_roles_strategy :roles_mask
+
+class User < ActiveRecord::Base    
+  include Roles::ActiveRecord
+  
+  strategy :roles_mask, :default
+  valid_roles_are :admin, :guest   
+end
+
+</pre>
+
+## Rails generators
+
+The library comes with a Rails 3 generator that lets you populate a user model with a given role strategy 
+The following role strategies are included by default. Add your own by adding extra files inside the strategy folder, one file for each role strategy is recommended.
+
+* admin_flag
+* role_string
+* roles_mask
+* one_role
+* many_roles
+          
+_Important:_ 
+
+The generators are a bit rusty and needs to be updated to take advantage of the [rails3_artifactor](http://github.com/kristianmandrup/rails3_artifactor) 
+Please see the [roles mongoid](http://github.com/kristianmandrup/roles_mongoid) for an example. You are most welcome to submit a patch to make it work for AR ;) 
+
+### Generators
+
+* active_record:roles
+* active_record:roles_migration
+
+Example: admin_flag Role strategy - generate migrations and model files
+
+<code>$ rails g active_record:roles User admin_flag</code>
+
+Example: admin_flag Role strategy - generate migrations only
+
+<code>$ rails g active_record:roles_migration User admin_flag</code>
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. 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 when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2010 Kristian Mandrup. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roles_active_record"
+    gem.summary = %Q{Implementation of Roles generic API for Active Record}
+    gem.description = %Q{Makes it easy to set a role strategy on your User model in Active Record}
+    gem.email = "kmandrup@gmail.com"
+    gem.homepage = "http://github.com/kristianmandrup/roles_for_dm"
+    gem.authors = ["Kristian Mandrup"]
+    gem.add_development_dependency "rspec", "~> 2.0.0.beta.19" 
+    gem.add_development_dependency 'database_cleaner', '~> 0.5.2'
+    gem.add_development_dependency "generator-spec",  '~> 0.4.5'
+
+    gem.add_dependency "activerecord",    "~> 3.0.0"
+    gem.add_dependency "activesupport",   "~> 3.0.0"
+    gem.add_dependency "arel",            "~> 1.0.0"    
+    gem.add_dependency "meta_where",      ">= 0.5.2"
+    gem.add_dependency "sugar-high",      "~> 0.2.2"
+    gem.add_dependency "require_all",     '~> 1.1.0' 
+    gem.add_dependency "sugar-high",      '~> 0.2.3'        
+    gem.add_dependency "roles_generic",   '~> 0.2.2'            
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/generators/active_record/roles/roles_generator.rb

@@ -0,0 +1,46 @@
+module ActiveRecord 
+  module Generators
+    class RolesGenerator < Rails::Generators::NamedBase
+      desc "Generate roles model for User" 
+      
+      argument :role_strategy, :type => :string, :aliases => "-r", :default => 'inline_role', :desc => "Create roles model for user"
+
+      hook_for :orm
+            
+      def self.source_root
+        @source_root ||= File.expand_path("../../templates", __FILE__)
+      end
+
+      def apply_role_strategy   
+        insert_into_model('user', role_strategy_statement)
+      end 
+      
+      protected                  
+
+      def match_expr
+        /< (.+?)\w+\s/
+      end
+
+      def role_strategy_statement 
+        "role_strategy #{role_strategy}"        
+      end
+
+      def role_strategy
+        options[:role_strategy]                
+      end
+      
+      def model_file(name)                          
+        File.join(Rails.root, "app/models/#{name}.rb")        
+      end
+        
+      def insert_into_model(model_name, insert_text)
+        model_name = model_name.to_s
+        file = File.new(model_file(model_name))
+        return if (file.read =~ /#{insert_text}/) 
+        gsub_file model_file(model_name), match_expr do |match|
+          match << insert_text
+        end
+      end              
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/roles_migration_generator.rb

@@ -0,0 +1,54 @@
+# require 'generators/migration_helper'
+# require 'generators/role_migrations'
+# require 'auth_assistant/model/user_config'
+
+module ActiveRecord 
+  module Generators
+    class RolesMigrationGenerator < Rails::Generators::NamedBase 
+      include Rails::Generators::MigrationHelper        
+      include RSpec::Rails::App
+      
+      desc "Generates user role migrations" 
+
+      # name is the user model to generate roles for      
+
+      class_option :strategy, :type => :string, :aliases => "-s", :default => 'inline_role', 
+                   :desc => "Role strategy to use (admin_flag, role_string, one_role, many_roles, roles_mask)"
+
+      class_option :reverse, :type => :boolean, :alias => "-r", :default => false, :desc => "Create a remove migration for reversing a strategy"
+
+      def self.source_root
+        @source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def valid_strategy?
+        if ![:admin_flag, :role_string, :one_role, :many_roles, :roles_mask].include?(strategy.to_sym)
+          info "Unknown role strategy #{strategy}"
+          raise ArgumentError, "Unknown role strategy #{strategy}"
+        end
+      end
+
+      def run_migration    
+        migration_name = "add_#{strategy}_strategy"
+        target_migration_name = reverse? ? reverse_migration_name(migration_name) : migration_name
+        migration_template "#{migration_name}.erb", "db/migrations/#{target_migration_name}" 
+        generated_migration = latest_migration_file(migration_dir, target_migration_name)
+        reverse_migration!(generated_migration) if generated_migration && reverse?
+      end   
+      
+      protected                  
+       
+      def reverse?
+        options[:reverse]
+      end
+        
+      def table_name
+        name.tableize
+      end
+      
+      def strategy
+        options[:strategy]
+      end
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/templates/add_admin_flag_strategy.erb

@@ -0,0 +1,14 @@
+class AddAdminFlagStrategy < ActiveRecord::Migration
+
+  def self.up           
+    change_table :<%= table_name %> do |t|
+      t.boolean :admin_flag, :default => false
+    end
+  end
+
+  def self.down
+    change_table :<%= table_name %> do |t|
+      t.remove :admin_flag
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/templates/add_many_roles_strategy.erb

@@ -0,0 +1,40 @@
+class AddManyRolesStrategy < ActiveRecord::Migration
+  class << self
+
+    def up          
+      create_roles
+      create_user_roles
+    end
+
+    def down      
+      drop_roles
+      drop_user_roles
+    end
+
+    protected
+
+    def create_user_roles
+      create_table :<%= table_name.singularize %>_roles do |t|
+        t.integer :<%= table_name.singularize %>_id
+        t.integer :role_id
+        t.timestamps
+      end
+    end
+
+    def drop_user_roles
+      drop_table :<%= table_name.singularize %>_roles
+    end
+
+
+    def create_roles
+      create_table :roles do |t|
+        t.string  :name
+        t.timestamps
+      end
+    end
+
+    def drop_roles
+      drop_table :roles
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/templates/add_one_role_strategy.erb

@@ -0,0 +1,40 @@
+class AddOneRoleStrategy < ActiveRecord::Migration
+  class << self
+
+    def up          
+      create_roles
+      add_user_role
+    end
+
+    def down      
+      drop_roles
+      remove_user_role
+    end
+
+    protected
+
+    def add_user_role
+      change_table :<%= table_name %> do |t|
+        t.integer :role_id
+      end
+    end
+
+    def remove_user_role
+      change_table :<%= table_name %> do |t|
+        t.remove :role_id
+      end
+    end
+
+
+    def create_roles
+      create_table :roles do |t|
+        t.string  :name
+        t.timestamps
+      end
+    end
+
+    def drop_roles
+      drop_table :roles
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/templates/add_role_string_strategy.erb

@@ -0,0 +1,13 @@
+class AddRoleStringStrategy < ActiveRecord::Migration
+  def self.up           
+    change_table :<%= table_name %> do |t|
+      t.string :role, :default => 'guest'
+    end
+  end
+
+  def self.down
+    change_table :<%= table_name %> do |t|
+      t.remove :role
+    end
+  end
+end

data/lib/generators/active_record/roles_migration/templates/add_roles_mask_to_users_migration.erb

@@ -0,0 +1,13 @@
+class AddRolesMaskStrategy < ActiveRecord::Migration
+  def self.up           
+    change_table :<%= table_name %> do |t|
+      t.integer :roles_mask, :default => 1
+    end
+  end
+
+  def self.down
+    change_table :<%= table_name %> do |t|
+      t.remove :roles_mask
+    end
+  end
+end

data/lib/generators/active_record/setup/setup_generator.rb

@@ -0,0 +1,40 @@
+require 'generators/migration_helper'
+require 'generators/role_migrations'
+require 'auth_assistant/model/user_config'
+
+module AuthAssistant 
+  module Generators
+    class SetupGenerator < Rails::Generators::NamedBase
+      desc "Sets up Devise Users and creates Role migrations" 
+
+      class_option :devise, :type => :boolean, :aliases => "-d", :default => false,
+                                     :desc => "Initialize devise."
+
+      class_option :admin, :type => :boolean, :aliases => "-a", :default => false,
+                                    :desc => "Create admin user."
+
+
+      class_option :migration, :type => :boolean, :aliases => "-m", :default => true,
+                                     :desc => "To generate a user role migration."
+           
+      hook_for :orm
+            
+      def self.source_root
+        @source_root ||= File.expand_path("../../templates", __FILE__)
+      end
+
+      def run_migration
+        clear_relations :user        
+        return nil if !options[:migration]                 
+        clazz = AuthAssist::RoleMigrations.clazz(name)
+        mig_obj = clazz.new(self)
+        mig_obj.run_migration if mig_obj.respond_to? :run_migration
+        mig_obj.configure if mig_obj.respond_to? :configure
+      end   
+      
+      protected                  
+        include ::AuthAssist::MigrationHelper
+        include ::AuthAssist::RoleMigrations      
+    end
+  end
+end

data/lib/roles_active_record/base.rb

@@ -0,0 +1,19 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+module Roles::ActiveRecord  
+  def self.included(base) 
+    base.extend Roles::Base
+    base.extend ClassMethods
+    base.orm_name = :active_record
+  end
+
+  module ClassMethods      
+    def strategy name, options=nil
+      role_strategy name, options
+    end    
+  end
+end

data/lib/roles_active_record/namespaces.rb

@@ -0,0 +1,12 @@
+require 'sugar-high/module'
+
+module Roles
+  modules :active_record do
+    nested_modules :user, :role
+  end
+  modules :base, :strategy
+end   
+
+module RoleStrategy
+  modules :active_record
+end

data/lib/roles_active_record/role.rb

@@ -0,0 +1,24 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+    if role_class_name
+      role_list.each do |name|
+        res = role_class_name.create(:name => name.to_s)        
+      end
+    end
+  end
+end
+
+class Role < ActiveRecord::Base
+  class << self
+    def find_roles(*role_names) 
+      where(:name.in => role_names.flatten)
+    end
+
+    def find_role role_name
+      raise ArgumentError, "#find_role takes a single role name as argument, not: #{role_name.inspect}" if !role_name.kind_of_label?
+      res = find_roles(role_name)
+      res ? res.first : res
+    end
+  end
+end  

data/lib/roles_active_record/strategy/multi/many_roles.rb

@@ -0,0 +1,70 @@
+class Role < ActiveRecord::Base  
+  scope :named, lambda{|role_names| where(:name.in => role_names.flatten)}  
+  has_many :users, :through => :user_roles
+  has_many :user_roles      
+end  
+
+class UserRole < ActiveRecord::Base  
+  belongs_to :user
+  belongs_to :role
+end  
+
+module RoleStrategy::ActiveRecord
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods            
+      base.has_many :many_roles, :through => :user_roles, :source => :role
+      base.has_many :user_roles    
+    end
+
+    module ClassMethods    
+      def in_role(role_name)                          
+        in_roles(role_name)
+      end
+
+      def in_roles(*role_names)                          
+        joins(:many_roles) & Role.named(role_names)
+      end
+    end
+    
+    module Implementation
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end 
+      
+      # assign roles
+      def roles=(*roles)  
+        raise "Role class #{role_class} does not have a #find_role(role) method" if !role_class.respond_to? :find_role
+        role_relations = role_class.find_roles(*roles) 
+        self.send("#{role_attribute}=", role_relations)
+        save
+      end
+
+      def add_roles(*roles)  
+        raise "Role class #{role_class} does not have a #find_role(role) method" if !role_class.respond_to? :find_role
+        role_relations = role_class.find_roles(*roles)
+        puts "role_relations: #{role_relations.inspect}"
+        self.send(role_attribute) << role_relations
+        save
+      end
+
+      # query assigned roles
+      def roles
+        self.send(role_attribute)
+      end
+
+      def roles_list     
+        [roles].flatten.map{|r| r.name }.compact.to_symbols
+      end
+    end 
+    
+    extend Roles::Generic::User::Configuration
+    configure :type => :role_class    
+  end
+end
+