roles_data_mapper 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/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 Data Mapper
+
+A Data Mapper implementation of [roles generic](http://github.com/kristianmandrup/roles_generic)
+
+## 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
+
+See [roles_active_record](http://github.com/kristianmandrup/roles_active_record) and [roles generic](http://github.com/kristianmandrup/roles_generic) for more info on using the API.
+
+## Install
+
+<code>gem install roles_data_mapper</code>
+
+To install from cloned repo:
+
+This gem is based on Jeweler, so simply:
+
+<code>rake install</code>
+
+## Rails generator
+
+_Note_:
+
+*The Rails generator is a bit "rusty" and hasn't been tested with the latest changes. I hope to update it soon.*
+
+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
+* inline_role
+* inline_roles
+* role_relations
+* role_mask
+
+Example:
+
+<code>$ rails g data_mapper:roles User --strategy 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,27 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roles_data_mapper"
+    gem.summary = %Q{Implementation of Roles generic API for DataMapper}
+    gem.description = %Q{Makes it easy to set a role strategy on your User model in DataMapper}
+    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_dependency "dm-core",       "~> 1.0"
+    gem.add_dependency "dm-types",      "~> 1.0"
+    gem.add_dependency "dm-migrations", "~> 1.0"
+
+    gem.add_dependency "activesupport",    "~> 3.0.0"
+    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/data_mapper/roles/roles_generator.rb

@@ -0,0 +1,74 @@
+require 'rails3_artifactor'
+require 'logging_assist'
+
+puts "Included!"
+
+module DataMapper 
+  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}"
+        begin
+          insert_into_model name do
+            insertion_text
+          end
+        rescue
+          say "Model #{name} not found"
+        end
+      end 
+      
+      protected                  
+
+      extend Rails3::Assist::UseMacro
+      use_orm :data_mapper
+      include Rails::Assist::BasicLogging
+
+      def orm
+        :data_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_data_mapper/base.rb

@@ -0,0 +1,32 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+module Roles
+  module DataMapper  
+    def self.included(base) 
+      base.extend Roles::Base
+      base.extend ClassMethods
+      base.orm_name = :data_mapper
+    end
+
+    module ClassMethods
+      
+      MAP = {
+        :admin_flag   => "property :admin_flag,   ::DataMapper::Property::Flag[:admin, :default]",
+        :roles_mask   => "property :roles_mask,   Integer, :default => 1",
+        :role_string  => "property :role_string,  String",
+        :roles_string => "property :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
+end

data/lib/roles_data_mapper/namespaces.rb

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

data/lib/roles_data_mapper/role.rb

@@ -0,0 +1,30 @@
+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 = role_class_name.create(:name => name.to_s)
+        role.save
+      end
+    end
+  end
+end
+
+class Role
+  include DataMapper::Resource
+  
+  property :id, Serial  
+  property :name, String
+
+  class << self
+    def find_roles(*role_names)
+      all(:name => 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_data_mapper/strategy/multi/many_roles.rb

@@ -0,0 +1,85 @@
+class Role
+  def self.named role_names 
+    where(:name.in => role_names.flatten)
+  end
+
+  property :id, Serial
+  has n, :user_roles      
+  has n, :users, :through => :user_roles
+end  
+
+class UserRole      
+  include DataMapper::Resource
+    
+  belongs_to :user, 'User', :key => true
+  belongs_to :role, 'Role', :key => true
+end  
+
+
+module RoleStrategy::DataMapper
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+      base.instance_eval %{ 
+        has n, :user_roles
+        has n, :many_roles, 'Role', :through => :user_roles, :via => :role
+      }      
+    end
+
+    module ClassMethods  
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end       
+        
+      def in_role(role_name)
+        role = Role.all(:name => role_name).first
+        all("user_roles.role_id" => role.id)
+      end
+
+      def in_roles(*roles)                          
+        role_ids = Role.all(:name.in => roles.flatten).map{|role| role.id}
+        all("user_roles.role_id" => role_ids)
+      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)
+        self.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)
+        role_relations.each do |rel|
+          self.send(role_attribute) << rel
+        end
+      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_data_mapper/strategy/multi/roles_mask.rb

@@ -0,0 +1,81 @@
+module RoleStrategy::DataMapper
+  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_data_mapper/strategy/single/admin_flag.rb

@@ -0,0 +1,56 @@
+puts "AF"
+
+module RoleStrategy::DataMapper
+  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
+          all(role_attribute => :admin)
+        else
+          all(role_attribute => :default)
+        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)        
+          value = first_role.admin? ? :admin : :default
+          self.send("#{role_attribute}=", value) 
+        else
+          raise ArgumentError, "The role #{first_role} is not a valid role"
+        end
+      end
+
+      # query assigned roles
+      def roles        
+        role = self.send(role_attribute).include?(:admin) ? 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_data_mapper/strategy/single/one_role.rb

@@ -0,0 +1,62 @@
+class Role
+  def self.named role_names 
+    where(:name.in => role_names.flatten)
+  end
+
+  belongs_to :user, :required => false
+end
+
+module RoleStrategy::DataMapper
+  module OneRole
+    def self.default_role_attribute
+      :one_role
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+      base.instance_eval "has 1, :one_role, 'Role'" # , :parent_key => [role_id], :child_key => [:id]
+    end
+
+    module ClassMethods 
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end       
+         
+      def in_role(role_name)                          
+        role = Role.all(:name => role_name).first
+        all('one_role.id' => role.id)
+      end
+
+      def in_roles(*roles)                          
+        role_ids = Role.all(:name.in => roles.flatten).map{|role| role.id}
+        all(:'one_role.id'.in => role_ids)
+      end
+    end
+
+    module Implementation      
+      # 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
+        first_role = roles.flatten.first
+        role_relation = role_class.find_role(first_role)  
+        self.send("#{role_attribute}=", role_relation)
+        save
+      end
+      alias_method :role=, :roles=
+      
+      # query assigned roles
+      def roles
+        role = self.send(role_attribute).name.to_sym
+        [role]
+      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_data_mapper/strategy/single/role_string.rb

@@ -0,0 +1,51 @@
+module RoleStrategy::DataMapper
+  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
+        all(:role_string => 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_data_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_data_mapper
+    end    
+  end
+end           
+

data/lib/roles_data_mapper.rb

@@ -0,0 +1,12 @@
+require 'roles_generic'
+require 'require_all'    
+require 'set'
+require 'sugar-high/array'
+
+require 'dm-core'
+require 'dm-types'
+require 'dm-migrations'
+
+require 'roles_data_mapper/namespaces'
+require 'roles_data_mapper/base'
+require 'roles_data_mapper/strategy'