burlesque 0.0.1 → 0.0.2

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+
+# Mac OS X
+.DS_Store

data/README.md

@@ -0,0 +1,49 @@
+Burlesque
+=========
+
+Crea estructura de roles y grupos para cualquier modelo, considera además las 3 tablas de _join_ que pudiesen darse.
+
+Installation
+------------
+
+Before you can use the generator, add the gem to your project's Gemfile as follows:
+
+```
+gem 'burlesque', :git => 'git@gitlab.acid.cl:burlesque.git'
+```
+
+Then install it by running:
+
+```
+bundle install
+```
+
+Finally, bootstrap your Rails app, for example:
+
+```
+rails generate burlesque:install
+rake db:migrate
+```
+
+CanCan
+------
+
+Burlesque makes no assumption about how auhtorizations are handled in your application. However it integrates nicely with [CanCan][cancan]; all you have to do is define the `Ability` model as follows:
+
+```ruby
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    if user
+      user.roles.each do |role|
+        action = role.name.split('_', 2).first
+        model  = role.name.split('_', 2).last.pluralize.classify.constantize
+        can action.to_sym, model
+      end
+    end
+  end
+end
+```
+
+  [cancan]: https://github.com/ryanb/cancan

data/burlesque.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["mespina"]
   s.email       = ["mespina.icc@gmail.com"]
   s.homepage    = ""
-  s.summary     = "Rolos y grupos para cancan"
-  s.description = "Rolos y grupos para cancan"
+  s.summary     = "Roles y Grupos"
+  s.description = "Crea estructura de roles y grupos para caulquier modelo, considera ademas las 3 tablas de join que pudiesen darse"
 
   s.rubyforge_project = "burlesque"
 

data/config/locales/burlesque.en.yml

@@ -0,0 +1,32 @@
+en:
+  errors: &errors
+    messages:
+      role_taken: already assigned
+      group_taken: already assigned
+      invalid_param: '<%{param}> invalid, try with <Class>, <String> or <Symbol>'
+      access_denied: You are not authorized to perform this action.
+  activerecord:
+    models:
+      role:
+        one: Privilege
+        other: Privileges
+      group:
+        one: Group
+        other: Groups
+    attributes:
+      role:
+        name: Name
+        created_at: created
+        updated_at: updated
+      group:
+        name: Name
+        roles: Privileges
+        created_at: created
+        updated_at: updated
+  authorizations:
+    read: List
+    show: Show
+    create: Create
+    update: Update
+    destroy: Destroy
+    manage: Manage

data/config/locales/burlesque.es-CL.yml

@@ -23,10 +23,10 @@
         roles: Privilegios
         created_at: Creado
         updated_at: Última actualización
-        internal: Uso exclusivo de Latamticket
   authorizations:
     read: Listar
     show: Mostrar
     create: Crear
     update: Actualizar
-    destroy: Eliminar
+    destroy: Eliminar
+    manage: Administrar

data/lib/burlesque.rb

@@ -1,5 +1,8 @@
+require "burlesque/admin_group"
+require "burlesque/authorization"
+require "burlesque/group"
+require "burlesque/role"
+require "burlesque/role_group"
+require "burlesque/locale"
+require "burlesque/admin"
 require "burlesque/version"
-
-module Burlesque
-  # Your code goes here...
-end

data/lib/burlesque/admin.rb

