ptomato-ramaze 2009.02

data/lib/proto/spec/main.rb

@@ -0,0 +1,25 @@
+require 'ramaze'
+require 'ramaze/spec/helper'
+
+require __DIR__('../start')
+
+describe MainController do
+  behaves_like 'http', 'xpath'
+  ramaze :view_root => __DIR__('../view'),
+         :public_root => __DIR__('../public')
+
+  it 'should show start page' do
+    got = get('/')
+    got.status.should == 200
+    puts got.body
+    got.at('//title').text.strip.should ==
+      MainController.new.index
+  end
+
+  it 'should show /notemplate' do
+    got = get('/notemplate')
+    got.status.should == 200
+    got.at('//div').text.strip.should ==
+      MainController.new.notemplate
+  end
+end

data/lib/proto/start.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'ramaze'
+
+# Add directory start.rb is in to the load path, so you can run the app from
+# any other working path
+$LOAD_PATH.unshift(__DIR__)
+
+# Initialize controllers and models
+require 'controller/init'
+require 'model/init'
+
+Ramaze.start :adapter => :webrick, :port => 7000

data/lib/proto/start.ru

@@ -0,0 +1,16 @@
+#!/usr/bin/env rackup
+# start.ru for ramaze apps
+# use thin>=0.6.3
+# thin start -r start.ru
+#
+# rackup is a useful tool for running Rack applications, which uses the
+# Rack::Builder DSL to configure middleware and build up applications easily.
+#
+# rackup automatically figures out the environment it is run in, and runs your
+# application as FastCGI, CGI, or standalone with Mongrel or WEBrick—all from
+# the same configuration.
+
+require 'start'
+Ramaze.trait[:essentials].delete Ramaze::Adapter
+Ramaze.start!
+run Ramaze::Adapter::Base

data/lib/proto/view/error.xhtml

@@ -0,0 +1,64 @@
+<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/proto/view/index.xhtml

@@ -0,0 +1,34 @@
+<p>Ramaze is working correctly with this application, now you can start
+working.</p>
+
+<p>To start you can modify:
+<ol>
+  <li>
+    <code>view/index.xhtml</code>, this page.
+  </li>
+  <li>
+    <code>view/page.xhtml</code>, the layout for this page.
+  </li>
+  <li>
+    <code>controller/main.rb</code>, where you can change the header of this
+    page and the <a href="/notemplate">notemplate</a> action
+  </li>
+</ol>
+</p>
+
+<p>For more documentation, check out <a href="http://ramaze.net">www.ramaze.net</a>, which includes:
+<ul>
+  <li>a <a href="http://ramaze.net/getting-started">getting started</a> guide</li>
+  <li>some <a href="http://ramaze.net/screencasts">screencasts</a></li>
+  <li>and an <a href="http://ramaze.rubyforge.org/tutorial/todolist.html">introductory tutorial</a></li>
+</ul>
+</p>
+
+<p>You can also read the
+<a href="http://ramaze.rubyforge.org/rdoc/files/doc/README.html">rdocs</a> or browse
+around the <a href="http://source.ramaze.net">Ramaze source code</a>.
+</p>
+
+<p>For help with Ramaze, visit the <a href="irc://chat.freenode.net/ramaze">#ramaze on irc.freenode.net</a> (you can use <a href="http://java.freenode.net/?channel=ramaze">this browser-based frontend</a>),
+or post on the <a href="http://groups.google.com/group/ramaze">Ramaze Google Group</a>.
+  </p>

data/lib/proto/view/page.xhtml

@@ -0,0 +1,27 @@
+<?xml version="1.0" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+  "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>#{@title}</title>
+    <meta http-equiv="Content-Script-Type" content="text/javascript" />
+    <meta http-equiv="Content-Style-Type" content="text/css" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="expires" content="0" />
+    <meta name="description" content="Description for search engines" />
+    <meta name="generator" content="Ramaze #{Ramaze::VERSION}" />
+    <meta name="keywords" content="Ramaze, Your own keywords" />
+    <meta name="author" content="Max Mustermann" />
+    <meta name="date" content="#{Time.now.iso8601}" />
+    <style type="text/css">
+      body { margin: 2em; }
+      #content { margin-left: 2em; }
+    </style>
+  </head>
+  <body>
+    <h1>#{@title}</h1>
+    <div id="content">
+      #@content
+    </div>
+  </body>
+</html>

data/lib/ramaze/action/render.rb

@@ -0,0 +1,192 @@
+#          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

data/lib/ramaze/action.rb

@@ -0,0 +1,159 @@
+#          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