ramaze 2009.03 → 2009.04

data/lib/proto/spec/main.rb

@@ -1,25 +1,21 @@
 require 'ramaze'
-require 'ramaze/spec/helper'
+require 'ramaze/spec'
 
 require __DIR__('../start')
+Ramaze.options.roots = __DIR__('../')
 
 describe MainController do
-  behaves_like 'http', 'xpath'
-  ramaze :view_root => __DIR__('../view'),
-         :public_root => __DIR__('../public')
+  behaves_like :mock
 
-  it 'should show start page' do
-    got = get('/')
-    got.status.should == 200
-    puts got.body
-    got.at('//title').text.strip.should ==
-      MainController.new.index
+  should 'show start page' do
+    get('/').status.should == 200
+    last_response['Content-Type'].should == 'text/html'
+    last_response.should =~ /<h1>Welcome to Ramaze!<\/h1>/
   end
 
-  it 'should show /notemplate' do
-    got = get('/notemplate')
-    got.status.should == 200
-    got.at('//div').text.strip.should ==
-      MainController.new.notemplate
+  should 'show /notemplate' do
+    get('/notemplate').status.should == 200
+    last_response['Content-Type'].should == 'text/html'
+    last_response.should =~ /there is no 'notemplate\.xhtml' associated with this action/
   end
 end

data/lib/proto/start.rb

@@ -1,12 +1,8 @@
-require 'rubygems'
-require 'ramaze'
+# Use this file directly like `ruby start.rb` if you don't want to use the
+# `ramaze start` command.
+# All application related things should go into `app.rb`, this file is simply
+# for options related to running the application locally.
 
-# 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__)
+require File.expand_path('app', File.dirname(__FILE__))
 
-# Initialize controllers and models
-require 'controller/init'
-require 'model/init'
-
-Ramaze.start :adapter => :webrick, :port => 7000
+Ramaze.start(:adapter => :webrick, :port => 7000, :file => __FILE__)

data/lib/proto/view/index.xhtml

@@ -1,34 +1,41 @@
-<p>Ramaze is working correctly with this application, now you can start
-working.</p>
+<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>
+  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>For more documentation, check out <a href="http://ramaze.net">ramaze.net</a> and <a href="http://wiki.ramaze.net">wiki.ramaze.net</a>, which includes:
+  <ul>
+    <li>a <a href="http://wiki.ramaze.net/Walkthrough">getting started</a> guide</li>
+    <li>some <a href="http://wiki.ramaze.net/Screencasts">screencasts</a></li>
+    <li>and an <a href="http://wiki.ramaze.net/Tutorials/Todolist">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>
+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>
+<p>
+For help with Ramaze, visit <a href="irc://chat.freenode.net/ramaze">#ramaze on irc.freenode.net</a>.<br />
+You can use <a href="http://embed.mibbit.com/?server=irc.freenode.net&channel=#ramaze,#ruby-lang&forcePrompt=true">Mibbit</a>, an AJAX based IRC client or <a href="http://java.freenode.net/?channel=ramaze">the official freenode irc java applet</a>.
+<br />
+Feel free to post to the <a href="http://groups.google.com/group/ramaze">Ramaze Google Group</a>, your first mail has to go through moderation, so please be patient.
+</p>

data/lib/ramaze.rb

@@ -1,139 +1,88 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-# StdLib
-require 'abbrev'
-require 'cgi'
-require 'digest/md5'
-require 'fileutils'
-require 'ipaddr'
-require 'optparse'
-require 'ostruct'
-require 'pathname'
-require 'pp'
-require 'set'
-require 'socket'
-require 'timeout'
-require 'tmpdir'
-require 'yaml'
-
-begin
-  require 'rubygems'
-rescue LoadError
-end
-
-# Rack
-require 'rack'
-require 'rack/utils'
-require 'rack/request'
-require 'rack/response'
-
-# The main namespace for Ramaze
-module Ramaze
-  BASEDIR = File.dirname(File.expand_path(__FILE__))
-  $LOAD_PATH.unshift BASEDIR
-  $LOAD_PATH.uniq!
-
-  # Shortcut to the HTTP_STATUS_CODES of Rack::Utils
-  # inverted for easier access
-
-  STATUS_CODE = Rack::Utils::HTTP_STATUS_CODES.invert
-end
-
-Thread.abort_on_exception = true
-
-# Bootstrap
-require 'ramaze/version'
-require 'ramaze/reloader'
-require 'ramaze/snippets'
-require 'ramaze/log'
-require 'ramaze/trinity'
-require 'ramaze/dispatcher'
-require 'ramaze/current'
-require 'ramaze/adapter'
-require 'ramaze/option'
-require 'ramaze/cache'
-require 'ramaze/tool'
-
-# Startup
-require 'ramaze/controller'
-
-# Complete
-require 'ramaze/template/ezamar'
-require 'ramaze/contrib'
-require 'ramaze/route'
-
+# Namespace for Ramaze
+#
+# THINK:
+#   * for now, we don't extend this with Innate to keep things clean. But we
+#     should eventually do it for a simple API, or people always have to find
+#     out whether something is in Innate or Ramaze.
+#     No matter which way we go, we should keep references point to the
+#     original location to avoid too much confusion for core developers.
 module Ramaze
