vanilla 1.15.1 → 1.16

data/Rakefile

@@ -46,10 +46,10 @@ if Object.const_defined?(:Gem)
     s.add_dependency("ratom", ">= 0.3.5")
     s.add_dependency("RedCloth", ">= 4.1.1")
     s.add_dependency("BlueCloth", ">= 1.0.0")
-    s.add_dependency("treetop", ">= 1.4.1")
     s.add_dependency("haml")
+    s.add_dependency("parslet", ">= 1.2.0")
 
-    s.add_development_dependency("kintama", ">= 0.1.5") # add any other gems for testing/development
+    s.add_development_dependency("kintama", ">= 0.1.6") # add any other gems for testing/development
     s.add_development_dependency("mocha")
 
     # If you want to publish automatically to rubyforge, you'll may need

data/lib/vanilla.rb

@@ -1,5 +1,5 @@
 module Vanilla
-  VERSION = "1.15.1"
+  VERSION = "1.16"
 
   autoload :Renderers, "vanilla/renderers"
   autoload :App, "vanilla/app"
@@ -7,6 +7,7 @@ module Vanilla
   autoload :Request, "vanilla/request"
   autoload :Routes, "vanilla/routes"
   autoload :Static, "vanilla/static"
+  autoload :SnipReferenceParser, "vanilla/snip_reference_parser"
 end
 
 # Load all the base dynasnip classes

data/lib/vanilla/renderers/base.rb

@@ -26,7 +26,7 @@ module Vanilla
       end
 
       def self.snip_regexp
