vanilla 1.0.2 → 1.2

data/public/javascripts/vanilla.js

@@ -1,21 +0,0 @@
-function vanillaPrepareEditor() {
-  $('input.attribute_name').change(function() {
-    var dl_children = $('dl.attributes').children();
-    var dt_index = dl_children.index(this.parentNode) + 1;
-    var textarea_for_this = dl_children[dt_index].childNodes[0];
-    textarea_for_this.name = this.value;
-  });
-}
-
-$(document).ready(function() {
-
-  $('a#add').click(function() {
-    $('dl.attributes').append('<dt><input class="attribute_name" type="text"></input></dt><dd><textarea></textarea></dd>');
-    vanillaPrepareEditor();
-    return false;
-  });
-  
-  vanillaPrepareEditor();
-
-});
-

data/spec/dynasnip_spec.rb

@@ -1,31 +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
-  
-  before(:each) do
-    @fake_app = nil
-  end
-  
-  it "should make the attribute available as an instance method" do
-    TestDyna.new(@fake_app).test_attribute.should == "test attribute content"
-  end
-
-  it "should store the attribute in the soup" do
-    TestDyna.persist!
-    Soup['test_dyna'].test_attribute.should == "test attribute content"
-  end
-  
-  it "should allow the attribute to be overriden by the soup contents" do
-    TestDyna.persist!
-    snip = Soup['test_dyna']
-    snip.test_attribute = "altered content"
-    snip.save
-    
-    TestDyna.new(@fake_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,42 +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
-      @test_dyna = TestDyna.persist!
-    end
-  
-    it "should render the result of the handle method" do
-      Vanilla::Test.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
-      @dyna = RestishDyna.persist!
-    end
-  
-    it "should render the result of the get method on GET requests" do
-      Vanilla::Test.response_body_for("/restish_dyna").should == 'get called'
-    end
-  
-    it "should render the result of the post method on POST requests" do
-      Vanilla::Test.response_body_for("/restish_dyna?_method=post") == 'post called'
-    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(: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(: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(:render_as => "MyRenderer")
-    @app.renderer_for(snip).should == MyRenderer      
-  end
-end

data/spec/spec_helper.rb

@@ -1,64 +0,0 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-require "vanilla"
-require "spec"
-require "fileutils"
-require "rack/mock"
-
-module Vanilla
-  module Test
-    def setup_clean_environment
-      test_soup_config = { :database => File.join(File.dirname(__FILE__), "soup_test.db")}
-      FileUtils.rm(test_soup_config[:database]) if File.exist?(test_soup_config[:database])
-      Soup.base = test_soup_config
-
-      # TODO: this is hard-coded for the AR implementation
-      require "active_record"
-      ActiveRecord::Migration.verbose = false
-  
-      Soup.prepare
-      require "vanilla/dynasnips/current_snip"
-      CurrentSnip.persist!
-      create_snip :name => "system", :main_template => "{current_snip}"
-    end
-    
-    def response_for(url)
-      Vanilla::App.new.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 set_main_template(template_content)
-      system = Vanilla.snip("system") || Snip.new(:name => "system")
-      system.main_template = template_content
-      system.save
-    end
-    
-    def create_snip(params)
-      s = Snip.new(params)
-      s.save
-      s
-    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
-    
-    extend self
-  end
-end
-
-Spec::Runner.configure do |config|
-  config.include(Vanilla::Test)
-  config.before { Vanilla::Test.setup_clean_environment }
-end
-

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 = Vanilla::App.new.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({}.to_yaml))
-      Vanilla::App.new
-    end
-    
-    it "should load a config file given" do
-      File.open("/tmp/vanilla_config.yml", "w") { |f| f.write({: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({: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
-    LinkTo.persist!
-    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(nil).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