pancake 0.1.8

data/spec/pancake/mime_types_spec.rb

@@ -0,0 +1,234 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "..", "spec_helper")
+
+describe Pancake::MimeTypes do
+  before do
+    Pancake::MimeTypes.reset!
+  end
+
+  it "should have many types" do
+    Pancake::MimeTypes.types.should be_an(Array)
+  end
+
+  it "should have a type for each mime type defined in Rack::Mime::MIME_TYPES" do
+    Rack::Mime::MIME_TYPES.each do |ext, type|
+      ext =~ /\.(.*)$/
+      t = Pancake::MimeTypes.type_by_extension($1)
+      t.should_not be_nil
+      t.should be_an_instance_of(Pancake::MimeTypes::Type)
+      t.type_strings.should include(type)
+    end
+  end
+
+  it "should find the type from an extension" do
+    t = Pancake::MimeTypes.type_by_extension("html")
+    t.should_not be_nil
+    t.type_strings.should include("text/html")
+  end
+
+  it "should allow me to add a new mime type" do
+    t = Pancake::MimeTypes::Type.new("foo", "text/foobar")
+    type = Pancake::MimeTypes.type_by_extension("foo")
+    type.should_not be_nil
+    type.type_strings.should have(1).item
+    type.type_strings.should include("text/foobar")
+  end
+
+  describe Pancake::MimeTypes::Type do
+    include Pancake::MimeTypes
+
+    before do
+      @type = Pancake::MimeTypes::Type.new("html", "text/html")
+    end
+
+    it "should have one extension" do
+      @type.extension.should == "html"
+    end
+
+    it "should tell me the type strings" do
+      @type.type_strings.should include("text/html")
+    end
+
+    it "should allow me to add type strings" do
+      @type.type_strings << "text/foo_html"
+      @type.type_strings.should include("text/foo_html")
+    end
+
+    it "should not add duplicate type strings" do
+      @type.type_strings.should have(1).item
+      @type.type_strings << "text/html"
+      @type.type_strings.should have(2).items
+      @type.type_strings.should include("text/html")
+    end
+
+    it "should add non duplicate tpe strying" do
+      @type.type_strings.should have(1).item
+      @type.type_strings << "text/foo_html"
+      @type.type_strings.should have(2).items
+      @type.type_strings.should include("text/foo_html")
+    end
+  end
+
+  describe "grouping types" do
+    it "should allow me to create a group of mime types" do
+      Pancake::MimeTypes.group(:html).should be_an(Enumerable)
+    end
+
+    it "should allow me to add mime types to the group" do
+      Pancake::MimeTypes.group_as(:foo, "html", "xhtml")
+      r = Pancake::MimeTypes.group(:foo)
+      r.should have(2).items
+      r.should include(Pancake::MimeTypes.type_by_extension("html"))
+      r.should include(Pancake::MimeTypes.type_by_extension("xhtml"))
+    end
+
+    it "should allow me to add to a group without creating duplicates" do
+      t = Pancake::MimeTypes::Type.new("foo", "foo/bar")
+      Pancake::MimeTypes.group_as(:bar, "xhtml", "html")
+      Pancake::MimeTypes.group(:bar).should have(2).items
+      Pancake::MimeTypes.group(:bar).should_not include(t)
+      Pancake::MimeTypes.group_as(:bar, "html", "foo", "xhtml")
+      Pancake::MimeTypes.group(:bar).should have(3).items
+      Pancake::MimeTypes.group(:bar).should include(t)
+    end
+
+    it "should allow me to look up a mime type via a string or symbol identifier" do
+      Pancake::MimeTypes.group(:html).should eql(Pancake::MimeTypes.group("html"))
+    end
+
+    it "should be empty empty when accessing a non existant mime type" do
+      r = Pancake::MimeTypes.group(:not_a_mime)
+      r.should_not be_nil
+      r.should be_empty
+      r.should respond_to(:each)
+    end
+
+    it "should populate the group with the types when first acessing when a type with that extension exists" do
+      r = Pancake::MimeTypes.group(:xml)
+      r.should_not be_empty
+      r.each do |t|
+        t.should be_an_instance_of(Pancake::MimeTypes::Type)
+      end
+    end
+  end
+
+  describe "prepared groups" do
+    it "should prepare the html group" do
+      g = Pancake::MimeTypes.group(:html)
+      g.should have(3).items
+      ["html", "htm", "xhtml"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+
+    it "should parepare the text group" do
+      g = Pancake::MimeTypes.group(:text)
+      g.should have(2).items
+      ["text", "txt"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+
+    it "should prepare the svg group" do
+      g = Pancake::MimeTypes.group(:svg)
+      g.should have(2).items
+      ["svg", "svgz"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+
+
+    it "should add the text/xml to the xml format" do
+      t = Pancake::MimeTypes.type_by_extension("xml")
+      t.type_strings.should include("text/xml", "application/xml")
+    end
+  end
+
+  describe "format from accept type" do
+    it "should return the first matching type" do
+      accept_type = "text/plain"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text)
+      group.should == :text
+      at.should == accept_type
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+    end
+
+    it "should return the first type if the matching type is */*" do
+      accept_type = "*/*;application/xml"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :xml, :html)
+      at.should == "text/plain"
+      group.should == :text
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+    end
+
+    it "should use */* if avaiable" do
+      # safari uses application/xml first
+      accept_type = "application/xml,*/*"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :html, :xml)
+      at.should == "text/html"
+      group.should == :html
+      r.should_not be_nil
+    end
+
+    it "should return nil if there is no matching class" do
+      accept_type = "text/xml"
+      group, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :html)
+      r.should be_nil
+      group.should be_nil
+    end
+
+    it "should return a type when it is not in the first position" do
+      accept_type = "text/xml, text/html,text/plain;"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :svg, :text)
+      group.should == :text
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+      r.extension.should == "text"
+    end
+
+    it "should recognize the type from a quality value" do
+      accept_type = "text/plain;q=0.5,text/html;q=0.8"
+      group, at,  r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :html)
+      group.should == :html
+      r.should_not be_nil
+      r.type_strings.should include("text/html")
+      r.extension.should == "html"
+    end
+  end
+
+  describe "mime from extension" do
+    it "should recognize the mime type from the extension" do
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("text", :html, :text)
+      group.should == :text
+      at.should == "text/plain"
+      r.should == Pancake::MimeTypes.type_by_extension("text")
+    end
+
+    it "should recognize grouped mimes by extension" do
+      Pancake::MimeTypes.group_as(:foo, "text", "txt", "html")
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("txt", :foo)
+      group.should == :foo
+      at.should == "text/plain"
+      r.extension.should == "txt"
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("text", :foo)
+      r.extension.should == "text"
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("html", :foo)
+      r.extension.should == "html"
+      at.should == "text/html"
+    end
+
+    it "should not negotiate by extension when there the extension is not part of the accepted types" do
+      Pancake::MimeTypes.group_as(:bar, "text")
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("svg", :bar)
+      group.should be_nil
+      at.should be_nil
+      r.should be_nil
+    end
+
+  end
+end
+

