the_role 1.4.1 → 1.5.0

data/config/routes.rb

@@ -1,18 +1,16 @@
 Rails.application.routes.draw do
   namespace :admin do
     resources :roles do
-      member do
-        get  :new
-        get  :index
-        post :new_role_section
-        post :new_role_policy
-      end
-      resources :sections, :controller => :role_section do
+      resources :sections, :controller => :role_sections, :only => :none do
+        collection do
+          post :create
+          post :create_rule
+        end
         member do
-          get :new_policy
-          delete :delete_policy
+          delete :destroy
+          delete :destroy_rule
         end
-      end#sections
-    end#policy
-  end#admin
+      end
+    end
+  end
 end

data/db/migrate/20111025025129_create_roles.rb

@@ -2,10 +2,10 @@ class CreateRoles < ActiveRecord::Migration
   def self.up
     create_table :roles do |t|
 
-      t.string :name
-      t.string :title
-      t.text :description
-      t.text :the_role, :null => false
+      t.string :name,        :null => false
+      t.string :title,       :null => false
+      t.text   :description, :null => false
+      t.text   :the_role,    :null => false
 
       t.timestamps
     end

data/lib/the_role.rb

@@ -6,111 +6,16 @@ require "the_role/engine"
 require "the_role/version"
 require "the_role/the_class_exists"
 
+require "the_role/modules/base"
+require "the_role/modules/param_helper"
+require "the_role/modules/user_model"
+require "the_role/modules/role_model"
+require "the_role/modules/controller_requires"
+
 module TheRole
+  # include TheRole::Base
   # include TheRole::Requires
   # include TheRole::UserModel
   # include TheRole::RoleModel
-
-  NAME_SYMBOLS = /^[a-zA-Z][a-zA-Z0-9_\-]*[a-zA-Z0-9]$/
-
-  # TheRole.get(@role.the_role)
-  def self.get str
-    str = str.is_a?(String) ? str : String.new
-    hash = YAML::load(str)
-    hash ? hash : Hash.new
-  end
-
-  module UserModel
-    def self.included(base)
-      base.class_eval do
-        belongs_to :role
-        attr_accessible :role
-        # when user changed - @the_role should be reload
-        after_save { |user| user.instance_variable_set(:@the_role, nil) }
-      end
-    end
-    
-    def the_role
-      @the_role ||= self.role ? TheRole.get(self.role.the_role) : Hash.new
-    end
-
-    def admin?
-      role = self.the_role[:system] ? self.the_role[:system][:administrator] : false
-      role && role.is_a?(TrueClass)
-    end
-    
-    def moderator? section
-      return true if self.admin?
-      role = self.the_role[:moderator] ? self.the_role[:moderator][section.to_sym] : false
-      role && role.is_a?(TrueClass)
-    end
-
-    # TRUE if user has role - administartor of system
-    # TRUE if user is moderator of this section (controller_name)
-    # FALSE when this section (or role) is nil
-    # return current value of role (TRUE|FALSE) if it exists
-    def has_role?(section, policy)
-      return true   if self.admin?
-      return true   if self.moderator? section 
-      if self.the_role[section.to_sym] && self.the_role[section.to_sym][policy.to_sym]
-        self.the_role[section.to_sym][policy.to_sym].is_a?(TrueClass)
-      else
-        false
-      end
-    end
-
-    # FALSE if object is nil
-    # If object is a USER - check for youself
-    # Check for owner field - :user_id
-    # Check for owner _object_ if owner field is not :user_id
-    def owner?(obj)
-      return false unless obj
-      return true if self.admin?
-      return true if self.moderator? obj.class.to_s.tableize # moderator? 'pages'
-      return self.id == obj.id          if obj.is_a?(User)
-      return self.id == obj[:user_id]   if obj[:user_id]
-      return self.id == obj[:user][:id] if obj[:user]
-      false
-    end
-  end#UserModel
-
-  module RoleModel
-    def self.included(base)
-      base.class_eval do
-        has_many :users
-        validates :name,  :presence => {:message => I18n.translate('the_role.name_presence')}
-        validates :title, :presence => {:message => I18n.translate('the_role.title_presence')}
-      end
-    end
-  end#RoleModel
-
-  # for application controller
-  # @the_role_object should be defined with before_filter
-  # @the_role_object = @page
-  module Requires
-    private
-    
-      def the_role_access_denied
-        flash[:error] = t('the_role.access_denied')
-        redirect_to root_path
-      end
-      
-      # before_filter :role_require
-      def the_role_require
-        the_role_access_denied unless current_user.has_role?(controller_name, action_name)
-      end
-
-      # before_filter :the_role_object
-      # define class variable for *the_owner_require* filter with Controller class name
-      # @the_role_object = @article
-      def the_role_object
-        variable_name   = self.class.to_s.tableize.split('_').first.singularize.split('/').last
-        @the_role_object = self.instance_variable_get("@#{variable_name}")
-      end
-
-      # before_filter :the_owner_require
-      def the_owner_require
-        the_role_access_denied unless current_user.owner?(@the_role_object)
-      end
-  end#Requires
-end#TheRole
+  # include TheRole::ParamHelper
+end

