vanilla 1.2 → 1.9.9

data/lib/vanilla/snip_reference.treetop

@@ -0,0 +1,48 @@
+grammar SnipReference
+  rule snip_call
+    "{" (snip_name) (spaces argument_list)? "}" <SnipCall>
+  end
+
+  rule snip_name
+    word "." word <SnipNameWithAttribute> /
+    word <SnipName>
+  end
+
+  rule argument_list
+    argument (argument_separator argument_list)? <ArgumentList>
+  end
+
+  rule argument
+    unquoted_words <NormalArgument> /
+    quoted_word <NormalArgument>
+  end
+
+  rule argument_separator
+    "," optional_spaces
+  end
+
+  rule word
+    unquoted_word / quoted_word
+  end
+
+  rule unquoted_word
+    ([a-zA-Z0-9_\-]+)
+  end
+
+  rule quoted_word
+    "\"" (unquoted_words) "\"" <QuotedWord> /
+    "'" (unquoted_words) "'" <QuotedWord>
+  end
+
+  rule unquoted_words
+    [a-zA-Z0-9_\- ]+
+  end
+
+  rule optional_spaces
+    [ ]*
+  end
+
+  rule spaces
+    [ ]+
+  end
+end

data/lib/vanilla/snip_reference_parser.rb

@@ -1,94 +1,111 @@
-require "parslet"
-
-module Vanilla
-  class SnipReferenceParser
-    class Reference
-      def initialize(attributes)
-        @attributes = attributes
-      end
-      def snip
-        @attributes[:snip]
-      end
-      def attribute
-        @attributes[:attribute]
-      end
-      def arguments
-        @attributes[:arguments] || []
-      end
+module SnipReference
+  module SnipCall
+    def snip
+      elements[1].name
     end
-
-    def parse(string)
-      Reference.new(SnipTransform.new.apply(SnipParser.new.parse(string)))
+    def attribute
+      elements[1].attribute
     end
-
-    class SnipParser < Parslet::Parser
-      rule(:spaces) { match('\s').repeat(1) }
-      rule(:spaces?) { spaces.maybe }
-      rule(:comma)  { match(',') }
-      rule(:dot)    { str(".") }
-      rule(:squote) { str("'") }
-      rule(:dquote) { str('"') }
-      rule(:escaped_dquote) { str('"') }
-      rule(:left_brace) { str("{") }
-      rule(:right_brace) { str("}") }
-
-      rule(:word) { match("[a-zA-Z0-9_\\-]").repeat(1) }
-      rule(:quotables) { word | comma | spaces }
-      rule(:double_quoted_string) do
-        dquote >> (quotables | squote).repeat(1).as(:string) >> dquote
-      end
-      rule(:single_quoted_string) do
-        squote >> (quotables | dquote).repeat(1).as(:string) >> squote
+    def arguments
+      if elements[2] && elements[2].elements
+        r = elements[2].elements[1].to_arguments
+        r.flatten! if r.respond_to?(:flatten!)
+        r
+      else
+        []
       end
