ramaze 2012.04.14 → 2012.12.08b

data/guide/general/special_thanks.md

@@ -1,3 +1,4 @@
+# @title Special Thanks
 # Special Thanks
 
 There are a large number of people who made Ramaze possible by their ongoing

data/guide/general/testing.md

@@ -1,3 +1,4 @@
+# @title Testing Ramaze
 # Testing Ramaze
 
 Ramaze uses and encourages BDD (Behaviour Driven Development). Ramaze itself is

data/guide/general/views.md

@@ -1,9 +1,10 @@
+# @title Views
 # Views
 
 Views are the last step in the process of a request to a MVC framework such as
 Ramaze. A controller loads a model, the model processes a certain amount of
 data and the controller will then pass this data to a view. The typical flow of
-a MVC framework (or any framework using a view system) looks like the following::
+a MVC framework (or any framework using a view system) looks like the following:
 
     Request --> Controller --> View
                   ^ |
@@ -62,10 +63,10 @@ The first way is passing a block to the layout() method:
       end
     end
 
-In this example two layouts are used, "index_layout" for the index() method and
-"alternative_layout" for all other methods.
+In this example two layouts are used, `index_layout` for the index() method and
+`alternative_layout` for all other methods.
 
-The second way is using the method "set_layout". This method works almost
+The second way is using the method `set_layout`. This method works almost
 identical to layout() but has one big advantage: it can set method specific
 layouts. Changing the code posted above so that it uses this method would look
 like the following:
@@ -78,7 +79,7 @@ like the following:
       set_layout 'index_layout' => [:index]
     end
 
-The set_layout method takes a hash where the keys are the names of the layouts
+The `set_layout` method takes a hash where the keys are the names of the layouts
 to use and the values the methods for which to use each layout. Below is another
 example that specifies a few extra layout/method combinations.
 
@@ -90,6 +91,14 @@ example that specifies a few extra layout/method combinations.
       set_layout 'main' => [:index, :edit], 'extra' => [:add, :synchronize]
     end
 
+<div class="note todo">
+    <p>
+        <strong>Note:</strong> layouts should be set <strong>outside</strong>
+        controller actions. Doing so can lead to unexpected behaviour as the
+        layout won't be visible until the next request.
+    </p>
+</div>
+
 ## Loading Views
 
 Loading views can be done in two different ways. When not explicitly calling a
@@ -122,18 +131,18 @@ because Ramaze will use the return value of a controller method as the body for
 the response that will be sent back to the visitor.
 
 Let's take a look at the other() method in our controller. As you can see it
-calls a method "render_view". This method is used to render a different view
+calls a method `render_view`. This method is used to render a different view
 (in this case foobar.xhtml) but without calling it's action, once this is done
 the contents of the view will be returned to the controller. When calling custom
 views you can use any of the following methods:
 
-* render_view
-* render_partial
-* render_file
-* render_custom
-* render_full
+* render\_view
+* render\_partial
+* render\_file
+* render\_custom
+* render\_full
 
-### render_view
+### render\_view
 
 As mentioned earlier this method is used to render a view without calling it's
 action. This can be useful if you have several methods that share the same view
@@ -148,13 +157,17 @@ variables to send to the view (more on this later).
     # Render "foo.xhtml" and send some extra data to it
     render_view :foo, :name => "Ramaze"
 
-### render_partial
+### render\_partial
+
+The `render_partial` method works similar to the `render_view` method but with
+two differences:
+
+1. This method *does* execute a matching action.
+2. This method *does not* render a layout.
 
-The render_partial method works very similar to the render_view method, the
-difference is that the render_partial method will not render a layout while
-render_view will. This makes the render_partial method useful for responses to
-Ajax calls that don't need (or don't want to) load both the view and the layout.
-This method has the same arguments as the render_view method.
+This makes the `render_partial` method useful for responses to Ajax calls that
+don't need (or don't want to) load both the view and the layout. This method has
+the same arguments as the `render_view` method.
 
     # Render the view "partial.xhtml"
     render_partial :partial
@@ -162,10 +175,10 @@ This method has the same arguments as the render_view method.
     # Render the partial "partial.xhtml" and send some extra data to it
     render_partial :partial, :name => "Ramaze"
 
-### render_file
+### render\_file
 
 There comes a time when you may want to render a file that's located somewhere
