ramaze 0.0.6

data/lib/ramaze/helper/link.rb

@@ -0,0 +1,80 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  # LinkHelper is included into the Template::Ramaze by default
+  #
+  # this helper tries to get along without any major magic, the only 'magic'
+  # thing is that it looks up controller-paths if you pass it a controller
+  # the text shown is always the last segmet of the finished link from split('/')
+  #
+  # usage is pretty much shown in test/tc_helper
+  # however, to give you some idea of how it actually works, some examples:
+  #
+  # link MainController, :foo                 #=> '<a href="/foo">foo</a>'
+  # link MinorController, :foo                #=> '<a href="/minor/foo">foo</a>'
+  # link MinorController, :foo, :bar          #=> '<a href="/minor/foo/bar">bar</a>'
+  # link MainController, :foo, :raw => true   #=> '/foo'
+  # link MainController, :foo => :bar         #=> '/?foo=bar'
+  #
+  # link_raw MainController, :foo             #=> '/foo'
+  # link_raw MinorController, :foo            #=> '/minor/foo'
+  # link_raw MinorController, :foo, :bar      #=> '/minor/foo/bar'
+  #
+  # TODO:
+  #   - handling of no passed parameters
+  #   - setting imagelinks
+  #   - setting of id or class
+  #   - taking advantae of Gestalt to build links
+  #   - lots of other minor niceties, for the moment i'm only concerned to keep
+  #     it as simple as possible
+  #
+
+  module LinkHelper
+
+    # Usage:
+    #   link MainController, :foo                 #=> '<a href="/foo">foo</a>'
+    #   link MinorController, :foo                #=> '<a href="/minor/foo">foo</a>'
+    #   link MinorController, :foo, :bar          #=> '<a href="/minor/foo/bar">bar</a>'
+    #   link MainController, :foo, :raw => true   #=> '/foo'
+    #   link MainController, :foo, :title => 'a'  #=> '<a href="/minor/foo/bar">a</a>'
+    #   link MainController, :foo => :bar         #=> '/?foo=bar'
+
+    def link *to
+      hash = to.last.is_a?(Hash) ? to.pop : {}
+
+      to = to.flatten
+
+      to.map! do |t|
+        t = t.class if not t.respond_to?(:transform) and t.is_a?(Controller)
+        Global.mapping.invert[t] || t
+      end
+
+      raw, title = hash.delete(:raw), hash.delete(:title)
+      opts = hash.inject('?'){|s,(k,v)| s << "#{k}=#{v};"}[0..-2]
+      link = to.join('/').squeeze('/') << (opts.empty? ? '' : opts)
+
+      if raw
+        link
+      else
+        title ||= link.split('/').last.to_s.split('?').first || 'index'
+        %{<a href="#{link}">#{title}</a>}
+      end
+    end
+
+    # Usage:
+    #   R MainController, :foo        #=> '/foo'
+    #   R MinorController, :foo       #=> '/minor/foo'
+    #   R MinorController, :foo, :bar #=> '/minor/foo/bar'
+
+    def R *to
+      if to.last.is_a?(Hash)
+        to.last[:raw] = true
+      else
+        to << {:raw => true}
+      end
+
+      link(*to)
+    end
+  end
+end

data/lib/ramaze/helper/redirect.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # RedirectHelper actually takes advantage of LinkHelper.link_raw to build the links
+  # it redirects to.
+  # It doesn't do much else than this:
+  #     setting a status-code of 303 and a head['Location'] = link
+  # returning some nice text for visitors who insist on ignoring those hints :P
+  #
+  # example of usage:
+  #   redirect MainController
+  #   redirect MainController, :foo
+  #   redirect 'foo/bar'
+  #
+  # TODO:
+  #   - setting custom status-code, it ignores any preset ones at the moment
+  #   - maybe some more options, like a delay
+  #
+
+  module RedirectHelper
+
+    # Usage:
+    #   redirect MainController
+    #   redirect MainController, :foo
+    #   redirect 'foo/bar'
+
+    def redirect *target
+      target = target.join('/')
+
+      response.head['Location'] = target
+
+      hash = target.find{|h| h.is_a?(Hash)} and status = hash.delete(:status) rescue nil
+
+      response.code = status || STATUS_CODE[:see_other]
+      response.out = %{Please follow <a href="#{target}">#{target}</a>!}
+
+      throw :respond
+    end
+
+    # redirect to the location the browser says it's coming from.
+
+    def redirect_referer
+      redirect request.referer
+    end
+  end
+end

data/lib/ramaze/helper/stack.rb

@@ -0,0 +1,67 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # provides an call/answer mechanism, this is useful for example in a
+  # login-system.
+  #
+  # It is basically good to redirect temporarly somewhere else without
+  # forgetting where you come from and offering a nice way to get back
+  # to the last urls.
+  #
+  # Example:
+  #
+  # class AuthController < Template::Ramaze
+  #   helper :stack
+  #
+  #   def login pass
+  #     if pass == 'password'
+  #       session[:logged_in] = true
+  #       answer if inside_stack?
+  #       redirect '/'
+  #     else
+  #       "failed"
+  #     end
+  #   end
+  #
+  #   def logged_in?
+  #     !!session[:logged_in]
+  #   end
+  # end
+  #
+  # class ImportantController < Template::Ramaze
+  #   helper :stack
+  #
+  #   def secret_information
+  #     call :login unless logged_in?
+  #     "Agent X is assinged to fight the RubyNinjas"
+  #   end
+  # end
+
+  module StackHelper
+    private
+
+    # redirect to another location and pushing the current location
+    # on the session[:STACK]
+
+    def call this
+      (session[:STACK] ||= []) << request.request_uri
+      redirect(this)
+    end
+
+    # return to the last location on session[:STACK]
+
+    def answer
+      redirect session[:STACK].pop if inside_stack?
+    end
+
+    # check if the stack has something inside.
+
+    def inside_stack?
+      not session[:STACK].empty?
+    rescue
+      false
+    end
+  end
+end

data/lib/ramaze/http_status.rb

@@ -0,0 +1,66 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  STATUS_CODE = {
+    # 1xx Informational (Request received, continuing process.)
+
+    :continue                         => 100,
+    :switching_protocols              => 101,
+
+    # 2xx Success (The action was successfully received, understood, and accepted.)
+
+    :ok                               => 200,
+    :created                          => 201,
+    :accepted                         => 202,
+    :non_authorative_information      => 203,
+    :no_content                       => 204,
+    :resent_content                   => 205,
+    :partial_content                  => 206,
+    :multi_status                     => 207,
+
+    # 3xx Redirection (The client must take additional action to complete the request.)
+
+    :multiple_choices                 => 300,
+    :moved_permamently                => 301,
+    :moved_temporarily                => 302,
+    :found                            => 302,
+    :see_other                        => 303,
+    :not_modified                     => 304,
+    :use_proxy                        => 305,
+    :switch_proxy                     => 306,
+    :temporary_redirect               => 307,
+
+    # 4xx Client Error (The request contains bad syntax or cannot be fulfilled.)
+
+    :bad_request                      => 400,
+    :unauthorized                     => 401,
+    :payment_required                 => 402,
+    :forbidden                        => 403,
+    :not_found                        => 404,
+    :method_not_allowed               => 405,
+    :not_aceptable                    => 406,
+    :proxy_authentication_required    => 407,
+    :request_timeout                  => 408,
+    :conflict                         => 409,
+    :gone                             => 410,
+    :length_required                  => 411,
+    :precondition_failed              => 412,
+    :request_entity_too_large         => 413,
+    :request_uri_too_long             => 414,
+    :unsupported_media_type           => 415,
+    :requested_range_not_satisfiable  => 416,
+    :expectation_failed               => 417,
+    :retry_with                       => 449,
+
+    # 5xx Server Error (The server failed to fulfill an apparently valid request.)
+
+    :internal_server_error            => 500,
+    :not_implemented                  => 501,
+    :bad_gateway                      => 502,
+    :service_unavailable              => 503,
+    :gateway_timeout                  => 504,
+    :http_version_not_supported       => 505,
+    :bandwidth_limit_exceeded         => 509, # (not official)
+  }
+end

data/lib/ramaze/inform.rb

@@ -0,0 +1,166 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # The module Inform is mainly used for Debugging and Logging.
+  #
+  # You can include/extend your objects with it and access its methods.
+  # Please note that all methods are private, so you should use them only
+  # within your object. The reasoning for making them private is simply
+  # to avoid interference inside the controller.
+  #
+  # In case you want to use it from the outside you can work over the
+  # Informer object. This is used for example as the Logger for WEBrick.
+  #
+  # Inform is a tag-based system, Global.inform_tags holds the tags
+  # that are used to filter the messages passed to Inform. The default
+  # is to use all tags :debug, :info and :error.
+  #
+  # You can control what gets logged over this Set.
+
+  module Inform
+    # the possible tags
+    trait :tags => [:debug, :info, :error]
+
+    private
+
+    # general debugging information, this yields quite verbose information
+    # about how requests make their way through Ramaze.
+    #
+    # Use it for your own debugging purposes.
+    # All messages you pass to it are going to be inspected.
+    # it is aliased to #D for convenience.
+
+    def debug *messages
+      return unless inform_tag?(:debug)
+      log(Global.inform_prefix_debug, *messages.map{|m| m.inspect})
+    end
+
+    alias D debug
+
+    # A little but powerful method to debug calls to methods.
+    #
+    #   def foo(*args)
+    #     meth_debug(:foo, args)
+    #   end
+    #
+    #   foo :bar
+    #
+    # Will give you
+    #
+    #   [2007-01-26 22:17:24] DEBUG  foo([:bar])
+    #
+    # It will also run inspect on all parameters you pass to it (only the
+    # method-name is processed with to_s)
+    #
+    # It is aliased to #mD
+
+    def meth_debug meth, *params
+      return unless inform_tag?(:debug)
+      log(Global.inform_prefix_debug, "#{meth}(#{params.map{|pa| pa.inspect}.join(', ')})")
+    end
+
+    alias mD meth_debug
+
+    # General information about startup, requests and other things.
+    #
+    # Use of this method is mainly for things that are not overly verbose
+    # but give you a general overview about what's happening.
+
+    def info message
+      return unless inform_tag?(:info)
+      log(Global.inform_prefix_info, message)
+    end
+
+    # Informing yourself about errors, you can pass it instances of Error
+    # but also simple Strings.
+    # (all that responds to :message/:backtrace or to_s)
+    #
+    # It will nicely truncate the backtrace to:
+    #   Global.inform_backtrace_size
+    # It will not differentiate its behaviour based on other tags, as
+    # having a full backtrace is the most valuable thing to fixing the issue.
+    #
+    # However, you can set a different behaviour by adding/removing tags from:
+    #   Global.inform_backtrace_for
+    # By default it just points to Global.inform_tags
+
+    def error *messages
+      return unless inform_tag?(:error)
+      prefix = Global.inform_prefix_error
+      messages.each do |e|
+        if e.respond_to?(:message) and e.respond_to?(:backtrace)
+          log prefix, e.message
+          if (Global.inform_backtrace_for || Global.inform_tags).any?{|t| inform_tag?(t)}
+            e.backtrace[0..10].each do |bt|
+              log prefix, bt
+            end
+          end
+        else
+          log prefix, e
+        end
+      end
+    end
+
+    # This uses Global.inform_timestamp or a date in the format of
+    #   %Y-%m-%d %H:%M:%S
+    #   # => "2007-01-19 21:09:32"
+
+    def timestamp
+      mask = Global.inform_timestamp
+      Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+    end
+
+    # is the given inform_tag in Global.inform_tags ?
+
+    def inform_tag?(inform_tag)
+      Global.inform_tags.include?(inform_tag)
+    end
+
+    # the common logging-method, you shouldn't have to call this yourself
+    # it takes the prefix and any number of messages.
+    #
+    # The produced inform-message consists of
+    #   [timestamp] prefix  message
+    # For the output is anything used that responds to :puts, the default
+    # is $stdout in:
+    #   Global.inform_to
+    # where you can configure it.
+    #
+    # To log to a file just do
+    #   Global.inform_to = File.open('log.txt', 'a+')
+
+    def log prefix, *messages
+      [messages].flatten.each do |message|
+        compiled = %{[#{timestamp}] #{prefix}  #{message}}
+        out =
+          case Global.inform_to
+          when $stdout, :stderr, 'stdout' : $stdout
+          when $stdout, :stderr, 'stderr' : $stderr
+          else
+            File.open(Global.inform_to, 'ab+')
+          end
+        out.puts(*compiled) unless (out.respond_to?(:closed?) and out.closed?)
+      end
+    end
+
+    extend self
+  end
+
+  class GlobalInformer
+    include Inform
+
+    public :error, :info, :meth_debug, :debug
+
+    # this simply sends the parameters to #debug
+
+    def <<(*str)
+      debug(*str)
+    end
+  end
+
+  Informer = GlobalInformer.new
+
+  include Inform
+end

data/lib/ramaze/snippets.rb

@@ -0,0 +1,5 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/snippets/kernel/aquire'
+aquire 'ramaze/snippets/*'

data/lib/ramaze/snippets/hash/keys_to_sym.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Hash
+
+  # convert all keys in the Hash to symbols.
+
+  def keys_to_sym!
+    each do |key, value|
+      self[key.to_sym] = delete(key)
+    end
+  end
+
+  # answer with a new Hash with all keys as symbols.
+
+  def keys_to_sym
+    dup.keys_to_sym!
+  end
+end