ramaze 2009.03 → 2009.04

data/examples/templates/template_xslt.rb

@@ -1,49 +0,0 @@
-require 'rubygems'
-require 'ramaze'
-require 'ramaze/gestalt'
-
-class MainController < Ramaze::Controller
-  view_root __DIR__(:template)
-  engine :XSLT
-
-  def index
-    redirect R(:external)
-  end
-
-  def external *args
-    r = lambda { |*a| R(*a) }
-    response['Content-Type'] = 'application/xhtml+xml'
-
-    #options = {:place => :internal, :action => 'internal',
-    #  :args => args, :request => request, :this => self}
-    Ramaze::Gestalt.build do
-      page(:title=>"Template::XSLT") do
-        heading "The external Template for XSLT"
-        text "Here you can pass some stuff if you like, parameters are just passed like this:"
-        list do
-          item {
-            link(:href => r.call(@this, :external, :one)) { "external/one" }
-          }
-          item {
-            link(:href => r.call(@this, :external, :one, :two, :three)) { "external/one/two/three" }
-          }
-          item {
-            link(:href => r.call(@this, :external, :one, :foo => :bar)) { "external/one?foo=bar" }
-          }
-        end
-        text "The arguments you have passed to this action are:"
-        if args.empty?
-          text "none"
-        else
-          list {
-            args.each do |arg|
-              item arg
-            end
-          }
-        end
-      end
-    end
-  end
-end
-
-Ramaze.start

data/lib/proto/public/css/ramaze_error.css

@@ -1,90 +0,0 @@
-body {
-  font-family: sans-serif;
-}
-
-h1.main {
-  text-align: center;
-}
-
-td {
-  padding: 4px;
-}
-
-table.main {
-  background: #444;
-  margin-left: 2em;
-}
-
-div.additional h3 {
-  cursor: pointer;
-}
-
-div.additional pre {
-  margin-left: 2em;
-}
-
-table.main tr.head {
-  background: #fee;
-  width:      100%;
-}
-
-table.main tr {
-  background: #fff;
-}
-
-table.main tr.source_container {
-  display:    none;
-}
-
-tr.source td {
-  padding: 0;
-}
-
-tr.source_container div {
-  width:      100%;
-  overflow:   auto;
-}
-
-tr.source_container div table {
-  background: #ddd;
-  width:      100%;
-}
-
-tr.source_container div table tr {
-  text-align:center;
-}
-
-tr.source_container div table tr.source {
-  text-align:left;
-}
-
-div.source {
-  background: #fff;
-  padding: 6px;
-}
-
-div.source td.editor {
-  font-size: 0.8em;
-}
-
-tr.source {
-  font-size: 1.0em;
-}
-
-tr.source td.lineno {
-  font-size: 0.9em;
-  font-family: monospace;
-}
-
-tr.source td.lineno, tr.line td.lineno {
-  text-align: right;
-}
-
-tr.line td {
-  cursor: pointer;
-}
-
-tr.source td.code pre {
-  margin: 0;
-  font-family: monospace;
-}

data/lib/proto/view/error.xhtml

@@ -1,64 +0,0 @@
-<link rel="stylesheet" href="/css/ramaze_error.css" />
-<script type="text/javascript" src="/js/jquery.js"></script>
-
-<p>The backtrace gives filenames and line numbers for all parts of the call stack.<br />
-Click on any of them to view the surrounding source code.</p>
-
-<h3>#@title</h3>
-
-<table class="main">
-  <tr class="head">
-    <td>File</td><td>Line</td><td>Method</td>
-  </tr>
-  <?r @backtrace.each do |lines, hash, file, lineno, meth| ?>
-    <tr class="line" id="#{hash}">
-      <td>#{file}</td><td class="lineno">#{lineno}</td><td><pre>#{meth}</pre></td>
-    </tr>
-    <tr id="source_#{hash}" style="display:none;">
-      <td colspan="3">
-        <div class="source">
-          <table style="width:100%;">
-            <tr>
-              <td class="editor" colspan="2">
-                #{@editor} #{file} +#{lineno}
-                <div style="float: right">
-                  <a href="txmt://open?url=file://#{file}&line=#{lineno}">open in textmate</a>
-                </div>
-              </td>
-            </tr>
-            <?r lines.each do |llineno, lcode, lcurrent| ?>
-              <tr class="source" #{'style="background:#faa;"' if lcurrent}>
-                <td class="lineno">#{llineno}</td>
-                <td class="code"><pre>#{lcode.to_s.rstrip}</pre></td>
-              </tr>
-            <?r end ?>
-          </table>
-        </div>
-      </td>
-    </tr>
-  <?r end ?>
-</table>
-
-<?r
-  { 'Session'   => Ramaze::STATE[:session],
-    'Request'   => Ramaze::STATE[:request],
-    'Response'  => Ramaze::STATE[:response],
-    'Global'    => Global,
-  }.each do |title, content|
-    hash = [title, content].object_id.abs
-  ?>
-  <div class="additional">
-    <h3 id="#{hash}">#{title}</h3>
-    <pre style="display:none" id="is_#{hash}">#{Rack::Utils.escape_html(content.pretty_inspect)}</pre>
-  </div>
-<?r end ?>
-
-<script type="text/javascript">
-  $("tr.line").click(function(){
-    $("tr#source_"+this.id).toggle()
-  });
-
-  $("div.additional > h3").click(function(){
-    $("pre#is_"+this.id).toggle()
-  });
-</script>

