ramaze 2009.03 → 2009.04

data/lib/ramaze/controller/default.rb

@@ -0,0 +1,12 @@
+module Ramaze
+  Log.debug "Default controller invoked"
+
+  class DefaultController < Ramaze::Controller
+    map '/'
+
+    def lobster
+      require 'rack/lobster'
+      respond Rack::Lobster::LobsterString
+    end
+  end
+end

data/lib/ramaze/current.rb

@@ -1,51 +1,7 @@
-require 'ramaze/current/request'
-require 'ramaze/current/response'
-require 'ramaze/current/session'
-
 module Ramaze
-  class Current
-    include Trinity
-    extend Trinity
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      setup(env)
-      before_call
-      record
-
-      @app.call(env)
-      finish
-    ensure
-      after_call
-    end
-
-    def record
-      return unless filter = Global.record
-      request = Current.request
-      Record << request if filter.call(request)
-    end
-
-    def setup(env)
-      self.request = Request.new(env)
-      self.response = Response.new
-      self.session = Session.new
-    end
-
-    def finish
-      session.finish if session
-      response.finish
-    end
-
-    def self.call(env)
-    end
-
-    def before_call
-    end
-
-    def after_call
+  class Current < Innate::Current
+    def setup(env, request = Request, response = Response, session = Session)
+      super
     end
   end
 end

data/lib/ramaze/files.rb

@@ -0,0 +1,24 @@
+module Ramaze
+  # Serving multiple public directories made easy.
+  class Files
+    def initialize(*roots)
+      @roots = roots.flatten.map{|root| File.expand_path(root.to_s) }
+      sync
+    end
+
+    def call(env)
+      @cascade.call(env)
+    end
+
+    def <<(path)
+      @roots << File.expand_path(path.to_s)
+      @roots.uniq!
+      sync
+    end
+
+    def sync
+      file_apps = @roots.map{|root| Rack::File.new(root) }
+      @cascade = Rack::Cascade.new(file_apps)
+    end
+  end
+end

data/lib/ramaze/gestalt.rb

@@ -1,4 +1,4 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 =begin rdoc
@@ -75,6 +75,11 @@ module Ramaze
       _gestalt_call_tag :p, args, &block
     end
 
+    # workaround for Kernel#select to make <select></select> work
+    def select(*args, &block)
+      _gestalt_call_tag(:select, args, &block)
+    end
+
     def _gestalt_call_tag(name, args, &block)
       if args.size == 1 and args[0].kind_of? Hash
         # args are just attributes, children in block...

data/lib/ramaze/helper.rb

@@ -1,87 +1,12 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/trinity'
+require 'innate/helper'
 
 module Ramaze
+  Helper = Innate::Helper
+  Innate::HelpersHelper.options.paths << File.dirname(__FILE__)
 
-  # A module used by the Templates and the Controllers
-  # it provides both Ramaze::Trinity (request/response/session)
-  # and also a helper method, look below for more information about it
-
-  module Helper
-    LOOKUP = Set.new
-    PATH = ['']
-    path = File.expand_path("#{BASEDIR}/../spec/ramaze/helper/")
-    trait :ignore => [
-      /#{Regexp.escape(path)}\//
-    ]
-
-    module Methods
-      def self.included other
-        other.send :extend, Trinity
-        other.send :extend, Methods
-        other.send :include, Trinity
-        super
-      end
-
-      def self.extend_object other
-        other.send :extend, Trinity
-        super
-      end
-
-      # This loads the helper-files from /ramaze/helper/helpername.rb and
-      # includes it into Ramaze::Template (or wherever it is called)
-      #
-      # Usage:
-      #   helper :redirect, :link
-
-      def helper(*syms)
-        syms.each do |sym|
-          name = sym.to_s
-          if mod = find_helper(name)
-            use_helper(mod)
-          else
-            if require_helper(name)
-              redo
-            else
-              raise LoadError, "helper #{name} not found"
-            end
-          end
-        end
-      end
-
-      private
-
-      # returns the Ramaze::Helper::Name Module Constant if exists.
-
-      def find_helper(name)
-        name = name.to_s.camel_case
-        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
-        if mod_name = ramaze_helper_consts.first
-          ::Ramaze::Helper.const_get(mod_name)
-        end
-      end
-
-      # Loads helper from /lib/ramaze/helper/name.(so, bundle, rb)
-      # raises LoadError if helper not found.
-
-      def require_helper(name)
-        paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
-        glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
-        files = Dir[glob]
-        ignore = Helper.trait[:ignore]
-        files.reject!{|f| ignore.any?{|i| f =~ i }}
-        raise LoadError, "file for #{name} not found" unless file = files.first
-        require(file)
-      end
-
-      # injects the helper via include and extend, takes Constant as argument.
-
-      def use_helper(mod)
-        include mod
-        extend mod
-      end
-    end
-  end
+  require 'ramaze/helper/flash'
+  require 'ramaze/helper/link'
 end