@@ -0,0 +1,112 @@
+require 'active_support/concern'
+
+module Burlesque
+  module Admin
+    extend ActiveSupport::Concern
+
+    included do
+      has_many        :authorizations,      as: :authorizable,    dependent: :destroy
+      has_many        :roles,          through: :authorizations
+
+      has_many        :admin_groups,        as: :adminable,       dependent: :destroy
+      has_many        :groups,         through: :admin_groups, after_remove: :remove_roles_from_admin
+
+      attr_accessible :group_ids,
+                      :role_ids
+    end
+
+    module InstanceMethods
+      # Public: Indica si tiene un rol en particular.
+      #
+      # role -  el rol que se quiere consultar, puede ser un Role o Role.name
+      #
+      # Returns Boolean.
+      def role? role
+        role_name = role.respond_to?(:name) ? role.name : role
+        self.roles.map(&:name).include?(role_name.to_s)
+      end
+
+      # Public: Indica si tiene un grupo en particular.
+      #
+      # group -  el grupo que se quiere consultar, puede ser un Group o Group.name
+      #
+      # Returns Boolean.
+      def group? group
+        group_name = group.respond_to?(:name) ? group.name : group
+        self.groups.map(&:name).include?(group_name.to_s)
+      end
+
+      # Public: Indica si un rol en particular esta presente en los grupos que tiene asignados.
+      #
+      # role -  el rol que se quiere consultar, puede ser un Role o Role.name
+      #
+      # Returns Boolean.
+      def role_in_groups? role
+        role_name = role.respond_to?(:name) ? role.name : role
+        groups.each do |group|
+          return true if group.role?(role_name)
+        end
+        false
+      end
+
+      # Public: Permite setear los grupos que se indican.
+      # Eliminando los grupos que no esten en la lista.
+      #
+      # ids - id's de los Roles que se desean asignar destructivamente.
+      #
+      # Returns nothing.
+      def group_ids=(ids)
+        ids.each do |group_id|
+          group = ::Group.find(group_id)
+          self.groups << group unless self.groups.include?(group)
+        end
+
+        to_deletes = []
+        self.groups.each do |group|
+          to_deletes << group unless ids.include?(group.id.to_s)# or ids.include?(group.id)
+        end
+
+        to_deletes.each do |group|
+          self.groups.delete(group) if self.group?(group)
+        end
+      end
+
+      # Public: Permite setear los roles que se indican.
+      # Eliminando los roles que no esten en la lista,
+      # salvo en caso de estar presente por asignacion de un grupo.
+      #
+      # ids - id's de los Roles que se desean asignar destructivamente.
+      #
+      # Returns nothing.
+      def role_ids=(ids)
+        ids.each do |role_id|
+          role = ::Role.find(role_id)
+          self.roles << role unless self.role?(role)
+        end
+
+        to_deletes = []
+        self.roles.each do |role|
+          to_deletes << role unless ids.include?(role.id.to_s) or self.role_in_groups?(role)# or ids.include?(role.id)
+        end
+
+        to_deletes.each do |role|
+          self.roles.delete(role) if self.roles.include?(role)
+        end
+      end
+
+      private
+      # Public: Permite eliminar los roles de un grupo eliminado.
+      #
+      # group - El grupo que se elimino.
+      #
+      # Returns nothing.
+      def remove_roles_from_admin group
+        group.roles.each do |role|
+          if authorizations.map(&:role).include?(role) and not role_in_groups?(role.name)
+            authorizations.find_by_role_id(role.id).destroy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/burlesque/admin_group.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+
+module Burlesque
+  module AdminGroup
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :group
+      belongs_to :adminable, polymorphic: true
+
+      validates_uniqueness_of :group_id, scope: [:adminable_id, :adminable_type], message: I18n.t('errors.messages.group_taken')
+
+      after_create :add_new_roles_to_admin
+    end
+
+    module InstanceMethods
+      private
+      def add_new_roles_to_admin
+        group.roles.each do |role|
+          adminable.roles << role unless adminable.roles.include? role
+        end
+      end
+    end
+  end
+end

data/lib/burlesque/authorization.rb

@@ -0,0 +1,13 @@
+require 'active_support/concern'
+module Burlesque
+  module Authorization
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :role
+      belongs_to :authorizable, polymorphic: true
+
+      validates_uniqueness_of :role_id, scope: [:authorizable_id, :authorizable_type], message: I18n.t('errors.messages.role_taken')
+    end
+  end
+end

data/lib/burlesque/group.rb

