ramaze 0.0.6

data/lib/ramaze/error.rb

@@ -0,0 +1,11 @@
+#          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 Error
+    class NoAction < StandardError; end
+    class NoController < StandardError; end
+    class WrongParameterCount < StandardError; end
+    class Template < StandardError; end
+  end
+end

data/lib/ramaze/gestalt.rb

@@ -0,0 +1,108 @@
+#          Copyright (c) 2006 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'
+
+  def random_color
+    r = lambda{|n| rand(n).to_s(16) }
+    '#' + [255, 255, 255].map{r[255] + r[255] + r[255]
+  end
+
+  puts Ramaze::Gestalt.build{
+    html do
+      head do
+        title{"Hello World"}
+      end
+      body do
+        h1{"Hello, World!"}
+        div(:style => 'width:100%') do
+          10.times do
+            div(:style => "width:#{rand(100)}%;height:#{rand(100)}%;background:#{random_color}"){ ' ' }
+          end
+        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_build_tag meth, *args, &block
+    end
+
+    # workaround for Kernel#p to make <p /> tags possible.
+
+    def p *args, &block
+      _gestalt_build_tag :p, *args, &block
+    end
+
+    # build a tag for `name`, using `args` and an optional block that
+    # will be yielded
+
+    def _gestalt_build_tag name, args = []
+      @out << "<#{name}"
+      if block_given?
+        @out << args.inject(''){ |s,v| s << %{ #{v[0]}="#{v[1]}"} }
+        @out << ">"
+        text = yield
+        @out << text if text != @out and text.respond_to?(:to_str)
+        @out << "</#{name}>"
+      else
+        @out << args.inject(''){ |s,v| s << %{ #{v[0]}="#{v[1]}"} }
+        @out << ' />'
+      end
+    end
+
+    # @out.to_s
+
+    def to_s
+      @out.to_s
+    end
+    alias to_str to_s
+  end
+end

data/lib/ramaze/global.rb

@@ -0,0 +1,120 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ostruct'
+require 'set'
+
+module Ramaze
+  class GlobalStruct < OpenStruct
+    # autoreload    - Interval for autoreloading changed source in seconds
+    # adapter       - Webserver-adapter ( :mongrel | :webrick )
+    # cache         - Cache to use   ( MemcachedCache | MemoryCache | YamlStoreCache )
+    # cache_actions - Finegrained caching based on actions (see CacheHelper)
+    # cache_all     - Naive caching for all responses ( true | false )
+    # error_page    - Show default errorpage with inspection and backtrace ( true | false )
+    # host          - Host to respond to ( '0.0.0.0' )
+    # mapping       - Route to controller map ( {} )
+    # port          - First port of the port-range the adapters run on. ( 7000 )
+    # run_loose     - Don't wait for the servers to finish, useful for testing ( true | false )
+    # tidy          - Run all text/html responses through Tidy ( true | false )
+    # template_root - Default directory for your templates.
+    #
+    # inform_to             - :stdout/'stdout'/$stderr (similar for stdout) or some path to a file
+    # inform_tags           - a Set with any of [ :debug, :info, :error ]
+    # inform_backtrace_size - size of backtrace to be logged (and show on error-page).
+    # inform_timestamp      - parameter for Time.strftime
+    # inform_prefix_info    - prefix for all the Inform#info messages
+    # inform_prefix_debug   - prefix for all the Inform#debug messages
+    # inform_prefix_error   - prefix for all the Inform#error messages
+    #
+    # startup         - List of methods and lambdas that are executed on startup
+    # ramaze_startup  - Internal list of methods and lambdas that are executed on startup
+    #
+    # shutdown        - List of methods and lambdas that are executed on startup
+    # ramaze_shutdown - Internal list of methods and lambdas that are executed on shutdown
+
+    DEFAULT = {
+      :autoreload     => 5,
+      :adapter        => :webrick,
+      :cache          => MemoryCache,
+      :cache_actions  => Hash.new{|h,k| h[k] = Set.new},
+      :cache_all      => false,
+      :cookies        => true,
+      :error_page     => true,
+      :host           => '0.0.0.0',
+      :mapping        => {},
+      :port           => 7000,
+      :run_loose      => false,
+      :tidy           => false,
+      :template_root  => 'template',
+
+      :inform_to             => $stdout,
+      :inform_tags           => Set.new([:debug, :info, :error]),
+      :inform_backtrace_size => 10,
+      :inform_timestamp      => "%Y-%m-%d %H:%M:%S",
+      :inform_prefix_info    => 'INFO ',
+      :inform_prefix_debug   => 'DEBUG',
+      :inform_prefix_error   => 'ERROR',
+
+      :startup => [],
+      :ramaze_startup => [
+          :find_controllers, :setup_controllers, :init_autoreload, :init_adapter
+        ],
+
+      :shutdown => [],
+      :ramaze_shutdown => [
+        :kill_threads,
+        :close_inform,
+        lambda{ puts "Shutdown Ramaze (it's save to kill me now if i hang)" },
+        :exit
+        ],
+    }
+
+    # takes an hash of options and optionally an block that is evaled in this
+    # instance of GlobalStruct.
+
+    def setup hash = {}, &block
+      Global.instance_eval(&block) if block_given?
+      table.merge!( hash.keys_to_sym )
+    end
+
+    # just update the hash, not deleting values already set.
+    # again, takes a block, but your assignments may be
+    # overwritten if they existed before.
+
+    def update hash = {}, &block
+      old_table = table.dup
+      Global.instance_eval(&block) if block_given?
+      table.merge!( hash.keys_to_sym.merge( old_table ) )
+    end
+
+    # synonym to Global.key = value
+
+    def []=(key, value)
+      table[key.to_sym] = value
+    end
+
+    # synonym for Global.key
+
+    def [](key)
+      table[key.to_sym]
+    end
+
+    # get all the values for the given keys in the right order.
+
+    def values_at(*keys)
+      table.values_at(*keys.map(&:to_sym))
+    end
+
+    # iterate over the GlobalStruct, no guarantee on the order.
+
+    def each
+      table.each do |e|
+        yield(e)
+      end
+    end
+  end
+
+  Thread.current[:global] = GlobalStruct.new(GlobalStruct::DEFAULT)
+  Global = Thread.current[:global]
+end

data/lib/ramaze/helper.rb

@@ -0,0 +1,32 @@
+#          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/trinity'
+
+module Ramaze
+
+  # 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
+    include Trinity
+
+    private
+
+    # 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|
+        mod_name = sym.to_s.capitalize + 'Helper'
+        require "ramaze/helper/#{sym}"
+        include ::Ramaze.const_get(mod_name)
+        extend ::Ramaze.const_get(mod_name)
+      end
+    end
+  end
+end

data/lib/ramaze/helper/aspect.rb

@@ -0,0 +1,189 @@
+#          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
+  # A helper that provides the means to wrap actions of the controller with
+  # other methods.
+  # For examples please look at the test/tc_aspect.rb
+  # this is not a default helper due to the possible performance-issues.
+  # However, it should be only an overhead of about 6-8 calls, so if you
+  # want this feature it shouldn't have too large impact ;)
+
+  module AspectHelper
+
+    # define the trait[:aspects] for the class that includes us
+    # also prepare hijacking of the :render method
+
+    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 => {}}}
+        unless defined?(klass.old_render)
+          klass.send(:alias_method, :old_render, :render)
+          klass.send(:alias_method, :render, :new_render)
+        end
+      end
+    end
+
+    private
+
+    # define pre-aspect which calls render(:your_pre_aspect)
+    # and appends it on your default action
+    # please note, that if you give can define
+    #   pre :all, :all_, :except => [:action1, :action2]
+    #   pre :all, :all_, :except => :action
+    # however, due to the nature of this helper, only action that have been
+    # defined so far are wrapped by the :all.
+    # methods that are in the :except (which is not mandatory) are ignored.
+    #
+    # the notion :all_ is a nice reminder that it is a pre-wrapper, you don't
+    # have to use the underscore, it's just my way to do it.
+    #
+    # Also, be careful, since :all will wrap other wraps that have been defined
+    # so far as well.
+    # Usually i don't think it's a good thing that order defines
+    # behaviour, but in this case it gives you quite powerful control
+    # over the whole process. Just watch out:
+    #   With great power comes great responsibility
+    #
+    # Example:
+    #   class FooController < Template::Ramaze
+    #
+    #     def index
+    #       'foo'
+    #     end
+    #     pre :index, :_index
+    #
+    #     def other
+    #       'foo'
+    #     end
+    #     pre :all, :all_, :except => :index
+    #
+    #     def _index
+    #       'I will be put before your action'
+    #     end
+    #
+    #     def _all
+    #       '<pre>'
+    #     end
+    #   end
+
+    def pre(*opts)
+      enwrap(:pre, *opts)
+    end
+    alias before pre
+
+    # define post-aspect which calls render(:your_post_aspect)
+    # and appends it on your default action
+    # please note, that if you give can define
+    #   post :all, :all_, :except => [:action1, :action2]
+    #   post :all, :all_, :except => :action
+    # however, due to the nature of this helper, only action that have been
+    # defined so far are wrapped by the :all.
+    # methods that are in the :except (which is not mandatory) are ignored.
+    #
+    # the notion :all_ is a nice reminder that it is a post-wrapper, you don't
+    # have to use the underscore, it's just my way to do it.
+    #
+    # Also, be careful, since :all will wrap other wraps that have been defined
+    # so far as well.
+    # Usually i don't think it's a good thing that order defines
+    # behaviour, but in this case it gives you quite powerful control
+    # over the whole process. Just watch out:
+    #   With great power comes great responsibility
+    #
+    # Example:
+    #   class FooController < Template::Ramaze
+    #
+    #     def index
+    #       'foo'
+    #     end
+    #     post :index, :index_
+    #
+    #     def other
+    #       'foo'
+    #     end
+    #     pre :all, :all_, :except => :index
+    #
+    #     def index_
+    #       'I will be put after your action'
+    #     end
+    #
+    #     def all_
+    #       '</pre>'
+    #     end
+    #   end
+
+    def post(*opts)
+      enwrap(:post, *opts)
+    end
+    alias after post
+
+    # a shortcut that combines pre and post
+    # same syntax as pre/post, just a linesaver
+
+    def wrap(*opts)
+      pre(*opts)
+      post(*opts)
+    end
+
+    # you shouldn't have to call this method directly
+    # however, if you really, really want to:
+    #
+    # enwrap(:post, :index, :my_post_method, :except => :bar
+
+    def enwrap(kind, key, meths, hash = {})
+      wrapping =
+      if key == :all
+        instance_methods(false).map{|im| im.to_sym}
+      else
+        if ([] + key rescue nil)
+          key.map{|k| k.to_sym}
+        else
+          [key.to_sym]
+        end
+      end
+
+      if hash[:except]
+        wrapping -= [hash[:except]].flatten.map{|m| m.to_sym}
+      end
+
+      wrapping.each do |meth|
+        ancestral_trait[:aspects][kind][meth] = meths
+      end
+    end
+
+    # find the post and pre actions for the current class
+
+    def resolve_aspect(action)
+      action = action.to_sym
+      aspects = ancestral_trait[:aspects]
+      {
+        :pre  => aspects[:pre][action],
+        :post => aspects[:post][action]
+      }
+    end
+
+    # this will be exchanged for the :render method which is aliased
+    # to old_render
+    # it just searches for post and pre wrappers, calls them
+    # before/after your action and joins the results
+
+    def new_render(action, *params)
+      arity_for = lambda{|meth| method(meth).arity rescue -1 }
+      post, pre = resolve_aspect(action).values_at(:post, :pre)
+
+      if pre
+        arity = arity_for[pre].abs
+        pre_content = old_render(pre, *params[0,arity]) if pre
+      end
+
+      unless (pre_content.delete(:skip_next_aspects) rescue false)
+        content = old_render(action, *params)
+        post_content = old_render(post, *params) if post
+      end
+
+      [pre_content, content, post_content].join
+    end
+  end
+end