ptomato-ramaze 2009.02

data/lib/ramaze/error.rb

@@ -0,0 +1,24 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # The general Namespace for Ramazes Errorclasses
+
+  class Error < StandardError
+    # No action found on Controller
+    class NoAction < Error; end
+
+    # No Controller found for request
+    class NoFilter < Error; end
+
+    # No Controller found for request
+    class NoController < Error; end
+
+    # Wrong parameter count for action
+    class WrongParameterCount < Error; end
+
+    # Error while transformation in template
+    class Template < Error; end
+  end
+end

data/lib/ramaze/gestalt.rb

@@ -0,0 +1,124 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+=begin rdoc
+Example:
+
+  require 'ramaze'
+  require 'ramaze/gestalt'
+
+  page = Ramaze::Gestalt.build{
+    title = 'Hello, World!'
+
+    html do
+      head{ title(title) }
+      body do
+        h1(title)
+        p 'I count to 10'
+        ('1'..'10').each do |count|
+          div(:style => 'width: 25px; height: 25px'){ count }
+        end
+      end
+    end
+  }
+=end
+
+module Ramaze
+
+  # Gestalt is the custom HTML/XML builder for Ramaze, based on a very simple
+  # DSL it will build your markup.
+
+  class Gestalt
+    attr_accessor :out
+
+    # The default way to start building your markup.
+    # Takes a block and returns the markup.
+    #
+    # Example:
+    #   html =
+    #     Gestalt.build do
+    #       html do
+    #         head do
+    #           title "Hello, World!"
+    #         end
+    #         body do
+    #           h1 "Hello, World!"
+    #         end
+    #       end
+    #     end
+    #
+
+    def self.build(&block)
+      self.new(&block).to_s
+    end
+
+    # Gestalt.new is like ::build but will return itself.
+    # you can either access #out or .to_s it, which will
+    # return the actual markup.
+    #
+    # Useful for distributed building of one page.
+
+    def initialize(&block)
+      @out = []
+      instance_eval(&block) if block_given?
+    end
+
+    # catching all the tags. passing it to _gestalt_build_tag
+
+    def method_missing(meth, *args, &block)
+      _gestalt_call_tag meth, args, &block
+    end
+
+    # workaround for Kernel#p to make <p /> tags possible.
+
+    def p(*args, &block)
+      _gestalt_call_tag :p, 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...
+        _gestalt_build_tag name, args[0], &block
+      else
+        # no attributes, but text
+        _gestalt_build_tag name, {}, args, &block
+      end
+    end
+
+    # build a tag for `name`, using `args` and an optional block that
+    # will be yielded
+
+    def _gestalt_build_tag(name, attr = {}, text = [])
+      @out << "<#{name}"
+      @out << attr.map{|k,v| %[ #{k}="#{_gestalt_escape_entities(v)}"] }.join
+      if text != [] or block_given?
+        @out << ">"
+        @out << _gestalt_escape_entities([text].join)
+        if block_given?
+          text = yield
+          @out << text.to_str if text != @out and text.respond_to?(:to_str)
+        end
+        @out << "</#{name}>"
+      else
+        @out << ' />'
+      end
+    end
+
+    def _gestalt_escape_entities(s)
+      s.to_s.gsub(/&/, '&amp;').
+        gsub(/"/, '&quot;').
+        gsub(/'/, '&apos;').
+        gsub(/</, '&lt;').
+        gsub(/>/, '&gt;')
+    end
+
+    def tag(name, *args, &block)
+      _gestalt_call_tag(name.to_s, args, &block)
+    end
+
+    def to_s
+      @out.join
+    end
+    alias to_str to_s
+  end
+end

data/lib/ramaze/helper/aspect.rb

@@ -0,0 +1,106 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # A helper that provides the means to wrap actions of the controller with
+  # other methods.
+  #
+  # For examples please look at the spec/ramaze/helper/aspect.rb
+  #
+  # Like every other helper, you can use it in your controller with:
+  #
+  #   helper :aspect
+
+  module Helper::Aspect
+
+    private
+
+    # lazily and smartly inherit copy of aspects trait from parent, or
+    # bootstrap our own
+    def aspects
+      trait[:aspects] ||= (
+        if hash = ancestral_trait[:aspects]
+          { :before => hash[:before].dup, :after => hash[:after].dup }
+        else
+          { :before => {}, :after => {} }
+        end
+      )
+    end
+
+    # run block before given actions or, if no actions specified, all actions.
+    def before(*meths, &block)
+      return before_all(*meths, &block) if meths.empty?
+      meths.each do |meth|
+        aspects[:before][meth.to_s] = block
+      end
+    end
+    alias pre before
+
+    # Run block before all actions.
+    def before_all(&block)
+      aspects[:before][:all] = block
+    end
+    alias pre_all before_all
+
+    # run block after given actions or, if no actions specified, all actions.
+    def after(*meths, &block)
+      return after_all(*meths, &block) if meths.empty?
+      meths.each do |meth|
+        aspects[:after][meth.to_s] = block
+      end
+    end
+    alias post after
+
+    # Run block after all actions.
+    def after_all(&block)
+      aspects[:after][:all] = block
+    end
+    alias post_all after_all
+
+    # run block before and after given actions, or, if no actions specified.
+    # all actions
+    def wrap(*meths, &block)
+      return wrap_all(*meths, &block) if meths.empty?
+      before(*meths, &block)
+      after(*meths, &block)
+    end
+
+    # run block before and after all actions.
+    def wrap_all(&block)
+      aspects[:before][:all] = block
+      aspects[:after][:all] = block
+    end
+  end
+
+  class Action
+
+    # overwrites the default Action hook and runs the neccesary blocks in its
+    # scope before actions are run, starting from Ramaze::Controller down the
+    # ancestor chain.
+    def before_process
+      common_aspect(:before)
+    end
+
+
+    # overwrites the default Action hook and runs the neccesary blocks in its
+    # scope after actions are run, starting from Ramaze::Controller down the
+    # ancestor chain.
+    def after_process
+      common_aspect(:after)
+    end
+
+    def common_aspect(aspect)
+      return unless path
+
+      controller.relevant_ancestors.reverse_each do |controller|
+        next unless aspects = controller.trait[:aspects]
+
+        [ aspects[aspect][name], aspects[aspect][:all] ].compact.map do |block|
+          instance.instance_eval(&block) if block
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/helper/auth.rb

@@ -0,0 +1,125 @@
+#          Copyright (c) 2008 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
+
+  # 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'
+
+    # 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.
+
+    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}
+        }
+      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
+
+    # call( R(self, :login) ) if not logged in
+
+    def login_required
+      call(Rs(:login)) unless logged_in?
+    end
+
+    # checks if the user is already logged in.
+    #   session[:logged_in] is not nil/false
+
+    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
+      return false if (not user or user.empty?) and (not pass or pass.empty?)
+      auth_table = ancestral_trait[:auth_table] ||= {}
+
+      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)
+
+      default_hashify = lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+
+      hashify  = (ancestral_trait[:auth_hashify] ||= default_hashify)
+      password = hashify[pass.to_s]
+
+      auth_table[user.to_s] == password
+    end
+  end
+end

data/lib/ramaze/helper/bench.rb

@@ -0,0 +1,43 @@
+require 'benchmark'
+
+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
+      # goes on to yield your block +iterations+ times.
+      #
+      # The last yielded return value will be returned upon completion of the
+      # benchmark and the result of the benchmark itself will be sent to
+      # Log.info
+      #
+      # Example:
+      #
+      #   class MainController < Ramaze::Controller
+      #     def index
+      #       @users = bench{ User.all }
+      #       @tags = bench{ Article.tags }
+      #     end
+      #   end
+      #
+      # This will show something like following in your log:
+      # [..] INFO   Bench ./start.rb:3:in `index': 0.121163845062256
+      # [..] INFO   Bench ./start.rb:4:in `index': 2.234987235098341
+      #
+      # 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]
+        delta = Benchmark.realtime{ iterations.times{ nil }}
+        taken = Benchmark.realtime{ iterations.times{ result = yield }}
+        Log.info "Bench #{from}: #{taken - delta}"
+        return result
+      end
+    end
+  end
+end

data/lib/ramaze/helper/cache.rb

@@ -0,0 +1,140 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # This helper is providing easy access to a couple of Caches to use for
+  # smaller amounts of data.
+
+  module Helper::Cache
+    C = Ramaze::Cache
+
+    # 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
+
+    # 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
+
+    def cache *args
+      return value_cache if args.size == 0
+
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      args.compact.each do |arg|
+        actions_cached[arg.to_sym] = opts
+      end
+    end
+
+    private
+
+    # use this to cache values in your controller and templates,
+    # for example heavy calculations or time-consuming queries.
+
+    def value_cache
+      C.value_cache
+    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
+
+    # 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
+
+    def actions_cached
+      ancestral_trait[:actions_cached]
+    end
+  end
+end