-        %r{(\{[\w\-_\d\.\"]+(\s+[^\}.]+)?\})}
+        %r{(\{[\w\-_\d\.\"\'\s]+(\s+[^\}.]+)?\})}
       end
 
       def default_layout_snip
@@ -61,7 +61,7 @@ module Vanilla
       end
 
       def parse_snip_reference(string)
-        @parser ||= SnipReferenceParser.new
+        @parser ||= Vanilla::SnipReferenceParser.new
         @parser.parse(string)
       end
 

data/lib/vanilla/routes.rb

@@ -2,7 +2,11 @@ module Vanilla
   # Expects to be able to call 'soup' on whatever it is included into
   module Routes
     def link_to(link_text, snip_name=link_text, part=nil)
-      soup[snip_name] ? existing_link(link_text, snip_name, part) : new_link(snip_name)
+      if 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
 
     def url_to(snip_name, part=nil)
@@ -10,22 +14,5 @@ module Vanilla
       url += "/#{part}" if part
       url
     end
-
-    def url_to_raw(snip_name, part=nil)
-      url = url_to(snip_name, part)
-      url += ".raw"
-    end
-
-    def existing_link(link_text, snip_name=link_text, part=nil)
-      %{<a href="#{url_to(snip_name, part)}">#{link_text}</a>}
-    end
-
-    def edit_link(snip_name, link_text)
-      %[<a href="/edit?name=#{snip_name.gsub(" ", "+")}">#{link_text}</a>]
-    end
-
-    def new_link(snip_name="New")
-      %[<a href="/new?name=#{snip_name ? snip_name.gsub(" ", "+") : nil}" class="new">#{snip_name}</a>]
-    end
   end
 end

data/lib/vanilla/snip_reference_parser.rb

@@ -1,71 +1,94 @@
-module SnipReference
-  module SnipCall
-    def snip
-      elements[1].name
-    end
-    def attribute
-      elements[1].attribute
-    end
-    def arguments
-      if elements[2] && elements[2].elements
-        r = elements[2].elements[1].to_arguments
-        r.flatten! if r.respond_to?(:flatten!)
-        r
-      else
-        []
+require "parslet"
+
+module Vanilla
+  class SnipReferenceParser
+    class Reference
+      def initialize(attributes)
+        @attributes = attributes
       end
-    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
-      if args.is_a?(Array)
-        args << elements[1].elements[1].to_arguments if elements[1].elements
-      elsif args.is_a?(Hash)
-        args.merge!(elements[1].elements[1].to_arguments) if elements[1].elements
+      def snip
+        @attributes[:snip]
+      end
+      def attribute
+        @attributes[:attribute]
+      end
+      def arguments
+        @attributes[:arguments] || []
       end
-      args
     end
-  end
-  module HashArgument
-    def to_arguments
-      key = elements[0].text_value
-      key = $1 if key =~ /\A:(.*)\Z/
-      {key.to_sym => elements[4].text_value}
+
+    def parse(string)
+      Reference.new(SnipTransform.new.apply(SnipParser.new.parse(string)))
     end
-  end
-  module NormalArgument
-    def to_arguments
-      [text_value]
+
+    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
+      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) }
+
+      rule(:arguments) { hash_arg_list | named_arg_list | string_arg_list }
+      rule(:snip_part) { string.as(:snip) >> (dot >> string.as(:attribute)).maybe }
+
+      rule(:snip_reference) do
+        left_brace >> spaces? >>
+          snip_part >> (spaces >> arguments.as(:arguments)).maybe >>
+          spaces? >> right_brace
+      end
+
+      root(:snip_reference)
     end
-  end
-  module EmptyArgument
-    def to_arguments
-      [nil]
+
+    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 }
+
+      class Arg
+        def initialize(k, v); @k, @v = k, v; end
+        def to_h; {@k.to_sym => @v}; end
+      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
-
-require 'treetop'
-require 'vanilla/snip_reference'
+end

data/pristine_app/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/james/Code/lazyatom/vanilla-rb
   specs:
-    vanilla (1.15)
+    vanilla (1.14.1)
       BlueCloth (>= 1.0.0)
       RedCloth (>= 4.1.1)
       haml
@@ -15,7 +15,7 @@ GEM
   specs:
     BlueCloth (1.0.1)
     RedCloth (4.2.7)
-    haml (3.0.25)
+    haml (3.1.1)
     libxml-ruby (2.0.2)
     polyglot (0.3.1)
     rack (1.2.2)

data/pristine_app/README

@@ -16,6 +16,8 @@ For an overview of vanilla, start your site and look at the tutorial:
   $ rackup   # then open http://localhost:9292/tutorial
 
 
+Editing snips
+-------------
 You can edit any file in the soup directory using your favourite editor,
 and the changes will be reflected automatically. The snip files are
 slightly modified YAML files. Here's an example, which you might save
@@ -34,3 +36,12 @@ in a file called 'soup.snip':
 
 The 'content' of the snip is at the top of the file, followed by the
 rest of the snip attributes on lines starting with ':'.
+
+
+The console
+-----------
+
+Within a vanilla app directory, you can run `vanilla console` to start
+an IRB session and interact with your app and snips. The `app` method
+returns your application object, and `app.soup['start']` will return
+the start snip from your soup(s).

data/pristine_app/soups/dynasnips/current_snip.rb

@@ -14,15 +14,15 @@ class CurrentSnip < Dynasnip
   |
 
   def handle(attribute=nil)
-    if attribute
-      app.request.snip.__send__(attribute)
-    else
-      if app.request.snip
-        app.render(app.request.snip, app.request.part)
+    if app.request.snip
+      if attribute ||= app.request.part
+        "{#{app.request.snip_name}.#{attribute}}"
       else
-        app.response.status = 404
-        %{Couldn't find snip "#{app.request.snip_name}"}
+        "{#{app.request.snip_name}}"
       end
+    else
+      app.response.status = 404
+      %{Couldn't find snip "#{app.request.snip_name}"}
     end
   end
   self

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

@@ -4,9 +4,9 @@ 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}).
+Here's the tutorial (helpfully included from {link_to tutorial}).
 
-{vanilla-rb-tutorial}
+{tutorial}
 
 
 [1]: http://github.com/lazyatom/vanilla

data/pristine_app/soups/tutorial/vanilla.snip

@@ -1,4 +1,4 @@
-The bliki upon which {link_to vanilla-rb} is based, writen by [Christian Langreiter][1]
+The bliki upon which {link_to vanilla-rb} is based, written by [Christian Langreiter][1]
 
 [Official Web HQ][2]
 

data/test/dynasnip_test.rb

@@ -26,4 +26,17 @@ describe Dynasnip do
       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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,19 @@
+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/{snip_reference_test.rb → snip_inclusion_test.rb}

@@ -1,6 +1,6 @@
 require "test_helper"
 
-context "The SnipReference parser" do
+context "When including snips in other snips" do
   setup do
     create_snip :name => "test", :content => "snip content"
   end

data/test/snip_reference_parser_test.rb

@@ -1,55 +1,123 @@
 require "test_helper"
-Treetop.load File.join(File.dirname(__FILE__), *%w[.. lib vanilla snip_reference])
 
 context "The SnipReference parser" do
+
   setup do
-    @parser = SnipReferenceParser.new
+    @parser = Vanilla::SnipReferenceParser.new
   end
 
   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 arg1,,arg3}|                       => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', nil, 'arg3']},
-    %|{snip arg1, ,arg3}|                      => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', nil, 'arg3']},
-    %|{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.attribute key1=>value1}|           => {:snip => 'snip', :attribute => 'attribute', :arguments => {:key1 => 'value1'}},
-    %|{snip key1 => value1, key2 => value2}|   => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
-    %|{snip :key1 => value1, :key2 => value2}| => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
-    %|{snip key1 => "value with spaces"}|      => {:snip => 'snip', :arguments => {:key1 => "value with spaces"}},
-    # %|{snip "key with spaces" => value} |      => {:snip => 'snip', :arguments => {:"key with spaces" => "value"}},
-    %|{snip key1:value1,key2:value2}|          => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
-    %|{snip key1:value1, key2:value2}|         => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
-    %|{snip key1: value1, key2: value2}|       => {:snip => 'snip', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
-    %|{snip key1:"value with spaces"}|         => {:snip => 'snip', :arguments => {:key1 => 'value with spaces'}}
+    :snip_names => {
+      %|{snip}|                  => {:snip => 'snip', :attribute => nil, :arguments => []},
+      %|{Snip}|                  => {:snip => 'Snip', :attribute => nil, :arguments => []},
+      %|{123snip}|               => {:snip => '123snip', :attribute => nil, :arguments => []},
+      %|{Snip123}|               => {:snip => 'Snip123', :attribute => nil, :arguments => []},
+      %|{snip-with-dashes}|      => {:snip => 'snip-with-dashes', :attribute => nil, :arguments => []},
+      %|{snip_with_underscores}| => {:snip => 'snip_with_underscores', :attribute => nil, :arguments => []},
+    },
+
+    :snip_attributes => {
+      %|{snip.snip_attribute}|     => {:snip => 'snip', :attribute => 'snip_attribute', :arguments => []},
+      %|{snip.snip_attribute arg}| => {:snip => 'snip', :attribute => 'snip_attribute', :arguments => ['arg']},
+      %|{snip."spaced attribute"}| => {:snip => 'snip', :attribute => 'spaced attribute', :arguments => []},
+      %|{snip.'spaced attribute'}| => {:snip => 'snip', :attribute => 'spaced attribute', :arguments => []}
+    },
+
+    :simple_arguments => {
+      %|{snip argument}|           => {:snip => 'snip', :attribute => nil, :arguments => ["argument"]},
+      %|{snip1 argument}|          => {:snip => 'snip1', :attribute => nil, :arguments => ["argument"]},
+      %|{snip arg-dashes}|         => {:snip => 'snip', :attribute => nil, :arguments => ["arg-dashes"]},
+      %|{snip arg_underscores}|    => {:snip => 'snip', :attribute => nil, :arguments => ["arg_underscores"]},
+      %|{snip arg1,arg2}|          => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', 'arg2']},
+      %|{snip arg1, arg2}|         => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', 'arg2']},
+      %|{snip arg1,  arg2}|        => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', 'arg2']},
+      %|{snip 1ARG, arg_2, arg-3}| => {:snip => 'snip', :attribute => nil, :arguments => ['1ARG', 'arg_2', 'arg-3']}
+    },
+
+    :snip_name_spaces => {
+      %|{"snip with spaces"}|           => {:snip => 'snip with spaces', :attribute => nil, :arguments => []},
+      %|{'snip with spaces'}|           => {:snip => 'snip with spaces', :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 with spaces" a, b}|      => {:snip => 'snip with spaces', :attribute => nil, :arguments => ['a', 'b']},
+      %|{'snip with spaces' a, b}|      => {:snip => 'snip with spaces', :attribute => nil, :arguments => ['a', 'b']},
+      %|{"snip with spaces".attribute}| => {:snip => 'snip with spaces', :attribute => 'attribute', :arguments => []},
+      %|{'snip with spaces'.attribute}| => {:snip => 'snip with spaces', :attribute => 'attribute', :arguments => []}
+    },
+
+    :arguments_with_spaces => {
+      # %|{snip arg spaces}|           => {:snip => 'snip', :attribute => nil, :arguments => ['arg spaces']},
+      # %|{snip arg spaces, and this}| => {:snip => 'snip', :attribute => nil, :arguments => ['arg spaces', 'and this']},
+      %|{snip "arg spaces"}|         => {:snip => 'snip', :attribute => nil, :arguments => ['arg spaces']},
+      %|{snip 'arg spaces'}|         => {:snip => 'snip', :attribute => nil, :arguments => ['arg spaces']},
+      %|{snip "arg spaces", arg2}|   => {:snip => 'snip', :attribute => nil, :arguments => ['arg spaces', 'arg2']}
+    },
+
+    :nil_arguments => {
+      %|{snip arg1,nil,arg3}|   => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', nil, 'arg3']},
+      %|{snip arg1, nil ,arg3}| => {:snip => 'snip', :attribute => nil, :arguments => ['arg1', nil, 'arg3']}
+    },
+
+    :classic_ruby_hash_arguments => {
+      %|{s key1=>value1, key2 => value2}|     => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s key1 => value1, key2 => value2}|   => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s :key1 => value1, :key2 => value2}| => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s key1 => "value with spaces"}|      => {:snip => 's', :arguments => {:key1 => "value with spaces"}},
+      %|{s.attr key1=>value1}|                => {:snip => 's', :attribute => 'attr', :arguments => {:key1 => 'value1'}},
+      # %|{s "key with spaces" => value}|       => {:snip => 's', :arguments => {:"key with spaces" => "value"}}
+    },
+
+    :named_arguments => {
+      %|{s key1:value1,key2:value2}|    => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s key1:value1, key2:value2}|   => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s key1: value1, key2: value2}| => {:snip => 's', :arguments => {:key1 => 'value1', :key2 => 'value2'}},
+      %|{s key1:"value with spaces"}|   => {:snip => 's', :arguments => {:key1 => 'value with spaces'}}
+    },
+
+    :quoting_arguments => {
+      # %|{s "arg \\" double"}| => {:snip => 's', :attribute => nil, :arguments => ['arg " double']},
+      # %|{s 'arg \\' single'}| => {:snip => 's', :attribute => nil, :arguments => ["arg ' single"]},
+      %|{s "arg ' single"}|   => {:snip => 's', :attribute => nil, :arguments => ["arg ' single"]},
+      %|{s 'arg " double'}|   => {:snip => 's', :attribute => nil, :arguments => ['arg " double']},
+      %|{s "arg, comma"}|     => {:snip => 's', :attribute => nil, :arguments => ['arg, comma']},
+      %|{s 'arg, comma'}|     => {:snip => 's', :attribute => nil, :arguments => ['arg, comma']},
+      # %|{s "arg { open"}|     => {:snip => 's', :attribute => nil, :arguments => ['arg { open']},
+      # %|{s "arg } close"}|    => {:snip => 's', :attribute => nil, :arguments => ['arg } close']}
+    }
   }
 
-  examples.each do |example, expected|
-    should "parse '#{example}' into #{expected.inspect}" 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}"
+  examples.each do |type, set|
+    context type.to_s.gsub("_", " ") do
+      set.each do |example, expected|
+        should "parse '#{example}' into #{expected.inspect}" 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
+            assert_parsable_by_vanilla example, expected
+          else
+            flunk "failed to parse: #{example} - #{@parser.failure_reason}"
+          end
+        end
       end
     end
   end
+
+  private
+
+  def assert_parsable_by_vanilla(example, expected)
+    create_snip_from_expected expected
+    create_snip :name => "test", :content => "alpha #{example} beta"
+    assert_response_body "alpha ok beta", "/test"
+  end
+
+  def create_snip_from_expected(expected)
+    simple_dyna = %|class SimpleDyna;def handle(*args); 'ok'; end;self;end|
+    attributes = {:name => expected[:snip], :content => simple_dyna, :render_as => "ruby"}
+    if expected[:attribute]
+      attributes[expected[:attribute]] = simple_dyna
+    end
+    create_snip(attributes)
+  end
 end