vanilla 1.0.2 → 1.2

data/test/snip_reference_parser_test.rb

@@ -0,0 +1,123 @@
+require "test_helper"
+
+context "The SnipReference parser" do
+
+  setup do
+    @parser = Vanilla::SnipReferenceParser.new
+  end
+
+  examples = {
+    :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 |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

data/test/test_helper.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require "kintama"
+require "kintama/mocha"
+require "fileutils"
+require "rack/mock"
+require "vanilla"
+
+module Vanilla
+  module Test
+    def setup_clean_environment
+      clean_environment
+      @app = Vanilla::App.new(:soup => soup_path)
+
+      require File.expand_path("../../pristine_app/soups/dynasnips/current_snip", __FILE__)
+      @app.soup << CurrentSnip.snip_attributes
+      create_snip :name => "layout", :content => "{current_snip}"
+    end
+
+    def response_for(url)
+      @app.call(mock_env_for_url(url))
+    end
+
+    def response_body_for(url)
+      response_for(url)[2].body[0]
+    end
+
+    def response_code_for(url)
+      response_for(url)[0]
+    end
+
+    def assert_response_body(expected, uri)
+      assert_equal expected.strip, response_body_for(uri).strip
+    end
+
+    def set_main_template(template_content)
+      @app.soup << {:name => "layout", :content => template_content}
+    end
+
+    def create_snip(params)
+      @app.soup << params
+    end
+
+    def mock_env_for_url(url)
+      Rack::MockRequest.env_for(url)
+    end
+
+    def mock_request(url)
+      Rack::Request.new(mock_env_for_url(url))
+    end
+
+    def test_app_directory
+      File.join(File.dirname(__FILE__), "tmp")
+    end
+
+    def soup_path
+      File.expand_path(File.join(test_app_directory, "soup"))
+    end
+
+    def clean_environment
+      FileUtils.rm_rf(test_app_directory)
+    end
+  end
+end
+
+Kintama.include Vanilla::Test
+Kintama.setup do
+  setup_clean_environment
+end
+
+Kintama.teardown do
+  clean_environment
+end

data/test/vanilla_app_test.rb

@@ -0,0 +1,83 @@
+require "test_helper"
+
+describe Vanilla::App do
+  context "when behaving as a Rack application" do
+    should "return an array of status code, headers and response" do
+      create_snip(:name => "test", :content => "content")
+      result = @app.call(mock_env_for_url("/test.text"))
+      assert_kind_of Array, result
+      assert_equal 200, result[0]
+      assert_kind_of Hash, result[1]
+      result[2].each{ |output| assert_equal "content", output }
+    end
+  end
+
+  context "when being configured" do
+    should "default the root snip to 'start'" do
+      create_snip :name => "start", :content => "default"
+      assert_response_body "default", "/"
+    end
+
+    should "allow a customised root snip" do
+      create_snip :name => "start", :content => "default"
+      create_snip :name => "custom", :content => "custom"
+      @app = Vanilla::App.new(:soup => soup_path, :root_snip => "custom")
+      assert_response_body "custom", "/"
+    end
+  end
+
+  context "when detecting the snip renderer" do
+    setup do
+      @app = Vanilla::App.new(:soup => soup_path)
+    end
+
+    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 "respect snip renderers passed in the config" do
+      app = Vanilla::App.new(:soup => soup_path, :renderers => {"markdown" => "Vanilla::Renderers::Bold"})
+      snip = create_snip(:name => "blah", :extension => "markdown")
+      assert_equal Vanilla::Renderers::Bold, app.renderer_for(snip)
+    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
+
+    should "load constants presented as a string" do
+      class ::MyRenderer
+      end
+      app = Vanilla::App.new(:soup => soup_path, :renderers => {"my_renderer" => "MyRenderer"})
+      snip = create_snip(:name => "blah", :render_as => "my_renderer")
+      assert_equal MyRenderer, app.renderer_for(snip)
+    end
+  end
+end

data/test/vanilla_presenting_test.rb

@@ -0,0 +1,125 @@
+require "test_helper"
+
+context "When presenting" do
+  setup do
+    set_main_template "<tag>{current_snip}</tag>"
+    create_snip :name => "test", :content => "blah {other_snip}", :part => 'part content'
+    create_snip :name => "other_snip", :content => "blah!"
+  end
+
+  context "HTML" do
+    should "render the snip's content in the system template if no format or part is given" do
+      assert_response_body "<tag>blah blah!</tag>", "/test"
+    end
+
+    should "render the snip's content in the system template if the HTML format is given" do
+      assert_response_body "<tag>blah blah!</tag>", "/test.html"
+    end
+
+    should "render the requested part within the main template when a part is given" do
+      assert_response_body "<tag>part content</tag>", "/test/part"
+    end
+
+    should "have a response code of 200" do
+      assert_equal 200, response_code_for("/test")
+      assert_equal 200, response_code_for("/test.html")
+      assert_equal 200, response_code_for("/test/part")
+      assert_equal 200, response_code_for("/test/part.html")
+    end
+
+    should "not allow rendering of the layout to produce infinite recursion" do
+      assert_response_body "Rendering of the current layout would result in infinite recursion.", "/layout"
+    end
+  end
+
+  context "as text" do
+    should "render the snip's content outside of the main template with its default renderer" do
+      assert_response_body "blah blah!", "/test.text"
+    end
+
+    should "render the snip part outside the main template when a format is given" do
+      assert_response_body "part content", "/test/part.text"
+    end
+
+    should "have a response code of 200" do
+      assert_equal 200, response_code_for("/test.text")
+      assert_equal 200, response_code_for("/test/part.text")
+    end
+  end
+
+  context "raw content" do
+    should "render the snips contents exactly as they are" do
+      assert_response_body "blah {other_snip}", "/test.raw"
+    end
+
+    should "render the snip content exactly even if a render_as attribute exists" do
+      assert_response_body "CurrentSnip", "/current_snip.raw"
+    end
+
+    should "render a snips part if requested" do
+      assert_response_body "part content", "/test/part.raw"
+    end
+
+    should "have a response code of 200" do
+      assert_equal 200, response_code_for("/test.raw")
+      assert_equal 200, response_code_for("/test/part.raw")
+    end
+  end
+
+  context "a snip with a custom layout" do
+    should "render the snips contents within that layout" do
+      create_snip :name => "custom-layout", :content => "<custom>{current_snip}</custom>"
+      create_snip :name => "test", :content => "this is a test", :layout => "custom-layout"
+      assert_response_body "<custom>this is a test</custom>", "/test"
+    end
+  end
+
+  class CustomRenderer < ::Vanilla::Renderers::Base
+    def default_layout_snip
+      soup['custom-layout']
+    end
+  end
+
+  context "a snip using a renderer that specifies a template" do
+    setup do
+      @app.register_renderer CustomRenderer, "custom"
+      create_snip :name => "custom-layout", :content => "<custom>{current_snip}</custom>"
+    end
+
+    should "use the renderer's specified layout" do
+      create_snip :name => "test", :content => "this is a test", :render_as => "custom"
+      assert_response_body "<custom>this is a test</custom>", "/test"
+    end
+
+    should "use the snips layout when given" do
+      create_snip :name => "snip-custom-layout", :content => "<snipcustom>{current_snip}</snipcustom>"
+      create_snip :name => "test", :content => "this is a test", :render_as => "custom", :layout => "snip-custom-layout"
+      assert_response_body "<snipcustom>this is a test</snipcustom>", "/test"
+    end
+  end
+
+  context "and a custom default renderer has been provided" do
+    should "use that renderer" do
+      @app = Vanilla::App.new(:soup => soup_path, :default_renderer => ::Vanilla::Renderers::Bold)
+      create_snip :name => "layout", :content => "{test}", :render_as => "base"
+      create_snip :name => "test", :content => "test"
+      assert_response_body "<b>test</b>", "/test"
+    end
+  end
+
+  context "and a missing snip is requested" do
+    should "render missing snip content in the main template" do
+      assert_response_body %{<tag>Couldn't find snip "missing_snip"</tag>}, "/missing_snip"
+    end
+
+    should "have a 404 response code" do
+      assert_equal 404, response_code_for("/missing_snip")
+    end
+  end
+
+  context "requesting an unknown format" do
+    should "return a 500 status code" do
+      assert_equal 500, response_code_for("/test.monkey")
+    end
+  end
+end

data/test/vanilla_request_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+describe Vanilla::Request do
+  context "when requesting the root" do
+    setup { @request = Vanilla::Request.new(mock_env_for_url("/"), @app) }
+
+    should "set snip to 'start' by default" do
+      assert_equal "start", @request.snip_name
+    end
+
+    should "set format to 'html'" do
+      assert_equal "html", @request.format
+    end
+  end
+
+  context "when requesting urls" do
+    setup { @request = Vanilla::Request.new(mock_env_for_url("/snip"), @app) }
+
+    should "use the first segement as the snip name" do
+      assert_equal "snip", @request.snip_name
+    end
+
+    should "try to load the snip based on the snip name" do
+      @app.soup.expects(:[]).with('snip').returns(:snip)
+      assert_equal :snip, @request.snip
+    end
+
+    should "have no part if the url contains only a single segment" do
+      assert_equal nil, @request.part
+    end
+
+    should "have a default format of html" do
+      assert_equal 'html', @request.format
+    end
+
+    should "determine the request method" do
+      assert_equal 'get', @request.method
+    end
+  end
+
+  context "when requesting a snip part" do
+    setup { @request = Vanilla::Request.new(mock_env_for_url("/snip/part"), @app) }
+
+    should "use the first segment as the snip, and the second segment as the part" do
+      assert_equal "snip", @request.snip_name
+      assert_equal "part", @request.part
+    end
+
+    should "have a default format of html" do
+      assert_equal "html", @request.format
+    end
+  end
+
+  context "when requesting a snip with a format" do
+    setup { @request = Vanilla::Request.new(mock_env_for_url("/snip.raw"), @app) }
+
+    should "use the extension as the format" do
+      assert_equal "raw", @request.format
+    end
+
+    should "retain the filename part of the path as the snip" do
+      assert_equal "snip", @request.snip_name
+    end
+  end
+
+  context "when requesting a snip part with a format" do
+    setup { @request = Vanilla::Request.new(mock_env_for_url("/snip/part.raw"), @app) }
+
+    should "use the extension as the format" do
+      assert_equal "raw", @request.format
+    end
+
+    should "retain the first segment of the path as the snip" do
+      assert_equal "snip", @request.snip_name
+    end
+
+    should "use the filename part of the second segment as the snip part" do
+      assert_equal "part", @request.part
+    end
+  end
+
+  context "when requested with a _method parameter" do
+    should "return the method using the parameter" do
+      assert_equal 'put', Vanilla::Request.new(mock_env_for_url("/snip?_method=put"), @app).method
+    end
+  end
+end