@@ -0,0 +1,89 @@
+require 'active_support/concern'
+
+module Burlesque
+  module Group
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :role_groups
+      has_many :roles, through: :role_groups, dependent: :destroy, after_remove: :remove_roles_from_admin
+
+      has_many :admin_groups, dependent: :destroy
+      # for has_many :admins relations see admins function
+
+      attr_accessible :name, :role_ids, :internal
+
+      validates :name, presence: true, uniqueness: true
+    end
+
+    module InstanceMethods
+      # Public: Relacion a muchos usuarios
+      #
+      # Se usa esta funcion dado que la tabla de administrador es polimorfica.
+      #
+      # Returns los administradores que tienen el rol en cuestion.
+      def admins
+        admin_groups.map &:adminable
+      end
+
+      # Public: Indica si el grupo tiene un rol en particular.
+      #
+      # role -  el rol que se quiere consultar, puede ser un Role o Role.name
+      #
+      # Returns Boolean.
+      def role? role
+        role_name = role.respond_to?(:name) ? role.name : role
+        self.roles.map(&:name).include?(role_name.to_s)
+      end
+
+      # Public: Setea los roles que se indican al grupo.
+      # Eliminando los roles que no esten en la lista.
+      #
+      # ids - id's de los Roles que se desean asignar destructivamente.
+      #
+      # Returns nothing.
+      def role_ids=(ids)
+        ids.each do |ri|
+          role = ::Role.find(ri)
+          self.roles << role unless self.roles.include? role
+        end
+
+        to_deletes = []
+        role_groups.each do |rg|
+          role = rg.role
+          to_deletes << role unless ids.include?(role.id.to_s) or ids.include?(role.id)
+        end
+
+        to_deletes.each do |role|
+          self.roles.delete(role) if self.roles.include?(role)
+        end
+      end
+
+      # Public: Permite agregar un grupo de Roles al Grupo
+      # No elimina los roles que no esten en la lista, solo agrega los que no estan.
+      #
+      # new_roles - el arreglo de roles que se quiere agregar al grupo
+      #
+      # Returns nothing.
+      def push_roles new_roles
+        new_roles.each do |role|
+          self.roles << role unless self.roles.include? role
+        end
+      end
+
+      private
+      # Public: Permite que al eliminar un rol de un grupo, tambien se modifiquen los roles de los administradores asociados a ese grupo.
+      #
+      # role -  el rol que se elimino del grupo.
+      #
+      # Returns nothing.
+      def remove_roles_from_admin role
+        admins.each do |admin|
+          if admin.authorizations.map(&:role_id).include?(role.id) and not admin.role_in_groups?(role.name)
+            admin.authorizations.find_by_role_id(role.id).destroy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/burlesque/locale.rb

@@ -0,0 +1,8 @@
+module Burlesque
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'rails-i18n' do |app|
+      I18n.load_path << Dir[File.join(File.expand_path(File.dirname(__FILE__) + '/../../config/locales'), '*.yml')]
+      I18n.load_path.flatten!
+    end
+  end
+end

data/lib/burlesque/role.rb

@@ -0,0 +1,80 @@
+require 'active_support/concern'
+
+module Burlesque
+  module Role
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :role_groups
+      has_many :groups, through: :role_groups, dependent: :destroy
+
+      has_many :authorizations, dependent: :destroy
+      # for has_many :admins relations see admins function
+
+      attr_accessible :name
+      validates :name, presence: true, uniqueness: true
+
+
+      scope :action,        lambda { |action| where('name LIKE ?',                          "#{action}_%") }
+      scope :not_action,    lambda { |action| where('name NOT LIKE ?',                      "#{action}_%") }
+      scope :resource,      lambda { |model|  where('name LIKE ? or name LIKE ?',           "%_#{model.to_s.singularize}", "%_#{model.to_s.pluralize}") }
+      scope :not_resource,  lambda { |model|  where('name NOT LIKE ? AND name NOT LIKE ?',  "%_#{model.to_s.singularize}", "%_#{model.to_s.pluralize}") }
+    end
+
+    module InstanceMethods
+      # Public: Relacion a muchos usuarios
+      #
+      # Se usa esta funcion dado que la tabla de administrador es polimorfica.
+      #
+      # Returns los administradores que tienen el rol en cuestion.
+      def admins
+        authorizations.map &:authorizable
+      end
+
+      # Public: Traduce el nombre de un rol.
+      #
+      # Primero revisa si existe una traducción para el rol bajo el scope de autorizaciones,
+      # luego si el no existe una traducción intenta traducir el nombre del rol usando la
+      # traduccion de Burleque, que traduce la acción por defecto e intenta usar las traducciones
+      # definidas para cada modelo
+      #
+      # Returns el nombre del rol ya traducido.
+      def translate_name
+        translate = I18n.t(name.to_sym, scope: :authorizations)
+        return translate unless translate.include?('translation missing:')
+
+
+        action, model = name.split('_', 2)
+
+        count = (model == model.pluralize) ? 2 : 1
+        model = model.pluralize
+
+        translate = I18n.t(action.to_sym, scope: :authorizations) + ' ' + model.classify.constantize.model_name.human(count: count)
+      end
+    end
+
+    module ClassMethods
+      # TODO
+      # Mejorar el retorno, para saber que paso, ej: si se agregaron los 5 roles o si ya existen
+      def for model
+        if model.class == String
+          resource = model.classify.constantize.model_name.underscore
+        elsif model.class == Symbol
+          resource = model.to_s.classify.constantize.model_name.underscore
+        elsif model.class == Class
+          resource = model.model_name.underscore
+        end
+
+        if resource
+          self.create(name:    "read_#{resource.pluralize}") unless self.where(name:    "read_#{resource.pluralize}").any?
+          self.create(name:    "show_#{resource}")           unless self.where(name:    "show_#{resource}").any?
+          self.create(name:  "create_#{resource}")           unless self.where(name:  "create_#{resource}").any?
+          self.create(name:  "update_#{resource}")           unless self.where(name:  "update_#{resource}").any?
+          self.create(name: "destroy_#{resource}")           unless self.where(name: "destroy_#{resource}").any?
+        else
+          raise I18n.t('errors.messages.invalid_param', param: model.class)
+        end
+      end
+    end
+  end
+end