-else. For this there is the render_file() method. This method takes a path,
+else. For this there is the `render_file()`` method. This method takes a path,
 either relative or absolute to a file that should be rendered. This can be
 useful if you have a cache  directory located outside of your project directory
 and you want to load a view from it.
@@ -187,7 +200,7 @@ action.
       action.layout = nil
     end
 
-### render_custom
+### render\_custom
 
 The render_custom() method can be used to create your personal render method and
 is actually used by methods such as the render_partial method. The syntax is the
@@ -202,7 +215,7 @@ argument should be the name of the action to render.
       action.method = nil
     end
 
-### render_full
+### render\_full
 
 Last but not least there's the render_full() method. This is the method Ramaze
 uses for calling a controller along with it's views and such. This method takes

data/lib/proto/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gem 'ramaze', '>= 2.0.0'
+gem 'rake'

data/lib/proto/README.md

@@ -0,0 +1,35 @@
+# Ramaze Application
+
+Welcome to your new Ramaze application. This README serves as a starting point
+for writing an application using the code you just generated.
+
+Once you've started working on your application you'll probably want to update
+this README so that its contents reflect your application's state and purpose.
+
+## Requirements
+
+In order to run this application you'll need to have Ramaze 2.0.0 or newer and
+Rake. Optionally you can install Bundler and use it for Gem management, this
+can be done as following:
+
+    $ gem install bundler
+    $ bundle install
+
+## Rake Tasks
+
+This application comes with a few predefined Rake tasks that make it easy to
+get started. You can list these tasks by running `rake -T` or `rake -D` (this
+shows longer descriptions for tasks if there are any).
+
+For example, to start a Ramaze console using Pry you'd run the following
+command:
+
+    $ rake ramaze:pry
+
+## Resources
+
+In case you need help you can refer to the following resources:
+
+* Ramaze website: <http://ramaze.net/>
+* Github repository: <https://github.com/ramaze/ramaze>
+* IRC channel: \#ramaze on Freenode

data/lib/proto/Rakefile

@@ -0,0 +1 @@
+Dir.glob(File.expand_path('../task/*.rake', __FILE__)) { |task| import task }

data/lib/proto/app.rb

@@ -1,13 +1,9 @@
-# This file contains your application, it requires dependencies and necessary parts of 
-# the application.
-#
-# It will be required from either `config.ru` or `start.rb`
+# This file contains your application, it requires dependencies and necessary
+# parts of the application.
 require 'rubygems'
 require 'ramaze'
 
 # Make sure that Ramaze knows where you are
 Ramaze.options.roots = [__DIR__]
 
-# Initialize controllers and models
-require __DIR__('model/init')
 require __DIR__('controller/init')

data/lib/proto/spec/helper.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../app', __FILE__)
+
+# This file can be used to set various configuration options for your testing
+# suite. Ramaze itself uses Bacon but you're not forced to use this. Want to
+# use Rspec instead? Go ahead!
+#
+# If you do happen to use Bacon you can uncomment the following lines to get
+# started with testing Ramaze using Bacon:
+#
+# require 'bacon'
+# require 'ramaze/spec/bacon'
+
+# The following code is an example on how to set up Capybara
+# (https://github.com/jnicklas/capybara) for Ramaze. If you don't use Capybara
+# you can safely remove these comments.
+#
+# require 'capybara/dsl'
+#
+# Capybara.configure do |config|
+#   config.default_driver = :rack_test
+#   config.app            = Ramaze
+# end
+#
+# shared :capybara do
+#   Ramaze.setup_dependencies
+#
+#   extend Capybara::DSL
+# end
+#
+
+# The following few lines of code are the most basic settings you'll want to
+# use for testing Ramaze. They ensure that the environment is set correctly and
+# that your output isn't clogged with non important information.
+Ramaze.middleware :spec do
+  run Ramaze.core
+end
+
+Ramaze::Log.level   = Logger::ERROR
+Ramaze.options.mode = :spec

data/lib/proto/task/ramaze.rake

@@ -0,0 +1,57 @@
+# This file contains a predefined set of Rake tasks that can be useful when
+# developing Ramaze applications. You're free to modify these tasks to your
+# liking, they will not be overwritten when updating Ramaze.
+
+namespace :ramaze do
+  app = File.expand_path('../../app', __FILE__)
+
+  desc 'Starts a Ramaze console using IRB'
+  task :irb do
+    require app
+    require 'irb'
+    require 'irb/completion'
+
+    ARGV.clear
+    IRB.start
+  end
+
+  # Pry can be installed using `gem install pry`.
+  desc 'Starts a Ramaze console using Pry'
+  task :pry do
+    require app
+    require 'pry'
+
+    ARGV.clear
+    Pry.start
+  end
+
+  # In case you want to use a different server or port you can freely modify
+  # the options passed to `Ramaze.start()`.
+  desc 'Starts Ramaze for development'
+  task :start do
+    require app
+
+    Ramaze.start(
+      :adapter => :webrick,
+      :port    => 7000,
+      :file    => __FILE__,
+      :root    => Ramaze.options.roots
+    )
+  end
+
+  desc 'Lists all the routes defined using Ramaze::Route'
+  task :routes do
+    require app
+
+    if Ramaze::Route::ROUTES.empty?
+      abort 'No routes have been defined using Ramaze::Route'
+    end
+
+    spacing = Ramaze::Route::ROUTES.map { |k, v| k.to_s }
+    spacing = spacing.sort { |l, r| r.length <=> l.length }[0].length
+
+    Ramaze::Route::ROUTES.each do |from, to|
+      puts "%-#{spacing}s => %s" % [from, to]
+    end
+  end
+end

data/lib/ramaze.rb

@@ -22,6 +22,8 @@ module Ramaze
     $LOAD_PATH.unshift(ROOT)
   end
 
+  extend Innate::SingletonMethods
+
   # vendored, will go into rack-contrib
   require 'vendor/route_exceptions'
 
@@ -34,11 +36,8 @@ module Ramaze
   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'
 
@@ -55,44 +54,18 @@ module Ramaze
     end
   end
 
-  extend Innate::SingletonMethods
-
-  options[:middleware_compiler] = Ramaze::MiddlewareCompiler
-
-  middleware! :dev do |m|
-    m.use Rack::Lint
-    m.use Rack::CommonLogger, Ramaze::Log
-    m.use Rack::ShowExceptions
-    m.use Rack::ShowStatus
-    m.use Rack::RouteExceptions
-    m.use Rack::ConditionalGet
+  ##
+  # @see Innate.core
+  #
+  def self.core
+    roots, publics = options[:roots], options[:publics]
 
-    # FIXME: This works around differences between Rack 1.2.1 and the git HEAD
-    if Rack::ETag.instance_method(:initialize).arity == 1
-      m.use Rack::ETag
-    else
-      m.use Rack::ETag, 'public'
-    end
+    joined  = roots.map { |r| publics.map { |p| File.join(r, p) } }
+    joined  = joined.flatten.map { |p| Rack::File.new(p) }
+    current = Current.new(Route.new(AppMap), Rewrite.new(AppMap))
 
-    m.use Rack::Head
-    m.use Ramaze::Reloader
-    m.run Ramaze::AppMap
+    return Rack::Cascade.new(joined << current, [404, 405])
   end
 
-  middleware! :live do |m|
-    m.use Rack::CommonLogger, Ramaze::Log
-    m.use Rack::RouteExceptions
-    m.use Rack::ShowStatus
-    m.use Rack::ConditionalGet
-
-    # FIXME: This works around differences between Rack 1.2.1 and the git HEAD
-    if Rack::ETag.instance_method(:initialize).arity == 1
-      m.use Rack::ETag
-    else
-      m.use Rack::ETag, 'public'
-    end
-
-    m.use Rack::Head
-    m.run Ramaze::AppMap
-  end
+  require 'ramaze/default_middleware'
 end

data/lib/ramaze/bin/create.rb

@@ -15,10 +15,8 @@ module Ramaze
     # @since  21-07-2011
     #
     class Create
-      # The description of this command as shown in the global help message.
-      Description = 'Allows developers to easily create new Ramaze applications.'
+      Description = 'Creates a new Ramaze application'
 
-      # The banner of this command.
       Banner = <<-TXT.strip
 Allows developers to easily create new Ramaze applications based on the
 prototype that ships with Ramaze.

data/lib/ramaze/bin/runner.rb

@@ -1,13 +1,7 @@
 require 'optparse'
 require 'pathname'
 
-require __DIR__('helper')
-require __DIR__('start')
-require __DIR__('restart')
-require __DIR__('stop')
 require __DIR__('create')
-require __DIR__('status')
-require __DIR__('console')
 
 module Ramaze
   #:nodoc:
@@ -28,18 +22,10 @@ module Ramaze
     # @since  21-07-2011
     #
     module Runner
-      # Hash containing all the available commands, their names and their
-      # classes.
       Commands = {
-        :start   => Ramaze::Bin::Start,
-        :stop    => Ramaze::Bin::Stop,
-        :restart => Ramaze::Bin::Restart,
-        :status  => Ramaze::Bin::Status,
         :create  => Ramaze::Bin::Create,
-        :console => Ramaze::Bin::Console,
       }
 
-      # String containing the banner of the main command.
       Banner = <<-TXT.strip
 Ramaze is a simple, light and modular open-source web application
 framework written in Ruby.

data/lib/ramaze/cache.rb

@@ -13,6 +13,27 @@ module Ramaze
     autoload :Sequel,        'ramaze/cache/sequel'
     autoload :Redis,         'ramaze/cache/redis'
 
+    ##
+    # Overwrites {Innate::Cache#initialize} to make cache classes application
+    # aware. This prevents different applications running on the same host and
+    # user from overwriting eachothers data.
+    #
+    # @since 14-05-2012
+    # @see   Innate::Cache#initialize
+    #
+    def initialize(name, klass = nil)
+      @name      = name.to_s.dup.freeze
+      klass    ||= options[@name.to_sym]
+      @instance  = klass.new
+
+      @instance.cache_setup(
+        ENV['HOSTNAME'],
+        ENV['USER'],
+        Ramaze.options.app.name.to_s,
+        @name
+      )
+    end
+
     ##
     # Clears the cache after a file has been reloaded.
     #