data/spec/pancake/mixins/publish_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Pancake::Controller publish declaration" do
+  before(:each) do
+    class ::PancakeTest
+      extend Pancake::Mixins::Publish
+      
+      provides :html
+      
+      publish
+      def simple_publish; end
+      
+      publish :id => as(:integer)
+      def integer_test; end
+      
+      publish :start => as(:date)
+      def date_test; end
+      
+      publish :page => as(:integer, 12)
+      def default_test; end
+      
+      publish :provides => [:xml, :json]
+      def provides_test; end
+      
+      publish :only_provides => :xml
+      def only_provides_test; end
+      
+      publish :name => as(:string, :opt)
+      def optional_test; end
+      
+      publish :provides => [:json, :txt],
+              :id       => as(:integer, :req), 
+              :name     => as(:string, "Campion"), 
+              :melon    => as(:integer, 50),
+              :jam      => as(:string, :opt),
+              :squeeze  => as(:string, :req)
+      def complex_test; end
+    end
+  end
+  
+  after do 
+    clear_constants "PancakeTest"
+  end
+  
+  it "should publish an action" do
+    PancakeTest.actions['simple_publish'].is_a?(Pancake::Mixins::Publish::ActionOptions).should == true
+  end
+  
+  it "should coerce a parameter into an integer" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'integer_test', 'id' => "30")
+    params['id'].should == 30
+  end
+  
+  it "should coerce a parameter into a date" do
+    date = Date.parse("2009/07/05")
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'date_test', 'start' => "2009/07/05")
+    params['start'].should == date
+  end
+  
+  it "should flag required params that are missing" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'integer_test', {})
+    missing.include?(['id', :integer]).should == true
+  end
+  
+  it "should allow parameters to be optional" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'optional_test', {})
+    missing.empty?.should == true
+  end
+  
+  it "should return a default value for a parameter" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'default_test', {})
+    params['page'].should == 12
+  end
+  
+  it "should append formats to the list allowed for an action" do
+    PancakeTest.actions['provides_test'].formats.should == [:html, :xml, :json]
+  end
+  
+  it "should replace the list of formats allowed for an action" do
+    PancakeTest.actions['only_provides_test'].formats.should == [:xml]
+  end
+  
+  it "should allow complex declarations" do
+    input = {'id' => "30", 'name' => "Purslane"}
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'complex_test', input)
+    params['id'].should == 30
+    params['name'].should == "Purslane"
+    params['melon'].should == 50
+    params['jame'].should be_nil
+    missing.include?(['squeeze', :string]).should == true
+    
+    PancakeTest.actions['complex_test'].formats.should == [:html, :json, :txt]
+  end
+end