data/lib/burlesque/role_group.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module Burlesque
+  module RoleGroup
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :role
+      belongs_to :group
+
+      validates_uniqueness_of :role_id, scope: :group_id, message: I18n.t('errors.messages.role_taken')
+
+      after_save :add_new_roles_to_admin
+    end
+
+
+    module InstanceMethods
+      private
+
+      # Public: Actualiza los roles de los administradores luego de haber actualizado el grupo de roles.
+      #
+      # Returns nothing.
+      def add_new_roles_to_admin
+        group.admins.each do |admin|
+          admin.roles << self.role unless admin.roles.include?(self.role)
+        end
+      end
+    end
+  end
+end

data/lib/burlesque/version.rb

@@ -1,3 +1,3 @@
 module Burlesque
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/generators/burlesque/install_generator.rb

@@ -0,0 +1,85 @@
+require 'rails/generators/migration'
+require 'thor/shell/basic.rb'
+
+module Burlesque
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_model_and_migration
+        ######## Role #######
+        # Crea el modelo Role
+        copy_file "role.rb", "app/models/role.rb"
+
+        # Crea la tabla del modelo
+        if not role = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/\d+_create_roles.rb$/).first
+          migration_template  "create_roles.rb", "db/migrate/create_roles.rb"
+        else
+          Thor::Shell::Basic.new.say_status :exist, role, :blue
+        end
+
+        ######## Authorization #######
+        # Crea el modelo Authorization
+        copy_file "authorization.rb", "app/models/authorization.rb"
+
+        # Crea la tabla del modelo
+        if not authorization = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/\d+_create_authorizations.rb$/).first
+          migration_template  "create_authorizations.rb", "db/migrate/create_authorizations.rb"
+        else
+          Thor::Shell::Basic.new.say_status :exist, authorization, :blue
+        end
+
+        ######## Group #######
+        # Crea el modelo Group
+        copy_file "group.rb", "app/models/group.rb"
+
+        # Crea la tabla del modelo
+        if not group = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/\d+_create_groups.rb$/).first
+          migration_template  "create_groups.rb", "db/migrate/create_groups.rb"
+        else
+          Thor::Shell::Basic.new.say_status :exist, group, :blue
+        end
+
+        ######## Role-Group #######
+        # Crea el modelo Role-Group
+        copy_file "role_group.rb", "app/models/role_group.rb"
+
+        # Crea la tabla del modelo
+        if not role_group = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/\d+_create_role_groups.rb$/).first
+          migration_template  "create_role_groups.rb", "db/migrate/create_role_groups.rb"
+        else
+          Thor::Shell::Basic.new.say_status :exist, role_group, :blue
+        end
+
+        ######## Admin-Group #######
+        # Crea el modelo Admin-Group
+        copy_file "admin_group.rb", "app/models/admin_group.rb"
+
+        # Crea la tabla del modelo
+        if not admin_group = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/\d+_create_admin_groups.rb$/).first
+          migration_template  "create_admin_groups.rb", "db/migrate/create_admin_groups.rb"
+        else
+          Thor::Shell::Basic.new.say_status :exist, admin_group, :blue
+        end
+      end
+
+
+      def self.next_migration_number path
+        # unless @prev_migration_nr
+        #   @prev_migration_nr = Dir.glob("#{Rails.root}/db/migrate/[0-9]*_*.rb").inject(0) do |max, file_path|
+        #     n = File.basename(file_path).split('_', 2).first.to_i
+        #     if n > max then n else max end
+        #   end
+        # else
+        #   @prev_migration_nr += 1
+        # end
+
+        # ActiveRecord::Migration.new.next_migration_number(@prev_migration_nr.to_s)
+
+        next_migration_number = current_migration_number(path) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+    end
+  end
+end

