vanilla 1.2 → 1.9.9

data/test/renderers/markdown_renderer_test.rb

@@ -1,31 +0,0 @@
-require "test_helper"
-
-describe Vanilla::Renderers::Markdown do
-  context "when rendering" do
-    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)
-      assert_response_body BlueCloth.new(content).to_html, "/test"
-    end
-
-    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")
-      assert_equal "<h1>markdown</h1> <p>and so lets include <b>blah</b></p>", response_body_for("/test").gsub(/\s+/, ' ')
-    end
-  end
-
-  def markdown_snip(attributes)
-    create_snip(attributes.merge(:render_as => "Markdown"))
-  end
-end

data/test/renderers/raw_renderer_test.rb

@@ -1,23 +0,0 @@
-require "test_helper"
-
-describe Vanilla::Renderers::Raw do
-  context "when rendering" do
-    setup do
-      @snip = create_snip(:name => "test", :content => "raw content", :part => "raw part")
-      set_main_template "<tag>{current_snip}</tag>"
-    end
-
-    should "render the contents part of the snip as it is" do
-      assert_response_body "raw content", "/test.raw"
-    end
-  
-    should "render the specified part of the snip" do
-      assert_response_body "raw part", "/test/part.raw"
-    end
-  
-    should "not perform any snip inclusion" do
-      create_snip(:name => "snip_with_inclusions", :content => "loading {another_snip}")
-      assert_response_body "loading {another_snip}", "/snip_with_inclusions.raw"
-    end
-  end
-end

data/test/renderers/ruby_renderer_test.rb

@@ -1,59 +0,0 @@
-require "test_helper"
-
-describe Vanilla::Renderers::Ruby do
-  context "when rendering normally" do
-    class ::TestDyna < Dynasnip
-      def handle(*args)
-        'handle called'
-      end
-    end
-
-    setup do
-      @app.soup << TestDyna.snip_attributes
-    end
-
-    should "render the result of the handle method" do
-      assert_response_body 'handle called', "/test_dyna"
-    end
-  end
-
-  context "when responding restfully" do
-    class ::RestishDyna < Dynasnip
-      def get(*args)
-        'get called'
-      end
-      def post(*args)
-        'post called'
-      end
-    end
-
-    setup do
-      @app.soup << RestishDyna.snip_attributes
-    end
-
-    should "render the result of the get method on GET requests" do
-      assert_response_body 'get called', "/restish_dyna"
-    end
-
-    should "render the result of the post method on POST requests" do
-      assert_response_body 'post called', "/restish_dyna?_method=post"
-    end
-  end
-
-  context "when knowing about enclosing snips" do
-    class ::Encloser < Dynasnip
-      def handle(*args)
-        "enclosing snip is #{enclosing_snip.name}"
-      end
-    end
-
-    setup do
-      @app.soup << Encloser.snip_attributes
-      create_snip(:name => "test", :content => "{encloser}")
-    end
-
-    should "know about the snip that called this dynasnip" do
-      assert_response_body 'enclosing snip is test', "/test"
-    end
-  end
-end

data/test/snip_inclusion_test.rb

@@ -1,56 +0,0 @@
-require "test_helper"
-
-context "When including snips in other snips" do
-  setup do
-    create_snip :name => "test", :content => "snip content"
-  end
-
-  should "match simple snips" do
-    assert_equal "rendering snip content", render("rendering {test}")
-  end
-
-  should "match snips with an argument" do
-    assert_equal "rendering snip content", render("rendering {test arg1}")
-  end
-
-  should "match snips with several arguments" do
-    assert_equal "rendering snip content", render("rendering {test arg1, arg2}")
-  end
-
-  should "match snips with hyphens" do
-    create_snip :name => "test-snip", :content => "snip content"
-    assert_equal "rendering snip content", render("rendering {test-snip}")
-  end
-
-  should "match snips with underscores" do
-    create_snip :name => "test_snip", :content => "snip content"
-    assert_equal "rendering snip content", render("rendering {test_snip}")
-  end
-
-  should "match snips with numbers" do
-    create_snip :name => "test1", :content => "snip content"
-    assert_equal "rendering snip content", render("rendering {test1}")
-  end
-
-  should "match snips with ruby 1.9 style hashes" do
-    create_snip :name => "test", :content => %{
-      class Blah
-        def handle(args)
-          args.inspect
-        end
-        self
-      end
-    }, :render_as => "Ruby"
-    assert_equal %{rendering {:x=>"1"}}, render("rendering {test x:1}")
-  end
-
-  should "ignore references that are rubyish" do
-    assert_equal "10.times { |x| puts x }", render("10.times { |x| puts x }")
-    assert_equal "10.times {|x| puts x }", render("10.times {|x| puts x }")
-  end
-
-  def render(content)
-    snip = create_snip :name => "test-content", :content => content
-    Vanilla::Renderers::Base.new(@app).render(snip)
-  end
-end

data/test/snip_reference_parser_test.rb

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

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

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