rad_kit 0.0.1

data/lib/kit/models/authorized_object.rb

@@ -0,0 +1,167 @@
+module Mongoid::AuthorizedObject
+  extend ActiveSupport::Concern
+  
+  included do
+    field :owner_name, 
+      type: String, 
+      default: lambda{rad.user? ? rad.user.name : nil}, 
+      protected: true
+    attr_protected :owner
+
+    field :collaborators, 
+      type: Array, 
+      default: [], 
+      protected: true
+    
+    # Contains the role and all upper roles. So complex becouse we need it in indexes.
+    field :viewers, 
+      type: Array, 
+      default: lambda{(
+        (rad.user? ? ['manager', "user:#{rad.user.name}"] : ['manager']) +
+        Array.wrap(rad.config.default_viewers)
+      ).uniq.sort}, 
+      protected: true
+   
+    validates_presence_of :owner_name
+    validate :validate_viewers
+    validate :validate_collaborators
+  end
+  
+  # 
+  # Owner
+  # 
+  def owner
+    return nil if owner_name.blank?
+    cache[:owner] ||= Models::User.by_name!(owner_name)
+  end      
+
+  def owner= user
+    user.must_be.an Models::User
+    cache[:owner] = user
+    self.owner_name = user.name
+    user
+  end
+      
+  # TODO3 update it later, MM uses public API to unmarshal object 
+  # http://groups.google.com/group/mongomapper/browse_thread/thread/ab34457e0ba9c472#
+  def owner_name= name                    
+    owner_role = "user:#{name}"
+    old_owner_role = "user:#{owner_name}"
+    
+    unless viewers.include? owner_role
+      viewers.delete old_owner_role
+      viewers << owner_role
+      viewers.sort!
+    end
+    
+    # write_attribute :owner_name, name
+    super name
+    clear_cache
+    owner_name
+  end
+
+  # 
+  # Viewers and Collaborators
+  # 
+  def add_viewer role
+    role = role.to_s
+    should_be_valid_user_input_role role                    
+    
+    return if viewers.include? role          
+    
+    roles = viewers
+    roles << role          
+    roles = Role.denormalize_to_higher_roles roles          
+    roles << 'manager' unless roles.include? 'manager'
+    self.viewers = roles.sort
+    viewers
+  end
+  
+  def remove_viewer role
+    role = role.to_s
+    should_be_valid_user_input_role role          
+    
+    return unless viewers.include? role
+    
+    roles = viewers
+    Role.denormalize_to_higher_roles([role]).each do |r|
+      roles.delete r
+    end
+    roles << 'manager' unless roles.include? 'manager'
+    self.viewers = roles.sort
+    
+    remove_collaborator role
+    
+    viewers
+  end
+  
+  def minor_viewers
+    unless minor_viewers = cache[:minor_viewers]
+      viewers = self.viewers.clone
+      viewers.delete 'manager'
+      minor_viewers = Role.minor_roles viewers
+      cache[:minor_viewers] = minor_viewers
+    end
+    minor_viewers
+  end
+  
+  def add_collaborator role
+    role = role.to_s
+    should_be_valid_user_input_role role
+    return if collaborators.include? role
+    collaborators = self.collaborators.clone       
+    collaborators << role
+    self.collaborators = collaborators
+    
+    add_viewer role
+    
+    collaborators
+  end
+  
+  def remove_collaborator role
+    role = role.to_s
+    should_be_valid_user_input_role role                    
+    collaborators.delete role
+    collaborators
+  end
+  
+  def normalized_collaborators
+    unless normalized_collaborators = cache[:normalized_collaborators]
+      normalized_collaborators = Role.denormalize_to_higher_roles collaborators
+      normalized_collaborators << "user:#{owner_name}"
+      normalized_collaborators.sort!
+      cache[:normalized_collaborators] = normalized_collaborators
+    end
+    normalized_collaborators
+  end
+  
+  
+  # 
+  # Special Permissions
+  # 
+  def able_view? user
+    user.roles.any?{|role| viewers.include? role}
+  end
+  
+  def able_update? user
+    user.roles.any?{|role| normalized_collaborators.include? role}
+  end
+  
+  protected        
+    def should_be_valid_user_input_role role
+      role.must_not ==  'manager'
+      role.must_not == "user:#{owner_name}"
+    end
+  
+    def validate_viewers
+      viewers.must == viewers.uniq
+                                  
+      viewers.must.include 'manager' # always
+      viewers.must.include "user:#{owner_name}"
+    end
+    
+    def validate_collaborators
+      collaborators.must_not.include "user:#{owner_name}"
+    end
+    
+end

