rapid 0.0.1

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Dir.chdir File.dirname(__FILE__)	
+
+# Specs
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"].select{|f| f !~ /\/_/}
+  t.libs = ['lib'].collect{|f| "#{File.dirname __FILE__}/#{f}"}
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+	s.name = "rapid"
+	s.version = "0.0.1" 
+	s.summary = "Rapid Application Development platform for Crystal framework"
+	s.description = "Rapid Application Development platform for Crystal framework"
+	s.author = "Alexey Petrushin"
+	#	s.email = ""
+	s.homepage = "http://github.com/alexeypetrushin/rapid"
+  
+	s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  # s.extra_rdoc_files = ["README.rdoc"]
+	
+  # s.files = (%w{rakefile readme.md .gitignore} + Dir.glob("{app,lib,spec,.git}/**/*"))
+  s.files = (['Rakefile', 'readme.md'] + Dir.glob("{lib,spec}/**/*"))
+	
+	s.require_paths = ["lib"]
+
+  [
+    'crystal',
+  ].each{|name| s.add_dependency(name)}
+
+end
+
+PACKAGE_DIR = "#{File.expand_path File.dirname(__FILE__)}/build"
+
+Rake::GemPackageTask.new(spec) do |p|
+	package_dir = PACKAGE_DIR
+#	FileUtils.mkdir package_dir unless File.exist? package_dir	
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+	p.need_zip = true
+	p.package_dir = package_dir
+end
+
+# CLEAN.include [ 'pkg', '*.gem']
+
+task :push do
+  dir = Dir.chdir PACKAGE_DIR do
+    gem_file = Dir.glob("rapid*.gem").first
+    system "gem push #{gem_file}"
+  end
+end
+
+task :clean do
+  system "rm -r #{PACKAGE_DIR}"
+end
+
+task :release => [:gem, :push, :clean]

data/lib/rad/http_controller/acts_as/authenticated.rb

@@ -0,0 +1,131 @@
+# require 'rack/auth/basic.rb'
+
+module Crystal
+  module HttpController
+    module Authenticated    
+    
+      module ClassMethods
+        def acts_as_authenticated
+          include Rad::Authenticated::InstanceMethods
+
+          # TODO2 what to do whith helper methods?
+          # helper_method :login_path, :logout_path, :signup_path, :user_path
+          
+          before :prepare_current_user_for_slave_domain
+        end
+      end
+
+      module InstanceMethods
+        protected     
+          def prepare_current_user_for_slave_domain
+            unless check_and_execute_cas_command
+              user = login_from_basic_auth || login_from_session || login_as_anonymous
+              raise "You probably don't create Anonymous User!" if user.nil?
+              User.current = user
+            end
+          end
+
+      
+          # 
+          # Authentication Methods
+          # 
+          def login_from_basic_auth            
+            # TODO2
+            # authenticate_with_http_basic do |login, password|
+            #   User.authenticate_by_password login, password unless login.blank? or password.blank?
+            # end
+            # username, password = workspace.request.credentials
+            # User.authenticate_by_password username, password unless username.blank? or password.blank?
+          end
+      
+          def login_from_session
+            session = workspace.request.session
+            User.find_by_id session['user_id'] unless session['user_id'].blank?
+          end
+      
+          def login_as_anonymous
+            workspace.request.session[:user_id] = User.anonymous.id.to_s
+            User.anonymous
+          end
+      
+      
+          # 
+          # CAS Authentication
+          # 
+          def check_and_execute_cas_command
+            return unless params.include?('cas_token') or params.include?('cas_logout')
+        
+            session = workspace.request.session
+            if params.include?('cas_token')
+              token = !params[:cas_token].blank? && SecureToken.by_token(params[:cas_token])
+              clear_session!
+              if token and !token[:user_id].blank? and (user = User.first(:id => token[:user_id], :state => 'active'))                
+                session[:user_id] = user.id.to_s
+              else
+                session[:user_id] = User.anonymous.id.to_s
+                flash[:sticky_info] = t(:cas_try_more)
+              end                            
+            elsif params.include? 'cas_logout'              
+              clear_session!
+              login_as_anonymous
+            end
+        
+            # redirect to remove CAS params
+            uri = Uri.parse request.url
+            values = uri.query_values || {}
+            values.delete 'cas_logout'
+            values.delete 'cas_token'
+            uri.query_values = values
+        
+            redirect_to uri.to_s
+          end
+      
+      
+          # 
+          # Helpers
+          # 
+          %w{login logout signup}.each do |path|
+            define_method "#{path}_path" do |*args|
+              options = args.first || {}
+              options = {
+                :host => config.master_domain!,
+                :port => config.port(nil),
+                :l => I18n.locale
+              }.merge(options)        
+              options[:_return_to] = request.url unless params.include? :_return_to
+              url_for "#{ServiceMix.relative_url_root}/#{path}", options
+            end
+          end          
+    
+          def user_path user, options = {}
+            url_for_path "#{ServiceMix.relative_url_root}/users/#{user.to_param}", options
+          end
+      
+      
+          # 
+          # Special
+          # 
+          PRESERVE_SESSION_KEYS = %w{authenticity_token}
+          crystal.after :config do |config|
+            if config.session?
+              session_id = config.session!.key!
+              PRESERVE_SESSION_KEYS << session_id unless PRESERVE_SESSION_KEYS.include? session_id
+            end
+          end
+          
+          
+          def clear_session!
+            workspace.request.session
+                 
+            session[:dumb_key] # hack, need this to initialize session, othervise it's empty               
+            to_delete = session.keys.select{|key| !PRESERVE_SESSION_KEYS.include?(key.to_s)}
+            to_delete.each{|key| session.delete key}
+          end
+        
+      end
+    
+    end
+  end
+end
+
+Crystal::HttpController.inherit Crystal::HttpController::Authenticated

