vanilla 1.9.13.2 → 1.9.14

data/Rakefile

@@ -2,14 +2,14 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'vanilla'
 load File.join(File.dirname(__FILE__), *%w[lib tasks vanilla.rake])
 
-require 'spec'
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new do |t|
-  t.spec_opts = %w(--format specdoc --colour)
-  t.libs = ["spec"]
-end
+task :default => :test
 
-task :default => :spec
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
 
 require "rubygems"
 require "rake/gempackagetask"
@@ -25,7 +25,7 @@ if Object.const_defined?(:Gem)
 
     # Change these as appropriate
     s.name              = "vanilla"
-    s.version           = "1.9.13.2"
+    s.version           = "1.9.14"
     s.summary           = "A bliki-type web content thing."
     s.author            = "James Adam"
     s.email             = "james@lazyatom.com.com"
@@ -36,7 +36,7 @@ if Object.const_defined?(:Gem)
     s.rdoc_options      = %w(--main README)
 
     # Add any extra files to include in the gem
-    s.files             = %w(config.example.yml config.ru Rakefile README README_FOR_APP) + Dir.glob("{spec,lib,bin,public}/**/*")
+    s.files             = %w(config.example.yml config.ru Rakefile README README_FOR_APP) + Dir.glob("{test,lib,bin,public}/**/*")
     s.executables       = ['vanilla']
     s.require_paths     = ["lib"]
 
@@ -49,7 +49,8 @@ if Object.const_defined?(:Gem)
     s.add_dependency("treetop", ">= 1.4.1")
     s.add_dependency("warden", ">= 0.5.2")
 
-    s.add_development_dependency("rspec") # add any other gems for testing/development
+    s.add_development_dependency("shoulda") # add any other gems for testing/development
+    s.add_development_dependency("mocha")
 
     # If you want to publish automatically to rubyforge, you'll may need
     # to tweak this, and the publishing task below too.

data/lib/vanilla/request.rb

@@ -72,7 +72,7 @@ module Vanilla
     def request_uri_parts(request)
       case CGI.unescape(uri_path(request))
       when URL_ROOT
-        ['start', nil, 'html']
+        [@app.config[:root_snip] || 'start', nil, 'html']
       when URL_SNIP
         [$1, nil, $3]
       when URL_SNIP_AND_PART

data/test/base_renderer_test.rb

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

data/test/dynasnip_test.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+require 'vanilla/dynasnip'
+
+class DynasnipTest < Vanilla::TestCase
+
+  context "when storing attributes" do
+
+    class ::TestDyna < Dynasnip
+      attribute :test_attribute, "test attribute content"
+    end
+
+    should "make the attribute available as an instance method" do
+      assert_equal "test attribute content", TestDyna.new(@app).test_attribute
+    end
+
+    should "store the attribute in the soup" do
+      @app.soup << TestDyna.snip_attributes
+      assert_equal "test attribute content", @app.soup['test_dyna'].test_attribute
+    end
+
+    should "allow the attribute to be overriden by the soup contents" do
+      @app.soup << TestDyna.snip_attributes
+      snip = @app.soup['test_dyna']
+      snip.test_attribute = "altered content"
+      snip.save
+
+      assert_equal "altered content", TestDyna.new(@app).test_attribute
+    end
+  end
+  
+end

data/test/erb_renderer_test.rb

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

data/test/markdown_renderer_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class MarkdownRendererTest < Vanilla::TestCase
+  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
+
+  private
+
+  def markdown_snip(attributes)
+    create_snip(attributes.merge(:render_as => "Markdown"))
+  end
+end

data/test/raw_renderer_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class RawRendererTest < Vanilla::TestCase
+  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/ruby_renderer_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class RubyRendererTest < Vanilla::TestCase
+  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/{spec/spec_helper.rb → test/test_helper.rb}

@@ -1,6 +1,9 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "rubygems"
 require "vanilla"
-require "spec"
+require "test/unit"
+require "shoulda"
+require "mocha"
 require "fileutils"
 require "rack/mock"
 
@@ -16,31 +19,35 @@ module Vanilla
       @app.soup << CurrentSnip.snip_attributes
       create_snip :name => "system", :main_template => "{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, response_body_for(uri)