data/lib/kit/models/default_permissions.yml

@@ -0,0 +1,29 @@
+# General
+view: [] #anonymous, registered
+
+# Administration
+administration: [admin]
+
+# Authorization
+add_admin_role: []
+add_custom_role: [manager]
+add_manager_role: []
+add_member_role: [manager]
+remove_admin_role: []
+remove_custom_role: [manager]
+remove_manager_role: []
+remove_member_role: [manager]
+update_access: [manager, owner]
+
+# User Management
+update_profile: [owner]
+
+# Items
+create: [member]
+# update: [manager, owner]
+destroy: [manager, owner]
+
+# Comments
+create_comment: [registered]
+update_comment: [manager, owner]
+destroy_comment: [manager, owner]

data/lib/kit/models/file_uploader.rb

@@ -0,0 +1,26 @@
+require 'carrierwave/processing/mini_magick'
+
+class Models::FileUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+  
+  storage rad.config.fs_type
+
+  # def sanitize_regexp
+  #   /[^[:word:]\.\-\+\s_]/i
+  # end
+
+  def file_path
+    "#{rad.config.fs_prefix}/system/#{model.class.model_name.underscore}/#{model.id}"
+  end
+
+  def store_dir
+    "#{root}#{file_path}"
+  end
+
+  def extension_white_list
+    [/.*/]
+  end
+
+  def cache_dir; rad.config.fs_cache_path end  
+  def root; rad.config.fs_path end  
+end

data/lib/kit/models/micelaneous.rb

@@ -0,0 +1 @@
+STRONG_NAME = /\A[a-z_][a-z_0-9]*\Z/

data/lib/kit/models/role.rb

@@ -0,0 +1,88 @@
+class Role
+  ORDERED_ROLES = %w{manager member user}.freeze
+  SYSTEM_ROLES = %w{admin anonymous manager member owner registered user}.sort.freeze
+  PRESERVED_USER_NAMES = SYSTEM_ROLES
+
+  class << self
+  
+    def normalize_roles roles    
+      ordinary_roles, ordered_roles = split roles
+      ordinary_roles << lower_role(ordered_roles)    
+      ordinary_roles.sort
+    end
+  
+    def denormalize_to_higher_roles roles
+      ordinary_roles, ordered_roles = split roles
+      ordinary_roles.push *higher_roles(lower_role(ordered_roles))
+      ordinary_roles.sort
+    end
+    
+    def denormalize_to_lower_roles roles
+      ordinary_roles, ordered_roles = split roles
+      ordinary_roles.push *lower_roles(higher_role(ordered_roles))
+      ordinary_roles.sort
+    end
+    
+    def higher_role roles
+      ORDERED_ROLES.each do |role|
+        return role if roles.include? role
+      end
+      nil
+    end
+    
+    def lower_role roles
+      ORDERED_ROLES.reverse.each do |role|
+        return role if roles.include? role
+      end
+      nil
+    end
+    
+    def major_roles roles            
+      major_roles = roles.select{|role| !SYSTEM_ROLES.include?(role)}
+      if higher_role = higher_role(roles)
+        major_roles << higher_role
+      end
+      major_roles.sort
+    end
+  
+    def minor_roles roles
+      minor_roles = roles.select{|role| !SYSTEM_ROLES.include?(role)}
+      if lower_role = lower_role(roles)
+        minor_roles << lower_role
+      end
+      minor_roles.sort
+    end
+  
+    protected
+      def split roles
+        ordinary_roles = []
+        ordered_roles = []
+
+        roles.collect do |role| 
+          if ORDERED_ROLES.include? role
+            ordered_roles << role
+          else
+            ordinary_roles << role
+          end
+        end
+      
+        [ordinary_roles, ordered_roles]
+      end
+  
+      def lower_roles role
+        return [] if role.nil?
+        
+        role.must_be.in ORDERED_ROLES
+        index = ORDERED_ROLES.index role
+        ORDERED_ROLES[index..-1]
+      end
+
+      def higher_roles role
+        return [] if role.nil?
+        
+        role.must_be.in ORDERED_ROLES
+        index = ORDERED_ROLES.index role
+        ORDERED_ROLES[0..index]
+      end      
+  end
+end