data/lib/rad/http_controller/acts_as/authenticated_master_domain.rb

@@ -0,0 +1,119 @@
+module Crystal
+  module HttpController
+    module AuthenticatedMasterDomain
+    
+      module ClassMethods
+        def acts_as_authenticated_master_domain
+          include Crystal::HttpController::AuthenticatedMasterDomain::InstanceMethods
+                  
+          # TODO1 what to do with helper_methods?
+          # helper_method :login_path, :logout_path, :signup_path, :user_path
+          before :prepare_current_user_for_master_domain
+        end
+      end
+    
+      module InstanceMethods           
+        include ::Crystal::HttpController::Authenticated::InstanceMethods
+      
+        protected     
+          def prepare_current_user_for_master_domain
+            user = login_from_basic_auth || login_from_session || login_from_cookie || login_as_anonymous
+            raise "You probably don't create Anonymous User!" if user.nil?
+            User.current = user
+          end
+
+        
+          # 
+          # Authentication Methods
+          # 
+          def login_from_cookie
+            session, cookies = workspace.request.session, workspace.request.cookies
+            
+            token = !cookies[:auth_token].blank? && SecureToken.by_token(cookies[:auth_token])
+            if token and !token[:user_id].blank? and (user = User.first(:id => token[:user_id], :state => 'active'))
+              session[:user_id] = user.id.to_s
+              user
+            end
+          end
+        
+        
+          # 
+          # CAS Authentication
+          # 
+        
+          # returns cas_token only for another domains
+          def return_to_path_with_cas_token
+            unless master_domain? params[:_return_to]
+              token = SecureToken.new
+              token.expires_at = 5.minutes.from_now
+              token[:type] = 'cas'
+              token[:user_id] = User.current.id.to_s
+              token.save!
+        
+              return return_to_path(:cas_token => token.token)
+            end
+          
+            return_to_path
+          end
+        
+          def return_to_path_with_logout_cas_token
+            unless master_domain? params[:_return_to]
+              return_to_path(:cas_logout => 'true')
+            else
+              return_to_path
+            end
+          end
+        
+          def return_cas_token_if_authenticated
+            # TODO1 fix it, there's no redirect anymore
+            redirect_to return_to_path_with_cas_token unless User.current.anonymous?
+          end
+        
+        
+          # 
+          # Special
+          # 
+          def master_domain? uri
+            unless uri.blank?
+              uri = Uri.parse(uri)
+            
+              if !uri.host.blank? and uri.normalized_host != SETTING.master_domain!                             
+                return false
+              end
+            end
+            true
+          end
+        
+          def set_current_user_with_updating_session user
+            session, cookies = workspace.request.session, workspace.request.cookies
+            current_user = User.current
+            user.must_not == current_user
+
+            # Clear
+            clear_session!
+            unless current_user.anonymous?
+              SecureToken.delete_all :user_id => current_user.id.to_s
+              cookies.delete :auth_token               
+            end
+
+            # Set session and cookie token
+            session[:user_id] = user.id.to_s      
+            unless user.anonymous?
+              token = SecureToken.new
+              token[:user_id] = user.id.to_s
+              token[:type] = 'cookie_auth'
+              token.expires_at = 2.weeks.from_now
+              token.save!
+
+              cookies[:auth_token] = {:value => token.token, :expires => token.expires_at}
+            end
+
+            User.current = user
+          end
+      end
+    
+    end
+  end
+end
+
+Crystal::HttpController.inherit Crystal::HttpController::AuthenticatedMasterDomain

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