+    end
+
     def set_main_template(template_content)
       system = @app.soup["system"] || Snip.new({:name => "system"}, @app.soup)
       system.main_template = template_content
       system.save
     end
-    
+
     def create_snip(params)
       s = Snip.new(params, @app.soup)
       s.save
       s
     end
-    
+
     def mock_env_for_url(url)
       Rack::MockRequest.env_for(url)
     end
@@ -48,23 +55,29 @@ module Vanilla
     def mock_request(url)
       Rack::Request.new(mock_env_for_url(url))
     end
-    
+
     def test_config_file
       File.join(File.dirname(__FILE__), "tmp", "config.yml")
     end
-    
+
+    def test_config(options={})
+      File.open(test_config_file, 'w') { |f| f.write({:soup => soup_path}.update(options).to_yaml) }
+    end
+
     def soup_path
       File.expand_path(File.join(File.dirname(__FILE__), "tmp", "soup"))
     end
-    
+
     def clear_soup
       FileUtils.rm_rf(soup_path)
     end
   end
 end
 
-Spec::Runner.configure do |config|
-  config.include(Vanilla::Test)
-  config.before { setup_clean_environment }
-end
+class Vanilla::TestCase < Test::Unit::TestCase
+  include Vanilla::Test
 
+  def setup
+    setup_clean_environment
+  end
+end

data/test/tmp/config.yml

@@ -0,0 +1,2 @@
+--- 
+:soup: /Users/james/Code/lazyatom/vanilla-rb/test/tmp/soup

data/{spec → test}/tmp/soup/current_snip.yml

@@ -1,8 +1,7 @@
 CurrentSnip--- # Soup attributes
+:updated_at: 2009-11-23 22:14:50.820298 +00:00
 :name: current_snip
 :render_as: Ruby
-:created_at: 2009-10-12 17:39:26.752915 +01:00
-:updated_at: 2009-10-12 17:39:26.752917 +01:00
 :usage: |-
   The current_snip dyna normally returns the result of rendering the snip named by the 
       'snip' value in the parameters. This way, it can be used in templates to place the currently
@@ -13,3 +12,4 @@ CurrentSnip--- # Soup attributes
         {current_snip name}
         
       will output the name of the current snip, or the name of the snip currently being edited.
+:created_at: 2009-11-23 22:14:50.820288 +00:00

data/test/tmp/soup/system.yml

@@ -0,0 +1,5 @@
+--- # Soup attributes
+:updated_at: 2009-11-23 22:14:50.821038 +00:00
+:name: system
+:main_template: "{current_snip}"
+:created_at: 2009-11-23 22:14:50.821036 +00:00

data/test/vanilla_app_test.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class VanillaAppTest < Vanilla::TestCase
+
+  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 "load a config file from the current working directory by default" do
+      File.expects(:open).with("config.yml").returns(StringIO.new({:soup => soup_path}.to_yaml))
+      Vanilla::App.new
+    end
+
+    should "load a config file given" do
+      File.open("/tmp/vanilla_config.yml", "w") { |f| f.write({:soup => soup_path, :hello => true}.to_yaml) }
+      app = Vanilla::App.new("/tmp/vanilla_config.yml")
+      assert app.config[:hello]
+    end
+
+    should "allow saving of configuration to the same file it was loaded from" do
+      config_file = "/tmp/vanilla_config.yml"
+      File.open(config_file, "w") { |f| f.write({:soup => soup_path, :hello => true}.to_yaml) }
+      app = Vanilla::App.new(config_file)
+      app.config[:saved] = true
+      app.config.save!
+
+      config = YAML.load(File.open(config_file))
+      assert config[:saved]
+    end
+  end
+
+  context "when detecting the snip renderer" do
+    setup do
+      @app = Vanilla::App.new(test_config_file)
+    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
+
+    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 outside of the Vanilla::Renderers module" do
+      class ::MyRenderer
+      end
+
+      snip = create_snip(:name => "blah", :render_as => "MyRenderer")
+      assert_equal MyRenderer, @app.renderer_for(snip)
+    end
+  end
+end

