rapid 0.0.1

data/lib/rad/mongo_mapper/acts_as/authorized.rb

@@ -0,0 +1,197 @@
+module MongoMapper
+  module Plugins
+    module Authorized            
+      ROLES = %w{admin manager member}
+      
+      module ClassMethods
+        def acts_as_authorized
+          key :global_admin, Boolean, :protected => true
+          key :admin_of_accounts, Array, :protected => true
+          # has_many :roles_containers, :class_name => 'RolesContainer', :protected => true          
+          space_key :space_roles, Array
+          
+          validate :validate_anonymous
+          validates_exclusion_of :name, :within => Role::PRESERVED_USER_NAMES, :if => lambda{|u| u.new_record?}
+        end
+        
+        def anonymous
+          User.find_by_name 'anonymous'
+        end
+      end
+      
+      module InstanceMethods
+        # 
+        # Owner
+        # 
+        def owner_name; anonymous? ? nil : name end
+        
+        def owner? object
+          # object.should! :respond_to?, :owner_name
+          !object.blank? and !name.blank? 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
+          Rad.multitenant_mode?.must_be.true
+          
+          if role == 'admin'
+            account_id = Account.current.id
+            admin_of_accounts << account_id unless admin_of_accounts.include? account_id
+          else              
+            roles = Role.denormalize_to_lower_roles [role]
+            self.space_roles = space_roles + [role] unless space_roles.include?(role)
+          end          
+          clear_cache
+          roles
+        end
+      
+        def remove_role role
+          role = role.to_s
+          Rad.multitenant_mode?.must_be.true
+                    
+          if role == 'admin'
+            admin_of_accounts.delete Account.current.id
+          else          
+            roles = Role.denormalize_to_higher_roles [role]
+            self.space_roles = space_roles - roles
+          end
+          clear_cache
+          roles
+        end
+            
+        def roles        
+          unless roles = cache[:roles]
+            if Rad.multitenant_mode?
+              roles = space_roles.clone
+              roles << 'admin' if admin_of_accounts.include? Account.current.id
+            else
+              roles = []
+            end
+          
+            roles << 'user'
+          
+            if anonymous?
+              roles << 'anonymous'
+            else
+              roles << 'registered'
+            end
+
+            roles << "user:#{name}" unless name.blank?
+          
+            roles << 'admin' if global_admin and !roles.include?('admin')
+            
+            roles << 'manager' if roles.include?('admin') and !roles.include?('manager')
+            
+            roles = Role.denormalize_to_lower_roles(roles)
+            
+            roles = HandyRoles.new roles
+                      
+            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_space_permissions[operation] or (
+            owner?(object) and effective_space_permissions_as_owner[operation]
+          )
+        end
+        
+        def can_view? object
+          can? :view, object
+        end
+        
+        
+        # 
+        # Effective Permissions
+        # 
+        def effective_space_permissions
+          unless effective_space_permissions = cache[:effective_space_permissions]          
+            effective_space_permissions = calculate_effective_roles_for roles
+            cache[:effective_space_permissions] = effective_space_permissions
+          end
+          effective_space_permissions
+        end
+
+        def effective_space_permissions_as_owner
+          unless effective_space_permissions_as_owner = cache[:effective_space_permissions_as_owner]          
+            effective_space_permissions_as_owner = calculate_effective_roles_for ['owner']
+            cache[:effective_space_permissions_as_owner] = effective_space_permissions_as_owner
+          end
+          effective_space_permissions_as_owner
+        end
+        
+        protected
+          # def effective_space_roles
+          #   ::Rails.should_be! :multitenant_mode        
+          #   unless roles = cache[:effective_space_roles]
+          #     roles = space_roles.clone
+          #     roles << 'admin' if admin_of_accounts.include? Account.current.id
+          #     cache[:effective_space_roles] = roles
+          #   end
+          #   roles
+          # end
+        
+          def validate_anonymous          
+            if anonymous? and (global_admin or !space_roles.blank?)
+              errors.add :base, "Anonymous can't be member or manager!"
+            end
+          end
+      
+          class HandyRoles < Array
+            def include? role
+              super role.to_s
+            end
+            alias_method :has?, :include?
+
+            def method_missing m, *args, &block
+              m = m.to_s
+              super unless m.last == '?'
+
+              self.include? m[0..-2]
+            end
+          end
+          
+          def calculate_effective_roles_for roles
+            permissions = Rad.multitenant_mode? ? Space.current.permissions : Space.permissions
+            effective_space_permissions = {}
+            permissions.each do |operation, allowed_roles|
+              effective_space_permissions[operation] = roles.any?{|role| allowed_roles.include? role}
+            end
+            effective_space_permissions
+          end
+      end
+      
+    end
+  end
+end

data/lib/rad/mongo_mapper/acts_as/authorized_object.rb