@@ -0,0 +1,83 @@
+module Crystal
+  module HttpController    
+    module Authorized
+  
+      module ClassMethods
+        def acts_as_authorized
+          include Crystal::HttpController::Authorized::InstanceMethods
+          extend Crystal::HttpController::Authorized::SingletonMethods
+
+          # TODO1 uncomment thouse helper methods
+          # helper_method :can?, :owner?
+        end
+      end
+
+      module SingletonMethods
+        def require_permission operation, *args, &object_proc
+          operation = operation.must_be.a([String, Symbol]).to_s
+          # operation.should! :be_in, Space.permissions
+        
+          options = args.extract_options!
+          # object_proc = args.size > 0 ? args.first : lambda{}
+          object_proc ||= lambda{}
+        
+          method = "require_permission_#{operation}"
+          define_method method do
+            require_permission operation, instance_eval(&object_proc)
+          end
+          before method, options
+        end
+        # alias_method :require_permission_to, :require_permission
+      end
+
+      module InstanceMethods
+        protected
+          def can? *args
+            User.current.can? *args
+          end          
+        
+          def owner? *args
+            User.current.owner? *args
+          end
+        
+          def login_required
+            access_denied! unless User.current.registered?
+          end
+
+          def login_not_required
+            raise_user_error t(:login_not_required) if User.current.registered?
+          end
+      
+          def require_permission operation, object = nil
+            operation = operation.must_be.a([String, Symbol]).to_s
+            # operation.should! :be_in, Space.permissions
+                    
+            unless User.current.can? operation, object
+              crystal.logger.warn "Access denied, #{User.current.name} hasn't rights to #{operation}!"
+              access_denied!
+            end
+          end
+        
+          def access_denied!            
+            raise_user_error t(:access_denied)
+          end
+
+          # def access_denied
+          #   respond_to do |format|
+          #     format.html do
+          #       flash[:info] = t(:login_required)
+          #       session[:_return_to] = request.request_uri
+          #       redirect_to new_session_path
+          #     end
+          #   
+          #     format.any(:json, :xml) do
+          #       request_http_basic_authentication 'Web Password'
+          #     end
+          #   end
+          # end
+      end
+    end
+  end
+end
+
+Crystal::HttpController.inherit Crystal::HttpController::Authorized

data/lib/rad/http_controller/acts_as/localized.rb

