vanilla 1.2 → 1.9.9

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

@@ -1,56 +0,0 @@
-{tutorial-links}
-
-Layouts
-=======
-
-Since you almost certainly want your site to look good, one of the first things you'll want to change in your vanilla site is the layout.
-
-When the browser requests a snip, normally vanilla will present it within a _layout_ template. This would typically include a header, a footer, and any other peripheral markup that shouldn't be within the content of the snip itself. If you're familiar with the construction of web applications, this will be exactly as you expect.
-
-Layouts are just like any other snip - they can be sent through a renderer, and include other snips. The default layout snip is called, predictable, `layout.snip`, and here's the content:
-
-    {raw layout}
-
-When you request `/start`, this is the snip that's actually rendered first. If this snip was just text, that's all that would be returned; however, there are some dynasnip calls in here which help us actually return the content that the user requested.
-
-
-`current_snip`
---------------
-
-The most significant is the call to `current_snip`. This figures out what snip was actually requested (e.g. if the url is `/start`, it's the {link_to start} snip), and renders it in place.
-
-Here's the source of `current_snip`:
-
-    {raw current_snip}
-
-The default case, as in our layout, is `app.render(app.request.snip, app.request.part)` - it delegates rendering back to the application, which then takes care of processing `start` using the right renderer and so on. This method call returns the fully rendered string, and vanilla replaces the call to the dynasnip with that output, placing our snip in the appropriate place in the layout.
-
-
-Other dynas
------------
-
-Of course, you can put other plain content in your layout, and other dynasnips too. In the provided layout there are calls to two other dynasnips.
-
-The first is `page_title`, which simply places a (hopefully) meaningful string in the title element of the page. Snips can set the title to be used by defining a `:page_title` attribute. As usual, the source explains it more clearly:
-
-    {raw page_title}
-
-The second dynasnip used is `link_to_current_snip`, which returns an HTML link to the snip that's currently being rendered. I'll let you figure out how to view the source yourself.
-
-
-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::App.new(:default_layout => "my_layout")
-
-
-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.
-
-Finally, if you implement a custom renderer class (see {link_to tutorial-renderers, "the renderers tutorial"}), you can also specify a layout to be used when the requested snip invokes that renderer. This can be useful if you have a particular kind of content that requires a different layout entirely.
-
-{tutorial-links}
-
-:render_as: Markdown
-:page_title: Tutorial - Layout

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

@@ -1,4 +0,0 @@
-{link_to tutorial}
-{link_to tutorial-layout}
-{link_to tutorial-renderers}
-{link_to tutorial-dynasnips}

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

@@ -1,77 +0,0 @@
-{tutorial-links}
-
-Renderers
-=========
-
-As well as the flexibility to combine pieces of content, another reason {link_to vanilla-rb} is more *interesting* than simpler wiki-ish software is that each piece of content can be processed by arbitrarily complex software before it is composed.
-
-In its simplest form, this means that some content can be written in one format (say, raw HTML) whereas other content can be written in different formats (like Textile or Markdown for richer content). You could write one blog post in Textile, and the next one in Markdown, without any issues, depending on what best suits your purpose.
-
-This is one of the principle drivers behind {link_to vanilla-rb}; you shouldn't have to make an upfront decision about how best to structure your all of your content.
-
-This has been covered generally in the {link_to tutorial, main tutorial}, but here we'll go into a bit more detail.
-
-Defining a renderer for a snip
--------------------
-
-The renderer used for a snip is determined in the following manner
-
-1. Using the snip `extension` attribute
-2. Using the snip `render_as` attribute
-3. Using the default renderer
-
-The snip `extension` is an attribute generated by the {link_to soup} library, which roughly corresponds to the file extension of the snip itself. So, if your snip is stored in a file called `my-schnip.markdown`, the `extension` property will be `markdown`. If the filename is `my-schnip.snip.markdown`, the `extension` is still just `markdown`.
-
-To determine the actual renderer from this attributes, a lookup hash is used, mapping these strings onto Ruby classes. The default is something like this:
-
-    {
-      "base" => Vanilla::Renderers::Base,
-      "markdown" => Vanilla::Renderers::Markdown,
-      "bold" => Vanilla::Renderers::Bold,
-      "erb" => Vanilla::Renderers::Erb,
-      "rb" => Vanilla::Renderers::Ruby,
-      "ruby" => Vanilla::Renderers::Ruby,
-      "haml" => Vanilla::Renderers::Haml,
-      "raw" => Vanilla::Renderers::Raw,
-      "textile" => Vanilla::Renderers::Textile
-    }
-
-
-Adding renderers
-----------------
-
-New renderers can be added as part of the application configuration:
-
-    Vanilla::App.new(:renderers => {
-      "rdoc" => MyRenderers::RDoc
-    })
-
-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).
-
-
-Writing new renderers
----------------------
-
-The simplest renderer inherits from `Vanilla::Renderers::Base`, and reimplement the `process_text` method:
-
-    module Vanilla::Renderers
-      class Bold < Base
-        def process_text(content)
-          "<b>#{content}</b>" 
-        end
-      end
-    end
-
-It is passed a string (either the selected snip's "content" attribute, or some other explicitly requested attribute), and should return that content in its rendered form. The `Vanilla::Renderers::Markdown` renderer shows this more clearly:
-
-    module Vanilla::Renderers
-      class Markdown < Base
-        def process_text(content)
-          BlueCloth.new(content).to_html
-        end
-      end
-    end
-
-There are a number of other methods which can be overridden by custom renderers, but these are beyond the scope of this tutorial; the best way to learn is to look at the set of provided renderers (such as the Erb and Haml ones) and work from there.
-
-{tutorial-links}

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

@@ -1,69 +0,0 @@
-{tutorial-links}
-
-Snips - the basic concept
-------------
-
-Firstly, open the raw contents of this snip - either in your editor (search for `vanilla-rb-tutorial.snip`), or by opening <a href="{current_snip name}.raw">this snip in raw format</a> in a new window or tab. Ready? OK.
-
-Every piece of information displayed here is stored as a {link_to snip}. Snips, within their contents, can also reference other snips. When you request a snip, it will render into a page (or another kind of response), and also render any snips that it internally references.
-
-For example, consider the snip {link_to tutorial-basic-snip-inclusion}:
-
-    {raw tutorial-basic-snip-inclusion}
-
-When this snip is rendered, it appears like this:
-
-> {tutorial-basic-snip-inclusion}
-
-Notice the use of curly brackets to reference one snip from inside another. {link_to vanilla-rb} finds these references to snips, then renders that snip and replaces it in the first snip. Neat!
-
-Renderers
---------
-
-The way that a snip is rendered depends on whether or not it has an extension, or a `render_as` attribute set. For instance, the extention of this snip is `{current_snip extension}`, and the `render_as` property of `markdown_example` is `Markdown`. Scroll to the bottom of the raw markdown_example snip in your editor, and you'll see this being declared.
-
-This means that the `content` of this snip will be passed through `Vanilla::Renderers::Markdown` before it is then rendered to the page. There are several different renders provided by Vanilla.rb at the moment:
-
-  * Markdown - as described above
-  * Textile - which performs similarly for Textile. This means that you can mix how you write the content of snips!
-  * Raw - which simply returns the content of the snip, as-is. If you attach a `.raw` extension to this url, you'll see it in action
-  * Bold - simply wraps the content in bold. It's a demo, essentially.
-  * Erb - passes the snip contents through Ruby's `Erb` library. It also makes some information available for use by ruby code within the snip's contents
-  * Ruby - parses the snips content as Ruby itself.
-
-You can see a lot of these renderers being exercised in the {link_to test} snip.
-
-It's using this last renderer that a second concept of Vanilla is implemented - dynasnips.
-
-
-Dynasnips
---------
-
-Because the curly braces simply cause a snip to be rendered, we can use this in conjunction with the Ruby renderer to run actual code. For instance, in the snip above:
-
-    {raw tutorial-basic-snip-inclusion}
-
-we can see a reference to the `link_to` snip - <tt>&#123;link\_to snip&#125;</tt>.
-
-Lets look at the raw content of `link_to`:
-
-    {raw link_to}
-
-As you can see, it simply refers to the Ruby class `LinkTo`, which is contained within the vanilla-rb codebase. When the Ruby renderer is called, expects the given code to evaulate to a Ruby class. It then instantiates the class, and calls a `handle` method on the instance, passing it any other arguments from the snip inclusion. So, in the case of <tt>&#123;link\_to snip&#125;</tt>, the only argument is `snip`.
-
-### Included Dynasnips
-
-Vanilla.rb includes a number of dynasnips by default. Here are a couple:
-
-  * `link_to`, to produce a link to another snip
-  * `raw`, which displays the raw contents of a snip
-  * `index`, which shows all of the available snips: {link_to index}
-  * ... and several others.
-
-
-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

@@ -1,16 +0,0 @@
-Vanilla.rb is the software powering this site. It's a sort-of wiki/bliki thing, based on {link_to vanilla}.
-
-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.
-
-Here's the tutorial (helpfully included from {link_to tutorial}).
-
-{tutorial}
-
-
-[1]: http://github.com/lazyatom/vanilla
-[2]: http://lazyatom.lighthouseapp.com/projects/11797-vanilla/tickets
-[3]: http://interblah.net/introducing-vanilla-rb
-
-:render_as: Markdown

data/pristine_app/soups/tutorial/vanilla.snip

@@ -1,8 +0,0 @@
-The bliki upon which {link_to vanilla-rb} is based, written by [Christian Langreiter][1]
-
-[Official Web HQ][2]
-
-[1]: http://www.langreiter.com
-[2]: http://www.vanillasite.at
-
-:render_as: Markdown

data/test/dynasnip_test.rb

@@ -1,42 +0,0 @@
-require "test_helper"
-require 'vanilla/dynasnip'
-
-describe Dynasnip do
-  context "when storing attributes" do
-
-    class ::TestDyna < Dynasnip
-      attribute :test_attribute, "test attribute content"
-    end
-
-    should "make the attribute available as an instance method" do
-      assert_equal "test attribute content", TestDyna.new(@app).test_attribute
-    end
-
-    should "store the attribute in the soup" do
-      @app.soup << TestDyna.snip_attributes
-      assert_equal "test attribute content", @app.soup['test_dyna'].test_attribute
-    end
-
-    should "allow the attribute to be overriden by the soup contents" do
-      @app.soup << TestDyna.snip_attributes
-      snip = @app.soup['test_dyna']
-      snip.test_attribute = "altered content"
-      snip.save
-
-      assert_equal "altered content", TestDyna.new(@app).test_attribute
-    end
-  end
-
-  context "when rendering usage" do
-    class ::ShowUsage < Dynasnip
-      usage "This is the usage"
-      def handle
-        usage
-      end
-    end
-
-    should "show the usage defined in the snip" do
-      assert_equal "This is the usage", ShowUsage.new(@app).handle
-    end
-  end
-end

data/test/dynasnips/link_to_current_snip_test.rb

@@ -1,19 +0,0 @@
-require "test_helper"
-$LOAD_PATH.unshift File.expand_path("../../../pristine_app/soups/dynasnips", __FILE__)
-require "link_to_current_snip"
-
-context "The link_to_current_snip dynasnip" do
-  setup do
-    @app.soup << LinkToCurrentSnip.snip_attributes
-    create_snip :name => "test", :content => "test {link_to_current_snip}"
-  end
-
-  should "render a link to the snip that was requested" do
-    assert_response_body %{test <a href="/test">test</a>}, "/test"
-  end
-
-  should "render a link to the snip that was requested even if it isn't the snip that included the dyna" do
-    create_snip :name => "othertest", :content => "othertest {test}"
-    assert_response_body %{othertest test <a href="/othertest">othertest</a>}, "/othertest"
-  end
-end

data/test/dynasnips/link_to_test.rb

@@ -1,27 +0,0 @@
-require "test_helper"
-$LOAD_PATH.unshift File.expand_path("../../../pristine_app/soups/dynasnips", __FILE__)
-require "link_to"
-
-context "The link_to dynasnip" do
-  setup do
-    create_snip :name => "start", :content => "hello"
-  end
-
-  should "render a link to a snip that exists" do
-    assert_equal %{<a href="/start">start</a>}, render_dynasnip(LinkTo, "start")
-  end
-
-  should "allow specification of the link text" do
-    assert_equal %{<a href="/start">the start snip</a>}, render_dynasnip(LinkTo, "start", "the start snip")
-  end
-
-  should "mark snips that are missing with a class" do
-    assert_equal %{<a class="missing" href="/missing">missing</a>}, render_dynasnip(LinkTo, "missing")
-  end
-
-  private
-
-  def render_dynasnip(klass, *args)
-    klass.new(@app).handle(*args)
-  end
-end

data/test/dynasnips/page_title_test.rb

@@ -1,19 +0,0 @@
-require "test_helper"
-$LOAD_PATH.unshift File.expand_path("../../../pristine_app/soups/dynasnips", __FILE__)
-require "page_title"
-
-context "The page_title dynasnip" do
-  setup do
-    @app.soup << PageTitle.snip_attributes
-  end
-
-  should "render as the requested snip name if that snip has no title" do
-    create_snip :name => "test", :content => "{page_title}"
-    assert_response_body %{test}, "/test"
-  end
-
-  should "render as the requested snip's page_title when that attribute is present" do
-    create_snip :name => "test", :content => "{page_title}", :page_title => "This is a test"
-    assert_response_body %{This is a test}, "/test"
-  end
-end

data/test/renderers/base_renderer_test.rb

@@ -1,43 +0,0 @@
-require "test_helper"
-
-describe Vanilla::Renderers::Base do
-  setup do
-    create_snip(:name => "test", :content => "content content", :part => "part content")
-  end
-
-  should "render the contents part of the snip as it is" do
-    assert_response_body "content content", "/test"
-  end
-
-  should "render the specified part of the snip" do
-    assert_response_body "part content", "/test/part"
-  end
-
-  should "include the contents of a referenced snip" do
-    create_snip(:name => "snip_with_inclusions", :content => "loading {test}")
-    assert_response_body "loading content content", "/snip_with_inclusions"
-  end
-
-  should "be able to render a snip attribute" do
-    create_snip(:name => "snip_with_inclusions", :content => "loading {test.part}")
-    assert_response_body "loading part content", "/snip_with_inclusions"
-  end
-
-  should "perform snip inclusion when rendering a part" do
-    create_snip(:name => "snip_with_inclusions", :content => "other content", :part => "loading {test}")
-    assert_response_body "loading content content", "/snip_with_inclusions/part"
-  end
-
-  should "include other snips using their renderers" do
-    create_snip(:name => "including_snip", :content => "lets include {another_snip}")
-    create_snip(:name => "another_snip", :content => "blah", :render_as => "Bold")
-    assert_equal "lets include <b>blah</b>", response_body_for("/including_snip").gsub(/\s+/, ' ')
-  end
-  
-  context "when trying to include a missing snip" do
-    should "return a string describing the missing snip" do
-      create_snip(:name => 'blah', :content => 'include a {missing_snip}')
-      assert_response_body "include a [snip 'missing_snip' cannot be found]", "/blah"
-    end
-  end
-end

data/test/renderers/erb_renderer_test.rb

@@ -1,29 +0,0 @@
-require "test_helper"
-
-describe Vanilla::Renderers::Erb do
-  context "when rendering" do
-    should "insert evaluated Erb content into the snip" do
-      erb_snip(:name => "test", :content => "<%= 1 + 2 %>")
-      assert_response_body "3", "/test"
-    end
-
-    should "evaluate Erb content in the snip" do
-      erb_snip(:name => "test", :content => "<% if false %>monkey<% else %>donkey<% end %>")
-      assert_response_body "donkey", "/test"
-    end
-
-    should "expose the snip as an instance variable" do
-      erb_snip(:name => "test", :content => "<%= @snip.name %>")
-      assert_response_body "test", "/test"
-    end
-
-    should "expose the app as an instance variable" do
-      erb_snip(:name => "test", :content => "<%= @app.class.name %>")
-      assert_response_body "Vanilla::App", "/test"
-    end
-  end
-
-  def erb_snip(params)
-    create_snip(params.merge(:render_as => "Erb"))
-  end
-end

data/test/renderers/haml_renderer_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-require 'haml'
-
-describe Vanilla::Renderers::Haml do
-  context "when rendering" do
-    should "render Haml into HTML" do
-      haml_snip(:name => "test", :content => "#hello\n  stuff")
-      assert_response_body %{<div id='hello'>\n  stuff\n</div>}, "/test"
-    end
-
-    should "insert evaluated Haml content into the snip" do
-      haml_snip(:name => "test", :content => "= 1 + 2")
-      assert_response_body "3", "/test"
-    end
-
-    should "evaluate Erb content in the snip" do
-      haml_snip(:name => "test", :content => "- if false\n  monkey\n- else\n  donkey")
-      assert_response_body "donkey", "/test"
-    end
-
-    should "expose the snip as an instance variable" do
-      haml_snip(:name => "test", :content => "= @snip.name")
-      assert_response_body "test", "/test"
-    end
-
-    should "expose the app as an instance variable" do
-      haml_snip(:name => "test", :content => "= @app.class.name")
-      assert_response_body "Vanilla::App", "/test"
-    end
-  end
-
-  def haml_snip(params)
-    create_snip(params.merge(:render_as => "Haml"))
-  end
-end