data/lib/ramaze/helper/auth.rb

@@ -1,125 +1,89 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'digest/sha1'
-
 module Ramaze
+  module Helper
 
-  # A simple way to do authentication. Please have a look at the docs for the
-  # check_auth method for detailed information
-
-  module Helper::Auth
-    Helper::LOOKUP << self
-
-    # add Helper::Aspect and Helper::Stack on inclusion of Helper::Auth
-
-    def self.included(klass)
-      klass.send(:helper, :aspect, :stack)
-    end
-
-    # The default Element to use (if any)
-
-    AUTH_ELEMENT = 'Page'
+    # A simple way to do authentication without a model.
+    # Please have a look at the docs of Auth#auth_login.
+    #
+    # If you want to do authentication with a model see Helper::User instead.
+    module Auth
+      Helper::LOOKUP << self
+      include Ramaze::Traited
 
-    # action for login, takes a password
-    # ( ?password=passwort or /login/passwort or via a form )
-    # if no password given, shows a simple form to input it.
+      trait :auth_table => {}
+      trait :auth_hashify => lambda{|pass| Digest::SHA1.hexdigest(pass) }
+      trait :auth_post_only => false
 
-    def login
-      username, password = request[:username, :password]
-      if check_auth(username, password)
-        session[:logged_in] = true
-        session[:username] = username
-        inside_stack? ? answer : redirect_referrer
-      else
-        if defined? AUTH_ELEMENT and AUTH_ELEMENT.to_s.split.any?
-          open_element = "<#{AUTH_ELEMENT}>"
-          close_element = "</#{AUTH_ELEMENT}>"
-        end
-        %{
-          #{open_element}
-            <form method="POST" action="#{Rs(:login)}">
-              <ul style="list-style:none;">
-                <li>Username: <input type="text" name="username" /></li>
-                <li>Password: <input type="password" name="password" /></li>
-                <li><input type="submit" /></li>
-              </ul>
-            </form>
-          #{close_element}
-        }
+      def self.included(into)
+        into.helper(:stack)
       end
-    end
-
-    # clear the session and redirect to the index action of the mapping of the
-    # current controller.
-
-    def logout
-      session.clear
-      redirect_referer
-    end
 
-    private
+      def login
+        return auth_template if trait[:auth_post_only] and !request.post?
+        @username, password = request[:username, :password]
+        answer(request.referer) if auth_login(@username, password)
+        return auth_template
+      end
 
-    # call( R(self, :login) ) if not logged in
+      def logout
+        auth_logout
+        answer(request.referer)
+      end
 
-    def login_required
-      call(Rs(:login)) unless logged_in?
-    end
+      private
 
-    # checks if the user is already logged in.
-    #   session[:logged_in] is not nil/false
+      def login_required
+        call(r(:login)) unless logged_in?
+      end
 
-    def logged_in?
-      !!session[:logged_in]
-    end
+      # @return [true false] whether user is logged in right now
+      def logged_in?
+        !!session[:logged_in]
+      end
 
-    # check the authentication (username and password) against the auth_table.
-    #
-    # auth_table is a trait, it may be the name of a method, a Proc or a simple
-    # Hash.
-    # If it is neither of the above it has at least to respond to #[]
-    # which will pass it the username as key and it should answer with the
-    # password as a Digest::SHA1.hexdigest.
-    #
-    # The method and Proc are both called on demand.
-    #
-    # If you want to change the way the password is hashed, change
-    #   trait[:auth_hashify]
-    #
-    # The default looks like:
-    #   lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
-    #
-    # As with the auth_table, this has to be an object that responds to #[]
-    #
-    # If you want all your controllers to use the same mechanism set the trait
-    # on one of the ancestors, the traits are looked up by #ancestral_trait
-    #
-    # Examples:
-    #
-    #   # The method to be called.
-    #   trait :auth_table => :auth_table
-    #   trait :auth_table => 'auth_table'
-    #
-    #   # Lambda that will be called upon demand
-    #   trait :auth_table => lambda{ {'manveru' => Digest::SHA1.hexdigest 'password'} }
-    #
-    #   # Hash holding the data.
-    #   trait :auth_table => {'manveru' => Digest::SHA1.hexdigest('password')}
+      def check_auth(user, pass)
+        Ramaze.deprecated('Helper::User#check_auth', 'Helper::User#auth_login')
+        auth_login(user, pass)
+      end
 