@@ -0,0 +1,27 @@
+module Crystal
+  module HttpController    
+    module Localized
+    
+      module ClassMethods
+        def acts_as_localized
+          include Crystal::HttpController::Localized::InstanceMethods
+          before :prepare_locale
+        end
+      end
+      
+      module InstanceMethods
+        protected     
+          def prepare_locale
+            default_language = (Space.current? ? Space.current.language : nil) || config.default_language('en')
+            I18n.locale = params[:l] || default_language
+        
+            # Delete l from params if language is the same as default
+            params.delete 'l' if params[:l] == default_language
+          end
+      end
+      
+    end    
+  end
+end
+
+Crystal::HttpController.inherit Crystal::HttpController::Localized

data/lib/rad/http_controller/acts_as/multitenant.rb

@@ -0,0 +1,53 @@
+module Crystal
+  module HttpController    
+    module Multitenant
+
+      module InstanceMethods
+        protected        
+          def select_account_and_space
+            begin
+              # preparing Account 
+              subdomains = request.subdomains.select{|n| n != 'www'}
+              subdomain = subdomains.last          
+              pure_domain = request.domain.sub(/\A#{subdomains.join(".")}\./, "")
+
+              domain = subdomain.blank? ? pure_domain : "#{subdomain}.#{pure_domain}"
+
+              Account.current = Account.first :conditions => {:domains => domain}
+              unless Account.current?
+                msg = "No Account registered for the '#{pure_domain}' Domain"
+                logger.debug msg
+                raise msg
+              end
+
+              # preparing Space
+              space_name = params[:s] || 'default'
+              Space.current = Account.current.spaces.first :name => space_name
+
+              unless Space.current?
+                msg = "No '#{space_name}' Space for '#{Account.current.name}' Account"
+                logger.debug msg
+                raise msg
+              end
+          
+              yield
+            ensure
+              Account.current = nil
+              Space.current = nil
+            end
+          end
+              
+      end
+    
+      module ClassMethods
+        def acts_as_multitenant
+          include Rad::Multitenant::InstanceMethods
+        
+          around :select_account_and_space
+        end
+      end
+    end
+  end
+end
+
+Crystal::HttpController.inherit Crystal::HttpController::Multitenant

data/lib/rad/http_controller/helpers/service_mix_helper.rb

@@ -0,0 +1,50 @@
+module ServiceMixHelper
+  
+  # [
+  # ['BOS-Tec', '/'],
+  # ['Lab', lab_path]
+  # ]
+  # 
+  def logo
+    return [] if @logo.blank?    
+    logo = @logo.is_a?(Array) ? @logo : [@logo]
+    logo.size.must_be.in 1..2
+    
+    # Delete default space name if there is
+    logo = logo.select do |item|
+      if item.is_a?(Array)
+        !Space.default?(item[0])
+      else
+        !Space.default?(item)
+      end
+    end
+
+    logo.collect{|item| item.is_a?(Array) ? link_to(item.first, item.last) : item}
+  end
+  
+  #   # [
+  #   # ['Users', user_path],
+  #   # ['Roles']
+  #   # ]
+  #   #
+  #   def breadcrumb
+  #     Array(@breadcrumb)
+  # end
+  # 
+	
+  # def visibility_selector_for object
+  #   object.should_not! :be_nil
+  #   object.should! :be_a, MongoMapper::Acts::AuthorizedObject
+  #   field_name = "#{object.class.model_name.underscore}[visibility_as_string]"
+  #   html = ""
+  #   Role::VISIBILITY_ROLES.each do |role|     
+  #     checked = role == object.visibility_as_string     
+  #     html += radio_button_tag field_name, role, checked
+  #     html += label_tag "#{field_name}_#{role}", t("#{role}_role")
+  #     html += "\n"
+  #   end
+  #   html
+  # end
+end
+
+Crystal::HttpController.helper ServiceMixHelper

data/lib/rad/http_controller.rb

@@ -0,0 +1,15 @@
+%w(
+  authenticated
+  authenticated_master_domain
+  authorized
+  localized
+  multitenant
+).each{|n| require "rad/http_controller/acts_as/#{n}"}
+
+require 'rad/http_controller/helpers/service_mix_helper'
+
+require 'rad/locales'
+
+Crystal::Config::DEFAULTS.merge!({
+  :master_domain => "localhost",
+}.stringify_keys)