ramaze 2012.03.07 → 2012.04.14

data/.gems

@@ -1,34 +1,35 @@
 # .gems generated gem export file. Note that any env variable settings will be missing. Append these after using a ';' field separator
 bacon -v1.1.0
-dalli -v1.1.4
+dalli -v2.0.2
 erector -v0.8.3
 erubis -v2.7.0
 ezamar -v2009.06
 haml -v3.1.4
-hpricot -v0.8.5
-innate -v2011.12
+hpricot -v0.8.6
+innate -v2012.03
 liquid -v2.3.0
 locale -v2.0.5
-localmemcache -v0.4.4
 lokar -v0.2.1
 maruku -v0.6.0
 mustache -v0.99.4
 nagoro -v2009.05
-nokogiri -v1.5.0
 polyglot -v0.3.3
-rack -v1.4.0
+rack -v1.4.1
 rack-contrib -v1.1.0
 rack-test -v0.6.1
-ramaze -v2011.12.28
+rake -v0.9.2.2
 rdiscount -v1.6.8
 redis -v2.2.2
 Remarkably -v0.6.1
-sass -v3.1.12
-sequel -v3.30.0
+sass -v3.1.15
+sequel -v3.34.1
+slim -v1.2.0
 slippers -v0.0.14
 sqlite3 -v1.3.5
 syntax -v1.0.0
-tagz -v9.0.0
+tagz -v9.3.0
+temple -v0.4.0
 tenjin -v0.7.1
+tilt -v1.3.3
 treetop -v1.4.10
-yard -v0.7.4
+yard -v0.7.5

data/.mailmap

@@ -31,3 +31,4 @@ Michael Fellinger <m.fellinger@gmail.com> Michael Fellinger m.fellinger@gmail.co
 Yorick Peterse <yorickpeterse@gmail.com> YorickPeterse <yorickpeterse@gmail.com>
 Yorick Peterse <yorickpeterse@gmail.com> YorickPeterse <info@yorickpeterse.com>
 Yorick Peterse <yorickpeterse@gmail.com> Yorick Peterse <info@yorickpeterse.com>
+Yorick Peterse <yorickpeterse@gmail.com> Yorick Peterse <yorick@isset.nl>

data/README.md

@@ -10,7 +10,7 @@ give you the ultimate tools, but you have to use them yourself to achieve
 perfect custom-tailored results.
 
 Another one of the goals during development of Ramaze was to make every part as
-modular and therefor reusable as possible, not only to provide a basic
+modular and therefore reusable as possible, not only to provide a basic
 understanding after the first glance, but also to make it as simple as possible
 to reuse parts of the code.
 
@@ -25,7 +25,7 @@ in their own way rather than being forced to work in a way that the framework
 importantly: it puts you back in control of your code. An example of this is the
 default file structure of new Ramaze projects.  Out of the box a new project
 uses the MVC pattern. The cool thing about Ramaze however is that you're not
-forced to use this pattern. If you prever HMVC, PAC or something else you can
+forced to use this pattern. If you prefer HMVC, PAC or something else you can
 simply apply it. Another example is the use of a database toolkit. Ramaze does
 not ship with one for a very simple reason: nobody likes the same toolkit. Some
 people prefer Sequel, others use Datamapper. With Ramaze you can use any tool
@@ -118,7 +118,7 @@ directory.
 * {file:general/sessions Sessions}
 * {file:general/cache Caching Data}
 * {file:general/logging Logging Information}
-* {file:general/testing Testing with Ramaze}
+* {file:general/testing Testing Ramaze}
 
 ## Tutorials
 

data/examples/app/wiktacular/mkd/markdown/current.mkd