data/test/vanilla_presenting_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class VanillaPresentingTest < Vanilla::TestCase
+  def setup
+    super
+    @app.soup << LinkTo.snip_attributes
+    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 "when presenting as 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
+  end
+
+  context "when presenting content 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 "when presenting 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 "when a missing snip is requested" do
+    should "render missing snip content in the main template" do
+      assert_response_body "<tag>Couldn't find snip #{LinkTo.new(@app).handle("missing_snip")}</tag>", "/missing_snip"
+    end
+
+    should "have a 404 response code" do
+      assert_equal 404, response_code_for("/missing_snip")
+    end
+  end
+
+  context "when 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,98 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class VanillaRequestTest < Vanilla::TestCase
+  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
+
+    context "with a start snip configuration set" do
+      setup do
+        test_config(:root_snip => "custom")
+        @app = Vanilla::App.new(test_config_file)
+      end
+
+      should "use specified snip as default" do
+        assert_equal "custom", Vanilla::Request.new(mock_env_for_url("/"), @app).snip_name
+      end
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: vanilla
 version: !ruby/object:Gem::Version 
-  version: 1.9.13.2
+  version: 1.9.14
 platform: ruby
 authors: 
 - James Adam
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-12 00:00:00 +00:00
+date: 2009-11-23 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -83,7 +83,17 @@ dependencies:
         version: 0.5.2
     version: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -106,20 +116,19 @@ files:
 - Rakefile
 - README
 - README_FOR_APP
-- spec/dynasnip_spec.rb
-- spec/renderers/base_renderer_spec.rb
-- spec/renderers/erb_renderer_spec.rb
-- spec/renderers/markdown_renderer_spec.rb
-- spec/renderers/raw_renderer_spec.rb
-- spec/renderers/ruby_renderer_spec.rb
-- spec/renderers/vanilla_app_detecting_renderer_spec.rb
-- spec/spec_helper.rb
-- spec/tmp/config.yml
-- spec/tmp/soup/current_snip.yml
-- spec/tmp/soup/system.yml
-- spec/vanilla_app_spec.rb
-- spec/vanilla_presenting_spec.rb
-- spec/vanilla_request_spec.rb
+- test/base_renderer_test.rb
+- test/dynasnip_test.rb
+- test/erb_renderer_test.rb
+- test/markdown_renderer_test.rb
+- test/raw_renderer_test.rb
+- test/ruby_renderer_test.rb
+- test/test_helper.rb
+- test/tmp/config.yml
+- test/tmp/soup/current_snip.yml
+- test/tmp/soup/system.yml
+- test/vanilla_app_test.rb
+- test/vanilla_presenting_test.rb
+- test/vanilla_request_test.rb
 - lib/defensio.rb
 - lib/tasks/vanilla.rake
 - lib/vanilla/app.rb

data/spec/dynasnip_spec.rb

@@ -1,28 +0,0 @@
-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
-  
-  it "should make the attribute available as an instance method" do
-    p TestDyna.new(@app).test_attribute
-    TestDyna.new(@app).test_attribute.should == "test attribute content"
-  end
-
-  it "should store the attribute in the soup" do
-    @app.soup << TestDyna.snip_attributes
-    @app.soup['test_dyna'].test_attribute.should == "test attribute content"
-  end
-  
-  it "should allow the attribute to be overriden by the soup contents" do
-    @app.soup << TestDyna.snip_attributes
-    snip = @app.soup['test_dyna']
-    snip.test_attribute = "altered content"
-    snip.save
-    
-    TestDyna.new(@app).test_attribute.should == "altered content"
-  end
-  
-end

data/spec/renderers/base_renderer_spec.rb

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

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

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

data/spec/renderers/raw_renderer_spec.rb

@@ -1,21 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper")
-
-describe Vanilla::Renderers::Raw, "when rendering" do
-  before(:each) do
-    @snip = create_snip(:name => "test", :content => "raw content", :part => "raw part")
-    set_main_template "<tag>{current_snip}</tag>"
-  end
-
-  it "should render the contents part of the snip as it is" do
-    response_body_for("/test.raw").should == "raw content"
-  end
-  
-  it "should render the specified part of the snip" do
-    response_body_for("/test/part.raw").should == "raw part"
-  end
-  
-  it "should not perform any snip inclusion" do
-    create_snip(:name => "snip_with_inclusions", :content => "loading {another_snip}")
-    response_body_for("/snip_with_inclusions.raw").should == "loading {another_snip}"
-  end
-end

