vanilla 1.0.0

data/lib/vanilla/renderers/ruby.rb

@@ -0,0 +1,35 @@
+require 'vanilla/renderers/base'
+
+module Vanilla::Renderers
+  # Snips that render_as "Ruby" should define a class.
+  # The class should have instance methods for any HTTP request methods that the dynasnip
+  # should respond to, i.e. get(), post(), and so on.
+  # Alternatively, it can respond to 'handle'.
+  #
+  # The result of the method invocation always has #to_s called on it.
+  # The last line of the content should be the name of that class, so that it
+  # is returned by "eval" and we can instantiate it.
+  # If the dynasnip needs access to the 'context' (i.e. probably the request
+  # itself), it should be a subclass of Dynasnip (or define an initializer
+  # that accepts the context as its first argument).
+  class Ruby < Base
+    def prepare(snip, part=:content, args=[])
+      @args = args
+      @snip = snip
+    end
+    
+    def process_text(content)
+      handler_klass = eval(content, binding, @snip.name)
+      instance = if handler_klass.ancestors.include?(Vanilla::Renderers::Base)
+        handler_klass.new(app)
+      else
+        handler_klass.new
+      end
+      if (method = app.request.method) && instance.respond_to?(method)
+        instance.send(method, *@args).to_s
+      else
+        instance.handle(*@args).to_s
+      end
+    end
+  end
+end

data/lib/vanilla/renderers/textile.rb

@@ -0,0 +1,13 @@
+require 'vanilla/renderers/base'
+
+require 'rubygems'
+gem 'RedCloth'
+require 'redcloth'
+
+module Vanilla::Renderers
+  class Textile < Base
+    def process_text(content)
+      RedCloth.new(content).to_html
+    end
+  end
+end

data/lib/vanilla/request.rb

@@ -0,0 +1,68 @@
+require "cgi"
+
+module Vanilla
+  # Create a request with symbolised access to the params, and some special
+  # accessors to the snip, part and format based on our routing.
+  class Request
+    attr_reader :snip_name, :part, :format, :method
+    
+    def initialize(env)
+      @rack_request = Rack::Request.new(env)
+      determine_request_uri_parts
+    end
+
+    def params
+      # Don't you just love how terse functional programming tends to look like maths?
+      @symbolised_params ||= @rack_request.params.inject({}) { |p, (k,v)| p[k.to_sym] = v; p }
+    end
+    
+    # Returns the snip referenced by the request's URL. Performs no exception
+    # handling, so if the snip does not exist, an exception will be thrown.
+    def snip
+      Vanilla.snip(snip_name)
+    end
+    
+    def cookies
+      @rack_request.cookies
+    end
+    
+    def ip
+      @rack_request.env["REMOTE_ADDR"]
+    end
+    
+    def session
+      @rack_request.env["rack.session"]
+    end
+    
+    private
+    
+    def determine_request_uri_parts
+      @snip_name, @part, @format = request_uri_parts(@rack_request)
+      @format ||= 'html'
+      @method = (params.delete(:_method) || @rack_request.request_method).downcase
+    end
+    
+    def uri_path(request)
+      request.path_info
+    end
+    
+    URL_ROOT          = /\A\/\Z/                                  # i.e. /
+    URL_SNIP          = /\A\/([\w\-\s]+)(\/|\.(\w+))?\Z/            # i.e. /start, /start.html
+    URL_SNIP_AND_PART = /\A\/([\w\-\s]+)\/([\w\-\s]+)(\/|\.(\w+))?\Z/ # i.e. /blah/part, /blah/part.raw
+    
+    # Returns an array of the requested snip, part and format
+    def request_uri_parts(request)
+      case CGI.unescape(uri_path(request))
+      when URL_ROOT
+        ['start', nil, 'html']
+      when URL_SNIP
+        [$1, nil, $3]
+      when URL_SNIP_AND_PART
+        [$1, $2, $4]
+      else
+        []
+      end
+    end
+    
+  end
+end  

data/lib/vanilla/routes.rb

