vanilla 1.2 → 1.9.9

data/public/javascripts/vanilla.js

@@ -0,0 +1,22 @@
+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;
+  });
+  $('textarea').autogrow();
+}
+
+$(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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+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/spec_helper.rb

@@ -0,0 +1,70 @@
+$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
+      FileUtils.mkdir_p(File.dirname(test_config_file))
+      clear_soup
+      File.open(test_config_file, 'w') { |f| f.write({:soup => soup_path}.to_yaml) }
+      @app = Vanilla::App.new(test_config_file)
+
+      require "vanilla/dynasnips/current_snip"
+      @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 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
+
+    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 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
+

data/spec/tmp/config.yml

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

data/spec/tmp/soup/current_snip.yml

@@ -0,0 +1,15 @@
+CurrentSnip--- # Soup attributes
+: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
+      requested snip, in its rendered form, within the page.
+      
+      It can also be used to determine the name of the current snip in a consistent way:
+      
+        {current_snip name}
+        
+      will output the name of the current snip, or the name of the snip currently being edited.

data/spec/tmp/soup/system.yml

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

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

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