data/spec/pancake/mixins/render/template_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "spec_helper")
+
+describe Pancake::Mixins::Render::Template do
+  before do
+    $captures = []
+    @templates_path = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "fixtures", "render_templates", "templates")
+    class ::FooBar
+      include Pancake::Mixins::Render
+    end
+  end
+  after do
+    clear_constants :FooBar, :BarFoo
+  end
+
+  describe "Creation" do
+    it "should create a template with a name and a path" do
+      result = FooBar::Template.new(:context, File.join(@templates_path, "context.erb"))
+      result.should_not be_nil
+    end
+
+    it "should raise an error when creating a template without a name" do
+      lambda do
+        FooBar::Template.new(nil, File.join(@templates_path, "context.erb"))
+      end.should raise_error(Pancake::Mixins::Render::Template::UnamedTemplate)
+    end
+
+    it "should raise an error when createing a template withouth a valid file name" do
+      lambda do
+        FooBar::Template.new(:foo, "/not/a/real/file.erb")
+      end.should raise_error(Pancake::Mixins::Render::Template::NotFound)
+    end
+
+    it "should raise an error when it cannot create a rendering object for the file" do
+      lambda do
+        FooBar::Template.new(:foo, "/not/registed")
+      end.should raise_error
+    end
+
+    describe "accessing information" do
+      before do
+        @template = FooBar::Template.new(:context, File.join(@templates_path, "context.erb"))
+      end
+
+      it "should provide access to it's name" do
+        @template.name.should == :context
+      end
+
+      it "should provide access to it's path" do
+        @template.path.should == File.join(@templates_path, "context.erb")
+      end
+
+      it "should render the template" do
+        @template.render.should match(/in context/m)
+      end
+
+      describe "contexts" do
+        before do
+          @context = mock("context")
+        end
+
+        it "should render with the given context" do
+          @template.render(@context)
+          $captures.first.should == @context
+        end
+      end
+    end
+  end
+
+end

data/spec/pancake/mixins/render/view_context_spec.rb

