manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/current.rb

@@ -1,110 +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
-    end
-  end
-end
-__END__
-
-  module Current
-    class << self
-      include Trinity
-
-      def call(env)
-        setup(env)
-        before_call
-
-        if filter = Global.record
-          request = Current.request
-          Record << request if filter[request]
-        end
-
-        Dispatcher.handle
-
-        finish
-      ensure
-        after_call
-      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 before(&block)
-        @before = block_given? ? block : @before
-      end
-
-      def before_call
-        return unless before
-        before.call
-      rescue Object => e
-        Ramaze::Log.error e
-        raise e
-      end
-
-      def after(&block)
-        @after = block_given? ? block : @after
-      end
-
-      def after_call
-        return unless after
-        after.call
-      rescue Object => e
-        Ramaze::Log.error e
-        raise e
-      end
+  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/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

data/lib/ramaze/helper/disqus.rb

@@ -0,0 +1,26 @@
+require 'disqus'
+require 'disqus/view_helpers'
+
+module Ramaze
+  module Helper
+
+    # Provides shortcuts via Disqus::ViewHelpers.
+    #
+    # Make sure that you set your disqus credentials when using this helper:
+    #   Disqus::defaults[:account] = "my_disqus_account"
+    # And optionally, only if you're using the API
+    #   Disqus::defaults[:api_key] = "my_disqus_api_key"
+    #
+    # Available methods are:
+    #
+    #   disqus_combo
+    #   disqus_comment_counts
+    #   disqus_popular_threads
+    #   disqus_recent_comments
+    #   disqus_thread
+    #   disqus_top_commenters
+    module Disqus
+      include ::Disqus::ViewHelpers
+    end
+  end
+end

data/lib/ramaze/helper/flash.rb

@@ -22,38 +22,41 @@ module Ramaze
   #
   # On the request after this, flash[:error] is gone.
 
-  module Helper::Flash
-    trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
-    # answers with Session.current.flash
+  module Helper
+    module Flash
+      include Innate::Traited
 
-    def flash
-      Session.current.flash
-    end
+      trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
 
-    # Use in your template to display all flash messages that may be stored.
-    # For example, given you stored:
-    #
-    #   flash # => { :error => 'Pleae enter your name'
-    #                :info => 'Do you see the fnords?' }
-    #
-    # Then a flashbox would display:
-    #
-    #   <div class='flash' id='flash_error'>Please enter your name</div>
-    #   <div class='flash' id='flash_info'>Do you see the fnords?</div>
-    #
-    # This is designed to be customized permanently or per usage:
-    #
-    #   flashbox("<div class='flash_%key'>%value</div>")
-    #
-    # Where any occurrence of %key and %value will be replaced by the actual
-    # contents of each element of flash
+      # answers with Current.session.flash
+      def flash
+        Current.session.flash
+      end
 
-    def flashbox(tag = ancestral_trait[:flashbox])
-      flash.map{|key, *values|
-        values.flatten.map do |value|
-          tag.gsub(/%key/, key.to_s).gsub(/%value/, value.to_s)
-        end
-      }.flatten.join("\n")
+      # Use in your template to display all flash messages that may be stored.
+      # For example, given you stored:
+      #
+      #   flash # => { :error => 'Pleae enter your name'
+      #                :info => 'Do you see the fnords?' }
+      #
+      # Then a flashbox would display:
+      #
+      #   <div class='flash' id='flash_error'>Please enter your name</div>
+      #   <div class='flash' id='flash_info'>Do you see the fnords?</div>
+      #
+      # This is designed to be customized permanently or per usage:
+      #
+      #   flashbox("<div class='flash_%key'>%value</div>")
+      #
+      # Where any occurrence of %key and %value will be replaced by the actual
+      # contents of each element of flash
+      def flashbox(tag = ancestral_trait[:flashbox])
+        flash.map{|key, *values|
+          values.flatten.map do |value|
+            tag.gsub(/%key/, key.to_s).gsub(/%value/, value.to_s)
+          end
+        }.flatten.join("\n")
+      end
     end
   end
 end