rad_kit 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake_ext'
+
+project(
+  name: "kit",
+  official_name: 'rad_kit',
+  gem: true,
+  summary: "Rapid Application Development Kit for Rad Framework",
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/rad_kit"
+)

data/lib/components/kit.rb

@@ -0,0 +1,16 @@
+rad.register :kit, depends_on: [:web, :assets, :common_interface, :models] do        
+  require 'kit/kit'
+  
+  rad.router.default_url = '/'
+  (rad.face.availiable_layouts[:default] ||= []) << :default
+  
+  rad.configure :web, "#{__FILE__}/../../.." do |c|    
+    c.routes
+    c.locales
+    c.template_paths 'app/views'
+    c.asset_paths 'app/static'
+    c.autoload_paths 'app'
+  end
+  
+  Rad::Kit.new
+end

data/lib/components/kit.yml

@@ -0,0 +1,3 @@
+fs_prefix: '/fs'
+fs_type: :file
+tags_count: 40

data/lib/components/models.rb

@@ -0,0 +1,7 @@
+rad.register :models do    
+  require 'kit/models'  
+  Rad::Models.new
+end
+rad.after :models do
+  require 'kit/models_after'
+end

data/lib/kit/factories.rb

@@ -0,0 +1,9 @@
+require 'factory_girl'
+
+Factory.define :item, class: 'Models::Item' do |o|
+  o.sequence(:name){|i| "item_#{i}"}
+end
+
+Factory.define :comment, class: 'Models::Comment', parent: :item do |c|
+  c.original_text "Some text"
+end

data/lib/kit/gems.rb

@@ -0,0 +1,16 @@
+# core gems
+gem 'bluecloth',     '2.0.9'
+gem 'sanitize',      '1.2.1'
+gem 'stringex',      '1.2.0'
+gem 'state_machine', '0.10.4'
+# gem 'paperclip',     '2.3.1.1'
+gem 'factory_girl',  '1.3.3'
+gem 'coderay',       '0.9.7'
+
+if respond_to? :fake_gem  
+  fake_gem 'rad_core'
+  fake_gem 'rad_ext'
+  fake_gem 'rad_common_interface'
+  fake_gem 'rad_assets'
+  fake_gem 'mongoid_misc'
+end

data/lib/kit/http_controller.rb

@@ -0,0 +1,4 @@
+%w(
+  authorized
+  localized
+).each{|n| require "kit/http_controller/#{n}"}

data/lib/kit/http_controller/authorized.rb

@@ -0,0 +1,51 @@
+module Rad::Controller::Http::Authorized
+  inherited do
+    helper_method :can?, :owner?
+  end
+  
+  module ClassMethods
+    def require_permission operation, *args, &object_proc
+      operation = operation.must_be.a(String, Symbol).to_s
+  
+      options = args.extract_options!
+      # object_proc = args.size > 0 ? args.first : lambda{}
+      object_proc ||= lambda{|controller|}
+  
+      method = "require_permission_#{operation}"
+      define_method method do
+        require_permission operation, instance_eval(&object_proc)
+      end
+      before method, options
+    end
+  end
+
+  protected
+    def can? *args
+      rad.user.can? *args
+    end          
+
+    def owner? *args
+      rad.user.owner? *args
+    end
+
+    def login_required
+      access_denied! unless rad.user.registered?
+    end
+
+    def login_not_required
+      raise_user_error t(:login_not_required) if rad.user.registered?
+    end
+
+    def require_permission operation, object = nil
+      operation = operation.must_be.a(String, Symbol).to_s
+
+      unless rad.user.can? operation, object
+        rad.logger.warn "RAD access denied, #{rad.user.name} hasn't rights to #{operation}!"
+        access_denied!
+      end
+    end
+
+    def access_denied!            
+      raise_user_error t(:access_denied)
+    end
+end

data/lib/kit/http_controller/localized.rb

@@ -0,0 +1,13 @@
+module Rad::Controller::Http::Localized
+  inherited do
+    before :prepare_locale
+  end
+
+  protected     
+    def prepare_locale
+      language = rad.environment.language
+      I18n.locale = params.l || language        
+      # Delete l from params if language is the same as default
+      params.delete :l if params.l == language
+    end
+end

data/lib/kit/kit.rb