data/lib/ramaze/action.rb

@@ -1,159 +0,0 @@
-#          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
-
-  unless defined?(Action) # prevent problems for SourceReload
-
-    members = %w[method params template controller path binding engine instance]
-
-    # The Action holds information that is essential to render the action for a
-    # request.
-
-    class Action < Ramaze::Struct.new('Action', *members)
-    end
-  end
-
-  require 'ramaze/action/render'
-  require 'ramaze/helper/link'
-
-  class Action
-    include Helper::Link
-
-    class << self
-
-      # Instantiate with given Hash, takes both string/symbol keys.
-      # Only keys that match members of the Action-Struct are used.
-
-      def create(hash = {})
-        i = new
-        members.each do |key|
-          i.send("#{key}=", (hash[key] || hash[key.to_sym]))
-        end
-        i
-      end
-
-      # alias for stack.last, returns the instance of Action you are currently in.
-
-      def current
-        stack.last
-      end
-
-      # Return the stacked actions for the current request
-      def stack
-        STATE[:action_stack] ||= []
-      end
-    end
-
-    # nicer representation of the Action
-
-    def to_s
-      m, p, t = method.inspect, params.inspect, template.inspect
-      %{#<Action method=#{m}, params=#{p} template=#{t}>}
-    end
-
-    # Set the method, will be converted to a string and set to nil if empty.
-
-    def method=(meth)
-      meth = meth.to_s
-      self[:method] = (meth.empty? ? nil : meth)
-    end
-
-    # runs all parameters assigned through flatten and unescape
-
-    def params=(*par)
-      self[:params] = par.flatten.compact.map{|pa| Rack::Utils.unescape(pa.to_s) }
-    end
-
-    # Use this as key for caches.
-
-    def relaxed_hash
-      [controller, method, params, template, path].hash
-    end
-
-    # A Hash representation of Action
-
-    def to_hash
-      hash = {}
-      members.each{|m| hash[m.to_sym] = send(m)}
-      hash
-    end
-
-    # Determines based on controller.trait[:engine] and the template extensions
-    # which engine has to be used.
-    # Defaults to Template::Ezamar
-
-    def engine
-      return self[:engine] if self[:engine]
-      default = controller.trait.fetch(:engine, Template::Ezamar)
-      return default unless template
-
-      Template::ENGINES.sort_by{|v| v.join}.each do |(engine, exts)|
-        if template =~ /\.(#{Regexp.union(*exts)})$/
-          return self[:engine] = engine
-        end
-      end
-
-      self[:engine] = default
-    end
-
-    # Returns an instance of controller, will be cached on first access.
-
-    def instance
-      self[:instance] ||= controller.new
-    end
-
-    # Returns a binding of the instance, will be cached on first access.
-
-    def binding
-      self[:binding] ||= instance.instance_eval{ binding }
-    end
-
-    # Try to figure out a sane name for current action.
-
-    def name
-      File.basename((self[:method] || self[:template]).to_s).split('.').first
-    end
-
-    # combined path to current action, from path and params
-
-    def extended_path
-      (path == "index" && !params.empty? ? params : Array[path, *params]).join('/')
-    end
-
-    # same as Ramaze::Action#extended_path, with mapping of the current controller prepended.
-
-    def full_path
-      File.join(self.controller.mapping, extended_path)
-    end
-
-    # Hook for AspectHelper
-
-    def before_process
-    end
-
-    # Hook for AspectHelper
-
-    def after_process
-    end
-
-    # Returns true if current request is valid REST request.
-
-    def valid_rest?
-      return true unless rest = controller.trait[:REST]
-      meth = Request.current.request_method
-
-      return true if rest[:any].include?(name)
-
-      if rest.has_key?(meth)
-        rest[meth].include?(name)
-      end
-    end
-  end
-
-  # Shortcut to create new instances of Action
-
-  def self.Action(hash = {})
-    Action.create(hash)
-  end
-end

data/lib/ramaze/action/render.rb

@@ -1,192 +0,0 @@
-#          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
-  class Action
-
-    # Use your block and jump into the Action::stack - this allows you to call
-    # nested actions.
-    def stack
-      Action.stack << self
-      yield self
-    rescue Object => ex
-      Log.error "#{ex} in: #{self}"
-      raise ex
-    ensure
-      Action.stack.pop
-    end
-
-    # Render this instance of Action, this will (eventually) pass itself to
-    # Action#engine.transform
-    # Usage, given that Foo is a Controller and has the method/template
-    # for index:
-    #  > Action(:controller => Foo).render
-    #  #> 'bar'
-
-    def render
-      Log.dev("Action: #{self}")
-      stack do
-        if should_cache?
-          # Ignore cache if there is flash session data as the response probably
-          # expects to include it, making it unique for this user and request.
-          if Global.no_cache_flash && !Current.session.flash.empty?
-            Log.debug("Action caching ignored as session flash data is present.")
-            uncached_render
-          else
-            cached_render
-          end
-        else
-          uncached_render
-        end
-      end
-    end
-
-    private
-
-    # Return the cached output of the action if it exists, otherwise do a
-    # normal Action#uncached_render and store the output in the Cache.actions.
-    # Action#cached_render is only called if Action#should_cache? returns
-    # true.
-
-    def cached_render
-      if cache_root = Global.file_cache
-        cached_render_file(cache_root)
-      else
-        cached_render_memory
-      end
-    end
-
-    # Uses files in the Global.public_root to provide a static ressource on
-    # next request and returns the rendered action
-
-    def cached_render_file(cache_root)
-      rendered = uncached_render
-
-      cr = cache_root.respond_to?(:to_str) ? cache_root.to_str : Global.public_root
-      global_epath = File.join(cr, self.controller.mapping, extended_path)
-      FileUtils.mkdir_p(File.dirname(global_epath))
-      File.open(global_epath, 'w+'){|fp| fp.print(rendered) }
-
-      rendered
-    end
-
-    # Using memory to cache, more sophisticated in terms of control but limited
-    # in terms of your RAM.
-
-    def cached_render_memory
-      cache = Cache.actions
-      options = cache_options
-      store_options = {}
-      key = full_path
-
-      if options.respond_to?(:values_at)
-        block, ttl = options.values_at(:key, :ttl)
-
-        key = [full_path, block.call] if block
-        store_options[:ttl] = ttl if ttl
-      end
-
-      cached_memory_process(cache, key, store_options)
-    end
-
-    def cached_memory_process(cache, key, store_options)
-      stored = cache[key] || {}
-
-      if content = stored[:content]
-        Log.debug "Action already cached"
-        Response.current['Content-Type'] = stored[:type]
-      else
-        Log.debug "Action will be rendered for caching"
-        stored[:content] = uncached_render
-        stored[:type] = Response.current['Content-Type']
-        cache.store(key, stored, store_options)
-      end
-
-      stored[:content]
-    end
-
-    # The 'normal' rendering process. Passes the Action instance to
-    # Action#engine.transform, which returns the output of the action.
-    # Layout will be found and rendered in this step after self was rendered.
-
-    def uncached_render
-      before_process
-
-      content = engine.transform(self)
-
-      if path and tlayout = layout
-        [instance, tlayout.instance].each do |i|
-          i.instance_variable_set("@content", content)
-        end
-
-        content = tlayout.render
-      end
-
-      content
-
-    ensure
-      after_process unless $!
-    end
-
-    # Determine whether or not we have a layout to process and sets it up
-    # correctly to be rendered in the same context as current action.  Will
-    # return false if the layout is the same as current action to avoid
-    # infinite recursion and also if no layout on this controller or its
-    # ancestors was found.
-
-    def layout
-      return false unless layouts = controller.ancestral_trait[:layout]
-
-      possible = [layouts[path], layouts[:all]].compact
-      denied = layouts[:deny].to_a
-
-      if layout = possible.first
-        if layout.to_s !~ /\A\// # late bind layout action to current controller
-          layout = R(controller, layout)
-        end
-        layout_action = Controller.resolve(layout)
-
-        return false if denied.any?{|deny| deny === path} or layout_action.path == path
-
-        if layout_action.controller != controller
-          instance.instance_variables.each do |x|
-            if layout_action.instance.instance_variable_defined?(x)
-              Log.warn "overwriting instance variable #{x} from layout controller with instance variable from action controller."
-            end
-            layout_action.instance.instance_variable_set(x, instance.instance_variable_get(x))
-          end
-        else
-          layout_action.binding = binding
-          layout_action.controller = controller
-          layout_action.instance = instance
-        end
-
-        layout_action.path = nil
-        layout_action
-      end
-    end
-
-    # List the cached actions, just a shortcut really
-
-    def actions_cached
-      controller.trait[:actions_cached]
-    end
-
-    # backwards compat with trait :actions_cached => []
-    def cache_options
-      actions_cached.is_a?(Hash) ? actions_cached[path.to_sym] : {}
-    end
-
-    # return true if the action is flagged for caching. Called by
-    # Action#render.
-
-    def should_cache?
-      ctrait = controller.trait
-
-      [ Global.cache_all,
-        ctrait[:cache_all],
-        actions_cached.map{|k,v| k.to_s}.include?(method),
-      ].any?
-    end
-  end
-end