-    def check_auth user, pass
-      return false if (not user or user.empty?) and (not pass or pass.empty?)
-      auth_table = ancestral_trait[:auth_table] ||= {}
+      # @return
+      def auth_login(user, pass)
+        return unless user and pass
+        return if user.empty? or pass.empty?
+        return unless table = ancestral_trait[:auth_table]
+        return unless hashify = ancestral_trait[:auth_hashify]
+
+        if table.respond_to?(:to_sym) or table.respond_to?(:to_str)
+          table = send(table)
+        elsif table.respond_to?(:call)
+          table = table.call
+        end
 
-      auth_table = method(auth_table) if auth_table.is_a?(Symbol)
-      auth_table = method(auth_table) if auth_table.respond_to?(:to_str)
-      auth_table = auth_table.call    if auth_table.respond_to?(:call)
+        return unless table[user] == hashify.call(pass)
 
-      default_hashify = lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+        session[:logged_in] = true
+        session[:username] = user
+      end
 
-      hashify  = (ancestral_trait[:auth_hashify] ||= default_hashify)
-      password = hashify[pass.to_s]
+      def auth_logout
+        session.delete(:logged_in)
+        session.delete(:username)
+      end
 
-      auth_table[user.to_s] == password
+      # @return [String] template for auth
+      def auth_template
+        <<-TEMPLATE.strip!
+<form method="post" action="#{r(:login)}">
+  <ul style="list-style:none;">
+    <li>Username: <input type="text" name="username" value="#@username"/></li>
+    <li>Password: <input type="password" name="password" /></li>
+    <li><input type="submit" /></li>
+  </ul>
+</form>
+        TEMPLATE
+      end
     end
   end
 end

data/lib/ramaze/helper/bench.rb

@@ -4,7 +4,6 @@ module Ramaze
   module Helper
 
     # Little helper to give you a hand when benching parts of actions
-
     module Bench
 
       # Will first run an empty loop to determine the overhead it imposes, then
@@ -29,7 +28,6 @@ module Ramaze
       #
       # So now we know that the Article.tags call takes the most time and
       # should be improved.
-
       def bench(iterations = 1)
         result = nil
         from = caller[0]

data/lib/ramaze/helper/cache.rb

@@ -1,140 +1,91 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+  module Helper
 
-  # This helper is providing easy access to a couple of Caches to use for
-  # smaller amounts of data.
+    # Caching of simple objects and whole action responses.
+    module Cache
 
-  module Helper::Cache
-    C = Ramaze::Cache
+      # Setup needed traits, add the singleton methods and add the caches used
+      # by this helper.
+      #
+      # @param [Class] into Class that this Module is included into
+      # @author manveru
+      def self.included(into)
+        into.extend(SingletonMethods)
+        into.add_action_wrapper(6.0, :cache_wrap)
+        into.trait[:cache_action] ||= Set.new
+        Ramaze::Cache.add(:action, :action_value)
+      end
 
-    # Create the Cache.value_cache on inclusion if it doesn't exist yet.
-    def self.included(klass)
-      C.add(:value_cache) unless C::CACHES.has_key?(:value_cache)
-    end
+      # @param [Action] action The currently wrapped action
+      # @yield The next block in wrap_action_call
+      # @return [String] the response body
+      # @see Innate::Node#wrap_action_call
+      # @author manveru
+      def cache_wrap(action)
+        cache = Innate::Cache.action
 
