vanilla 1.17 → 1.17.1

data/pristine_app/soups/base/start.snip

@@ -1,19 +1,20 @@
-<h1>Welcome to Vanilla.rb</h1>
+<div id="welcome">
+  <h1>Welcome to <a href="/">Vanilla.rb</a></h1>
+</div>
 
-<p>Vanilla.rb is a web-experiment (a <em>websperiment</em>?) about storing and reusing data on a website. It can also function as a <a href="http://www.wikipedia.com/wiki/Bliki">bliki</a>.</p>
+<div class="grid_16 alpha">
+    <h2>First time?</h2>
 
-<p>From a technical perspective, vanilla is a Ruby rack application, and should play well within the rack ecosystem. It uses a simple document store called `soup` to store data.</p>
+    <p>Start at {link_to tutorial, the tutorial} for some orientation.</p>
 
-<h2>What now?</h2>
+    <h2>What is this?</h2>
+    <p>Vanilla is a simple web framework for playing with content. It can function as a a CMS, a wiki, a bliki, or anything in between.</p>
+    
+    <p>Under the hood it is a Rack application, which means it should play nice in the Ruby web ecosystem. {link_to vanilla-rb, Learn more}.</p>
+    
+    <h2>Adding your content</h2>
 
-<p>If this is your first time using vanilla, you should investigate the {link_to tutorial} for some orientation.</p>
+    <p>This is the {link_to start} snip, which is the default home page. You can find this content in <code>soups/base/start.snip</code>. You should replace this content with whatever you want on your site's home page.</p>
 
-<h2>What next?</h2>
-
-<p>This is the {link_to start} snip, which is the default home page. You can find this content in `start.snip`.</p>
-
-<p>You should replace this content with whatever you want on your site's home page.</p>
-
-<p>Once your site is ready to run, you'll probably want to remove the tutorial; you can do this by editing the configuration in `config.ru`, and deleting the `soups/tutorial` directory.</p>
-
-<p>Good luck!</p>
+    <p>Good luck!</p>
+</div>

data/pristine_app/soups/system/current_snip.rb

@@ -16,9 +16,9 @@ class CurrentSnip < Dynasnip
   def handle(attribute=nil)
     if app.request.snip
       if attribute ||= app.request.part
-        "{#{app.request.snip_name}.#{attribute}}"
+        %|{"#{app.request.snip_name}"."#{attribute}"}|
       else
-        "{#{app.request.snip_name}}"
+        %|{"#{app.request.snip_name}"}|
       end
     else
       app.response.status = 404

data/pristine_app/soups/system/feed.rb

@@ -0,0 +1,30 @@
+require "vanilla/dynasnip"
+
+class Feed < Dynasnip
+  def handle(*args)
+    Atom::Feed.new do |f|
+      f.title = "blah"
+      f.updated = Time.now
+      f.id = "tag:x,2008-06-01:kind/x"
+      f.entries = entries
+    end.to_xml
+  end
+
+  private
+  
+  def entries
+    app.soup.all_snips.map do |snip|
+      Atom::Entry.new do |e|
+        # e.published = snip.created_at
+        # e.updated = snip.updated_at || snip.created_at
+        e.content = Atom::Content::Html.new(app.render(snip))
+        # e.title = snip.name
+        # e.authors = [Atom::Person.new(:name => snip.author || domain)]
+        # e.links << Atom::Link.new(:href => "http://#{domain}#{url_to(snip.name)}")
+        # e.id = "tag:#{domain},#{(snip.created_at.to_s || Date.today.to_s).split[0]}:/#{snip.name}"
+      end
+    end
+  end
+
+  self
+end

data/pristine_app/soups/system/index.rb

@@ -2,10 +2,10 @@ require 'vanilla/dynasnip'
 
 class Index < Dynasnip
   def get(*args)