@@ -0,0 +1,29 @@
+require 'kit/support'
+
+# Configs
+class Rad::Kit
+  attr_accessor :default_item, :fs_prefix, :fs_type, :fs_cache_path, :fs_path, :tags_count
+  require_attr :default_item, :tags_count, :fs_prefix, :fs_type, :fs_path, :fs_cache_path
+  def items; @items ||= [] end  
+end
+
+rad.router.class.class_eval do
+  attr_accessor :default_url
+  require_attr :default_url
+end
+
+rad.config.class.class_eval do  
+  def custom_roles; @custom_roles ||= [] end
+  def permissions; @permissions ||= {} end
+  def default_viewers; @default_viewers ||= [] end
+end
+
+
+# Kit
+# 
+# TODO3 move :text_utils to standalone text_utils gem
+%w(  
+  support
+  text_utils  
+  http_controller
+).each{|f| require "kit/#{f}"}

data/lib/kit/models.rb

@@ -0,0 +1,8 @@
+require 'kit/support'
+require 'kit/mongoid'
+require 'state_machine'
+StateMachine::Integrations::Mongoid.defaults[:action] = nil
+
+class Rad::Models
+  attr_accessor :config
+end

data/lib/kit/models/attachment_uploader.rb

@@ -0,0 +1,15 @@
+class Models::AttachmentUploader < Models::FileUploader
+  rad.extension :attachment_file_path, self do
+    define_method :file_path do
+      "#{rad.kit.fs_prefix}/#{model.item.id}"
+    end
+  end
+  
+  version :icon do
+    process resize_to_fit: [50, 50]
+  end
+  
+  version :thumb do
+    process resize_to_fit: [150, 150]
+  end
+end

data/lib/kit/models/attachments_uploader_helper.rb

@@ -0,0 +1,79 @@
+module Mongoid::AttachmentsUploaderHelper
+  extend ActiveSupport::Concern
+  
+  class FileHelper
+    attr_reader :object
+    def initialize object
+      @object = object
+    end
+    
+    def file?
+      object.is_a?(Hash) or object.is_a?(IO)
+    end
+    
+    def name
+      if object.is_a?(Hash)
+        object['filename'] || object[:filename]
+      elsif object.is_a?(IO)
+        File.basename(object.path)
+      else
+        object
+      end
+    end
+  end
+  
+  def get_attachments association_name, field_name
+    send(association_name).
+      sort{|a, b| a.send(field_name).name <=> b.send(field_name).name}.
+      collect{|o| {name: o.send(field_name).name, url: o.send(field_name).url}.to_openobject}
+  end
+  
+  def set_attachments association_name, field_name, values
+    association = send(association_name)
+    existing_names = association.collect{|o| o.send(field_name).name}.sort    
+    
+    add = values.select do |o| 
+      h = FileHelper.new o
+      h.file? and !existing_names.include?(h.name)
+    end        
+    update = values.select do |o| 
+      h = FileHelper.new o
+      h.file? and existing_names.include?(h.name) 
+    end     
+    remove = association.select do |model|
+      values.none? do |o|
+        h = FileHelper.new o
+        model.send(field_name).name == h.name
+      end
+    end    
+        
+    add.each{|file| association.build field_name => file}    
+    update.each do |file|
+      h = FileHelper.new file
+      association.each do |model|
+        if model.send(field_name).name == h.name
+          model.send "#{field_name}=", file
+          break
+        end
+      end
+    end    
+    remove.each do |model|
+      association.where(_id: model.id).destroy_all
+    end
+  end
+
+  module ClassMethods
+    def mount_attachments_uploader association_name, field_name
+      define_method "#{association_name}_as_attachments" do
+        get_attachments association_name, field_name
+      end
+      
+      define_method "#{association_name}_as_attachments=" do |values|
+        set_attachments association_name, field_name, values
+      end
+      
+      # we can't allow to destroy model with changed attachments because it's too complicated to support this case.
+      before_destroy{|o| raise "Can't destroy item with changed attachments!" if o.changes.include? association_name}
+    end
+  end
+end

data/lib/kit/models/authorized.rb