-      rule(:string) do
-        single_quoted_string | double_quoted_string | str("nil").as(:nil) | word.as(:string)
-      end
-      rule(:symbol) { str(":") >> string }
-
-      rule(:comma_separator) { spaces? >> comma >> spaces? }
-      rule(:hash_separator) { spaces? >> str("=>") >> spaces? }
-      rule(:named_separator) { spaces? >> str(":") >> spaces? }
-
-      rule(:hash_arg) { (symbol | string).as(:key) >> hash_separator >> string.as(:value) }
-      rule(:named_arg) { string.as(:key) >> named_separator >> string.as(:value) }
-
-      rule(:string_arg_list) { (string.as(:string_arg) >> further_string_args.repeat).as(:string_arg_list) }
-      rule(:further_string_args) { comma_separator >> string.as(:string_arg) }
-
-      rule(:hash_arg_list) { (hash_arg.as(:hash_arg) >> further_hash_args.repeat).as(:key_value_arg_list) }
-      rule(:further_hash_args) { comma_separator >> hash_arg.as(:hash_arg) }
-
-      rule(:named_arg_list) { (named_arg.as(:named_arg) >> further_named_args.repeat).as(:key_value_arg_list) }
-      rule(:further_named_args) { comma_separator >> named_arg.as(:named_arg) }
+    end
+  end
+  module SnipName
+    def name
+      text_value
+    end
+    def attribute
+      nil
+    end
+  end
+  module SnipNameWithAttribute
+    def name
+      elements[0].text_value
+    end
+    def attribute
+      elements[2].text_value
+    end
+  end
+  module QuotedWord
+    def text_value
+      elements[1].text_value
+    end
+  end
+  module ArgumentList
+    def to_arguments
+      args = elements[0].to_arguments
+      args << elements[1].elements[1].to_arguments if elements[1].elements
+      args
+    end
+  end
+  module NormalArgument
+    def to_arguments
+      [text_value]
+    end
+  end
+end
 
-      rule(:arguments) { hash_arg_list | named_arg_list | string_arg_list }
-      rule(:snip_part) { string.as(:snip) >> (dot >> string.as(:attribute)).maybe }
+require 'treetop'
+require 'vanilla/snip_reference'
 
-      rule(:snip_reference) do
-        left_brace >> spaces? >>
-          snip_part >> (spaces >> arguments.as(:arguments)).maybe >>
-          spaces? >> right_brace
-      end
 
-      root(:snip_reference)
-    end
+if __FILE__ == $0
 
-    class SnipTransform < Parslet::Transform
-      rule(:nil => simple(:x)) { nil }
-      rule(:string => simple(:x)) { x.to_s }
-      rule(:string_arg => simple(:x)) { x }
-      rule(:string_arg_list => simple(:x)) { [x] }
-      rule(:string_arg_list => sequence(:x)) { x }
+Treetop.load "vanilla/snip_reference"
+require 'test/unit'
 
-      class Arg
-        def initialize(k, v); @k, @v = k, v; end
-        def to_h; {@k.to_sym => @v}; end
+class SnipReferenceParserTest < Test::Unit::TestCase
+  examples = {
+    %|{snip}|                               => {:snip => 'snip', :attribute => nil, :arguments => []},
+    %|{snip argument}|                      => {:snip => 'snip', :attribute => nil, :arguments => ["argument"]},
+    %|{"snip with spaces"}|                 => {:snip => 'snip with spaces', :attribute => nil, :arguments => []},
+    %|{snip-with-dashes}|                   => {:snip => 'snip-with-dashes', :attribute => nil, :arguments => []},
+    %|{snip_with_underscores}|              => {:snip => 'snip_with_underscores', :attribute => nil, :arguments => []},
+    %|{"snip with spaces" argument}|        => {:snip => 'snip with spaces', :attribute => nil, :arguments => ['argument']},
+    %|{'snip with spaces' argument}|        => {:snip => 'snip with spaces', :attribute => nil, :arguments => ['argument']},
+    %|{snip "argument with spaces"}|        => {:snip => 'snip', :attribute => nil, :arguments => ['argument with spaces']},
+    %|{snip 'argument with spaces'}|        => {:snip => 'snip', :attribute => nil, :arguments => ['argument with spaces']},
+    %|{snip arg1,arg2}|                     => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', 'arg2']},
+    %|{snip arg1, arg2}|                    => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', 'arg2']},
+    %|{snip "argument with spaces", arg2}|  => {:snip => 'snip', :attribute => nil, :arguments => ['argument with spaces', 'arg2']},
+    %|{"snip with spaces" arg1, arg2}|      => {:snip => 'snip with spaces', :attribute => nil, :arguments => ['arg1', 'arg2']},
+    %|{snip.snip_attribute}|                => {:snip => 'snip', :attribute => 'snip_attribute', :arguments => []},
+    %|{snip."spaced attribute"}|            => {:snip => 'snip', :attribute => 'spaced attribute', :arguments => []},
+    %|{"snip with spaces".attribute}|       => {:snip => 'snip with spaces', :attribute => 'attribute', :arguments => []},
+    %|{snip.snip_attribute arg}|            => {:snip => 'snip', :attribute => 'snip_attribute', :arguments => ['arg']},
+    %|{snip arg with spaces}|               => {:snip => 'snip', :attribute => nil, :arguments => ['arg with spaces']},
+    %|{snip arg with spaces, another arg}|  => {:snip => 'snip', :attribute => nil, :arguments => ['arg with spaces', 'another arg']},
+    # %|{snip key1:value1,key2:value2}| => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+    # %|{snip key1:value1, key2:value2}| => {:snip => 'snip', :arguments => {:key}},
+    # %|{snip key1: value1, key2: value2}|,
+    # %|{snip key1 => value1, key2 => value2}|,
+    # %|{snip :key1 => value1, :key2 => value2}|,
+    # %|{snip key1:"value with spaces"}|,
+    # %|{snip key1 => "value with spaces"}|   => {:snip => 'snip', :arguments => {:key1 => "value with spaces"}}
+  }
+  
+  def setup
+    @parser = SnipReferenceParser.new
+  end
+  
+  examples.each do |example, expected|
+    define_method :"test_parsing_#{example}" do
+      reference = @parser.parse(example)
+      if reference
+        assert_equal expected[:snip],      reference.snip
+        assert_equal expected[:attribute], reference.attribute
+        assert_equal expected[:arguments], reference.arguments
+      else
+        flunk "failed to parse: #{example}"
       end