-    # Example:
-    #
-    #   class FooController < Ramaze::Controller
-    #     helper :cache
-    #     cache :index, :map_of_the_internet
-    #   end
-    #
-    # cache supports these options
-    #   [+:ttl+]  time-to-live in seconds
-    #   [+:key+]  proc that returns a key to store cache with
-    #
-    # Example:
-    #
-    #   class CacheController < Ramaze::Controller
-    #     helper :cache
-    #
-    #     # for each distinct value of request['name']
-    #     # cache rendered output of name action for 60 seconds
-    #     cache :name, :key => lambda{ request['name'] }, :ttl => 60
-    #
-    #     def name
-    #       "hi #{request['name']}"
-    #     end
-    #   end
-    #
-    # cache acts as a wrapper for value_cache if no args are given
+        ancestral_trait[:cache_action].each do |cache_action|
+          temp  = cache_action.dup
+          block = temp.delete(:key)
+          ttl   = temp.delete(:ttl)
 
-    def cache *args
-      return value_cache if args.size == 0
+          if temp.all?{|key, value| action[key] == value }
+            cache_key = action.full_path
+            cache_key << "_#{action.instance.instance_eval(&block).to_s}" if block
 
-      opts = args.last.is_a?(Hash) ? args.pop : {}
+            if cached = cache[cache_key]
+              action.options[:content_type] = cached[:type]
+            else
+              cached = {
+                :body => catch(:respond) { yield },
+                :type => response['Content-Type']
+              }
 
-      args.compact.each do |arg|
-        actions_cached[arg.to_sym] = opts
-      end
-    end
+              if ttl
+                cache.store(cache_key, cached, :ttl => ttl)
+              else
+                cache.store(cache_key, cached)
+              end
+            end
 
-    private
+            return cached[:body]
+          end
+        end
 
-    # use this to cache values in your controller and templates,
-    # for example heavy calculations or time-consuming queries.
+        yield
+      end
 
-    def value_cache
-      C.value_cache
-    end
+      # @return [Object] The cache wrapper assigned for :action_value
+      # @see Innate::Cache
+      # @author manveru
+      def cache_value
+        Ramaze::Cache.action_value
+      end
 
-    # action_cache holds rendered output of actions for which caching is enabled.
-    #
-    # For simple cases:
-    #
-    #   class Controller < Ramaze::Controller
-    #     map '/path/to'
-    #     helper :cache
-    #     cache :action
-    #
-    #     def action with, params
-    #       'rendered output'
-    #     end
-    #   end
-    #
-    #   { '/path/to/action/with/params' => {
-    #       :time => Time.at(rendering),
-    #       :type => 'content/type',
-    #       :content => 'rendered output'
-    #     }
-    #   }
-    #
-    # If an additional key is provided:
-    #
-    #   class Controller < Ramaze::Controller
-    #     map '/path/to'
-    #     helper :cache
-    #     cache :action, :key => lambda{ 'value of key proc' }
-    #
-    #     def action
-    #       'output'
-    #     end
-    #   end
-    #
-    #   { '/path/to/action' => {
-    #       'value of key proc' => {
-    #         :time => Time.at(rendering),
-    #         :type => 'content/type',
-    #         :content => 'output'
-    #       }
-    #     }
-    #   }
-    #
-    # Caches can be invalidated after a certain amount of time
-    # by supplying a :ttl option (in seconds)
-    #
-    #   class Controller < Ramaze::Controller
-    #     helper :cache
-    #     cache :index, :ttl => 60
-    #
-    #     def index
-    #       Time.now.to_s
-    #     end
-    #   end
-    #
-    # or by deleting values from action_cache directly
-    #
-    #   action_cache.clear
-    #   action_cache.delete '/index'
-    #   action_cache.delete '/path/to/action'
 
-    def action_cache
-      C.actions
-    end
+      # @deprecated Use the #cache_value method instead
+      # @author manveru
+      def value_cache
+        Ramaze::deprecated('Innate::Helper::Cache#value_cache',
+                           'Innate::Helper::Cache#cache_value')
+        cache_value
+      end
 
-    # This refers to the class-trait of cached actions, you can
-    # add/remove actions to be cached.
-    #
-    # Example:
-    #
-    #   class FooController < Ramaze::Controller
-    #     trait :actions_cached => [:index, :map_of_the_internet]
-    #   end
+      module SingletonMethods
+        def cache(name, hash = {})
+          Ramaze.deprecated('Helper::Cache::cache', 'Helper::Cache::cache_action')
+          cache_action(hash.merge(:method => name))
+        end
 
-    def actions_cached
-      ancestral_trait[:actions_cached]
+        def cache_action(hash, &block)
+          hash[:key] = block if block_given?
+          hash[:method] = hash[:method].to_s
+          trait[:cache_action] << hash
+        end
+      end
     end
   end
 end