@@ -1,3 +1,3 @@
-# Markdown
-
+# Markdown
+
 Markdown is a engine for converting plain text to [[HTML]]. You can find more information at [markdown homepage](http://daringfireball.net/projects/markdown/)

data/examples/app/wiktacular/mkd/testing/2007-07-21_18-46-01.mkd

@@ -1,11 +1,11 @@
-# Just a test
-
-Some more text
-
-## nothing serious
-
-And some text
-
-### Even less serious
-
-Here is a [[link]]
+# Just a test
+
+Some more text
+
+## nothing serious
+
+And some text
+
+### Even less serious
+
+Here is a [[link]]

data/examples/app/wiktacular/mkd/testing/2007-07-21_18-46-32.mkd

@@ -1,13 +1,13 @@
-# Just a test
-
-Some more text
-
-## nothing serious
-
-And some text
-
-### Even less serious
-
-Here is a [[link]]
-
+# Just a test
+
+Some more text
+
+## nothing serious
+
+And some text
+
+### Even less serious
+
+Here is a [[link]]
+
   <a href="foo">foo</a>

data/guide/general/special_thanks.md

@@ -65,3 +65,4 @@ I would like to thank:
 I'd also like to thank the following people for contributing to the guide:
 
 * [Stas Sușcov](https://github.com/stas)
+* [John Pagonis](https://github.com/pagojo)

data/guide/general/testing.md

@@ -1,25 +1,193 @@
-# Testing With Ramaze
+# Testing Ramaze
+
+Ramaze uses and encourages BDD (Behaviour Driven Development). Ramaze itself is
+tested using [Bacon][bacon] and supports it out of the box, it however isn't
+limited to just Bacon.
+
+One might wonder why to bother with writing tests. The answer to this is quite
+simple: stability. Manually testing an application works on a very basic level
+but there are various issues that will arise once your application grows. The
+two biggest issues are human errors and repeatability. Especially the latter
+becomes an issue when your development team grows in size, while the initial
+developer may be willing to manually test every feature every time a change has
+been made others might not. Even worse, there's a chance they won't test their
+code at all and assume it's production ready because on their setup.
+
+Writing tests that can be executed using a single command (or automatically)
+makes your life a lot easier as you no longer have to worry about any of these
+issues (assuming people actually write tests). Whenever somebody commits code
+they write a test and you can easily verify if it works on different setups by
+simply running said test.
+
+When writing Ruby code you can pick from a large collection of testing libraries
+such as Bacon and [Rspec][rspec] for general tests, [SimpleCov][simplecov] for
+code coverage and [Capybara][capybara] for testing form based actions and the
+like. Of course the list doesn't stop here, there's simply too much to discuss
+everything.
+
+## Bacon
+
+Bacon is a small and lightweight Rspec clone that's used by Ramaze and Innate
+and is the recommended tool to use. Each bacon test consists out of at least two
+bits: a "describe" block and an "it" (or "should") block. The describe block can
+be seen as a group of multiple it/should blocks. In most cases these blocks are
+used to specify the name of a class, module, etc. The it/should blocks are used
+for individual tests.
+
+Lets take a look at a simple block of code:
+
+    class Person
+      attr_accessor :name
+
+      def initialize(name = nil)
+        @name = name
+      end
+    end
+
+Using Bacon we can test this code as following:
+
+    require 'bacon'
+
+    describe 'Person' do
+      should 'respond to #name' do
+        person = Person.new
+
+        person.respond_to?(:name).should  == true
+        person.respond_to?(:name=).should == true
+      end
+
+      should 'set the name in the constructor' do
+        person = Person.new('Matz')
+
+        person.name.should == 'Matz'
+      end
+
+      should 'set the name using #name=' do
+        person = Person.new
+
+        person.name = 'Matz'
+
+        person.name.should == 'Matz'
+      end
+    end
 
-Ramaze uses and encourages BDD (Behaviour Driven Development). It comes out of
-the box with a helper for [Bacon][bacon]. Bacon is a small [Rspec][rspec] clone
-used by Ramaze for all specifications (also known as "specs").
+For more information on the syntax of Bacon and other information see the
+[Bacon Github project][bacon].
+
+### Bacon With Ramaze
+
+Ramaze makes it easy to test your code using Bacon by providing you with a small
+helper file. This file can be loaded as following:
+
+    require 'ramaze/spec/bacon'
+
+This file adds two bacon contexts (rack_test and webrat), configures Ramaze to
+only show error messages and adds a few helper methods.
+
+### Bacon and Rack::Test
+
+In order to test Ramaze specific code you'll need to use a tool that's capable
+of mocking Rack requests or execute this request in a different way (e.g. using
+Selenium). Rack::Test (gem install rack-test) makes it possible to test your
+Rack based (and thus Ramaze) applications without having to use a webbrowser.
+
+Ramaze makes it easy to use Rack::Test by defining a special bacon context:
+"rack_test". This context can be used by calling `behaves_like :rack_test`
+inside your describe block:
+
+    describe 'Using Rack::Test' do
+      behaves_like :rack_test
+    end
+
+Once loaded you can execute HTTP requests using methods such as `get`:
+
+    describe 'Using Rack::Test' do
+      behaves_like :rack_test
+
+      should 'display the homepage' do
+        get('/').body.should == 'Hello, Rack::Test!'
+      end
+    end
 
-Writing tests with Bacon results to clean and complete specifications with
-minimum learning time and effort for adaptation. When creating a new Ramaze
-application using ``ramaze create`` Ramaze will automatically generate a
-directory for your specifications.
+More information about Rack::Test can be found on the [Github page of
+Rack::Test][rack-test].
 
-Ramaze does not enforce the use of a particular testing library but for the sake
-of simplicity this guide assumes you'll be using Bacon. In order to use Bacon
-you must first install it from Rubygems. This can be done using the following
-command:
+## Capybara
 
-    gem install bacon
+Capybara is a Gem that can be used to simulate browser requests using
+Rack::Test, Selenium or other drivers, it's even capable of testing Javascript
+based code using Selenium.
 
-In order to run the tests in the spec directory you can run the following
-command:
+In order to use Capybara you must first install it:
 
-    bacon spec/*
+    $ gem install capybara
+
+Once installed you'll have to configure Capybara so it knows how to use your
+Ramaze application. Depending on the testing Gem you're using you'll also have
+to configure said Gem, for this guide it's assumed that you're using Bacon.
+
+First you should load and configure Capybara:
+
+    require 'capybara'
+    require 'capybara/dsl'
+    require 'bacon'
+
+    # Tells Capybara which driver to use and where to find your application.
+    # Without this Capybara will not work properly.
+    Capybara.configure do |config|
+      config.default_driver = :rack_test
+      config.app            = Ramaze.middleware
+    end
+
+Next you'll have to set up a context for Bacon:
+
+    shared :capybara do
+      Ramaze.setup_dependencies
+      extend Capybara::DSL
+    end
+
+Last but not least, make sure Ramaze knows about your root directories and set
+your mode:
+
+    Ramaze.options.roots << 'path/to/spec/directory'
+    Ramaze.options.mode  = :spec
+
+Once all of this has been done you can start using Capybara. A simple example of
+this is the following:
+
+    class MainController < Ramaze::Controller
+      map '/'
+
+      def index
+        return 'Hello, Ramaze!'
+      end
+
+      def redirect_request
+        redirect(MainController.r(:index))
+      end
+    end
+
+    describe 'Testing Ramaze' do
+      behaves_like :capybara
+
+      it 'Go to the homepage' do
+        visit '/'
+
+        page.has_content?('Hello, Ramaze!').should == true
+      end
+
+      it 'Follow redirects' do
+        visit '/redirect_request'
+
+        page.current_path.should == '/index'
+        page.has_content?('Hello, Ramaze!').should == true
+      end
+    end
+
+For more information on how to use Capybara with other testing tools, how to use
+the syntax and so on you should resort to the [Capybara Github page][capybara].
+
+## Code Coverage using SimpleCov
 
 To test the Ramaze application tests coverage, you can use a tool like
 [SimpleCov][simplecov]. SimpleCov requires minimal effort to get integrated,
@@ -48,14 +216,12 @@ In order to run the file you'd simply invoke the following:
 
 Upon success SimpleCov will create a new directory ``coverage`` with the
 results. You can point your browser to the index.html file inside that directory
-If you have Python installed you can start a webserver directly on port 11111
-and browse to the same folder. This can be done as following:
-
-    python -m SimpleHTTPServer 11111
+to view the results.
 
-For more information on using Simplecov see the [Github project][simplecov gh].
+For more information on using Simplecov see the [Github project][simplecov].
 
 [bacon]: https://github.com/chneukirchen/bacon
 [simplecov]: https://github.com/colszowka/simplecov
 [rspec]: http://relishapp.com/rspec
-[simplecov gh]: https://github.com/colszowka/simplecov
+[capybara]: http://jnicklas.github.com/capybara/
+[rack-test]: https://github.com/brynary/rack-test

data/lib/ramaze/cache/memcache.rb

@@ -1,5 +1,5 @@
 Ramaze.setup(:verbose => false) do
-  gem 'dalli'
+  gem 'dalli', ['>= 2.0.2']
 end
 
 # Kgio gives a nice performance boost but it isn't required
@@ -62,7 +62,7 @@ module Ramaze
         :expires_in => 604800,
 
         # Compresses everything with Gzip if it's over 1K
-        :compression => true,
+        :compress => true,
 
         # Array containing all default Memcache servers
         :servers => ['localhost:11211']

data/lib/ramaze/cache/redis.rb

@@ -81,9 +81,8 @@ module Ramaze
       #  information.
       #
       def initialize(options = {})
-        self.class.options ||= Ramaze::Cache::Redis.trait[:default].merge(
-          options
-        )
+        self.class.options ||=
+          Ramaze::Cache::Redis.trait[:default].merge(options)
 
         @options = options.merge(self.class.options)
       end
@@ -103,8 +102,8 @@ module Ramaze
       #
       def cache_setup(hostname, username, appname, cachename)
         options[:namespace] = [
-          hostname, username, appname, cachename
-        ].compact.join('-')
+          'ramaze', hostname, username, appname, cachename
+        ].compact.join(':')
 
         @client = ::Redis.new(options)
       end
@@ -126,7 +125,7 @@ module Ramaze
       # @param  [Array] *keys An array of key names to remove.
       #
       def cache_delete(*keys)
-        @client.del(*keys)
+        @client.del(*keys.map{|key| namespaced_key(key) })
       end
 
       ##
@@ -139,8 +138,8 @@ module Ramaze
       # @return [Mixed]
       #
       def cache_fetch(key, default = nil)
-        value = @client.get(key)
-        value.nil? ? default : value
+        value = @client.get(namespaced_key(key))
+        value.nil? ? default : ::Marshal.load(value)
       end
 
       ##
@@ -155,10 +154,15 @@ module Ramaze
       #
       def cache_store(key, value, ttl = nil, options = {})
         ttl = options[:ttl] || @options[:expires_in]
-        @client.setex(key, ttl, value)
+
+        @client.setex(namespaced_key(key), ttl, ::Marshal.dump(value))
 
         return value
       end
+
+      def namespaced_key(key)
+        [options[:namespace], key].join(':')
+      end
     end # Redis
   end # Cache
 end # Ramaze

data/lib/ramaze/helper/paginate.rb

@@ -14,6 +14,15 @@ module Ramaze
       trait :paginate => {
         :limit => 10,
         :var   => 'pager',
+        :css   => {
+            :first    => 'first',
+            :prev     => 'prev',
+            :next     => 'next',
+            :last     => 'last',
+            :current  => 'current',
+            :number   => '',
+            :disabled => 'grey'
+        }
       }
 
       ##
@@ -41,9 +50,37 @@ module Ramaze
       #
       # Note that you must first extend Sequel with the pagination extension"
       #
-      #
       #     Sequel.extension :pagination
       #
+      # Customizing the classes to use for the various HTML elements of the
+      # page list can be done by passing a key ``:css`` to the list of options.
+      # In this hash you can set the following keys:
+      #
+      # * first, defaults to "first"
+      # * prev, defaults to "prev"
+      # * next, defaults to "next"
+      # * last, defaults to "last"
+      # * current, defaults to "current"
+      # * number, empty by default
+      # * disabled, defaults to "grey"
+      #
+      # These options can also be specified globally in the trait ``:paginate``
+      # as following:
+      #
+      #     class Posts < Ramaze::Controller
+      #       map '/'
+      #
+      #       trait :paginate => {
+      #         :limit => 10,
+      #         :var   => 'page',
+      #         :css   => {
+      #           :first => 'first_item',
+      #           :prev  => 'prev_item',
+      #           # and so on.
+      #         }
+      #       }
+      #     end
+      #
       # @param [Sequel::Dataset|Array] dataset May be a Sequel dataset or an
       #  Array
       # @param [Hash] options A hash containing custom options that takes
@@ -56,23 +93,30 @@ module Ramaze
       # @option options [Fixnum] :page The page you are currently on, if not
       #  given it will be retrieved from current request variables. Defaults to
       #  1 if neither exists.
+      # @option options [Hash] :css A hash containing various options that can
+      #  be used to customize the HTML classes to use for the various page
+      #  links.
       #
       def paginate(dataset, options = {})
         options = ancestral_trait[:paginate].merge(options)
         limit = options[:limit]
         var   = options[:var]
         page  = options[:page] || (request[var] || 1).to_i
-
-        Paginator.new(dataset, page, limit, var)
+        opts = {}
+        opts.merge!({:css => options[:css]}) if options[:css]
+        Paginator.new(dataset, page, limit, var, opts)
       end
 
       # Provides easy pagination and navigation
       class Paginator
         include Ramaze::Helper
         helper :link, :cgi
+        attr_reader :css
 
-        def initialize(data = [], page = 1, limit = 10, var = 'pager')
+        def initialize(data = [], page = 1, limit = 10, var = 'pager', opts = {})
           @data, @page, @limit, @var = data, page, limit, var
+          @css = Paginate.trait[:paginate][:css].dup
+          @css.merge!(opts[:css]) if opts[:css]
           @pager = pager_for(data)
           @page = @page > page_count ? page_count : @page
           @pager = pager_for(data)
@@ -110,34 +154,35 @@ module Ramaze
           g = Ramaze::Gestalt.new
           g.div :class => :pager do
             if first_page?
-              g.span(:class => 'first grey'){ h('<<') }
-              g.span(:class => 'previous grey'){ h('<') }
+              g.span(:class => "#{@css[:first]} #{@css[:disabled]}"){ h('<<') }
+              g.span(:class => "#{@css[:prev]} #{@css[:disabled]}"){ h('<') }
             else
-              link(g, 1, '<<', :class => :first)
-              link(g, prev_page, '<', :class => :previous)
+              link(g, 1, '<<', :class => @css[:first])
+              link(g, prev_page, '<', :class => @css[:prev])
             end
 
             lower = limit ? (current_page - limit) : 1
             lower = lower < 1 ? 1 : lower
 
             (lower...current_page).each do |n|
-              link(g, n)
+              link(g, n, n, :class => @css[:number])
             end
 
-            link(g, current_page, current_page, :class => :current)
+            link(g, current_page, current_page,
+              :class => "#{@css[:current]} #{@css[:number]}" )
 
             if last_page?
-              g.span(:class => 'next grey'){ h('>') }
-              g.span(:class => 'last grey'){ h('>>') }
+              g.span(:class => "#{@css[:next]} #{@css[:disabled]}"){ h('>') }
+              g.span(:class => "#{@css[:last]} #{@css[:disabled]}"){ h('>>') }
             elsif next_page
               higher = limit ? (next_page + limit) : page_count
               higher = [higher, page_count].min
               (next_page..higher).each do |n|
-                link(g, n)
+                link(g, n, n, :class => @css[:number])
               end
 
-              link(g, next_page, '>', :class => :next)
-              link(g, page_count, '>>', :class => :last)
+              link(g, next_page, '>', :class => @css[:next])
+              link(g, page_count, '>>', :class => @css[:last])
             end
           end
           g.to_s