@@ -0,0 +1,248 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "spec_helper")
+
+describe Pancake::Mixins::Render::ViewContext do
+
+  before do
+    $captures = []
+    class ::FooBar
+      include Pancake::Mixins::Render
+      attr_accessor :params, :data
+
+      def _template_name_for(name, opts)
+        "#{name}"
+      end
+      push_paths :views, "", "**/*"
+
+      roots << File.join(File.expand_path(File.dirname(__FILE__)),"..","..", "fixtures", "render_templates", "view_context")
+    end
+  end
+
+  after do
+    clear_constants :FooBar, :BarFoo
+  end
+
+  it "should setup the spec correctly" do
+    %w(helper_methods.erb context.erb).each do |f|
+      File.exists?(File.join(FooBar.roots.first, f)).should be_true
+    end
+  end
+
+  describe "view contexts" do
+
+    it "should inherit from Pancake::Mixins::Render::ViewContext" do
+      FooBar::ViewContext.should inherit_from(Pancake::Mixins::Render::ViewContext)
+    end
+
+    #it "should allow me to setup the view context before the view is run" do
+    #  FooBar.class_eval do
+    #    def view_context_before_render(context)
+    #      super
+    #      $captures << :here
+    #    end
+    #  end
+    #  $captures.should be_blank
+    #  FooBar.new.render(:context)
+    #  $captures.should include(:here)
+    #end
+
+    #it "should execute the before render block in the instance" do
+    #  FooBar.class_eval do
+    #    def view_context_before_render(context)
+    #     super
+    #      $captures << data
+    #    end
+    #  end
+    #  foobar = FooBar.new
+    #  foobar.data = {:some => :data}
+    #  foobar.render(:context)
+    #  $captures.should include(:some => :data)
+    #  $captures.clear
+    #  FooBar.new.render(:context)
+    #  $captures.should_not include(:some => :data)
+    #end
+  end
+
+  describe "inheriting classes" do
+    before do
+      FooBar::ViewContext.class_eval do
+        def some_helper
+          $captures << :some_helper
+        end
+      end
+
+      class ::BarFoo < FooBar
+      end
+
+    end
+
+    it "should inherit the view context when inheriting the outer class" do
+      BarFoo::ViewContext.should inherit_from(FooBar::ViewContext)
+    end
+  end
+
+  describe "delegation" do
+    before do
+      @renderer = mock("renderer", :null_object => true)
+    end
+
+    it "should provide access to the object the view context is rendering for" do
+      context = FooBar::ViewContext.new(@renderer)
+      context._view_context_for.should == @renderer
+    end
+
+    it "should grab the template from the view context when rendering" do
+      context = FooBar::ViewContext.new(@renderer)
+      @renderer.should_receive(:template).with(:foo).and_return(@renderer)
+      context.render(:foo, :some => :opts)
+    end
+  end
+
+  describe "capturing" do
+    before do
+    end
+
+    it "should render the haml template with a capture" do
+      result = FooBar.new.render(:capture_haml)
+      result.should_not include("captured haml")
+
+      context = $captures.first
+      context.should_not be_nil
+      context.instance_variable_get("@captured_haml").should include("captured haml")
+    end
+
+    it "should capture in erb" do
+      result = FooBar.new.render(:capture_erb)
+      result.should_not include("captured erb")
+      context = $captures.first
+      context.should_not be_nil
+      context.instance_variable_get("@captured_erb").should include("captured erb")
+    end
+
+    it "should concat in haml" do
+      result = FooBar.new.render(:concat_haml)
+      result.should include("concatenated")
+    end
+
+    it "should concat in erb" do
+      result = FooBar.new.render(:concat_erb)
+      result.should include("concatenated")
+    end
+  end
+
+  describe "content_block" do
+    before do
+      @foo = FooBar.new
+    end
+
+    it "should include the default text" do
+      result = @foo.render(:inherited_haml_level_0)
+      result.should include("inherited haml level 0")
+      result.should include("default content block content")
+    end
+
+    it "should inherit the content block from a parent template" do
+      result = @foo.render(:inherited_haml_level_1)
+      result.should include("inherited haml level 0")
+      result.should include("inherited haml level 1 content")
+    end
+
+    it "should inherit the default text in erb" do
+      result = @foo.render(:inherited_erb_level_0)
+      result.should include("inherited erb level 0")
+      result.should include("default content block content")
+    end
+
+    it "should inherit the content block from a parent template in erb" do
+      result = @foo.render(:inherited_erb_level_1)
+      result.should include("inherited erb level 0")
+      result.should include("inherited erb level 1 content")
+    end
+
+    it "should inherit erb from haml" do
+      result = @foo.render(:inherited_erb_from_haml)
+      result.should include("inherited haml level 0")
+      result.should include("inherited erb content")
+    end
+
+    it "should inherit haml from erb" do
+      result = @foo.render(:inherited_haml_from_erb)
+      result.should include("inherited erb level 0")
+      result.should include("inherited haml content")
+    end
+
+  end
+
+  describe "super blocks" do
+    before do
+      @foo = FooBar.new
+    end
+
+    it "should render the super text" do
+      result = @foo.render(:super_haml_from_haml_0)
+      result.should include("default content block content")
+    end
+
+    it "should render the super text and the new text" do
+      result = @foo.render(:super_haml_from_haml_1)
+      result.should include("default content block content")
+      result.should include("new content with super")
+    end
+
+    it "should render the super text in erb templates" do
+      result = @foo.render(:super_erb_from_erb_0)
+      result.should include("default content block content")
+    end
+
+    it "should render the super text and the new text in erb" do
+      result = @foo.render(:super_erb_from_erb_1)
+      result.should include("new content with super")
+      result.should include("default content block content")
+    end
+
+    it "should inherit haml from erb" do
+      result = @foo.render(:super_haml_from_erb_0)
+      result.should include("default content block content")
+    end
+
+    it "should inherit haml from erb with with additional contnet" do
+      result = @foo.render(:super_haml_from_erb_1)
+      result.should include("new content from haml")
+      result.should include("default content block content")
+    end
+
+    it "should inherit erb from haml" do
+      result = @foo.render(:super_erb_from_haml_0)
+      result.should include("default content block content")
+    end
+
+    it "should inherit erb from haml" do
+      result = @foo.render(:super_erb_from_haml_1)
+      result.should include("new content from erb")
+      result.should include("default content block content")
+    end
+  end
+
+  describe "multiple context blocks" do
+    before do
+      @foo = FooBar.new
+    end
+
+    it "should allow nested default captures" do
+      result = @foo.render(:nested_content_level_0)
+      result.should include("level 0 content")
+      result.should include("nested foo content")
+      result.should include("nested bar content")
+    end
+
+    it "should allow inherited nested content to overwrite a given block" do
+      result = @foo.render(:nested_content_level_1)
+      result.should include("level 0 content")
+      result.should include("nested foo content")
+      result.should include("nested new bar content")
+    end
+  end
+end
+
+
+
+