+  ROOT = File.expand_path(File.dirname(__FILE__)) unless defined?(Ramaze::ROOT)
 
-  # Each of these classes will be called ::startup upon Ramaze.startup
-
-  trait :essentials => [
-    Global, Cache, Contrib, Controller, Session, Adapter
-  ]
-
-  trait :started => false
-
-  class << self
-
-    # The one place to start Ramaze, takes an Hash of options to pass on to
-    # each class in trait[:essentials] by calling ::startup on them.
-
-    def startup options = {}
-      options = options.to_hash
-
-      force = options.delete(:force)
-      force ||= !trait[:started]
-
-      options[:runner] ||= caller[0][/^(.*?):\d+/, 1]
-      Global.merge!(options)
-
-      if force
-        Log.info("Starting up Ramaze (Version #{VERSION})")
-        trait[:started] = true
-
-        trait[:essentials].each do |obj|
-          obj.startup(options)
-        end
-      else
-        Log.info "Ramaze already started, skipped start."
-      end
-    end
-
-    # A shortcut for setting Ramaze.trait[:started] = true.
-
-    def skip_start
-      trait[:started] = true
-    end
-
-    # Forces the startup of Ramaze regardless if trait[:started] is set.
+  unless $LOAD_PATH.any?{|lp| File.expand_path(lp) == ROOT }
+    $LOAD_PATH.unshift(ROOT)
+  end
 
-    def start!(options = {})
-      trait[:started] = false
-      startup(options)
+  # 3rd party
+  require 'innate'
+
+  @options = Innate.options
+  class << self; attr_accessor :options; end
+
+  # vendored, will go into rack-contrib
+  require 'vendor/etag'
+  require 'vendor/route_exceptions'
+
+  # Ramaze itself
+  require 'ramaze/version'
+  require 'ramaze/log'
+  require 'ramaze/snippets'
+  require 'ramaze/helper'
+  require 'ramaze/view'
+  require 'ramaze/controller'
+  require 'ramaze/cache'
+  require 'ramaze/reloader'
+  require 'ramaze/setup'
+  require 'ramaze/app'
+  require 'ramaze/files'
+  require 'ramaze/middleware_compiler'
+  require 'ramaze/plugin'
+  require 'ramaze/request'
+  require 'ramaze/current'
+
+  # Usually it's just mental overhead to remember which module has which
+  # constant, so we just assign them here as well.
+  # This will not affect any of the module functions on Innate, you still have
+  # to reference the correct module for them.
+  # We do not set constants already set from the requires above.
+  Innate.constants.each do |const|
+    begin
+      Ramaze.const_get(const)
+    rescue NameError
+      Ramaze.const_set(const, Innate.const_get(const))
     end
+  end
 
-    # This will be called when you hit ^C or send SIGINT.
-    # It sends ::shutdown to every class in trait[:essentials] and informs you
-    # when it is done
-
-    def shutdown
-      Log.info "Initiate shutdown"
-
-      Timeout.timeout(5) do
-        trait[:essentials].each do |obj|
-          obj.shutdown if obj.respond_to?(:shutdown)
-        end
-
-        puts "Ramazement is over, have a nice day."
-
-        exit
-      end
-    rescue Timeout::Error
-      puts "Shutdown timed out, issuing exit!"
-      exit!
-    end
+  extend Innate::SingletonMethods
+
+  options[:middleware_compiler] = Ramaze::MiddlewareCompiler
+
+  middleware! :dev do |m|
+    m.use Rack::Lint
+    m.use Rack::CommonLogger
+    m.use Ramaze::Reloader
+    m.use Rack::ShowStatus
+    m.use Rack::RouteExceptions
+    m.use Rack::ShowExceptions
+    m.use Rack::Head
+    m.use Rack::ETag
+    m.use Rack::ConditionalGet
+    m.use Rack::ContentLength
+    m.run Ramaze::AppMap
+  end
 