@@ -0,0 +1,29 @@
+module Vanilla
+  module Routes
+    def link_to(link_text, snip_name=link_text, part=nil)
+      %{<a href="#{Vanilla::Routes.url_to(snip_name, part)}">#{link_text}</a>}
+    end
+  
+    def url_to(snip_name, part=nil)
+      url = "/#{snip_name}"
+      url += "/#{part}" if part
+      url
+    end
+
+    def url_to_raw(snip_name, part=nil)
+      url = "/#{snip_name}"
+      url += "/#{part}" if part
+      url += ".raw"
+    end
+  
+    def edit_link(snip_name, link_text)
+      %[<a href="/edit?name=#{snip_name}">#{link_text}</a>]
+    end
+  
+    def new_link(snip_name="New")
+      %[<a href="/new?name=#{snip_name}" class="new">#{snip_name}</a>]
+    end
+  
+    extend self
+  end
+end

data/lib/vanilla/snip_handling.rb

@@ -0,0 +1,33 @@
+module Vanilla
+  module SnipHandling
+    class MissingSnipException < Exception; end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def snip(name)
+        snip = Soup[name]
+        if snip.is_a?(Array) && snip.empty?
+          return nil
+        end
+        snip
+      end
+
+      def snip!(name)
+        snip = snip(name)
+        raise MissingSnipException, "can't find '#{name}'" unless snip
+      end
+
+      def snip_exists?(name)
+        snip = Soup[name]
+        if snip.is_a?(Array) && snip.empty?
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/vanilla/snips/start.rb

@@ -0,0 +1,18 @@
+start = Snip.new(:name => 'start')
+start.content = <<-START
+This is the {link_to start} snip, which is the default home page.
+
+You might want to check out the {link_to vanilla-rb-tutorial} snip. 
+
+In fact - I'll include it here for you:
+
+{vanilla-rb-tutorial}
+
+---
+
+That was the end of the tutorial snip. We're back in the start snip now. There's also the {link_to test} snip, that might be interesting.
+
+Anyway, welcome.
+START
+start.render_as = "Markdown"
+start.save

data/lib/vanilla/snips/system.rb

@@ -0,0 +1,76 @@
+system = Snip.new(:name => "system")
+system.content = "You're in the system snip now. You probably want to {edit_link system,edit} it though."
+
+system.main_template = <<-HTML
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+  <title>{current_snip name}</title>
+  <script language="javascript" src="/public/javascripts/jquery-1.2.3.js"></script>
+  <script language="javascript" src="/public/javascripts/vanilla.js"></script>
+  <link rel="stylesheet" type="text/css" media="screen"  href="<%= Vanilla::Routes.url_to("system", "css.css") %>" />
+</head>
+<body>
+  <div id="content">
+    <div id="controls">
+      <strong><a href="/">home</a></strong>, 
+      <%= Vanilla::Routes.new_link %> ::
+      <strong>{link_to_current_snip}</strong> &rarr; 
+      <%= Vanilla::Routes.edit_link("{current_snip name}", "Edit") %>
+    </div>
+    {current_snip}
+  </div>
+</body>
+</html>
+HTML
+
+system.css = <<-CSS
+body {
+  font-family: Helvetica;
+  background-color: #666;
+  margin: 0;
+  padding: 0;
+}
+
+div#content {
+  width: 800px;
+  margin: 0 auto;
+  background-color: #fff;
+  padding: 1em;
+}
+
+div#controls {
+font-size: 80%;
+padding-bottom: 1em;
+margin-bottom: 1em;
+border-bottom: 1px solid #999;
+}
+
+textarea {
+  width: 100%;
+}
+
+textarea.content {
+  min-height: 10em;
+}
+
+pre {
+  background-color: #f6f6f6;
+  border: 1px solid #ccc;
+  padding: 1em;
+}
+
+a.new {
+  background-color: #f0f0f0;
+  text-decoration: none;
+  color: #999;
+  padding: 0.2em;
+}
+
+a.new:hover {
+  text-decoration: underline;
+}
+CSS
+
+system.save

data/lib/vanilla/snips/tutorial.rb

@@ -0,0 +1,158 @@
+tutorial = Snip.new(:name => 'vanilla-rb-tutorial')
+tutorial.render_as = "Markdown"
+tutorial.content = <<-END_OF_TUTORIAL
+Basic Concepts
+------------
+
+Every piece of information displayed here is stored as a {link_to snip}. Snips, within their contents, can also reference other snips. 
+
+For example, consider the snip {link_to tutorial-basic-snip-inclusion}:
+
+{raw tutorial-basic-snip-inclusion}
+
+is rendered into:
+
+{tutorial-basic-snip-inclusion}
+
+Notice the use of curly brackets to reference one snip from inside another. 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 a `render_as` attribute set. For instance, the `render_as` property of this snip ({link_to vanilla-rb}) is "Markdown". 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.
+
+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`.
+
+Vanilla.rb includes a number of dynasnips by default. Here are a couple:
+
+  * `rand`, which generates a random number (a silly demo really); {link_to rand}, or an example: {rand}
+  * `link_to`, to produce a link to another snip
+  * `kind`, which selects and renders sets of snips based on their `kind` attribute (this is how the blog is currently implemented)
+  * `raw`, which displays the raw contents of a snip
+  * `edit`, which implements the editor
+  * `index`, which shows all of the available snips: {link_to index}
+  * ... and several others.
+
+While dynasnip classes can be provided as part of the vanilla codebase, it's envisioned that much of these will be created by end users in their own sites, either by refering to local classes, or defining the classes directly as the content. Here's an example of that, as the raw content of {link_to hello\_world}:
+
+{raw hello_world}
+
+which, when rendered, gives:
+
+{hello_world}
+
+Note that the `handle` method can take one (optional) argument. Lets try including it with <tt>&#123;hello\_world Dave&#125;</tt>:
+
+{hello_world Dave}
+
+Anyway - that should be enough to get you started.
+END_OF_TUTORIAL
+
+tutorial.save
+
+tutorial_basic_snip_inclusion = Snip.new(:name => 'tutorial-basic-snip-inclusion')
+tutorial_basic_snip_inclusion.content = <<-EOS
+This is a snip, which includes another {link_to snip}: {tutorial-another-snip}
+EOS
+tutorial_basic_snip_inclusion.save
+
+tutorial_another_snip = Snip.new(:name => 'tutorial-another-snip')
+tutorial_another_snip.content = "this is another snip!"
+tutorial_another_snip.save
+
+hello_world = Snip.new(:name => 'hello_world', :render_as => "Ruby")
+hello_world.content = <<-END_OF_RUBY
+class HelloWorld
+  # although the name doesn't need to match the snip name,
+  # it's simple to follow that convention where appropriate
+
+  def handle(name=nil)
+    if name
+      "Hey \#{name} - Hello World!"
+    else
+      "Hello World!"
+    end
+  end
+
+  # note that this code must evaluate to a class. One way of achieving that is by 
+  # putting 'self' at the end of the class definition.
+  self
+end
+# Another way is by referring to the class at the end of the content. Either works fine.
+HelloWorld
+END_OF_RUBY
+hello_world.save
+
+snip = Snip.new(:name => 'snip', :render_as => "Markdown")
+snip.content = <<-EOS
+A snip is the basic building block of information for {link_to vanilla-rb}. Essentially, it is a piece of content with arbitrary attributes. Vanilla anticipates the presence of some key attributes:
+
+ * `name` - the name of the snip, which is how it will be referred to. The `name` of this snip is _snip_.
+ * `content` - the default part of the snip to render. You can see the `content` of this snip <a href="/snip/content.raw">here</a>.
+ * `render_as` - the name of the renderer to use when rendering the content. The `render_as` of this snip is {snip.render_as}.
+
+One implementation of the snip store is {link_to soup}.
+EOS
+snip.save
+
+soup = Snip.new(:name => 'soup')
+soup.content = <<-EOS
+Soup is a data store supporting the {link_to snip}-space that {link_to vanilla-rb} expects.
+
+It's hosted on github <a href="http://github.com/lazyatom/soup">here</a>.
+EOS
+soup.save
+
+vanilla_rb = Snip.new(:name => 'vanilla-rb', :render_as => "Markdown")
+vanilla_rb.content = <<-EOS
+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 vanilla-rb-tutorial}).
+
+{vanilla-rb-tutorial}
+
+
+[1]: http://github.com/lazyatom/vanilla
+[2]: http://lazyatom.lighthouseapp.com/projects/11797-vanilla/tickets
+[3]: http://interblah.net/introducing-vanilla-rb
+EOS
+vanilla_rb.save
+
+vanilla = Snip.new(:name => 'vanilla')
+vanilla.content = <<-EOS
+The bliki upon which {link_to vanilla-rb} is based, writen by [Christian Langreiter][1]
+
+[Official Web HQ][2]
+
+[1]: http://www.langreiter.com
+[2]: http://www.vanillasite.at
+EOS
+vanilla.save

data/lib/vanilla/test_snips.rb

@@ -0,0 +1,85 @@
+test = Snip.new(:name => "test")
+test.content =<<EOF
+Linking is good: {link_to bold}
+Here's a bold snip: {bold}
+
+- Here's a random number between 5 and 15: {rand 5,15}
+- Here's a random number between 1 and 90 (the default min): {rand 90}
+- Here's a random number between 1 and 100 (the default range): {rand}
+
+And lets include some textile: 
+
+{textile_example}
+
+The source for that was 
+
+{pre textile_example}
+
+And lets include some markdown!: 
+
+{markdown_example}
+
+The source for that was 
+
+{pre markdown_example}
+
+How about some {link_to debug} information: {debug}
+
+What about a missing snip? Lets try to include one: {monkey}
+
+And an error when running? {bad_dynasnip}
+
+EOF
+test.render_as = "Markdown"
+test.save
+
+bold = Snip.new(:name => "bold")
+bold.content =<<EOF
+Snip2 in da house!
+EOF
+bold.render_as = "Bold"
+bold.save
+
+textile = Snip.new(:name => "textile_example")
+textile.content =<<EOF
+
+# testing lists
+# because lists are common things
+
+monkey
+
+what the *hell* are __you__ looking at?
+
+"Beyotch":http://example.com
+
+EOF
+textile.render_as = "Textile"
+textile.save
+
+textile = Snip.new(:name => "markdown_example")
+textile.content =<<EOF
+
+# testing header
+
+so, how are you?
+
+- item one
+- item two
+- item three
+
+
+what the *hell* are looking at, [beyotch](http://example.com)?
+EOF
+textile.render_as = "Markdown"
+textile.save
+
+bad_dynasnip = Snip.new(:name => "bad_dynasnip", :render_as => "Ruby")
+bad_dynasnip.content = <<EOF
+class BadDynasnip
+  def get(*args)
+    raise "Oh no"
+  end
+end
+BadDynasnip
+EOF
+bad_dynasnip.save

data/lib/vanilla.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+gem 'soup', '>= 0.1.4'
+require 'soup'
+require 'vanilla/snip_handling'
+
+module Vanilla
+  include SnipHandling
+end
+
+# Load all the other renderer subclasses
+Dir[File.join(File.dirname(__FILE__), 'vanilla', 'renderers', '*.rb')].each { |f| require f }  
+
+# Load the routing information
+require 'vanilla/routes'
+
+# Load all the base dynasnip classes
+Dir[File.join(File.dirname(__FILE__), 'vanilla', 'dynasnips', '*.rb')].each do |dynasnip|
+  require dynasnip
+end

data/spec/dynasnip_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require 'vanilla/dynasnip'
+
+describe Dynasnip, "when storing attributes" do
+  class TestDyna < Dynasnip
+    attribute :test_attribute, "test attribute content"
+  end
+  
+  before(:each) do
+    @fake_app = nil
+  end
+  
+  it "should make the attribute available as an instance method" do
+    TestDyna.new(@fake_app).test_attribute.should == "test attribute content"
+  end
+
+  it "should store the attribute in the soup" do
+    TestDyna.persist!
+    Soup['test_dyna'].test_attribute.should == "test attribute content"
+  end
+  
+  it "should allow the attribute to be overriden by the soup contents" do
+    TestDyna.persist!
+    snip = Soup['test_dyna']
+    snip.test_attribute = "altered content"
+    snip.save
+    
+    TestDyna.new(@fake_app).test_attribute.should == "altered content"
+  end
+  
+end

data/spec/renderers/base_renderer_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Vanilla::Renderers::Base do
+  describe "in general" do
+    before(:each) do
+      create_snip(:name => "test", :content => "content content", :part => "part content")
+    end
+
+    it "should render the contents part of the snip as it is" do
+      response_body_for("/test").should == "content content"
+    end
+  
+    it "should render the specified part of the snip" do
+      response_body_for("/test/part").should == "part content"
+    end
+  
+    it "should include the contents of a referenced snip" do
+      create_snip(:name => "snip_with_inclusions", :content => "loading {test}")
+      response_body_for("/snip_with_inclusions").should == "loading content content"
+    end
+  
+    it "should perform snip inclusion when rendering a part" do
+      create_snip(:name => "snip_with_inclusions", :content => "other content", :part => "loading {test}")
+      response_body_for("/snip_with_inclusions/part").should == "loading content content"
+    end
+  
+    it "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")
+      response_body_for("/including_snip").gsub(/\s+/, ' ').should == "lets include <b>blah</b>"
+    end
+  end
+  
+  describe "when trying to include a missing snip" do
+    it "should return a string describing the missing snip" do
+      create_snip(:name => 'blah', :content => 'include a {missing_snip}')
+      response_body_for("/blah").should == "include a [snip 'missing_snip' cannot be found]"
+    end
+  end
+end

data/spec/renderers/erb_renderer_spec.rb

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

data/spec/renderers/markdown_renderer_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Vanilla::Renderers::Markdown, "when rendering" do
+  def markdown_snip(attributes)
+    create_snip(attributes.merge(:render_as => "Markdown"))
+  end
+  
+  it "should return the snip contents rendered via Markdown" do
+    content = <<Markdown
+# markdown
+
+* totally
+* [rocks](http://www.example.com)!
+Markdown
+    markdown_snip(:name => "test", :content => content)
+    response_body_for("/test").should == BlueCloth.new(content).to_html
+  end
+  
+  it "should include other snips using their renderers" do
+    markdown_snip(:name => "test", :content => <<-Markdown
+# markdown
+
+and so lets include {another_snip}    
+    Markdown
+    )
+    create_snip(:name => "another_snip", :content => "blah", :render_as => "Bold")
+    response_body_for("/test").gsub(/\s+/, ' ').should == "<h1>markdown</h1> <p>and so lets include <b>blah</b> </p>"
+  end
+end