data/lib/the_role/hash.rb

@@ -1,25 +1,29 @@
 class Hash
-  def the_reset!(default_value= false)
-    base= self
-    base.each do |key, v|
-      if base[key.to_sym].is_a?(Hash)
-        base[key.to_sym]= base[key.to_sym].the_reset!(default_value)
-      else
-        base[key.to_sym]= default_value
-      end
+  # load 'the_role/hash.rb' - UPDATE, BUT NOT RELOAD
+
+  # {'a b' => 1, "x y" => {'hello' => 1, :hello => 2} }.underscorify_keys => {:a_b=>1, :x_y=>{:hello=>2}}
+  def underscorify_keys
+    hash = {}
+    self.each do |key, value|
+      new_key       = key.to_s.parameterize.underscore.to_sym
+      hash[new_key] = self[key].is_a?(Hash) ? self[key].underscorify_keys : value
     end
+    hash
   end
 
-  def the_merge!(hash= nil, default_value= true)
-    return self unless hash.is_a?(Hash)
-    base= self
-    hash.each do |key, v|
-      if base[key.to_sym].is_a?(Hash) && hash[key.to_sym].is_a?(Hash)
-        base[key.to_sym]= base[key.to_sym].the_merge!(hash[key.to_sym], default_value)
-      else
-        base[key.to_sym]= default_value
-      end
+  def deep_reset(default = false)
+    hash = dup
+    hash.each do |key, value|
+      hash[key] = hash[key].is_a?(Hash) ? hash[key].deep_reset(default) : default
     end
-    base.to_hash
+    hash
+  end
+
+  def underscorify_keys!
+    replace underscorify_keys
+  end
+
+  def deep_reset!(default = false)
+    replace deep_reset(default)
   end
 end

data/lib/the_role/modules/base.rb

@@ -0,0 +1,23 @@
+module TheRole
+  module Base
+    def has_role? section_name, rule_name
+      hash         =  role_hash
+      section_name =  param_prepare(section_name)
+      rule_name    =  param_prepare(rule_name)
+      return true  if hash[:system]    and hash[:system][:administrator]
+      return true  if hash[:moderator] and hash[:moderator][section_name]
+      return false unless hash[section_name]
+      return false unless hash[section_name].key? rule_name
+      hash[section_name][rule_name]
+    end
+
+    def moderator? section_name
+      section_name = param_prepare(section_name)
+      has_role? section_name, :any_crazy_name
+    end
+
+    def admin?
+      has_role? :any_crazy_name, :any_crazy_name
+    end
+  end
+end

data/lib/the_role/modules/controller_requires.rb

@@ -0,0 +1,28 @@
+module TheRole
+  module Requires
+    private
+    
+      def role_access_denied
+        flash[:error] = t('the_role.access_denied')
+        redirect_to root_path
+      end
+      
+      # before_filter :role_require
+      def role_require
+        role_access_denied unless current_user.has_role?(controller_name, action_name)
+      end
+
+      # before_filter :simple_object_finder
+      # define class variable for *owner_require* filter with Controller class name
+      # @object_for_ownership_checking = @article
+      def simple_object_finder
+        variable_name                  = self.class.to_s.tableize.split('_').first.singularize.split('/').last
+        @object_for_ownership_checking = self.instance_variable_get("@#{variable_name}")
+      end
+
+      # before_filter :owner_require
+      def owner_require
+        role_access_denied unless current_user.owner?(@object_for_ownership_checking)
+      end
+  end
+end

data/lib/the_role/modules/param_helper.rb

@@ -0,0 +1,7 @@
+module TheRole
+  module ParamHelper
+    def param_prepare param
+      param.to_s.parameterize.underscore.to_sym
+    end
+  end
+end

data/lib/the_role/modules/role_model.rb