-    alias start startup
-    alias stop shutdown
+  middleware! :live do |m|
+    m.use Rack::CommonLogger
+    m.use Rack::RouteExceptions
+    m.use Rack::ShowStatus
+    m.use Rack::ShowExceptions
+    m.use Rack::Head
+    m.use Rack::ETag
+    m.use Rack::ConditionalGet
+    m.use Rack::ContentLength
+    m.run Ramaze::AppMap
   end
 end

data/lib/ramaze/app.rb

@@ -0,0 +1,124 @@
+module Ramaze
+  # An application is a collection of controllers and options that have a
+  # common name.
+  # Every application has a location it dispatches from, this behaves similar
+  # to Rack::URLMap.
+
+  AppMap = Innate::URLMap.new
+
+  def self.to(object)
+    app_name = object.ancestral_trait[:app]
+    App[app_name].to(object)
+  end
+
+  # App is the superclass for applications and acts as their prototype when it
+  # comes to configuration.
+  #
+  # An application consists of options, a location, and a list of objects. The
+  # objects are usually {Controller}s.
+  #
+  # The options are inherited, the basics are set in Ramaze.options, from there
+  # to Ramaze::App.options, and finally into every instance of App.
+  #
+  # This allows to collect {Controller}s of your application into a common
+  # group that can easily be used in other applications, while retaining the
+  # original options.
+  #
+  # Every instance of {App} is mapped in {AppMap}, which is the default
+  # location to #call from Rack.
+  #
+  # Additionally, every {App} can have custom locations for
+  # root/public/view/layout directories, which allows reuse beyond directory
+  # boundaries.
+  #
+  # In contrast to Innate, where all Nodes share the same middleware, {App}
+  # also has a subset of middleware that handles serving static files, routes
+  # and rewrites.
+  #
+  # To indicate that a {Controller} belongs to a specific application, you can
+  # pass a second argument to {Controller::map}
+  #
+  # @example adding Controller to application
+  #
+  #   class WikiController < Ramaze::Controller
+  #     map '/', :wiki
+  #   end
+  #
+  # The App instance will be created for you and if you don't use any other
+  # applications in your code there is nothing else you have to do. Others can
+  # now come and simply reuse your code in their own applications.
+  #
+  # There is some risk of name collisions if everybody calls their app `:wiki`,
+  # but given that you only use one foreign app of this kind might give less
+  # reason for concern.
+  #
+  # If you still try to use two apps with the same name, you have to be
+  # careful, loading one first, renaming it, then loading the second one.
+  #
+  # The naming of an App has no influence on any other aspects of dispatching
+  # or configuration.
+  class App
+    include Innate::Optioned
+
+    # options not found here will be looked up in Ramaze.options
+    options.dsl do
+      o "Unique identifier for this application",
+        :name, :pristine
+    end
+
+    APP_LIST = {}
+
+    attr_reader :name, :location, :url_map, :options
+
+    def initialize(name, location)
+      @name = name.to_sym
+      @url_map = Innate::URLMap.new
+      self.location = location
+
+      APP_LIST[@name] = self
+
+      @options = self.class.options.sub(@name)
+    end
+
+    def sync
+      AppMap.map(location, self)
+    end
+
+    def location=(location)
+      @location = location.to_str.freeze
+      sync
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+
+    def to_app
+      files = Ramaze::Files.new(*public_roots)
+      app = Current.new(Route.new(url_map), Rewrite.new(url_map))
+      Rack::Cascade.new([files, app])
+    end
+
+    def map(location, object)
+      url_map.map(location, object)
+    end
+
+    def to(object)
+      return unless mapped = url_map.to(object)
+      [location, mapped].join('/').squeeze('/')
+    end
+
+    def public_roots
+      roots, publics = [*options.roots], [*options.publics]
+      roots.map{|root| publics.map{|public| ::File.join(root, public) }}.flatten
+    end
+
+    def self.find_or_create(name, location = '/')
+      self[name] || new(name, location)
+    end
+
+    def self.[](name)
+      APP_LIST[name.to_sym]
+    end
+  end
+end