roles_mongoid_zhd 0.4.8

data/.bundle/config

@@ -0,0 +1,2 @@
+--- {}
+

data/.document

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

data/.rspec

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

data/Gemfile

@@ -0,0 +1,17 @@
+source :rubygems
+source 'http://gems.github.com/'
+
+# group :default do
+#   gem "mongoid",           '~> 2.0.0.rc.5'
+#   gem 'bson',              '>= 1.1.5'
+#   gem "activesupport",     '~> 3.0.3'
+#   gem "require_all",       '~> 1.2.0' 
+#   gem "sugar-high",        '>= 0.3.5'        
+#   gem "roles_generic",     '>= 0.3.8'        
+#   # gem 'logging_assist',    '>= 0.2.1'  
+# end
+# 
+# group :test do
+#   gem 'rspec',            '>= 2.4.0'
+#   gem 'generator-spec',   '>= 0.7.0'
+# 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.textile

@@ -0,0 +1,99 @@
+h1.fork info
+
+Update Mongoid to 2.0.2 support.
+
+h1. Roles for Mongoid
+
+A Mongoid implementation of [Roles Generic](http://github.com/kristianmandrup/roles_generic). 
+See the Roles [wiki](http://github.com/kristianmandrup/roles_generic/wiki) for an overview of the API and how to use it.
+
+h2. Role strategies
+
+Role strategies implemented:
+
+Inline attribute on User
+
+* admin_flag
+* roles_mask
+* role_string
+* role_strings
+
+Reference Role
+
+* many_roles
+* one_role
+
+Embedded Role
+
+* embed_many_roles
+* embed_one_role
+
+h2. Install
+
+<code>gem install roles_mongoid</code>
+
+h3. Install in Rails app
+
+Insert in Gemfile:
+
+<code>gem 'roles_mongoid'</code>
+
+Run <code>$ bundle install</code> from terminal
+
+Alternatively install using [Cream](http://github.com/kristianmandrup/cream)
+
+h2. Strategy and roles configuration
+
+Example: _role_string_ strategy
+
+<pre>class User
+  include Mongoid::Document  
+  include Roles::Mongoid 
+
+  strategy :one_role
+  valid_roles_are :admin, :guest, :user
+end  
+</pre>
+
+Example: _one_role_ strategy
+
+<pre>class User
+  include Mongoid::Document  
+  include Roles::Mongoid 
+
+  strategy :one_role
+  valid_roles_are :admin, :guest, :user
+end  
+</pre>
+
+h2. Rails generators
+
+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.
+
+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> 
+
+h2. 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.
+
+h2. 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_mongoid_zhd"
+    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 = "blackanger.z@gmail.com"
+    gem.homepage = "https://github.com/ZhangHanDong/roles_mongoid"
+    gem.authors = ["ZhangHanDong"]
+    gem.add_development_dependency 'rspec',             '>= 2.4.1'
+    gem.add_development_dependency 'generator-spec',    '>= 0.7.3'
+
+    gem.add_dependency 'mongoid',           '>= 2.0.2'
+    gem.add_dependency 'bson',              '>= 1.3.1'
+
+    gem.add_dependency 'sugar-high',        '~> 0.4.0'
+    gem.add_dependency 'require_all',       '~> 1.2.0'
+    gem.add_dependency "roles_generic",     '~> 0.3.8'
+    
+    gem.add_dependency 'rails_artifactor',  '>= 0.3.5'
+  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.0.0

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

@@ -0,0 +1,11 @@
+class String
+  def as_filename
+    self.underscore  
+  end
+end
+
+class Symbol
+  def as_filename
+    self.to_s.underscore  
+  end
+end

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

@@ -0,0 +1,173 @@
+require 'rails_artifactor'
+require 'generators/mongoid/roles/core_ext'
+
+module Mongoid 
+  module Generators
+    class RolesGenerator < Rails::Generators::Base      
+      desc "Add role strategy to a Mongoid User model" 
+
+      argument     :user_class,   :type => :string,   :default => 'User',                     :desc => "User class name"
+      
+      class_option :strategy,     :type => :string,   :aliases => "-s",   :default => 'role_string', 
+                   :desc => "Role strategy to use (admin_flag, role_string, roles_string, role_strings, roles_mask, one_role, many_roles, embed_one_role, embed_many_roles)"
+
+      class_option :roles,        :type => :array,    :aliases => "-r",   :default => [],     :desc => "Valid roles"
+      class_option :role_class,   :type => :string,   :aliases => "-rc",  :default => 'Role', :desc => "Role class name"
+
+      class_option :logfile,      :type => :string,   :aliases => "-l",   :default => nil,    :desc => "Logfile location"
+
+      source_root File.dirname(__FILE__) + '/templates'
+
+      def apply_role_strategy
+        if logfile?
+          require 'logging_assist'
+          
+          class_eval do
+            send :include, RailsAssist::BasicLogger
+          end
+          
+          logger.add_logfile :logfile => logfile if logfile
+          debug "apply_role_strategy for : #{strategy} in model #{user_file}"
+        end
+
+        if !valid_strategy?
+          error "Strategy #{strategy} is not currently supported, please try one of #{valid_strategies.join(', ')}"
+        end
+
+        if !has_model_file?(user_file)
+          error "User model #{user_file} not found"
+          return 
+        end
+
+        if !is_mongoid_model?(user_file)
+          error "User model #{user_file} is not a Mongoid Document"
+          return 
+        end
+        
+        begin 
+          debug "Trying to insert roles code into #{user_file}"
+
+          insert_into_model user_file, :after => /include Mongoid::\w+/ do
+            insertion_text
+          end     
+        rescue Exception => e
+          error "Error: #{e.message}" if logger
+        end
+        
+        copy_role_class if role_class_strategy?
+      end 
+      
+      protected                  
+
+      def logger
+        nil
+      end
+
+      def debug msg
+        logger.debug msg if logger
+      end
+
+      def info msg
+        logger.info msg if logger
+      end
+
+      def error msg
+        logger.error msg if logger
+      end
+
+      
+      extend RailsAssist::UseMacro
+
+      use_orm :mongoid
+
+      def user_file
+        user_class.as_filename
+      end
+
+      def role_file
+        role_class.as_filename
+      end
+
+      def is_mongoid_model? name
+        read_model(name) =~ /include Mongoid::\w+/
+      end
+
+      def valid_strategy?
+        valid_strategies.include? strategy.to_sym
+      end
+
+      def valid_strategies
+        [:admin_flag, :one_role, :embed_one_role, :role_string, :embed_many_roles, :many_roles, :role_strings, :roles_mask]
+      end
+
+      def logfile?
+        logfile
+      end
+
+      def logfile
+        options[:logfile]
+      end
+
+      def orm
+        :mongoid
+      end
+
+      def orm_class
+        orm.to_s.camelize 
+      end
+
+      def default_roles
+        [:admin, :guest]        
+      end
+
+      def copy_role_class
+        debug "generating role model: #{role_file}"
+        template 'role.rb', "app/models/#{role_file}.rb"
+      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} #{strategy_option_arg}"
+      end
+
+      def strategy_option_arg
+        return ", :role_class => '#{role_class}'" if role_class_strategy? && role_class.to_s != 'Role'
+        ''
+      end
+
+      def role_class_strategy?
+        [:one_role, :many_roles, :embed_one_role, :embed_many_roles].include? strategy.to_sym
+      end
+
+      def valid_roles_statement
+        return '' if has_valid_roles_statement?
+        roles ? "valid_roles_are #{roles.join(', ')}" : ''
+      end
+
+      def has_valid_roles_statement? 
+        !(read_model(user_class) =~ /valid_roles_are/).nil?
+      end
+
+      def insertion_text
+        %Q{include Roles::#{orm_class} 
+  #{role_strategy_statement}
+  #{valid_roles_statement}}
+      end
+
+      def role_class
+        options[:role_class].classify || 'Role'
+      end
+
+      def strategy
+        options[:strategy]                
+      end
+    end
+  end
+end

data/lib/generators/mongoid/roles/templates/role.rb

@@ -0,0 +1,8 @@
+class <%= role_class %>
+  include Mongoid::Document
+  field :name, :type => String
+
+  validates_uniqueness_of :name
+
+  extend RoleClass::ClassMethods
+end  

data/lib/roles_mongoid.rb

@@ -0,0 +1,10 @@
+require 'roles_generic'
+require 'require_all'    
+require 'set'
+require 'sugar-high/array'
+require 'sugar-high/kind_of'
+require 'mongoid'
+require 'bson'
+require 'roles_mongoid/namespaces'
+require 'roles_mongoid/base'
+require 'roles_mongoid/strategy'

data/lib/roles_mongoid/base.rb

@@ -0,0 +1,91 @@
+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_old   => "references_many :many_roles, :stored_as => :array, :class_name => 'Role'",
+        :many_roles       => "references_and_referenced_in_many :many_roles, :class_name => 'Role'",
+        :one_role         => "referenced_in :one_role, :class_name => 'Role'",
+
+        :embed_many_roles   => "embeds_many :many_roles, :class_name => 'Role'",
+        :embed_one_role     => "embeds_one :one_role, :class_name => 'Role'",
+
+        :roles_mask   => "field :roles_mask, :type => Integer, :default => 0",
+        :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 = {}
+        strategy_name = name.to_sym
+        raise ArgumentError, "Unknown role strategy #{strategy_name}" if !MAP.keys.include? strategy_name
+        use_roles_strategy strategy_name
+
+        set_role_class(strategy_name, options) if strategies_with_role_class.include? strategy_name
+        
+        if default_options?(options) && MAP[strategy_name]
+          instance_eval statement(MAP[strategy_name])
+        end       
+
+        case name
+        when :embed_one_role
+          raise ArgumentError, "#strategy class method must take :role_class option when using an embedded role strategy" if !@role_class_name
+          @role_class_name.embedded_in :user, :inverse_of => :one_role
+        when :embed_many_roles
+          raise ArgumentError, "#strategy class method must take :role_class option when using an embedded role strategy" if !@role_class_name
+          @role_class_name.embedded_in :user, :inverse_of => :many_roles
+        end
+
+        set_role_strategy strategy_name, options
+      end    
+
+      private
+
+      def set_role_class strategy_name, options = {}
+        @role_class_name = !options.kind_of?(Symbol) ? get_role_class(strategy_name, options) : default_role_class(strategy_name)
+      end
+
+      def default_options? options = {}
+        return true if options == :default                           
+        if options.kind_of? Hash
+          return true # if options[:config] == :default || options == {} 
+        end
+        false
+      end
+
+      def statement code_str
+        code_str.gsub /Role/, @role_class_name.to_s
+      end
+
+      def default_role_class strategy_name
+        if defined? ::Role
+          require "roles_mongoid/role"
+          return ::Role 
+        end
+        raise "Default Role class not defined"
+      end
+
+      def strategies_with_role_class
+        [:one_role, :embed_one_role, :many_roles,:embed_many_roles]
+      end 
+
+      def get_role_class strategy_name, options
+        options[:role_class] ? options[:role_class].to_s.camelize.constantize : default_role_class(strategy_name)
+      end      
+    end
+  end
+end