@@ -0,0 +1,188 @@
+module Mongoid::Authorized
+  extend ActiveSupport::Concern
+  
+  class << self
+    attr_writer :custom_permissions
+    def custom_permissions; @custom_permissions ||= {} end    
+    def permissions
+      @default_permissions ||= YAML.load_file("#{__FILE__.dirname}/default_permissions.yml").freeze
+      @default_permissions.merge(rad.config.permissions).merge(custom_permissions)
+    end
+  end
+  
+  included do
+    validate :validate_anonymous
+    validates_exclusion_of :name, in: Role::PRESERVED_USER_NAMES, if: lambda{|u| u.new_record?}                    
+
+    rad.extension :model_authorization, self do
+      field :roles, type: Array, protected: true, default: []
+      alias_method :mm_roles,  :roles
+      alias_method :mm_roles=, :roles=          
+    
+      field :admin, type: Boolean, protected: true, default: false                        
+    end
+    
+    alias_method :roles, :handy_roles
+  end
+       
+  module ClassMethods
+    def anonymous
+      Models::User.by_name('anonymous') || raise("You probably don't create Anonymous User!")
+    end
+  end
+  
+  # 
+  # Owner
+  # 
+  def owner_name; anonymous? ? nil : name end
+  
+  def owner? object
+    !object.blank? and !name.blank? and !anonymous? and object.respond_to(:owner_name) == self.name
+  end
+  
+  # 
+  # Roles
+  # 
+  def anonymous?
+    name == 'anonymous'
+  end
+
+  def registered?
+    !anonymous?
+  end
+
+  def add_role role
+    role = role.to_s
+    unless roles.include? role
+      if role == 'admin'
+        self.admin = true
+      else                      
+        self.mm_roles -= Role.denormalize_to_lower_roles [role]
+        self.mm_roles += [role]
+      end          
+      clear_cache
+    end
+    roles
+  end
+
+  def remove_role role
+    role = role.to_s
+    if roles.include? role
+      if role == 'admin'
+        self.admin = false
+      else
+        self.mm_roles -= Role.denormalize_to_higher_roles [role]
+      end
+      clear_cache
+    end    
+    roles
+  end
+      
+  def handy_roles        
+    unless roles = cache[:roles]            
+      roles = if self.mm_roles.empty?
+        ['user']
+      else
+        Role.denormalize_to_lower_roles self.mm_roles
+      end            
+      if anonymous?
+        roles << 'anonymous'
+      else
+        roles << 'registered'
+      end
+      roles << "user:#{name}" unless name.blank?
+      if admin
+        roles << 'admin'
+        %w(manager member).each{|r| roles << r unless roles.include? r}
+      end
+      
+      roles.must_be == roles.uniq
+      
+      roles = HandyRoles.new roles.sort                                              
+      cache[:roles] = roles
+    end
+    roles
+  end
+
+  def major_roles
+    cache[:major_roles] ||= Role.major_roles roles
+  end
+
+  def has_role? role
+    roles.include? role
+  end
+  
+  
+  # 
+  # can?
+  #       
+  def can? operation, object = nil
+    operation = operation.to_s
+    
+    return true if has_role?(:admin)
+    
+    custom_method = "able_#{operation}?"          
+    return object.send custom_method, self if object.respond_to? custom_method
+    
+    (
+      effective_permissions[operation] or 
+      (owner?(object) and effective_permissions_as_owner[operation])
+    )
+  end
+  
+  def can_view? object
+    can? :view, object
+  end
+  
+  
+  # 
+  # Effective Permissions
+  # 
+  def effective_permissions
+    unless ep = cache[:effective_permissions]          
+      ep = calculate_effective_roles_for roles
+      cache[:effective_permissions] = ep
+    end
+    ep
+  end
+
+  def effective_permissions_as_owner
+    unless epo = cache[:effective_permissions_as_owner]          
+      epo = calculate_effective_roles_for ['owner']
+      cache[:effective_permissions_as_owner] = epo
+    end
+    epo
+  end
+
+  protected                  
+    def calculate_effective_roles_for roles            
+      effective_permissions = {}
+      permissions = ::Mongoid::Authorized.permissions
+      # permissions = rad.config.permissions(DEFAULT_PERMISSIONS).to_h #.to_h(to_s: true)
+      permissions.each do |operation, allowed_roles|
+        operation = operation.to_s
+        effective_permissions[operation.to_s] = roles.any?{|role| allowed_roles.include? role}
+      end
+      effective_permissions
+    end
+  
+    def validate_anonymous          
+      errors.add :base, "Anonymous can't have any roles!" if anonymous? and !self.mm_roles.blank?
+    end
+
+    class HandyRoles < Array
+      def include? role
+        super role.to_s
+      end
+      alias_method :has?, :include?
+      
+      protected
+        def method_missing m, *args, &block
+          m = m.to_s
+          super unless m.last == '?'
+
+          self.include? m[0..-2]
+        end
+    end
+      
+end