data/spec/renderers/ruby_renderer_spec.rb

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

data/spec/renderers/vanilla_app_detecting_renderer_spec.rb

@@ -1,35 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper")
-
-describe "when detecting the snip renderer" do
-  before(:each) do
-    @app = Vanilla::App.new
-  end
-
-  it "should return the constant refered to in the render_as property of the snip" do
-    snip = create_snip(:name => "blah", :render_as => "Raw")
-    @app.renderer_for(snip).should == Vanilla::Renderers::Raw
-  end
-
-  it "should return Vanilla::Renderers::Base if no render_as property exists" do
-    snip = create_snip(:name => "blah")
-    @app.renderer_for(snip).should == Vanilla::Renderers::Base
-  end
-
-  it "should return Vanilla::Renderers::Base if the render_as property is blank" do
-    snip = create_snip(:name => "blah", :render_as => '')
-    @app.renderer_for(snip).should == Vanilla::Renderers::Base
-  end
-
-  it "should raise an error if the specified renderer doesn't exist" do
-    snip = create_snip(:name => "blah", :render_as => "NonExistentClass")
-    lambda { @app.renderer_for(snip) }.should raise_error
-  end
-
-  it "should load constants outside of the Vanilla::Renderers module" do
-    class ::MyRenderer
-    end
-  
-    snip = create_snip(:name => "blah", :render_as => "MyRenderer")
-    @app.renderer_for(snip).should == MyRenderer      
-  end
-end

data/spec/tmp/config.yml

@@ -1,2 +0,0 @@
---- 
-:soup: /Users/james/Code/lazyatom/vanilla-rb/spec/tmp/soup

data/spec/tmp/soup/system.yml

@@ -1,5 +0,0 @@
---- # Soup attributes
-:name: system
-:created_at: 2009-10-12 17:39:26.757197 +01:00
-:updated_at: 2009-10-12 17:39:26.757199 +01:00
-:main_template: "{current_snip}"

data/spec/vanilla_app_spec.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Vanilla::App do
-  describe "when behaving as a Rack application" do
-    it "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"))
-      result.should be_a_kind_of(Array)
-      result[0].should == 200
-      result[1].should be_a_kind_of(Hash)
-      result[2].each{ |output| output.should == "content" }
-    end
-  end
-  
-  describe "when being configured" do
-    it "should load a config file from the current working directory by default" do
-      File.should_receive(:open).with("config.yml").and_return(StringIO.new({:soup => soup_path}.to_yaml))
-      Vanilla::App.new
-    end
-    
-    it "should load a config file given" do
-      File.open("/tmp/vanilla_config.yml", "w") { |f| f.write({:soup => soup_path, :hello => true}.to_yaml) }
-      app = Vanilla::App.new("/tmp/vanilla_config.yml")
-      app.config[:hello].should be_true
-    end
-    
-    it "should allow saving of configuration to the same file it was loaded from" do
-      config_file = "/tmp/vanilla_config.yml"
-      File.open(config_file, "w") { |f| f.write({:soup => soup_path, :hello => true}.to_yaml) }
-      app = Vanilla::App.new(config_file)
-      app.config[:saved] = true
-      app.config.save!
-      
-      config = YAML.load(File.open(config_file))
-      config[:saved].should be_true
-    end
-  end
-end

