roles_mongo_mapper 0.1.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/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,62 @@
+# Roles for Mongo Mapper
+
+A *Mongo Mapper* 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_mongo_mapper</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 mongo_mapper:roles User --strategy admin_flag</code>
+
+Apply :admin_flag Role strategy to User model using default roles and extra role :author
+
+<code>$ rails g mongo_mapper: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 mongo_mapper: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,26 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roles_mongo_mapper"
+    gem.summary = %Q{Implementation of Roles generic API for MongoMapper}
+    gem.description = %Q{Makes it easy to set a role strategy on your User model in MongoMapper}
+    gem.email = "kmandrup@gmail.com"
+    gem.homepage = "http://github.com/kristianmandrup/roles_mongo_mapper"
+    gem.authors = ["Kristian Mandrup"]
+
+    gem.add_development_dependency "rspec",           "~> 2.0.0.beta.22"
+    gem.add_development_dependency 'generator-spec',  "~> 0.6.4"
+
+    gem.add_dependency "mongo_mapper",      '~> 0.8.4'
+    gem.add_dependency "activesupport",     '~> 3.0.0'
+    gem.add_dependency "require_all",       '~> 1.1.0'
+    gem.add_dependency "sugar-high",        '~> 0.2.10'
+    gem.add_dependency "roles_generic",     '~> 0.2.6'
+    gem.add_dependency 'logging_assist',    '~> 0.1.3'
+
+  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.1

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

@@ -0,0 +1,69 @@
+require 'rails3_artifactor'
+require 'logging_assist'
+
+module MongoMapper 
+  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
+        logger.add_logfile
+        logger.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 :mongo_mapper
+
+      include Rails3::Assist::BasicLogger
+
+      def orm
+        :mongo_mapper
+      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_mongo_mapper.rb

@@ -0,0 +1,8 @@
+require 'roles_generic'
+require 'require_all'    
+require 'set'
+require 'sugar-high/array'
+require 'mongo_mapper'
+require 'roles_mongo_mapper/namespaces'
+require 'roles_mongo_mapper/base'
+require 'roles_mongo_mapper/strategy'

data/lib/roles_mongo_mapper/base.rb

@@ -0,0 +1,34 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+module Roles::MongoMapper  
+  def self.included(base) 
+    base.extend Roles::Base
+    base.extend ClassMethods
+    base.orm_name = :mongo_mapper
+  end
+
+  module ClassMethods
+    
+    MAP = {
+      :admin_flag   => "key :admin_flag, 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   => "key :roles_mask,    Integer, :default => 1",
+      :role_string  => "key :role_string,   String",
+      :role_strings => "key :role_strings,  Array",
+      :roles_string => "key :roles_string,  String"
+    }
+    
+    def strategy name, options = nil
+      if options == :default && MAP[name]
+        instance_eval MAP[name] 
+      end
+
+      role_strategy name, options
+    end    
+  end
+end

data/lib/roles_mongo_mapper/namespaces.rb

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

data/lib/roles_mongo_mapper/role.rb

@@ -0,0 +1,31 @@
+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).save
+      end
+    end
+  end
+end
+
+class Role
+  include MongoMapper::Document
+  key :name, String
+
+  scope :by_name,  lambda { |name| where(:name => name.to_s) }
+  scope :by_names,  lambda { |*names| where(:name => names.to_strings) }
+
+
+  class << self
+    def find_roles(*role_names)
+      # return all(:name => role_names.to_strings)
+      by_names(*role_names).all
+    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?
+      by_name(role_name).first
+    end
+  end
+end  

data/lib/roles_mongo_mapper/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_mongo_mapper
+    end    
+  end
+end           
+

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

@@ -0,0 +1,69 @@
+module RoleStrategy::MongoMapper
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+      base.key :many_roles_ids, Array, :typecast => 'ObjectId'
+      base.many :many_roles, class_name: 'Role', :in => :many_roles_ids 
+      base.ensure_index :many_role_ids     
+    end
+
+    module ClassMethods  
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end       
+
+      def role_id_attribute
+        "#{role_attribute}_ids".to_sym
+      end       
+        
+      def in_role(role_name)
+        role = Role.find_role(role_name)
+        res = all(role_id_attribute => role.id)        
+      end
+
+      def in_roles(*role_names)                          
+        role_ids = Role.find_roles(role_names).map{|role| role.id}
+        all(role_id_attribute.in => role_ids)
+      end
+    end
+    
+    module Implementation
+      def role_id_attribute
+        "#{role_attribute}_ids".to_sym
+      end
+      
+      # assign roles
+      def roles=(*role_names)  
+        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(*role_names) 
+        self.send("#{role_attribute}=", role_relations)
+        save
+      end
+
+      def add_roles(*role_names)  
+        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(*role_names)
+        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_mongo_mapper/strategy/multi/role_strings.rb

@@ -0,0 +1,59 @@
+module RoleStrategy::MongoMapper
+  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_strings)
+        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