@@ -0,0 +1,121 @@
+module TheRole
+  module RoleModel
+    include TheRole::Base
+    include TheRole::ParamHelper
+
+    def role_hash; to_hash; end
+    alias_method :has?, :has_role?
+
+    def has_section? section_name
+      section_name = param_prepare(section_name)
+      to_hash.key? section_name
+    end
+
+    def self.included(base)
+      base.class_eval do
+        has_many  :users
+        validates :name,        :presence => true, :uniqueness => true
+        validates :title,       :presence => true, :uniqueness => true
+        validates :description, :presence => true
+        before_create do
+          self.name     = param_prepare(name) 
+          self.the_role = {}.to_yaml
+        end
+
+        # C
+        
+        def create_section section_name = nil
+          return false unless section_name
+          role         =  to_hash
+          section_name =  param_prepare(section_name)
+          return false if section_name.blank?
+          return true  if role[section_name]
+          role[section_name] = {}
+          update_attributes(:the_role => role.to_yaml)
+        end
+                
+        def create_rule section_name, rule_name
+          return false unless create_section(section_name)
+          role         =  to_hash
+          rule_name    =  param_prepare(rule_name)
+          section_name =  param_prepare(section_name)
+          return true  if role[section_name][rule_name]
+          role[section_name][rule_name] = false
+          update_attributes(:the_role => role.to_yaml)
+        end
+
+        # R
+
+        def to_hash
+          begin YAML::load(the_role) rescue {} end
+        end
+
+        def to_yaml
+          the_role
+        end
+
+        def to_s
+          the_role
+        end
+
+        # U
+
+        # source_hash will be reset to false
+        # except true items from new_role_hash
+        # all keys will become symbols
+        # look at lib/the_role/hash.rb to find definition of *underscorify_keys* method
+        def update_role new_role_hash
+          new_role_hash = new_role_hash.try(:to_hash) || {}
+          new_role      = new_role_hash.underscorify_keys
+          role          = to_hash.underscorify_keys.deep_reset
+          role.deep_merge! new_role
+          update_attributes(:the_role => role.to_yaml)
+        end
+
+        def rule_on section_name, rule_name
+          role         =  to_hash
+          rule_name    =  param_prepare(rule_name)
+          section_name =  param_prepare(section_name)
+          return false unless role[section_name]
+          return false unless role[section_name].key? rule_name
+          return true  if     role[section_name][rule_name]
+          role[section_name][rule_name] = true
+          update_attributes(:the_role => role.to_yaml)
+        end
+
+        def rule_off section_name, rule_name
+          role         = to_hash
+          rule_name    = param_prepare(rule_name)
+          section_name = param_prepare(section_name)
+          return false unless role[section_name]
+          return false unless role[section_name].key? rule_name
+          return true  unless role[section_name][rule_name]
+          role[section_name][rule_name] = false
+          update_attributes(:the_role => role.to_yaml)
+        end
+
+        # D
+
+        def delete_section section_name = nil
+          return false unless section_name
+          role         =  to_hash
+          section_name =  param_prepare(section_name)
+          return false if section_name.blank?
+          return false unless role[section_name]
+          role.delete  section_name
+          update_attributes(:the_role => role.to_yaml)
+        end
+
+        def delete_rule section_name, rule_name
+          role         = to_hash
+          rule_name    = param_prepare(rule_name)
+          section_name = param_prepare(section_name)
+          return false unless role[section_name]
+          return false unless role[section_name].key? rule_name
+          role[section_name].delete rule_name
+          update_attributes(:the_role => role.to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/the_role/modules/user_model.rb

@@ -0,0 +1,32 @@
+module TheRole
+  module UserModel
+    include TheRole::Base
+    include TheRole::ParamHelper
+    def role_hash; @role_hash ||= role.to_hash; end
+
+    # FALSE if object is nil
+    # If object is a USER - check for youself
+    # Check for owner field - :user_id
+    # Check for owner _object_ if owner field is not :user_id
+    def owner? obj
+      return false unless obj
+      return true  if admin?
+
+      section_name = obj.class.to_s.tableize
+      return true  if moderator?(section_name)
+
+      return id == obj.id          if obj.is_a?(User)
+      return id == obj[:user_id]   if obj[:user_id]
+      return id == obj[:user][:id] if obj[:user]
+      false
+    end
+
+    def self.included(base)
+      base.class_eval do
+        belongs_to      :role
+        attr_accessible :role
+        after_save { |user| user.instance_variable_set(:@role_hash, nil) }
+      end
+    end
+  end
+end

data/lib/the_role/version.rb

@@ -1,3 +1,3 @@
 module TheRole
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/the_role.gemspec

@@ -17,10 +17,9 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
-  s.add_dependency 'haml', '~> 3.0'
+  
+  s.add_dependency 'haml'
   s.add_dependency 'sass'
+  s.add_dependency 'sass-rails'
+  s.add_dependency 'coffee-rails'
 end