data/spec/vanilla_presenting_spec.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Vanilla::App do  
-  before(:each) do
-    @app.soup << LinkTo.snip_attributes
-    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
-  
-  describe "when presenting as HTML" do
-    it "should render the snip's content in the system template if no format or part is given" do
-      response_body_for("/test").should == "<tag>blah blah!</tag>"
-    end
-  
-    it "should render the snip's content in the system template if the HTML format is given" do
-      response_body_for("/test.html").should == "<tag>blah blah!</tag>"
-    end
-  
-    it "should render the requested part within the main template when a part is given" do
-      response_body_for("/test/part").should == "<tag>part content</tag>"
-    end
-    
-    it "should have a response code of 200" do
-      response_code_for("/test").should == 200
-      response_code_for("/test.html").should == 200
-      response_code_for("/test/part").should == 200
-      response_code_for("/test/part.html").should == 200
-    end
-  end
-
-  describe "when presenting content as text" do
-    it "should render the snip's content outside of the main template with its default renderer" do
-      response_body_for("/test.text").should == "blah blah!"
-    end
-  
-    it "should render the snip part outside the main template when a format is given" do
-      response_body_for("/test/part.text").should == "part content"
-    end
-    
-    it "should have a response code of 200" do
-      response_code_for("/test.text").should == 200
-      response_code_for("/test/part.text").should == 200
-    end
-  end
-
-
-  describe "when presenting raw content" do
-    it "should render the snips contents exactly as they are" do
-      response_body_for("/test.raw").should == "blah {other_snip}"
-    end
-  
-    it "should render the snip content exactly even if a render_as attribute exists" do
-      response_body_for("/current_snip.raw").should == "CurrentSnip"
-    end
-  
-    it "should render a snips part if requested" do
-      response_body_for("/test/part.raw").should == "part content"
-    end
-    
-    it "should have a response code of 200" do
-      response_code_for("/test.raw").should == 200
-      response_code_for("/test/part.raw").should == 200
-    end
-  end
-  
-  
-  describe "when a missing snip is requested" do
-    it "should render missing snip content in the main template" do
-      response_body_for("/missing_snip").should == "<tag>Couldn't find snip #{LinkTo.new(@app).handle("missing_snip")}</tag>"
-    end
-    
-    it "should have a 404 response code" do
-      response_code_for("/missing_snip").should == 404
-    end
-  end
-  
-  
-  describe "when requesting an unknown format" do
-    it "should return a 500 status code" do
-      response_code_for("/test.monkey").should == 500
-    end  
-  end
-end

data/spec/vanilla_request_spec.rb

@@ -1,73 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Vanilla::Request, "when requesting urls" do
-  before(:each) { @request = Vanilla::Request.new(mock_env_for_url("/snip"), @app) }
-  
-  it "should use the first segement as the snip name" do
-    @request.snip_name.should == "snip"
-  end
-  
-  it "should try to load the snip based on the snip name" do
-    @app.soup.should_receive(:[]).with('snip').and_return(:snip)
-    @request.snip.should == :snip
-  end
-  
-  it "should have no part if the url contains only a single segment" do
-    @request.part.should == nil    
-  end
-  
-  it "should have a default format of html" do
-    @request.format.should == 'html'
-  end
-  
-  it "should determine the request method" do
-    @request.method.should == 'get'
-  end
-end
-
-describe Vanilla::Request, "when requesting a snip part" do
-  before(:each) { @request = Vanilla::Request.new(mock_env_for_url("/snip/part"), @app) }
-  
-  it "should use the first segment as the snip, and the second segment as the part" do
-    @request.snip_name.should == "snip"
-    @request.part.should == "part"
-  end
-  
-  it "should have a default format of html" do
-    @request.format.should == "html"
-  end
-end
-
-describe Vanilla::Request, "when requesting a snip with a format" do
-  before(:each) { @request = Vanilla::Request.new(mock_env_for_url("/snip.raw"), @app) }
-  
-  it "should use the extension as the format" do
-    @request.format.should == "raw"
-  end
-  
-  it "should retain the filename part of the path as the snip" do
-    @request.snip_name.should == "snip"
-  end
-end
-
-describe Vanilla::Request, "when requesting a snip part with a format" do
-  before(:each) { @request = Vanilla::Request.new(mock_env_for_url("/snip/part.raw"), @app) }
-  
-  it "should use the extension as the format" do
-    @request.format.should == "raw"
-  end
-  
-  it "should retain the first segment of the path as the snip" do
-    @request.snip_name.should == "snip"
-  end
-  
-  it "should use the filename part of the second segment as the snip part" do
-    @request.part.should == "part"
-  end
-end
-
-describe Vanilla::Request, "when requested with a _method paramter" do
-  it "should return the method using the parameter" do
-    Vanilla::Request.new(mock_env_for_url("/snip?_method=put"), @app).method.should == 'put'
-  end
-end