@@ -0,0 +1,171 @@
+module MongoMapper
+  module Plugins
+    module AuthorizedObject
+      
+      module ClassMethods
+        def acts_as_authorized_object
+          key :owner_name, String, :default => lambda{User.current? ? User.current.name : nil}, :protected => true
+          key :collaborators, Array, :protected => true
+          # Contains the role and all upper roles. So complex becouse we need it in indexes.
+          key :viewers, Array, :default => lambda{User.current? ? ["user:#{User.current.name}", 'manager'].sort : ['manager']}, :protected => true
+         
+          validates_presence_of :owner_name
+          validate :validate_viewers
+          validate :validate_collaborators
+        end        
+      end
+      
+      module InstanceMethods
+        # 
+        # Owner
+        # 
+        def owner
+          return nil if owner_name.blank?
+          cache[:owner] ||= User.find_by_name! owner_name
+        end      
+      
+        def owner= user
+          user.must_be.an User
+          cache[:owner] = user
+          self.owner_name = user.name
+          user
+        end
+            
+        # TODO2 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
+            # ::Rails.should_be! :multitenant_mode
+            # (Role::ORDERED_ROLES + Space.current.custom_roles).should! :include, role.to_s
+            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
+      
+      # module ClassMethods
+      #   def can? operation, user
+      #     method = "can_#{operation}?"
+      #     if respond_to? method
+      #       send method, user
+      #     else
+      #       user.effective_space_permissions[operation]
+      #     end
+      #   end        
+      # end
+    end
+  end
+end

data/lib/rad/mongo_mapper/multitenant.rb

@@ -0,0 +1,34 @@
+module MongoMapper
+  module Plugins
+    module Multitenant
+      
+      module ClassMethods                
+        def connect_to_global_database      
+          use_database :global
+        end
+        
+        def belongs_to_space!
+          keys.symbolize_keys.must_not.include :account_id
+          
+          key :account_id, ObjectId, :default => lambda{Account.current? ? Account.current.id : nil}, :protected => true
+          belongs_to :account
+
+          key :space_id, ObjectId, :default => lambda{Space.current? ? Space.current.id : nil}, :protected => true
+          belongs_to :space    
+
+          validates_presence_of :account_id, :space_id
+
+          default_scope do 
+            Space.current? ? {:space_id => Space.current.id} : {}
+          end
+          
+          # defer do
+          ensure_index :account_id
+          ensure_index :space_id
+          # end
+        end        
+      end
+      
+    end
+  end
+end

data/lib/rad/mongo_mapper/rad_micelaneous.rb

@@ -0,0 +1,43 @@
+module MongoMapper
+  module Plugins
+    module RadMicelaneous
+      module InstanceMethods
+        delegate :config, :to => Crystal
+        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 MM as_json conversion
+          hash = as_json(options)
+          
+          # MM fix
+          hash['id'] = hash.delete :id 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
+      end
+      
+      module ClassMethods
+        delegate :config, :to => Crystal
+        delegate :t, :to => I18n
+      end
+    end
+  end
+end
+      

data/lib/rad/mongo_mapper/space_keys.rb

@@ -0,0 +1,62 @@
+module MongoMapper
+  module Plugins
+    module SpaceKeys
+      
+      class SpaceKeysContainer
+        include MongoMapper::EmbeddedDocument
+        key :space_id, ObjectId
+        
+        SKIP_KEYS = %w{_id space_id}
+        
+        def blank?
+          self.class.keys.keys.select{|k| !SKIP_KEYS.include?(k.to_s)}.all?{|k| value = send(k); value.blank? or value == 0}          
+        end
+      end
+      
+      module InstanceMethods        
+        def get_create_or_delete_space_keys_container modifying_operation, &block
+          Rad.multitenant_mode?.must_be.true
+          
+          unless modifying_operation
+            container = space_keys_containers.select{|c| c.space_id == Space.current.id}.first || \
+              SpaceKeysContainer.new(:space_id => Space.current.id)
+            block.call container
+          else
+            container = space_keys_containers.select{|c| c.space_id == Space.current.id}.first || \
+              space_keys_containers.build(:space_id => Space.current.id)              
+            block.call container            
+            space_keys_containers.delete container if container.blank?
+          end
+        end
+      end
+      
+      module ClassMethods
+        def space_key key, type, options = {}
+          define_space_keys_containers
+          
+          SpaceKeysContainer.send :key, key, type, options
+          
+          define_method key do
+            get_create_or_delete_space_keys_container false do |container|
+              container.send key
+            end
+          end
+          
+          define_method "#{key}=" do |value|
+            get_create_or_delete_space_keys_container true do |container|
+              container.send "#{key}=", value
+              value
+            end
+          end
+        end        
+        
+        def define_space_keys_containers
+          unless associations.keys.include? 'space_keys_containers'
+            has_many :space_keys_containers, :class_name => 'MongoMapper::Plugins::SpaceKeys::SpaceKeysContainer', :protected => true
+          end
+        end      
+      end
+      
+    end
+  end
+end

