ramaze 0.0.9 → 0.1.0

data/lib/ramaze/helper/aspect.rb

@@ -20,7 +20,7 @@ module Ramaze
     def self.included(klass)
       # if we haven't been included yet...
       unless defined?(Traits[klass][:aspects]) and Traits[klass][:aspects]
-        Traits[klass] = {:aspects => {:pre => {}, :post => {}, :wrap => {}}}
+        klass.trait :aspects => {:pre => {}, :post => {}, :wrap => {}}
         unless defined?(klass.old_render)
           klass.class_eval do
             class << self
@@ -188,21 +188,23 @@ module Ramaze
     # it just searches for post and pre wrappers, calls them
     # before/after your action and joins the results
 
-    def new_render(action, *params)
+    def new_render(action)
       arity_for = lambda{|meth| method(meth).arity rescue -1 }
-      post, pre = resolve_aspect(action).values_at(:post, :pre)
+      post, pre = resolve_aspect(action.method).values_at(:post, :pre)
 
       if pre
         arity = arity_for[pre].abs
-        pre_content = old_render(pre, *params[0,arity])
+        pre_action = resolve_action(pre, *action.params[0,arity])
+        pre_content = old_render(pre_action)
       end
 
       unless (pre_content.delete(:skip_next_aspects) rescue false)
-        content = old_render(action, *params)
+        content = old_render(action)
 
         if post
           arity = arity_for[post].abs
-          post_content = old_render(post, *params[0,arity])
+          post_action = resolve_action(post, *action.params[0,arity])
+          post_content = old_render(post_action)
         end
       end
 

data/lib/ramaze/helper/auth.rb

@@ -60,14 +60,14 @@ module Ramaze
       redirect_referer
     end
 
-    private
-
     # call( R(self, :login) ) if not logged in
 
     def login_required
-      call(R(self, :login)) unless logged_in?
+      call(Rs(:login)) unless logged_in?
     end
 
+    private
+
     # checks if the user is already logged in.
     #   session[:logged_in] is not nil/false
 

data/lib/ramaze/helper/cache.rb

@@ -10,7 +10,7 @@ module Ramaze
 
     # Cache for values returned from actions
 
-    trait :action_cache => Global.cache.new
+    trait :action_cache => Controller.trait[:action_cache]
 
     private
 
@@ -38,7 +38,7 @@ module Ramaze
     #   action_cache.delete_if{|key, value| key =~ /"index",/}
 
     def action_cache
-      ancestral_trait[:action_cache]
+      Controller.trait[:action_cache]
     end
 
     # This refers to the class-trait of cached actions, you can

data/lib/ramaze/helper/file.rb

@@ -0,0 +1,14 @@
+#          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
+  module FileHelper
+    private
+
+    def send_file(file, mime_type = Tool::MIME.type_for(file))
+      response.header["Content-Type"] = mime_type
+      response.body = File.open(file)
+      throw(:respond)
+    end
+  end
+end

data/lib/ramaze/helper/inform.rb

@@ -0,0 +1,36 @@
+#          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
+  module InformHelper
+
+    private
+
+    # The various (default) tags you can use are:
+    #
+    # :info  - just outputs whatever you give to it without modification.
+    # :debug - applies #inspect to everything you pass
+    # :error - can take normal strings or exception-objects
+    #
+    #
+    # Usage:
+    #
+    #   inform :info, 'proceeding as planned'
+    #   # [2007-04-04 23:38:39] INFO   proceeding as planned
+    #
+    #   inform :debug, [1,2,3]
+    #   # [2007-04-04 23:38:39] DEBUG  [1, 2, 3]
+    #
+    #   inform :error, 'something bad happened'
+    #   # [2007-04-04 23:38:39] ERROR  something bad happened
+    #
+    #   inform :error, exception
+    #   # [2007-04-04 23:40:59] ERROR  #<RuntimeError: Some exception>
+    #   # [2007-04-04 23:40:59] ERROR  hello.rb:23:in `index'
+    #   # ... rest of backtrace ...
+
+    def inform tag, *args
+      Inform.send(tag, *args)
+    end
+  end
+end

data/lib/ramaze/helper/link.rb

@@ -32,6 +32,8 @@ module Ramaze
 
   module LinkHelper
 
+    private
+
     # Usage:
     #   link MainController, :foo                 #=> '<a href="/foo">foo</a>'
     #   link MinorController, :foo                #=> '<a href="/minor/foo">foo</a>'
@@ -40,7 +42,7 @@ module Ramaze
     #   link MainController, :foo, :title => 'a'  #=> '<a href="/minor/foo/bar">a</a>'
     #   link MainController, :foo => :bar         #=> '/?foo=bar'
 
-    def link *to
+    def Rlink *to
       hash = to.last.is_a?(Hash) ? to.pop : {}
 
       to = to.flatten
