simple_roles 0.0.5 → 0.0.6

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# master
+
+...
+
+# Version 0.0.6
+
+### Added
+
+* Added strategies: "One" - the simplest strategy possible and "Many" - the former only strategy from older versions.
+
+### Changed
+
+* SimpleRoles.configure - much better DSL
+
+### Removed
+
+* Removed RolesArray presenter in "Many" strategy
+
+# Versions <= 0.0.5 
+
+Long-long history here undocumented...

data/Gemfile

@@ -7,16 +7,14 @@ source "http://rubygems.org"
 gem 'require_all'
 gem 'sugar-high'
 gem 'sweetloader'
+gem 'activerecord'
 
 group :development, :test do
-  gem 'activerecord'
   gem 'rake-kit'
   gem 'devise'
   gem 'mysql2'
   gem 'jeweler'
   gem 'cutter'
-  gem 'rails'
-  gem 'rspec-rails'
-  gem 'capybara'
+  gem 'rspec'
   gem 'factory_girl'
 end

data/README.md

@@ -10,7 +10,7 @@ If you are looking for a real serious roles system solution try [Troles](https:/
 
 ### Prerequisites
 
-SimpleRoles only assumes you have User model
+SimpleRoles requires you have User model. That's all.
 
 ### Not a Gem yet
 
@@ -21,7 +21,7 @@ gem 'simple_roles', :git => "git://github.com/stanislaw/simple_roles.git"
 bundle update
 ```
 
-### Set up valid roles you're gonna have in your app
+### Set up valid roles you're gonna have in your app and choose a Strategy. 
 
 Create file simple_roles.rb in config/initializers and write there:
 
@@ -29,19 +29,88 @@ Create file simple_roles.rb in config/initializers and write there:
 # config/initializers/simple_roles.rb
 SimpleRoles.configure do |config|
   config.valid_roles = [:user, :admin, :editor]
+  config.strategy = :many # Default is :one
 end
 ```
 
-### Copy and migrate SimpleRoles migrations by following rake task:
+or in a nicer way:
+
+```ruby
+# config/initializers/simple_roles.rb
+SimpleRoles.configure do
+  valid_roles :user, :admin, :editor
+  strategy :many # Default is :one
+end
+```
+
+Now it is time to choose beetween two strategies possible:
+
+* One - each of your users has only one role. It is the most common
+  choise for the most of the apps.
+* Many - your user can be _:editor_ and _:curator_ and _:instructor_ all
+  at the same time. More rare one, setup is slightly more complex.
+
+### One Strategy
+
+One strategy assumes your User model has string-typed 'role' column. Add this to your migrations and run them:
+
+```ruby
+class CreateUsers < ActiveRecord::Migration
+  def up
+    create_table(:users) do |t|
+      # ...
+      t.string :role
+      # ... 
+    end
+  end
+
+  def down
+    drop_table :users
+  end
+end
+```
+
+Finally, include 'simple_roles' macros in your User model:
+
+```ruby
+class User
+  simple_roles
+end
+```
+
+### Many strategy
+
+In its background 'Many' strategy has following setup, based on <i>has_many :through</i> relations:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :user_roles
+  has_many :roles, :through => :user_roles
+end
+  
+class UserRole < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+end
+
+class Role < ActiveRecord::Base
+  has_many :user_roles
+  has_many :users, :through => :user_roles
+end
+```
+
+**You don't need to create these classes (UserRoles, Roles) and write these associations by hands** - all these classes SimpleRoles configures **automatically**. The only class you need is User and you must have *simple_roles* in it (see below).
+
+**But you need** to supply migrations for them - copy and migrate SimpleRoles migrations by following rake task:
 
 ```ruby
 rake simple_roles_engine:install:migrations
 rake db:migrate
 ```
 
-Note! Migrations are based on roles you set up as valid (see previous step). If you do not create initializer with valid_roles, then valid_roles will be set up to defaults: :user and :admin.
+**Note!** Migrations are based on roles you are to set up as valid (see previous step). If you do not create initializer with valid_roles, then valid_roles will be set up to defaults: :user and :admin.
 
-### And finally include 'simple_roles' macros in your User model:
+And finally include 'simple_roles' macros in your User model:
 
 ```ruby
 class User
@@ -49,33 +118,47 @@ class User
 end
 ```
 
-## Usage
+### Notes
+
+You can skip configuration in initializers and write it the following
+way:
 
 ```ruby
-user.roles => #<RolesArray: {}>
+class User
+  simple_roles do
+    strategy :one
+    valid_roles :user, :editor
+  end
+end
+```
+
+## Usage example
+
+```ruby
+user = User.new
+user.roles # => []
 
 user.roles = :admin
-user.roles # => #<RolesArray: {:admin}>
-user.roles_list # => #<RolesArray: {:admin}>
+user.roles # => [:admin]
+user.roles_list # => [:admin]
+
 user.admin? # => true
 user.is_admin? # => true
 
-user.roles << :user
-user.roles # => #<RolesArray: {:admin, :user}>
+user.roles = [:admin, :user]
+user.roles # => [:admin, :user]
 user.is_user? # => true
 
 user.add_role :editor
-user.roles # => #<RolesArray: #{:admin, :user, :editor}>
+user.roles # => [:admin, :user, :editor]
 
 user.remove_role :user
-user.roles # => #<RolesArray: {:admin, :editor}>
+user.roles # => [:admin, :editor]
 user.has_role?(:admin) # => true
 user.has_any_role?(:admin, :blip) # => true
 user.has_role?(:blogger) # => false
 ```
 
-## Todo:
+## Copyright
 
-- Write role groups part
-- Provide some more config options
-- More and better tests
+Copyright (c) 2012 Stanislaw Pankevich.

data/Rakefile

@@ -12,6 +12,9 @@ rescue LoadError
   RDoc::Task = Rake::RDocTask
 end
 
+$:.unshift File.expand_path('lib', File.dirname(__FILE__))
+require 'simple_roles'
+
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
@@ -22,6 +25,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Simple Role System for Rails Apps}
   gem.email = "s.pankevich@gmail.com"
   gem.authors = ["stanislaw"]
+  gem.version = SimpleRoles::VERSION
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -35,19 +39,9 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
 
+load 'rails/tasks/engine.rake'
 
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task :default => :test
+# task :default => :test

data/db/migrate/001_create_user_roles.rb

@@ -1,11 +1,12 @@
 class CreateUserRoles < ActiveRecord::Migration
   def up
-   create_table :user_roles do |t|
-    t.integer :user_id
-    t.integer :role_id
+    create_table :user_roles do |t|
+      t.integer :user_id, :null => false
+      t.integer :role_id, :null => false
 
-    t.timestamps
+      t.timestamps
     end
+
     add_index :user_roles, [:user_id, :role_id]
  end
 

data/db/migrate/002_create_roles.rb

@@ -1,10 +1,12 @@
 class CreateRoles < ActiveRecord::Migration
   def up
     create_table :roles do |t|
-      t.string :name
+      t.string :name, :null => false
       t.timestamps
     end
 
+    add_index :roles, :name, :unique => true
+
     create_roles
   end
 
@@ -12,10 +14,11 @@ class CreateRoles < ActiveRecord::Migration
     drop_table :roles
   end
 
-
   def create_roles
     SimpleRoles::Configuration.valid_roles.each do |role|
-      Role.create(:name => role.to_s)
+      r = Role.new
+      r.name = role.to_s
+      r.save
     end
   end
 end

data/lib/simple_roles/configuration.rb

@@ -1,33 +1,86 @@
-require 'singleton'
 module SimpleRoles
   module Configuration
-
     extend self
     
-    attr_accessor :valid_roles, :user_models
+    attr_writer :strategy, :user_models
 
     def user_models
       @user_models ||= []
     end
 
+    def valid_roles *vr
+      if vr.any?
+        self.valid_roles = vr.flatten
+      end
+
+      @valid_roles ||= default_roles
+    end
+
     def valid_roles= vr
-      raise "There should be an array of valid roles" if !vr.kind_of?(Array)
+      check_roles(vr)
+
       @valid_roles = vr
-      distribute_methods
-    end
 
-    def valid_roles
-      @valid_roles || default_roles
+      distribute_methods
     end
 
     def default_roles
       [:user, :admin]
     end
 
-    def distribute_methods
-      user_models.each do |um|
-        um.register_roles_methods
+    def strategy st = nil
+      if st
+        self.strategy = st
       end
+
+      @strategy ||= default_strategy
+    end
+
+    def strategy= st
+      check_strategy st
+
+      @strategy = st
+    end
+
+    def available_strategies
+      strategies.keys
+    end
+
+    def strategy_class _strategy = nil
+      strategies[_strategy || strategy]
+    end
+
+    def strategies
+      {
+        :one => SimpleRoles::One,
+        :many => SimpleRoles::Many
+      }
+    end
+
+    private
+
+    def distribute_methods
+      user_models.each(&:register_dynamic_methods)
+    end
+
+    def check_strategy strategy
+      raise "Wrong strategy!" unless available_strategies.include? strategy
+    end
+
+    def check_roles rolez = valid_roles
+      raise "There should be an array of valid roles" unless rolez.kind_of?(Array)
+
+      rolez.map do |rolle|
+        begin
+          Role.find_by_name! rolle.to_s
+        rescue
+          puts "SimpleRoles warning: Couldn't find Role for #{rolle}. Maybe you need to re-run migrations?"
+        end
+      end if strategy == :many
+    end
+    
+    def default_strategy
+      :one
     end
   end
 end

data/lib/simple_roles/engine.rb

@@ -1,4 +1,6 @@
 module SimpleRoles
   class Engine < Rails::Engine
+    initializer 'simple_roles' do |app|
+    end
   end
 end

data/lib/simple_roles/macros.rb

@@ -1,11 +1,8 @@
 module SimpleRoles
   module Macros
-    def self.included(base)
-    end
-
     def simple_roles &block
-      yield SimpleRoles::Configuration if block
-      include SimpleRoles::Base
+      SimpleRoles.config.instance_exec(SimpleRoles.config, &block) if block
+      SimpleRoles.package self
     end
   end
 end

data/lib/simple_roles/many/persistence.rb

@@ -0,0 +1,44 @@
+module SimpleRoles
+  module Many
+    module Persistence
+      class << self
+        def included base
+          base.class_eval %{ 
+            has_many :user_roles
+            has_many :roles, :through => :user_roles
+          }
+        end
+      end
+
+      def roles
+        super.map(&:name).map(&:to_sym)
+      end
+
+      def roles= *rolez
+        rolez.to_symbols!.flatten!
+
+        super retrieve_roles(rolez)
+
+        save!
+      end
+
+      private
+
+      def retrieve_roles rolez
+        raise "Not a valid role!" if (rolez - config.valid_roles).size > 0
+
+        rolez.map do |rolle|
+          begin
+            Role.find_by_name! rolle.to_s
+          rescue
+            raise "Couldn't find Role for #{rolle}. Maybe you need to re-run migrations?"
+          end
+        end
+      end
+
+      def config
+        SimpleRoles::Configuration
+      end
+    end
+  end
+end

data/lib/simple_roles/many/roles_methods.rb

@@ -0,0 +1,88 @@
+module SimpleRoles
+  module Many
+    module RolesMethods
+      class << self
+        def included base
+          base.class_eval %{
+            extend SimpleRoles::Many::RolesMethods::DynamicMethods
+          }
+        end
+      end
+
+      module DynamicMethods
+        class << self
+          def extended base
+            base.register_dynamic_methods
+          end
+        end
+
+        def register_dynamic_methods
+          valid_roles.each do |role|
+            class_eval %{
+              def self.#{role}s
+                Role.find_by_name("#{role}").users
+              end
+
+              def self.#{role}s_ids
+                Role.find_by_name("#{role}").user_ids
+              end
+            }
+
+            define_method :"#{role}?" do
+              roles.include?(:"#{role}")
+            end
+
+            alias_method :"is_#{role}?", :"#{role}?"
+          end
+        end
+
+        def valid_roles
+          SimpleRoles::Configuration.valid_roles
+        end
+      end
+
+      def roles_list
+        roles
+      end
+
+      def mass_assignment_authorizer *args
+        super.empty? ? super : (super + [:roles])
+      end
+
+      def has_roles? *rolez
+        rolez.flatten!
+
+        # rrr roles
+        rolez.all? do |role|
+          roles.include? role
+        end
+      end
+
+      alias_method :has_role?, :has_roles?
+
+      def has_any_role? *rolez
+        rolez.flatten!
+
+        rolez.any? do |role|
+          roles.include? role
+        end
+      end
+
+      def add_roles *rolez
+        self.roles = roles + rolez
+      end
+
+      alias_method :add_role, :add_roles
+
+      def remove_roles *rolez
+        self.roles = roles - rolez
+      end
+
+      alias_method :remove_role, :remove_roles
+
+      def set_role r
+        self.roles = r
+      end
+    end
+  end
+end

data/lib/simple_roles/many.rb

@@ -0,0 +1,5 @@
+module SimpleRoles
+  module Many
+    autoload_modules :Persistence, :RolesMethods
+  end
+end

data/lib/simple_roles/one/persistence.rb

@@ -0,0 +1,13 @@
+module SimpleRoles
+  module One
+    module Persistence
+      def role
+        super.to_sym
+      end
+
+      def role= r
+        super r.to_s
+      end
+    end
+  end
+end

data/lib/simple_roles/one/roles_methods.rb

@@ -0,0 +1,38 @@
+module SimpleRoles
+  module One
+    module RolesMethods
+      include SimpleRoles::One::Persistence
+
+      class << self
+        def included base
+          base.extend DynamicMethods
+        end
+      end
+
+      def set_role r
+        self.role= r
+        save!
+      end
+
+      module DynamicMethods
+        class << self
+          def extended base
+            base.register_dynamic_methods
+          end
+        end
+
+        def register_dynamic_methods
+          SimpleRoles.config.valid_roles.each do |r|
+            scope :"#{r}s", where(:role => r.to_s)
+            
+            define_method :"#{r}?" do
+              role == r
+            end
+
+            alias_method :"is_#{r}?", :"#{r}?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_roles/one.rb

@@ -0,0 +1,5 @@
+module SimpleRoles
+  module One
+    autoload_modules :Persistence, :RolesMethods
+  end
+end

data/lib/simple_roles/packager.rb

@@ -0,0 +1,18 @@
+module SimpleRoles
+  module Packager 
+    extend self
+
+    def package clazz, strategy = config.strategy
+      SimpleRoles::Configuration.user_models << clazz
+
+      clazz.send :include, SimpleRoles::config.strategy_class(strategy)::Persistence
+      clazz.send :include, SimpleRoles::config.strategy_class(strategy)::RolesMethods
+    end
+
+    private
+
+    def config
+      SimpleRoles.config
+    end
+  end
+end

data/lib/simple_roles/version.rb

@@ -1,3 +1,3 @@
 module SimpleRoles
-  VERSION = "0.0.1"
+  VERSION = "0.0.6"
 end

data/lib/simple_roles.rb

@@ -1,19 +1,34 @@
-require "sweetloader"
-require "require_all"
-require "sugar-high/array"
-require "sugar-high/dsl"
+require 'sweetloader'
+require 'require_all'
 
-require "simple_roles/engine" if defined?(Rails)
-require "simple_roles/macros"
+require 'sugar-high/array'
+require 'sugar-high/dsl'
 
-require_all File.expand_path("../../app", __FILE__)
+require 'active_record'
+
+require 'simple_roles/version'
+
+require 'simple_roles/engine' if defined?(Rails)
+require 'simple_roles/macros'
+
+require_all File.expand_path('../../app', __FILE__)
 
 module SimpleRoles
-  autoload_modules :Base, :Configuration, :RolesArray
+  autoload_modules :Configuration, :Packager, :One, :Many
+
+  extend self
+
+  def configure &block
+    config.instance_exec config, &block
+  end
+
+  def config
+    SimpleRoles::Configuration
+  end
 
-  class << self
-    def configure &block
-      yield SimpleRoles::Configuration
-    end
+  def packager
+    SimpleRoles::Packager
   end
+  
+  delegate :package, :to => :packager, :prefix => false
 end