data/lib/rad/mongo_mapper/text_processor.rb

@@ -0,0 +1,47 @@
+module MongoMapper
+  module Plugins
+    module TextProcessor
+      
+      module ClassMethods
+        def markup_key attr_name, opt = {}
+          attr_name = attr_name.to_s
+          opt = opt.to_openobject
+          original_attr_name = "original_#{attr_name}"
+          
+          key original_attr_name, String
+          key attr_name, String, :protected => true unless keys.keys.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=", 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.on(original_attr_name) and (err = errors.on(attr_name))
+              errors.add original_attr_name, err
+            end
+          end
+          after_validation ce_method_name          
+        end
+      end
+      
+    end
+  end
+end

data/lib/rad/mongo_mapper.rb

@@ -0,0 +1,20 @@
+require 'mongo_mapper_ext'
+
+%w(
+  multitenant
+  space_keys
+  text_processor
+  rad_micelaneous
+  acts_as/authenticated_by_open_id
+  acts_as/authenticated_by_password
+  acts_as/authorized
+  acts_as/authorized_object
+).each{|n| require "rad/mongo_mapper/#{n}"}
+
+module RadPluginsAddition
+  def self.included(model)
+    model.plugin MongoMapper::Plugins::Multitenant
+    model.plugin MongoMapper::Plugins::RadMicelaneous
+  end
+end
+MongoMapper::Document.append_inclusions(RadPluginsAddition)

data/lib/rad/paperclip/callbacks.rb

@@ -0,0 +1,40 @@
+Paperclip::ClassMethods.class_eval do
+  def trace_file attachment
+    upd_method_name = "update_file_size_for_#{attachment}"
+    define_method upd_method_name do
+      return if disable_file_audit?
+      
+      size = file_size_for(attachment) 
+      old_size = old_file_size_for(attachment)      
+      
+      if (difference = size - old_size) != 0
+        self.class.increase_user_and_account_files_size difference
+        set_old_file_size_for(attachment, size)
+      end
+    end
+    protected upd_method_name
+    before_save upd_method_name
+    
+    clear_method_name = "clear_file_size_for_#{attachment}"
+    define_method clear_method_name do
+      return if disable_file_audit?
+
+      difference = - old_file_size_for(attachment)
+      self.class.increase_user_and_account_files_size difference
+    end
+    protected clear_method_name
+    after_destroy clear_method_name
+  end
+  
+  def increase_user_and_account_files_size difference
+    # Upsert can't be used becouse user.files_size is not just an attribute
+    # User.current.files_size += difference    
+    # User.upsert :$inc => {:files_size => difference}
+    u = User.current
+    u.files_size += difference
+    u.save!
+    
+    Account.current.files_size += difference
+    Account.current.upsert :$inc => {:files_size => difference}
+  end
+end

data/lib/rad/paperclip/extensions.rb

@@ -0,0 +1,64 @@
+# interpolation = "/system/:class/:attachment/:id_partition/:style_:filename"
+interpolation = "/system/:account/:space/:class/:slug/:attachment/:filename_with_style"
+
+# Paperclip::Attachment.class_eval do
+#   default_options.merge!({
+#     :url => "#{ActionController::Base.relative_url_root}#{interpolation}",
+#     :path => ":rails_root/public" + interpolation,
+#     # :default_url   => "/:attachment/:style/missing.png",
+#   })
+# end
+
+crystal.after :config do |config|
+  Paperclip::Attachment.class_eval do
+    default_options.merge!({
+      :url => "#{config.root('')}#{interpolation}",
+      :path => ":crystal_root/public" + interpolation,
+      # :default_url   => "/:attachment/:style/missing.png",
+    })
+  end
+end
+
+module Paperclip
+  class << self
+    inject :logger => :logger
+  end
+  
+  module Interpolations
+    def filename_with_style attachment, style
+      val = filename(attachment, style).clone
+      if style.to_s != 'original'
+        basename_index = val.rindex('.') || (val.size - 1)
+        val.insert basename_index, ".#{style}"
+      end
+      val
+    end
+    
+    # Handle string ids (mongo)
+    # def id_partition attachment, style
+    #   if (id = attachment.instance.id).is_a?(Integer)
+    #     ("%09d" % id).scan(/\d{3}/).join("/")
+    #   else
+    #     id.to_s.scan(/.{3}/).first(3).join("/")
+    #   end
+    # end
+    
+    %w{name slug}.each do |name|
+      define_method name do |attachment, style|
+        attachment.instance.send name
+      end
+    end
+    
+    def account attachment, style
+      Account.current.name
+    end
+    
+    def space attachment, style
+      Space.current.name
+    end
+    
+    def crystal_root attachment, style
+      crystal.config.root('')
+    end
+  end
+end