-    list = app.soup.instance_eval { @backend }.send(:all_snips).sort_by { |a| a.updated_at || Time.at(0) }.reverse.map { |snip|
-      "<li>#{link_to snip.name}</li>"
+    list = app.soup.all_snips.sort_by { |a| a.updated_at || Time.at(0) }.reverse.map { |snip|
+      "<li>{link_to #{snip.name}}</li>"
     }
-    "<ol>#{list}</ol>"
+    %{<ol id="index">#{list}</ol>}
   end
 
   self

data/pristine_app/soups/system/link_to.rb

@@ -9,7 +9,11 @@ The link_to dyna lets you create links between snips:
 would insert a link to the blah snip.|
 
   def handle(snip_name, link_text=snip_name, part=nil)
-    link_to(link_text, snip_name, part)
+    if app.soup[snip_name]
+      %{<a href="#{url_to(snip_name, part)}">#{link_text}</a>}
+    else
+      %{<a class="missing" href="#{url_to(snip_name, part)}">#{link_text}</a>}
+    end
   end
 
   self

data/pristine_app/soups/system/link_to_current_snip.rb

@@ -2,12 +2,11 @@ require 'vanilla/dynasnip'
 
 class LinkToCurrentSnip < Dynasnip
   usage %|
-    Renders a link to the current snip, or the snip currently being edited
-    (if we're currently editing)
+    Renders a link to the current snip
   |
 
   def handle(*args)
-    link_to app.request.snip_name
+    %{<a href="#{url_to(app.request.snip_name)}">#{app.request.snip_name}</a>}
   end
 
   self

data/pristine_app/soups/tutorial/tutorial-layout.snip

@@ -41,9 +41,16 @@ The second dynasnip used is `link_to_current_snip`, which returns an HTML link t
 Other layouts
 -------------
 
-Vanilla looks for a snip called `layout` by default, but this can be changed by passing in a `:default_layout` option to `Vanilla::App.new`, e.g.
+Vanilla looks for a snip called `layout` by default, but this can be changed by setting the `default_layout` configuration option in your application, e.g.
 
-    Vanilla::App.new(:default_layout => "my_layout")
+    class Application < Vanilla::App; end
+
+    Application.configure do |config|
+
+      # other stuff..
+
+      config.default_layout = "my_layout"
+    end
 
 
 You can also override the layout on a per-snip basis, simply by setting the `:layout` attribute of the snip to the name of the layout snip to use instead.

data/pristine_app/soups/tutorial/tutorial-links.snip

@@ -1,4 +1,5 @@
 {link_to tutorial, "Basics"}
 {link_to tutorial-layout, "Learn about Layouts"}
 {link_to tutorial-renderers, "Renderer fun"}
-{link_to tutorial-dynasnips, "More about Dynasnips"}
+{link_to tutorial-dynasnips, "More about Dynasnips"}
+{link_to tutorial-removing, "Cleaning up"}

data/pristine_app/soups/tutorial/tutorial-removing.snip.markdown

@@ -0,0 +1,8 @@
+{tutorial-links}
+
+Removing this tutorial
+======================
+
+Once your site is ready to run, you'll probably want to remove the tutorial; you can do this by editing the configuration in `application.rb`, and deleting the `soups/tutorial` directory.
+
+{tutorial-links}

data/pristine_app/soups/tutorial/tutorial-renderers.snip.markdown

@@ -42,9 +42,15 @@ Adding renderers
 
 New renderers can be added as part of the application configuration:
 
-    Vanilla::App.new(:renderers => {
-      "rdoc" => MyRenderers::RDoc
-    })
+    class Application < Vanilla::App; end
+
+    Application.configure do |config|
+
+      # other stuff..
+
+      config.renderers[:my_format] = MyRenderer # the class
+    end
+
 
 These will be added to the lookup, and can also used to override the defaults (changing the renderer for "markdown" snips to use RDiscount, or Redcarpet, for example).
 
@@ -57,7 +63,7 @@ The simplest renderer inherits from `Vanilla::Renderers::Base`, and reimplement
     module Vanilla::Renderers
       class Bold < Base
         def process_text(content)
-          "<b>#{content}</b>" 
+          "<b>#{content}</b>"
         end
       end
     end

data/pristine_app/soups/tutorial/tutorial.snip.markdown

@@ -65,5 +65,4 @@ Anyway - that should be enough to get you started.
 
 {tutorial-links}
 
-
 :updated_at: 2011-04-28 16:21:00 +01:00

data/pristine_app/soups/tutorial/vanilla-rb.snip

@@ -2,15 +2,13 @@ Vanilla.rb is the software powering this site. It's a sort-of wiki/bliki thing,
 
 Here's the [introductory blog post][3].
 
-It's developed on [github][1], and has a [lighthouse bug tracker][2]. At the moment it's not very well documented, since I'm exploring how the concept might work and the internals are subject to change. However, please do play around with it.
+It's developed on [github][1], and has a [bug tracker][2]. At the moment it's not very well documented, since I'm exploring how the concept might work and the internals are subject to change. However, please do play around with it.
 
-Here's the tutorial (helpfully included from {link_to tutorial}).
+You may be able to view the {link_to tutorial} on this site, if it hasn't been removed.
 
-{tutorial}
 
-
-[1]: http://github.com/lazyatom/vanilla
-[2]: http://lazyatom.lighthouseapp.com/projects/11797-vanilla/tickets
+[1]: http://github.com/lazyatom/vanilla-rb
+[2]: http://github.com/lazyatom/vanilla-rb/issues
 [3]: http://interblah.net/introducing-vanilla-rb
 
 :render_as: Markdown

data/test/core/configuration_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+context "Configuring a Vanilla app" do
+  class TestConfigurationApp < Vanilla::App
+  end
+
+  setup do
+    TestConfigurationApp.reset!
+  end
+
+  context "with defaults" do
+    should "set the soups to base and system" do
+      assert_equal ["soups/base", "soups/system"], TestConfigurationApp.new.config.soups
+    end
+
+    should "set the default layout snip to 'layout'" do
+      assert_equal "layout", TestConfigurationApp.new.config.default_layout_snip
+    end
+
+    should "set the default root directory to the current directory" do
+      assert_equal Dir.pwd, TestConfigurationApp.new.config.root
+    end
+
+    should "use Vanilla::Renderers::Base as the default renderer" do
+      assert_equal Vanilla::Renderers::Base, TestConfigurationApp.new.config.default_renderer
+    end
+  end
+
+  context "with a custom root" do
+    setup do
+      soup_dir = File.join(Dir.tmpdir, "my_soup")
+      FileUtils.mkdir_p(soup_dir)
+      File.open(File.join(soup_dir, "blah.snip"), "w") { |f| f.write "Hello superfriends" }
+
+      TestConfigurationApp.configure do |c|
+        c.root = Dir.tmpdir
+        c.soups = ["my_soup"]
+      end
+    end
+
+    should "expand soup paths relative to the root to aide loading external soups" do
+      assert_equal "Hello superfriends", TestConfigurationApp.new.soup['blah'].content
+    end
+  end
+
+  context "with a custom root_snip" do
+    setup do
+      TestConfigurationApp.configure do |c|
+        c.root_snip = "hello"
+      end
+    end
+
+    should "use the given snip as the root_snip" do
+      assert_equal "hello", TestConfigurationApp.new.config.root_snip
+    end
+  end
+
+  context "with a specific set of soups" do
+    setup do
+      TestConfigurationApp.configure do |c|
+        c.soups = ["blah", "monkey"]
+      end
+    end
+
+    should "use only the specified soups" do
+      assert_equal ["blah", "monkey"], TestConfigurationApp.new.config.soups
+    end
+  end
+
+  context "with new renderers" do
+    should "load new renderer constants presented as a string" do
+      class ::MyRenderer
+      end
+      TestConfigurationApp.configure do |c|
+        c.renderers[:my_renderer] = "MyRenderer"
+      end
+      snip = create_snip(:name => "blah", :render_as => "my_renderer")
+      assert_equal MyRenderer, TestConfigurationApp.new.renderer_for(snip)
+    end
+
+    should "allow existing renderers to be overridden" do
+      TestConfigurationApp.configure do |c|
+        c.renderers["markdown"] = "Vanilla::Renderers::Bold"
+      end
+      snip = create_snip(:name => "blah", :extension => "markdown")
+      assert_equal Vanilla::Renderers::Bold, TestConfigurationApp.new.renderer_for(snip)
+    end
+  end
+end

data/test/{renderers → core/renderers}/base_renderer_test.rb

@@ -40,4 +40,41 @@ describe Vanilla::Renderers::Base do
       assert_response_body "include a [snip 'missing_snip' cannot be found]", "/blah"
     end
   end
+
+  context "when generating a link" do
+    setup do
+      snip = create_snip(:name => "blah")
+      @soup = stub('soup', :[] => snip)
+      @app = stub('app', :url_to => "/url", :soup => @soup)
+      @renderer = Vanilla::Renderers::Base.new(@app)
+    end
+
+    should "call url_to on the app to generate the url" do
+      @app.expects(:url_to).with("blah", nil).returns("/blah")
+      link = @renderer.link_to("blah")
+      assert_equal %{<a href="/blah">blah</a>}, link
+    end
+
+    should "use the snip name as the link text" do
+      link = @renderer.link_to("blah")
+      assert_equal %{<a href="/url">blah</a>}, link
+    end
+
+    should "use any explicit link text given" do
+      link = @renderer.link_to("something", "blah")
+      assert_equal %{<a href="/url">something</a>}, link
+    end
+
+    should "render a missing link if the snip couldn't be found" do
+      @soup.stubs(:[]).returns(nil)
+      link = @renderer.link_to("blah")
+      assert_equal %{<a class="missing" href="/url">blah</a>}, link
+    end
+
+    should "be able to link to a specified part" do
+      @app.expects(:url_to).with("blah", "part").returns("/blah/part")
+      link = @renderer.link_to("blah part", "blah", "part")
+      assert_equal %{<a href="/blah/part">blah part</a>}, link
+    end
+  end
 end

data/test/core/routing_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+context "Parsing routes" do
+
+  { "/" => [nil, nil, nil],
+   "/blah" => ["blah", nil, nil],
+   "/blah-face" => ["blah-face", nil, nil],
+   "/blah+face" => ["blah face", nil, nil],
+   "/blah.text" => ["blah", nil, "text"],
+   "/blah.html" => ["blah", nil, "html"],
+   "/blah/part" => ["blah", "part", nil],
+   "/blah/part.raw" => ["blah", "part", "raw"]}.each do |path, (snip, part, format)|
+
+    context "parsing #{path}" do
+      setup { @parsed_route = Vanilla::Routing.parse(path) }
+
+      should "return #{snip.inspect} as the snip" do
+        assert_equal snip, @parsed_route[0]
+      end
+      should "return #{part.inspect} as the part" do
+        assert_equal part, @parsed_route[1]
+      end
+      should "return #{format.inspect} as the format" do
+        assert_equal format, @parsed_route[2]
+      end
+
+    end
+  end
+
+end

data/test/{test_helper.rb → core/test_helper.rb}

@@ -1,16 +1,16 @@
-$LOAD_PATH.unshift(File.expand_path("../../lib"), __FILE__)
+$LOAD_PATH.unshift(File.expand_path("../../../lib"), __FILE__)
 require "kintama"
 require "kintama/mocha"
 require "vanilla/test_helper"
 
-class Application < Vanilla::App
+class TestApplication < Vanilla::App
 end
 
 module TestHelper
   include Vanilla::TestHelper
-  
+
   def create_simple_layout
-    require File.expand_path("../../pristine_app/soups/system/current_snip", __FILE__)
+    require File.expand_path("../../../pristine_app/soups/system/current_snip", __FILE__)
     app.soup << CurrentSnip.snip_attributes
     create_snip :name => "layout", :content => "{current_snip}"
   end
@@ -20,6 +20,7 @@ Kintama.include TestHelper
 
 Kintama.setup do
   vanilla_setup
+  TestApplication.reset!
   create_simple_layout
 end
 

data/test/core/vanilla_app_test.rb

@@ -0,0 +1,51 @@
+require "test_helper"
+require "tmpdir"
+
+describe Vanilla::App do
+  context "when behaving as a Rack application" do
+    should "return a valid rack response" do
+      create_snip(:name => "test", :content => "content")
+      get "/test.text"
+      assert_equal 200, last_response.status
+      assert_kind_of Hash, last_response.headers
+      assert_equal "content", last_response.body
+    end
+  end
+
+  context "when detecting the snip renderer" do
+    should "return the constant refered to in the render_as property of the snip" do
+      snip = create_snip(:name => "blah", :render_as => "Raw")
+      assert_equal Vanilla::Renderers::Raw, app.renderer_for(snip)
+    end
+
+    context "using the snip extension" do
+      {
+        "markdown" => Vanilla::Renderers::Markdown,
+        "textile" => Vanilla::Renderers::Textile,
+        "erb" => Vanilla::Renderers::Erb,
+        "rb" => Vanilla::Renderers::Ruby,
+        "haml" => Vanilla::Renderers::Haml
+      }.each do |extension, renderer|
+        should "return the renderer #{renderer} when the snip has extension #{extension}" do
+          snip = create_snip(:name => "blah", :extension => extension)
+          assert_equal renderer, app.renderer_for(snip)
+        end
+      end
+    end
+
+    should "return Vanilla::Renderers::Base if no render_as property exists" do
+      snip = create_snip(:name => "blah")
+      assert_equal Vanilla::Renderers::Base, app.renderer_for(snip)
+    end
+
+    should "return Vanilla::Renderers::Base if the render_as property is blank" do
+      snip = create_snip(:name => "blah", :render_as => '')
+      assert_equal Vanilla::Renderers::Base, app.renderer_for(snip)
+    end
+
+    should "raise an error if the specified renderer doesn't exist" do
+      snip = create_snip(:name => "blah", :render_as => "NonExistentClass")
+      assert_raises(NameError) { app.renderer_for(snip) }
+    end
+  end
+end