@@ -64,6 +66,8 @@ module Ramaze
       end
     end
 
+    alias link Rlink
+
     # Usage:
     #   R MainController, :foo        #=> '/foo'
     #   R MinorController, :foo       #=> '/minor/foo'
@@ -76,11 +80,11 @@ module Ramaze
         to << {:raw => true}
       end
 
-      link(*to)
+      Rlink(*to)
     end
 
     def Rs(*to)
-      R(self, *to)
+      R(Controller.current, *to)
     end
   end
 end

data/lib/ramaze/helper/markaby.rb

@@ -0,0 +1,30 @@
+#          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
+  module MarkabyHelper
+    private
+
+    # use this inside your controller to directly build Markaby
+    # Refer to the Markaby-documentation and testsuite for more examples.
+    # Usage:
+    #   mab { h1 "Apples & Oranges"}                    #=> "<h1>Apples &amp; Oranges</h1>"
+    #   mab { h1 'Apples', :class => 'fruits&floots' }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
+
+    def markaby(ivs = {}, helpers = nil, &block)
+      builder = ::Markaby::Builder
+      builder.extend(Ramaze::Helper)
+      builder.send(:helper, :link)
+
+      iv_hash = {}
+      instance_variables.each do |iv|
+        key, value = iv.gsub('@', '').to_sym, instance_variable_get(iv)
+        iv_hash[key] = value
+      end
+
+      builder.new(iv_hash.merge(ivs), helpers, &block).to_s
+    end
+
+    alias mab markaby
+  end
+end

data/lib/ramaze/helper/redirect.rb

@@ -21,6 +21,8 @@ module Ramaze
 
   module RedirectHelper
 
+    private
+
     # Usage:
     #   redirect R(MainController)
     #   redirect R(MainController, :foo)

data/lib/ramaze/inform.rb

@@ -1,187 +1,13 @@
 #          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
-
-    def debug?() inform_tag?(:debug) end
-
-    # 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
-
-    def info?() inform_tag?(:info) 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
-
-    def error?() inform_tag?(:error) 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"
+require 'ramaze/inform/informing'
 
-    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}}
-
-        pipes = Global.inform_pipes = pipify(Global.inform_to)
-
-        pipes.each do |pipe|
-          pipe.puts(*compiled) unless (pipe.respond_to?(:closed?) and pipe.closed?)
-        end
-      end
-    end
-
-    def pipify *ios
-      ios.flatten.map do |io|
-        case io
-        when :stdout, 'stdout' : $stdout
-        when :stderr, 'stderr' : $stderr
-        when IO : io
-        else
-          File.open(io.to_s, 'ab+')
-        end
-      end
-    end
-
-    extend self
-  end
-
-  # This class acts as a object you can pass to any other logger, it's basically
-  # just including Inform and making its methods public
-
-  class GlobalInformer
-    include Inform
-
-    public :error, :error?, :info, :info?, :meth_debug, :debug, :debug?
-
-    # this simply sends the parameters to #debug
-
-    def <<(*str)
-      debug(*str)
-    end
-  end
-
-  # The usual instance of GlobalInformer, for example used for WEBrick
-
-  Informer = GlobalInformer.new
-
-  include Inform
+module Ramaze
+  autoload :Analogger, "ramaze/inform/analogger.rb"
+  autoload :Informer,  "ramaze/inform/informer.rb"
+  autoload :Syslog,    "ramaze/inform/syslog.rb"
+  autoload :Growl,     "ramaze/inform/growl.rb"
+  autoload :Xosd,      "ramaze/inform/xosd.rb"
+  autoload :LogHub,    "ramaze/inform/hub.rb"
 end

data/lib/ramaze/inform/analogger.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.
+
+require 'swiftcore/Analogger/Client'
+
+module Ramaze
+
+  class Analogger < ::Swiftcore::Analogger::Client
+    include Informing
+
+    def initialize(name = 'walrus', host = '127.0.0.1', port = 6766)
+      super
+    end
+
+    def inform(tag, *args)
+      log(tag, args.join("\n"))
+    end
+  end
+end

data/lib/ramaze/inform/growl.rb

@@ -0,0 +1,28 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ruby-growl'
+
+module Ramaze
+  class Growl < ::Growl
+
+    trait :defaults => {
+      :name => 'walrus',
+      :host => 'localhost',
+      :password => 'walrus',
+      :all_notifies => %w[error warn debug info],
+      :default_notifies => %w[error warn info]
+    }
+
+    def initialize(options = {})
+      options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
+      super(*options)
+    end
+
+    def inform(tag, *args)
+      notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
+    rescue Errno::EMSGSIZE
+      # Send size was to big (not really), ignore
+    end
+  end
+end