data/lib/generators/burlesque/templates/admin_group.rb

@@ -0,0 +1,3 @@
+class AdminGroup < ActiveRecord::Base
+  include Burlesque::AdminGroup
+end

data/lib/generators/burlesque/templates/authorization.rb

@@ -0,0 +1,3 @@
+class Authorization < ActiveRecord::Base
+  include Burlesque::Authorization
+end

data/lib/generators/burlesque/templates/create_admin_groups.rb

@@ -0,0 +1,13 @@
+class CreateAdminGroups < ActiveRecord::Migration
+  def change
+    create_table :admin_groups do |t|
+      t.references  :group
+      t.integer     :adminable_id
+      t.string      :adminable_type
+
+      t.timestamps
+    end
+    add_index :admin_groups, :group_id
+    add_index :admin_groups, [:adminable_id, :adminable_type], name: 'by_adminable'
+  end
+end

data/lib/generators/burlesque/templates/create_authorizations.rb

@@ -0,0 +1,13 @@
+class CreateAuthorizations < ActiveRecord::Migration
+  def change
+    create_table :authorizations do |t|
+      t.references  :role
+      t.integer     :authorizable_id
+      t.string      :authorizable_type
+
+      t.timestamps
+    end
+    add_index :authorizations, :role_id
+    add_index :authorizations, [:authorizable_id, :authorizable_type], name: 'by_authorizable'
+  end
+end

data/lib/generators/burlesque/templates/create_groups.rb

@@ -0,0 +1,9 @@
+class CreateGroups < ActiveRecord::Migration
+  def change
+    create_table :groups do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/burlesque/templates/create_role_groups.rb

@@ -0,0 +1,12 @@
+class CreateRoleGroups < ActiveRecord::Migration
+  def change
+    create_table :role_groups do |t|
+      t.references :role
+      t.references :group
+
+      t.timestamps
+    end
+    add_index :role_groups, :role_id
+    add_index :role_groups, :group_id
+  end
+end

data/lib/generators/burlesque/templates/create_roles.rb

@@ -0,0 +1,9 @@
+class CreateRoles < ActiveRecord::Migration
+  def change
+    create_table :roles do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/burlesque/templates/group.rb

@@ -0,0 +1,3 @@
+class Group < ActiveRecord::Base
+  include Burlesque::Group
+end

data/lib/generators/burlesque/templates/role.rb

@@ -0,0 +1,3 @@
+class Role < ActiveRecord::Base
+  include Burlesque::Role
+end

data/lib/generators/burlesque/templates/role_group.rb

@@ -0,0 +1,3 @@
+class RoleGroup < ActiveRecord::Base
+  include Burlesque::RoleGroup
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: burlesque
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-28 00:00:00.000000000 Z
+date: 2013-08-29 00:00:00.000000000 Z
 dependencies: []
-description: Rolos y grupos para cancan
+description: Crea estructura de roles y grupos para caulquier modelo, considera ademas
+  las 3 tablas de join que pudiesen darse
 email:
 - mespina.icc@gmail.com
 executables: []
@@ -20,11 +21,31 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- README.md
 - Rakefile
 - burlesque.gemspec
+- config/locales/burlesque.en.yml
 - config/locales/burlesque.es-CL.yml
 - lib/burlesque.rb
+- lib/burlesque/admin.rb
+- lib/burlesque/admin_group.rb
+- lib/burlesque/authorization.rb
+- lib/burlesque/group.rb
+- lib/burlesque/locale.rb
+- lib/burlesque/role.rb
+- lib/burlesque/role_group.rb
 - lib/burlesque/version.rb
+- lib/generators/burlesque/install_generator.rb
+- lib/generators/burlesque/templates/admin_group.rb
+- lib/generators/burlesque/templates/authorization.rb
+- lib/generators/burlesque/templates/create_admin_groups.rb
+- lib/generators/burlesque/templates/create_authorizations.rb
+- lib/generators/burlesque/templates/create_groups.rb
+- lib/generators/burlesque/templates/create_role_groups.rb
+- lib/generators/burlesque/templates/create_roles.rb
+- lib/generators/burlesque/templates/group.rb
+- lib/generators/burlesque/templates/role.rb
+- lib/generators/burlesque/templates/role_group.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -45,8 +66,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: burlesque
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Rolos y grupos para cancan
+summary: Roles y Grupos
 test_files: []