roles_mongoid 0.2.4

data/.bundle/config

@@ -0,0 +1,2 @@
+--- 
+BUNDLE_DISABLE_SHARED_GEMS: "1"

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,15 @@
+source :rubygems
+source 'http://gems.github.com/'
+
+group :default do
+  gem "mongoid",           '~> 2.0.0.beta.18'
+  gem 'bson',              '~> 1.0.7'
+  gem "activesupport",     '~> 3.0.0'
+  gem "require_all",       '~> 1.2.0' 
+  gem "sugar-high",        '~> 0.2.10'        
+  gem "roles_generic",     '~> 0.2.6'        
+end
+
+group :test do
+  gem "rspec", '~> 2.0.0.beta.22'
+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,59 @@
+# Roles for Mongoid
+
+A Mongoid implementation of [roles generic](http://github.com/kristianmandrup/roles_generic)
+
+## Intro
+
+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
+* role_strings
+
+# Install
+
+<code>gem install roles_mongoid</code>
+
+## Rails generator
+
+The library comes with a Rails 3 generator that lets you populate a user model with a role strategy of your choice. 
+
+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
+* many_roles
+* one_role
+* roles_mask
+* role_string
+* role_strings
+
+*Roles generator*
+
+Apply :admin_flag Role strategy to User model using default roles :admin and :guest (default)
+
+<code>$ rails g mongoid:roles User --strategy admin_flag</code>
+
+Apply :admin_flag Role strategy to User model using default roles and extra role :author
+
+<code>$ rails g mongoid:roles_migration User --strategy admin_flag --roles author</code>
+
+Apply :one_role Role strategy to User model without default roles, only with roles :user, :special and :editor
+
+<code>$ rails g mongoid:roles_migration User --strategy one_role --roles user special editor --no-default-roles</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,24 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roles_mongoid"
+    gem.summary = %Q{Implementation of Roles generic API for Mongoid}
+    gem.description = %Q{Makes it easy to set a role strategy on your User model in Mongoid}
+    gem.email = "kmandrup@gmail.com"
+    gem.homepage = "http://github.com/kristianmandrup/roles_mongoid"
+    gem.authors = ["Kristian Mandrup"]
+    gem.add_development_dependency "rspec", '~> 2.0.0.beta.22'
+
+    gem.add_dependency "mongoid",           '~> 2.0.0.beta.18'
+    gem.add_dependency 'bson',              '~> 1.0.7'
+    gem.add_dependency "activesupport",     '~> 3.0.0'
+    gem.add_dependency "require_all",       '~> 1.2.0' 
+    gem.add_dependency "sugar-high",        '~> 0.2.11'        
+    gem.add_dependency "roles_generic",     '~> 0.2.7'        
+
+  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.2.4

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

@@ -0,0 +1,68 @@
+require 'rails3_artifactor'
+require 'logging_assist'
+
+module Mongoid 
+  module Generators
+    class RolesGenerator < Rails::Generators::NamedBase      
+      desc "Add role strategy to a model" 
+      
+      class_option :strategy, :type => :string, :aliases => "-s", :default => 'role_string', 
+                   :desc => "Role strategy to use (admin_flag, role_string, roles_string, role_strings, one_role, many_roles, roles_mask)"
+
+
+      class_option :roles, :type => :array, :aliases => "-r", :default => [], :desc => "Valid roles"
+
+      def apply_role_strategy
+        log.add_logfile
+        log.debug "apply_role_strategy for : #{strategy} in model #{name}"
+        insert_into_model name do
+          insertion_text
+        end
+      end 
+      
+      protected                  
+
+      extend Rails3::Assist::UseMacro
+      use_orm :mongoid
+      include Rails::Assist::BasicLogging
+
+      def orm
+        :mongoid
+      end
+
+      def default_roles
+        [:admin, :guest]        
+      end
+
+      def roles_to_add
+        @roles_to_add ||= default_roles.concat(options[:roles]).to_symbols.uniq
+      end
+
+      def roles        
+        roles_to_add.map{|r| ":#{r}" }
+      end
+
+      def role_strategy_statement 
+        "strategy :#{strategy}, :default\n#{role_class_stmt}"
+      end
+
+      def role_class_stmt
+        "  role_class :role" if [:one_role, :many_roles].include? (strategy.to_sym)
+      end
+
+      def roles_statement
+        roles ? "valid_roles_are #{roles.join(', ')}" : ''
+      end
+
+      def insertion_text
+        %Q{include Roles::#{orm.to_s.camelize} 
+  #{role_strategy_statement}
+  #{roles_statement}}
+      end
+
+      def strategy
+        options[:strategy]                
+      end
+    end
+  end
+end

data/lib/roles_mongoid/base.rb

@@ -0,0 +1,35 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+module Roles
+  module Mongoid  
+    def self.included(base) 
+      base.extend Roles::Base
+      base.extend ClassMethods
+      base.orm_name = :mongoid
+    end
+
+    module ClassMethods
+      
+      MAP = {
+        :admin_flag   => "field :admin_flag, :type => Boolean",
+        :many_roles   => "references_many :many_roles, :stored_as => :array, :class_name => 'Role', :default => []",
+        :one_role     => "references_one :one_role, :class_name => 'Role'",
+        :roles_mask   => "field :roles_mask, :type => Integer, :default => 1",
+        :role_string  => "field :role_string, :type => String",
+        :role_strings => "field :role_strings, :type => Array",
+        :roles_string => "field :roles_string, :type => String"
+      }
+      
+      def strategy name, options=nil
+        if options == :default && MAP[name]
+          instance_eval MAP[name] 
+        end
+        role_strategy name, options
+      end    
+    end
+  end
+end

data/lib/roles_mongoid/namespaces.rb

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

data/lib/roles_mongoid/role.rb

@@ -0,0 +1,28 @@
+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|
+        role_class_name.create(:name => name.to_s)
+      end
+    end
+  end
+end
+
+class Role
+  include Mongoid::Document
+  field :name, :type => String
+  referenced_in :user
+
+  class << self
+    def find_roles(*role_names)
+      where(:name.in => role_names.flatten).to_a
+    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_mongoid/strategy/multi/many_roles.rb

@@ -0,0 +1,67 @@
+module RoleStrategy::Mongoid
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods  
+      def role_attribute
+        "#{strategy_class.roles_attribute_name.to_s.singularize}_ids".to_sym
+      end       
+        
+      def in_role(role_name)  
+        in_roles(role_name)
+      end
+
+      def in_roles(*role_names)
+        begin           
+          role_ids = Role.where(:name.in => role_names.to_strings).to_a.map(&:_id)
+          criteria.in(role_attribute => role_ids).to_a      
+        rescue
+          return []
+        end
+      end  
+    end
+    
+    module Implementation
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end 
+      
+      # assign roles
+      def roles=(*_roles) 
+        _roles = get_roles(_roles)
+        return nil if roles.none?                
+        
+        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)
+        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
+

data/lib/roles_mongoid/strategy/multi/role_strings.rb

@@ -0,0 +1,59 @@
+module RoleStrategy::Mongoid
+  module RoleStrings    
+    def self.default_role_attribute
+      :role_strings
+    end    
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end 
+
+      def in_role(role_name)  
+        in_roles(role_name)
+      end
+
+      def in_roles(*role_names)
+        begin
+          where(role_attribute.in => role_names).to_a      
+        rescue
+          return []
+        end
+      end  
+    end
+    
+    module Implementation 
+      # assign roles
+      def roles=(*new_roles)
+        new_roles = new_roles.flatten.map{|r| r.to_s if valid_role?(r)}.compact
+        if new_roles && new_roles.not.empty?
+          self.send("#{role_attribute}=", new_roles.compact.uniq) 
+        end
+      end
+      alias_method :role=, :roles=
+
+      def add_roles(*roles_to_add)
+        roles_to_add = roles_to_add.flatten.map{|r| r.to_s if valid_role?(r)}.compact
+        if new_roles && new_roles.not.empty?
+          self.send(role_attribute) << new_roles.compact.uniq
+        end
+      end
+
+      # query assigned roles
+      def roles
+        self.send(role_attribute).map{|r| r.to_sym}
+      end
+      
+      def roles_list     
+        [roles].flatten
+      end      
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure            
+  end
+end

data/lib/roles_mongoid/strategy/multi/roles_mask.rb

@@ -0,0 +1,81 @@
+module RoleStrategy::Mongoid
+  module RolesMask
+    def self.default_role_attribute
+      :roles_mask
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end 
+
+      def in_role(role)     
+        mask = calc_index(role.to_s)
+        all.select do |user| 
+          (user.send(role_attribute) & mask) > 0
+        end
+      end    
+
+      def in_roles(*roles)
+        all.select do |user| 
+          roles.flatten.any? do |role|
+            mask = calc_index(role.to_s)
+            (user.send(role_attribute) & mask) > 0
+          end
+        end
+      end    
+  
+      def calc_index(r)
+        2**strategy_class.valid_roles.index(r.to_sym)
+      end 
+    end
+
+    module Implementation 
+      class Roles < ::Set # :nodoc:
+        attr_reader :model_instance
+
+        def initialize(sender, *roles)
+          super(*roles)
+          @model_instance = sender
+        end
+
+        def <<(role)
+          model_instance.roles = super.to_a
+          self
+        end
+      end
+
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end 
+
+      # assign roles
+      def roles=(*roles)
+        self.send("#{role_attribute}=", (roles.flatten.map { |r| r.to_sym } & strategy_class.valid_roles).map { |r| calc_index(r) }.inject { |sum, bitvalue| sum + bitvalue })
+      end
+      alias_method :role=, :roles=
+      
+      # query assigned roles
+      def roles
+        strategy_class::Roles.new(self, strategy_class.valid_roles.reject { |r| ((self.send(role_attribute) || 0) & calc_index(r)).zero? })
+      end
+
+      def roles_list
+        roles.to_a
+      end        
+
+      protected
+
+      def calc_index(r)
+        2**strategy_class.valid_roles.index(r)
+      end
+    end    
+    
+    extend Roles::Generic::User::Configuration
+    configure            
+  end
+end

data/lib/roles_mongoid/strategy/single/admin_flag.rb

@@ -0,0 +1,53 @@
+module RoleStrategy::Mongoid
+  module AdminFlag    
+    def self.default_role_attribute
+      :admin_flag
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods 
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end
+           
+      def in_role(role_name) 
+        case role_name.downcase.to_sym
+        when :admin
+          where(role_attribute => true)
+        else
+          where(role_attribute => false)
+        end          
+      end
+    end
+
+    module Implementation
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end
+          
+      # assign roles
+      def roles=(*new_roles)                                 
+        first_role = new_roles.flatten.first
+        if valid_role?(first_role)
+          self.send("#{role_attribute}=", new_roles.flatten.first.admin?) 
+        else
+          raise ArgumentError, "The role #{first_role} is not a valid role"
+        end
+      end
+
+      # query assigned roles
+      def roles
+        role = self.send(role_attribute) ? strategy_class.admin_role_key : strategy_class.default_role_key
+        [role]
+      end
+      alias_method :roles_list, :roles
+
+    end # Implementation
+    
+    extend Roles::Generic::User::Configuration
+    configure :num => :single
+  end   
+end

data/lib/roles_mongoid/strategy/single/one_role.rb

@@ -0,0 +1,57 @@
+module RoleStrategy::Mongoid
+  module OneRole
+    def self.default_role_attribute
+      :one_role
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods 
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end       
+         
+      def in_role(role_name)  
+        in_roles(role_name)
+      end
+
+      def in_roles(*role_names)
+        begin
+          role_ids = Role.where(:name.in => role_names.to_strings).to_a.map(&:user_id)
+          where(:_id.in => role_ids)
+        rescue 
+          return []
+        end
+      end  
+    end
+
+    module Implementation      
+      # assign roles
+      def roles=(*_roles) 
+        _roles = get_roles(_roles)
+        return nil if _roles.none?                
+                
+        role_relation = role_class.find_role(_roles.first)  
+        self.send("#{role_attribute}=", role_relation)
+        one_role.save
+      end
+      alias_method :role=, :roles=
+      
+      # query assigned roles
+      def roles
+        role = self.send(role_attribute)
+        role ? [role.name.to_sym] : []
+      end
+      
+      def roles_list
+        self.roles.to_a
+      end      
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure :num => :single, :type => :role_class    
+  end  
+end

data/lib/roles_mongoid/strategy/single/role_string.rb

@@ -0,0 +1,51 @@
+module RoleStrategy::Mongoid
+  module RoleString    
+    def self.default_role_attribute
+      :role_string
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end 
+
+      def in_role(role_name) 
+        where(role_attribute => role_name)
+      end
+    end
+
+    
+    module Implementation 
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end 
+                  
+      # assign roles
+      def roles=(*roles)
+        self.role = roles.select_labels.first.to_s
+      end 
+      
+      def role= role_name
+        if role_name.kind_of_label? && valid_role?(role_name)
+          self.send("#{role_attribute}=", role_name.to_s) 
+        end        
+      end
+
+      # query assigned roles
+      def roles
+        role = self.send(role_attribute)
+        [role.to_sym]
+      end
+      alias_method :roles_list, :roles
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure :num => :single
+  end
+end
+
+

data/lib/roles_mongoid/strategy.rb

@@ -0,0 +1,15 @@
+require 'sugar-high/file'
+require 'sugar-high/array'
+
+module Roles::Strategy
+  class << self    
+    def role_dir
+      File.dirname(__FILE__)
+    end    
+
+    def gem_name
+      :roles_mongoid
+    end    
+  end
+end           
+