-
-      rule(:hash_arg => subtree(:x)) { Arg.new(x[:key], x[:value]) }
-      rule(:named_arg => subtree(:x)) { Arg.new(x[:key], x[:value]) }
-      rule(:key_value_arg_list => simple(:x)) { x.to_h }
-      rule(:key_value_arg_list => sequence(:x)) { x.inject({}) { |h, kv| h.merge(kv.to_h) } }
     end
   end
+end
+
 end

data/lib/vanilla/snips/start.rb

@@ -0,0 +1,28 @@
+app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+start = app.snip(:name => 'start')
+start.content = <<-START
+Welcome to Vanilla.rb
+=============
+
+Vanilla.rb is a web-experiment (a _websperiment_?) about storing and reusing data on a website. It can also function as a [bliki](http://www.wikipedia.com/wiki/Bliki). 
+
+The fundamental building block is the 'snip', which is a malleable object that can store content and arbitrary metadata.
+
+---
+
+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,77 @@
+app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+system = app.snip(: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.js"></script>
+  <script language="javascript" src="/public/javascripts/vanilla.js"></script>
+  <link rel="stylesheet" type="text/css" media="screen"  href="<%= url_to("system", "css.css") %>" />
+</head>
+<body>
+  <div id="content">
+    <div id="controls">
+      <strong><a href="/">home</a></strong>, 
+      <%= new_link %> ::
+      <strong>{link_to_current_snip}</strong> &rarr; 
+      {edit_link}
+    </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,244 @@
+app = Vanilla::App.new(ENV['VANILLA_CONFIG'])
+tutorial = app.snip(: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. 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. 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 = app.snip(: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 = app.snip(:name => 'tutorial-another-snip')
+tutorial_another_snip.content = "this is another snip!"
+tutorial_another_snip.save
+
+hello_world = app.snip(: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 = app.snip(: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 = app.snip(: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 = app.snip(: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 = app.snip(:name => 'vanilla', :render_as => "Markdown")
+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
+
+test = app.snip(: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 = app.snip(:name => "bold")
+bold.content =<<EOF
+Snip2 in da house!
+EOF
+bold.render_as = "Bold"
+bold.save
+
+textile = app.snip(: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 = app.snip(: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 = app.snip(: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