data/lib/kit/models_after.rb

@@ -0,0 +1,27 @@
+# use database config if provided
+if rad.models.config
+  b = lambda do
+    Mongoid.configure do |config|  
+      config.logger = rad.logger
+    end
+    Mongoid.from_hash rad.models.config
+  end
+
+  # hiding MongoDB connecting messages
+  rad.logger.respond_to?(:silence) ? rad.logger.silence(&b) : b.call
+end
+
+
+%w(
+  micelaneous
+  role      
+  authorized
+  authorized_object
+  file_uploader
+  attachments_uploader_helper
+  attachment_uploader
+).each{|n| require "kit/models/#{n}"}
+
+Mongoid::Document.class_eval do
+  include Mongoid::AttachmentsUploaderHelper
+end

data/lib/kit/mongoid.rb

@@ -0,0 +1,22 @@
+require 'mongoid_misc'
+require 'carrierwave_ext'
+require 'rad'
+
+# 
+# Attribute protection
+# 
+Mongoid::Document.included do
+  attr_protected :id, :_id, :_type, :created_at, :updated_at
+end
+
+module Models
+end
+
+%w(
+  text_processor
+  rad_micelaneous    
+).each{|n| require "kit/mongoid/#{n}"}
+
+(rad.extension(:mm_plugins){[]} + [Mongoid::RadMicelaneous]).each do |plugin|
+  Mongoid::Document.include plugin
+end

data/lib/kit/mongoid/rad_micelaneous.rb

@@ -0,0 +1,36 @@
+module Mongoid::RadMicelaneous
+  extend ActiveSupport::Concern
+  
+  delegate :t, to: I18n
+  
+  def to_rson options = {}
+    with_errors = if options.include?('errors')
+      options.delete 'errors'
+    elsif options.include?(:errors)
+      options.delete :errors
+    else
+      true
+    end
+    
+    # standard MongoMaper as_json conversion
+    hash = as_json(options)
+    
+    # MongoMaper fix
+    hash['id'] = hash.delete('_id').to_s if hash.include? '_id'
+              
+    # adding errors
+    if with_errors            
+      errors = {}
+      errors.each do |name, list|
+        errors[name.to_s] = list
+      end
+      hash['errors'] = errors unless errors.empty?
+    end
+    
+    hash
+  end
+  
+  module ClassMethods
+    delegate :t, to: I18n
+  end
+end

data/lib/kit/mongoid/text_processor.rb

@@ -0,0 +1,44 @@
+module Mongoid::TextProcessor
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    def markup_field attr_name, opt = {}
+      attr_name = attr_name.to_s
+      opt = opt.to_openobject
+      original_attr_name = "original_#{attr_name}"
+      
+      field original_attr_name, type: String, default: ''
+      field attr_name,          type: String, protected: true, default: '' unless fields.include? attr_name
+              
+      validates_presence_of attr_name, original_attr_name if opt.required?
+      
+      alias_method "#{attr_name}_without_markup=", "#{attr_name}="
+      alias_method "#{original_attr_name}_without_markup=", "#{original_attr_name}="
+      
+      define_method "#{attr_name}=" do |value|            
+        send "#{original_attr_name}_without_markup=", value
+        send "#{attr_name}_without_markup=", value
+      end
+              
+      define_method "#{original_attr_name}=" do |value|
+        send "#{original_attr_name}_without_markup=", value            
+        send "#{attr_name}_without_markup=", Rad::TextUtils.markup(value)
+      end
+      
+      define_method "#{attr_name}_as_text" do
+        value = send(attr_name)
+        return "" if value.blank?
+        Nokogiri::XML(value).content
+      end
+              
+      ce_method_name = "copy_errors_for_#{attr_name}"
+      define_method ce_method_name do
+        if !errors.include?(original_attr_name) and errors.include?(attr_name)
+          errors.add original_attr_name, errors[attr_name]
+        end
+      end
+      after_validation ce_method_name          
+    end
+  end
+  
+end