data/spec/pancake/mixins/render_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Pancake::Mixins::Render do
+  before do
+    class ::RenderSpecClass
+      include Pancake::Mixins::Render
+
+      # setup the renderer
+      roots << File.expand_path(File.join(File.dirname(__FILE__), "..", "fixtures", "render_templates"))
+      push_paths :views, "/", "**/*"
+
+      def params
+        @params ||= {}
+      end
+
+      def string
+        render :text => "A String"
+      end
+
+      def the_current_context
+        "the current context"
+      end
+    end
+
+    @render = RenderSpecClass.new
+  end
+  after do
+    clear_constants "RenderSpecClass"
+  end
+
+  it "should allow me to render a string" do
+    @render.string.should == "A String"
+  end
+
+  it "should render a haml" do
+    @render.render(:haml_template).chomp.should == "IN HAML"
+  end
+
+  it "should render erb" do
+    @render.render(:erb_template).should == "IN ERB"
+  end
+
+  it "should render an xml format" do
+    @render.render(:haml_template, :format => :xml).chomp.should == "IN HAML XML"
+  end
+
+  it "should render an erb template for json" do
+    @render.render(:erb_template, :format => :json).chomp.should == "IN ERB JSON"
+  end
+
+  it "should render with the rendering controller as the current context" do
+    @render.render(:context_template)
+    $captures.first.should be_a_kind_of(Pancake::Mixins::Render::ViewContext)
+  end
+
+end