spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/unit/test_formats.rb

@@ -6,6 +6,7 @@ class FormatsTest < MiniTest::Spec
   context "Pages" do
     setup do
       @site = setup_site
+      @site.paths.add :templates, File.expand_path('../../fixtures/outputs/templates', __FILE__)
       class Page < Spontaneous::Page; end
       class FPage < Page; end
     end
@@ -16,80 +17,290 @@ class FormatsTest < MiniTest::Spec
       teardown_site
     end
 
-    should "default to a single :html format" do
-      FPage.formats.should == [:html]
+    context "default output" do
+      should "be named :html" do
+        FPage.outputs.map(&:name).should == [:html]
+      end
+
+      should "be html format" do
+        FPage.outputs.map(&:format).should == [:html]
+      end
+
+      should "be public" do
+        FPage.outputs.map(&:private?).should == [false]
+        FPage.outputs.map(&:public?).should ==  [true]
+      end
+
+      should "be static" do
+        FPage.outputs.map(&:dynamic?).should == [false]
+      end
     end
 
-    should "have a default format of :html" do
-      FPage.default_format.should == :html
+    should "have tests for supported outputs" do
+      FPage.provides_output?(:html).should be_true
+      FPage.provides_output?(:rss).should be_false
     end
 
-    should "have tests for supported formats" do
-      FPage.provides_format?(:html).should be_true
-      FPage.provides_format?(:rss).should be_false
+    should "map an empty output onto the default one" do
+      FPage.provides_output?(nil).should be_true
     end
 
-    should "return the mime-type for a format" do
+    should "return the mime-type for a output" do
       FPage.mime_type(:html).should == "text/html"
       FPage.mime_type(:atom).should == "application/atom+xml"
     end
 
 
+    should "return the output class for a named output" do
+      FPage.output(:html).must_be_instance_of(Class)
+      FPage.output(:html).ancestors.include?(S::Output::HTML).should be_true
+    end
+
+    should "correctly determine mimetypes for new (known) formats" do
+      FPage.add_output :au
+      FPage.output(:au).mimetype.should == "audio/basic"
+    end
+
+    should "dynamically generate output classes for unknown formats" do
+      FPage.add_output :fish, :format => :unknown
+      FPage.output(:fish).ancestors[1].should == S::Output::UNKNOWN
+      FPage.output(:fish).ancestors[2].should == S::Output::Plain
+    end
+
+    should "dynamically generate output classes based on HTML for outputs with unspecified formats" do
+      FPage.add_output :fish
+      FPage.output(:fish).ancestors[1].should == S::Output::HTML
+    end
+
+    should "return the format wrapper for a format name string" do
+      FPage.output("html").should == FPage.output(:html)
+    end
+
+    should "give the default format for blank format names" do
+      html = FPage.output(:html)
+      FPage.output(nil).should == html
+      FPage.output.should == html
+    end
+
+    should "provide a symbol version of the output name" do
+      FPage.output(:html).to_sym.should == :html
+    end
+
+    should "provide the correct output extension for dynamic pages" do
+      FPage.output.extension(true).should == ".html.cut"
+      FPage.output.extension(true, "erb").should == ".html.erb"
+    end
+
+    should "override an existing output if the format is the same" do
+      FPage.add_output :rss
+      FPage.outputs.length.should == 2
+      FPage.outputs.map(&:format).should == [:html, :rss]
+      format = FPage.outputs.first.format
+      FPage.add_output format, :dynamic => true
+      FPage.outputs.length.should == 2
+      FPage.outputs.map(&:format).should == [:html, :rss]
+      FPage.output(format).dynamic?.should be_true
+    end
+
+    should "correctly set the format from the output name if it's recognised" do
+      FPage.add_output :pdf
+      FPage.output(:pdf).format.should == :pdf
+      FPage.output(:pdf).mimetype.should == "application/pdf"
+    end
+
+    should "default to a format of html for unknown output formats" do
+      FPage.outputs [:xyzz]
+      FPage.default_output.format.should == :html
+      FPage.output(:xyzz).format.should == :html
+      FPage.output(:xyzz).mimetype.should == "text/html"
+    end
+
+    should "allow the setting of a default format for an output" do
+      FPage.add_output :rss, :format => :html
+      FPage.output(:rss).format.should == :html
+      FPage.output(:rss).mimetype.should == "text/html"
+    end
+
+    should "allow for custom mimetypes" do
+      FPage.add_output :rss, :format => :html, :mimetype => "application/xhtml+xml"
+      FPage.output(:rss).format.should == :html
+      FPage.output(:rss).mimetype.should == "application/xhtml+xml"
+    end
+
+    should "allow for marking an output as 'private'" do
+      FPage.add_output :rss, :private => true
+      FPage.output(:rss).public?.should be_false
+      FPage.output(:rss).private?.should be_true
+    end
+
+    should "provide the correct output extension for static pages" do
+      FPage.output(:html).extension.should == ".html"
+    end
+
+    should "provide the correct output extension for static pages of non-html formats" do
+      FPage.add_output :pdf
+      FPage.output(:pdf).extension.should == ".pdf"
+    end
+
+    should "name the output according to the format" do
+      FPage.add_output :atom, :format => :html
+      FPage.output(:atom).extension.should == ".atom"
+    end
+
+    should "name the output using the configured extension" do
+      FPage.add_output :atom, :format => :html, :extension => "rss"
+      FPage.output(:atom).extension.should == ".rss"
+    end
+
+    should "allow for complex custom file extensions" do
+      FPage.add_output :rss, :extension => ".rss.xml.php"
+      FPage.output(:rss).extension.should == ".rss.xml.php"
+      FPage.output(:rss).extension(true).should == ".rss.xml.php"
+    end
+
+    # not sure I need this. The dynamic? flag is either set to always true in the output defn
+    # in which case you can use the :extension setting to just absolutely set the final output
+    # extension, or the rendered page is detected as dynamic by the templating system in which
+    # case it's most likely that the output language is the same as the templating system.
+    should "allow for setting a custom dynamic extension" do
+      FPage.add_output :fish, :format => :html, :dynamic => true, :language => "php"
+      FPage.output(:fish).extension.should == ".fish.php"
+      FPage.add_output :foul, :format => :html, :language => "php"
+      FPage.output(:foul).extension(true).should == ".foul.php"
+    end
+
+    # What would be more useful perhaps is a way to define a custom, per output, test for "dynamicness"
+    should "allow for a custom test for dynamicness"
+
+    should "override extension even for dynamic outputs" do
+      FPage.add_output :fish, :dynamic => true, :extension => "php"
+      FPage.output(:fish).extension(true).should == ".php"
+      FPage.add_output :foul, :dynamic => true, :extension => ".php"
+      FPage.output(:foul).extension(true).should == ".php"
+    end
+
+    context "format classes" do
+      should "enable new formats" do
+        S::Output.unknown_format?(:fishhtml).should be_true
+        class FishHTMLFormat < S::Output::HTML
+          provides_format :fishhtml
+        end
+        S::Output.unknown_format?(:fishhtml).should be_false
+      end
+
+      should "inherit helper classes from their superclass" do
+        module CustomHelper1
+          def here_is_my_custom_helper1; end
+        end
+        Site.register_helper CustomHelper1, :newhtml
+
+        class NewHTMLFormat < S::Output::HTML
+          provides_format :newhtml
+        end
+
+        FPage.add_output :newhtml
+        page = FPage.new
+        output = page.output(:newhtml)
+        newhtml_context = output.context
+        html_context_ancestors = page.output(:html).context.ancestors[1..-1]
+        Set.new(newhtml_context.ancestors[1..-1]).should == Set.new(html_context_ancestors + [CustomHelper1])
+      end
+    end
+
     context "instances" do
       setup do
+        FPage.add_output :pdf, :dynamic => true
         @page = FPage.new
       end
-      should "pass on their formats to instances" do
-        @page.formats.should == [:html]
-        @page.default_format.should == :html
-        @page.provides_format?(:html).should be_true
+
+      should "generate a list of output instances tied to the page" do
+        outputs = @page.outputs
+        outputs.map(&:class).should == [FPage.output(:html), FPage.output(:pdf)]
+      end
+
+      should "generate output instances tied to the page" do
+        @page.outputs.map(&:format).should == [:html, :pdf]
+        @page.default_output.format.should == :html
+
+        output = @page.output(:html)
+        output.must_be_instance_of FPage.output(:html)
+        output.page.should == @page
+        output.format.should == :html
+        output.dynamic?.should be_false
+        output.extension.should == ".html"
+
+        @page.output(:pdf).dynamic?.should be_true
+      end
+
+      should "provide a default output instance" do
+        output = @page.default_output
+        output.must_be_instance_of FPage.output(:html)
+      end
+
+      should "know that they provide a certain format" do
+        @page.provides_output?(:html).should be_true
+        @page.provides_output?(:pdf).should be_true
+        @page.provides_output?(:xyz).should be_false
+      end
+
+      should "provide a symbol version of the output name" do
+        @page.output(:html).to_sym.should == :html
+      end
+
+      should "return the output instance if used as an output request" do
+        output = @page.output(:html)
+        @page.output(output).should == output
       end
     end
 
     context "with custom formats" do
       setup do
-        FPage.formats :rss, :html, :json
+        FPage.outputs :rss, :html, :json
       end
 
       should "be able to define their supported formats" do
-        FPage.formats.should == [:rss, :html, :json]
+        FPage.outputs.map(&:format).should == [:rss, :html, :json]
       end
 
       should "re-define the default format" do
-        FPage.default_format.should == :rss
+        FPage.default_output.format.should == :rss
       end
 
       should "have tests for supported formats" do
-        FPage.provides_format?(:html).should be_true
-        FPage.provides_format?(:rss).should be_true
-        FPage.provides_format?(:json).should be_true
-        FPage.provides_format?(:xyz).should be_false
+        FPage.provides_output?(:html).should be_true
+        FPage.provides_output?(:rss).should be_true
+        FPage.provides_output?(:json).should be_true
+        FPage.provides_output?(:xyz).should be_false
       end
 
-      should "raise an error if trying to use an unknown format without specifying a mime-type" do
-        lambda { FPage.formats [:xyz] }.must_raise(Spontaneous::UnknownFormatException)
-      end
 
       should "accept new formats when accompanied by a mime-type" do
-        FPage.formats [{:xyz => "application/xyz"}]
+        FPage.outputs [:xyz, {:mimetype => "application/xyz"}]
       end
 
       should "allow addition of a single format" do
-        FPage.add_format :atom
-        FPage.formats.should == [:rss, :html, :json, :atom]
+        FPage.add_output :atom
+        FPage.outputs.map(&:format).should == [:rss, :html, :json, :atom]
+      end
+
+      should "allow custom post-processing of render" do
+        FPage.add_output :atom, :postprocess => lambda { |page, output| output.gsub(/a/, 'x') }
+        page = FPage.new
+        page.render(:atom).should =~ /<xtom>/
       end
     end
 
     context "with custom mime-types" do
       setup do
-        FPage.formats [ {:html => "application/xhtml+xml"}, {:js => "application/json"} ]
+        FPage.outputs [ :html, {:mimetype => "application/xhtml+xml"}], [:js, {:mimetype => "application/json"} ]
       end
 
       should "still provide the correct default format" do
-        FPage.default_format.should == :html
+        FPage.default_output.format.should == :html
+        FPage.default_output.name.should == :html
       end
 
-      should "return the custom mime-type for a format" do
+      should "return the custom mime-type for a output" do
         FPage.mime_type(:html).should == "application/xhtml+xml"
         FPage.mime_type(:js).should == "application/json"
         FPage.mime_type(:atom).should == "application/atom+xml"
@@ -100,9 +311,9 @@ class FormatsTest < MiniTest::Spec
         page.mime_type(:html).should == "application/xhtml+xml"
       end
 
-      should "allow addition of a single custom format" do
-        FPage.add_format :ddd => "application/ddd"
-        FPage.formats.should == [:html, :js, :ddd]
+      should "allow addition of a single custom output" do
+        FPage.add_output :ddd, :mimetype => "application/ddd"
+        FPage.outputs.map(&:format).should == [:html, :js, :ddd]
         page = FPage.new
         page.mime_type(:ddd).should == "application/ddd"
       end
@@ -110,7 +321,7 @@ class FormatsTest < MiniTest::Spec
 
     context "with subclasses" do
       setup do
-        FPage.formats :html, :rss, { :xxx => "application/xxx" }
+        FPage.outputs :html, :rss, [:xxx, { :mimetype => "application/xxx" }]
         class FSubPage < FPage
         end
       end
@@ -119,13 +330,35 @@ class FormatsTest < MiniTest::Spec
         self.class.send(:remove_const, :FSubPage) rescue nil
       end
 
-      should "inherit the list of provided formats" do
-        FSubPage.formats.should == FPage.formats
+      should "inherit the list of provided outputs" do
+        FSubPage.outputs.should == FPage.outputs
       end
+
       should "inherit any custom mimetypes" do
         FPage.mime_type(:xxx).should == "application/xxx"
         FSubPage.mime_type(:xxx).should == "application/xxx"
       end
     end
+
+    context "that generate dynamic outputs" do
+      should "be able to specify that a output is always dynamic" do
+        FPage.add_output :rss, :dynamic => true
+        FPage.output(:rss).dynamic?.should be_true
+      end
+
+      should "be able to specify that a output with custom mimetype is always dynamic" do
+        FPage.add_output :mako, :mimetype => "application/x-mako", :dynamic => true
+        FPage.output(:mako).mime_type.should == "application/x-mako"
+        FPage.output(:mako).dynamic?.should be_true
+      end
+
+      should "be able to override the default dynamic extension" do
+        FPage.add_output :html, :dynamic => true, :language => "mako"
+        FPage.add_output :alternate, :mimetype => "text/html", :dynamic => true, :language => "mako"
+        FPage.output(:html).dynamic?.should be_true
+        FPage.output(:html).extension.should == ".html.mako"
+        FPage.output(:alternate).extension.should == ".alternate.mako"
+      end
+    end
   end
 end

data/test/unit/test_helpers.rb

@@ -4,9 +4,80 @@ require File.expand_path('../../test_helper', __FILE__)
 
 class HelpersTest < MiniTest::Spec
 
-  context "HTML helper" do
+  def setup
+    @site = setup_site
+    @site.paths.add :templates, File.expand_path("../../fixtures/helpers/templates", __FILE__)
+    @renderer = S::Output::Template::Renderer.new(false)
+    S::Output.renderer = @renderer
+
+  end
+
+  def teardown
+    teardown_site
+  end
+
+  context "Helpers" do
+    should "be assignable to a particular format" do
+      CustomHelper1 = Site.helper :html do
+        def here_is_my_custom_helper1; end
+      end
+
+      included_helpers = [
+        CustomHelper1,
+        Spontaneous::Output::Helpers::ConditionalCommentHelper,
+        Spontaneous::Output::Helpers::ClassesHelper,
+        Spontaneous::Output::Helpers::ScriptHelper,
+        Spontaneous::Output::Helpers::StylesheetHelper
+      ]
+      helper_module = Site.context :html
+      join = included_helpers & helper_module.ancestors
+      Set.new(join).should == Set.new(included_helpers)
+      helper_module.respond_to?(:here_is_my_custom_helper1).should be_true
+    end
+
+    should "be assigned to all formats if none given" do
+      CustomHelper2 = Site.helper do
+        extend self
+        def here_is_my_custom_helper2; end
+      end
+
+      assert CustomHelper2.respond_to?(:here_is_my_custom_helper2)
+
+      helper_module = Site.context :html
+      helper_module.ancestors.include?(CustomHelper2).should be_true
+
+      helper_module = Site.context :pdf
+      helper_module.ancestors.include?(CustomHelper2).should be_true
+    end
+
+    should "be available during the render step" do
+      class Page < Spontaneous::Page
+        add_output :mobile
+      end
+
+      Site.helper :html do
+        def here_is_my_custom_helper3
+          "here_is_my_custom_helper3"
+        end
+        extend self
+      end
+
+      Site.helper :mobile do
+        def here_is_my_custom_helper4
+          "here_is_my_custom_helper4"
+        end
+        extend self
+      end
+
+      page = Page.new
+      page.render(:html).should == "<here_is_my_custom_helper3>\n"
+      page.render(:mobile).should == "<here_is_my_custom_helper4>\n"
+    end
+  end
+
+  context "Classes helper" do
     setup do
-      @helper = Spontaneous::Render::Helpers::HTMLHelper
+      @helper = Spontaneous::Output::Helpers::ClassesHelper
     end
     should "enable easy addition of classes" do
       classes = @helper.classes("a", "b", "c", :active => false, :invisible => true)
@@ -28,6 +99,12 @@ class HelpersTest < MiniTest::Spec
       classes = @helper.classes("a b c", :active => false, :invisible => true)
       classes.should == %(class="a b c invisible")
     end
+  end
+
+  context "ConditionalComment helper" do
+    setup do
+      @helper = Spontaneous::Output::Helpers::ConditionalCommentHelper
+    end
 
     should "provide a wrapper around IE conditional comments" do
       @helper.ie_only.should == "<!--[if IE]>"

data/test/unit/test_images.rb

@@ -55,6 +55,7 @@ class ImagesTest < MiniTest::Spec
       class ::ResizingImageField < FieldTypes::ImageField
         size :preview do
           width 200
+          optimize!
         end
         size :tall do
           height 200
@@ -113,6 +114,15 @@ class ImagesTest < MiniTest::Spec
         @image.reformatted.src.should =~ /\.png$/
       end
     end
+
+    context "with optimization xxx" do
+      should "run jpegoptim" do
+        Spontaneous.expects(:system).with(regexp_matches(/jpegoptim/)).at_least_once
+        Spontaneous.expects(:system).with(regexp_matches(/jpegtran/)).at_least_once
+        @image.value = @origin_image.to_s
+      end
+    end
+
     context "in templates" do
 
       should "render an <img/> tag in HTML format" do

data/test/unit/test_layouts.rb

@@ -5,9 +5,9 @@ require File.expand_path('../../test_helper', __FILE__)
 class LayoutsTest < MiniTest::Spec
 
   def setup
-    Spontaneous::Render.use_development_renderer
-    self.template_root = ::File.expand_path('../../fixtures/layouts', __FILE__)
+    @template_root = ::File.expand_path('../../fixtures/layouts', __FILE__)
     @site = setup_site
+    @site.paths.add(:templates, @template_root)
   end
 
   def teardown
@@ -37,7 +37,7 @@ class LayoutsTest < MiniTest::Spec
       end
       should "default to layouts/standard.html... if nothing defined" do
         page = LayoutPage.new
-        assert_correct_template(page, 'layouts/standard')
+        assert_correct_template(page, @template_root / 'layouts/standard')
         page.render.should == "layouts/standard.html.cut\n"
       end
 
@@ -45,14 +45,14 @@ class LayoutsTest < MiniTest::Spec
         LayoutPage.layout :custom1
         LayoutPage.layout :custom2
         page = LayoutPage.new
-        assert_correct_template(page, 'layouts/custom1')
+        assert_correct_template(page, @template_root / 'layouts/custom1')
         page.render.should == "layouts/custom1.html.cut\n"
       end
       should "return the layout declared default" do
         LayoutPage.layout :custom1
         LayoutPage.layout :custom2, :default => true
         page = LayoutPage.new
-        assert_correct_template(page, 'layouts/custom2')
+        assert_correct_template(page, @template_root / 'layouts/custom2')
         page.render.should == "layouts/custom2.html.cut\n"
       end
 
@@ -60,7 +60,7 @@ class LayoutsTest < MiniTest::Spec
         LayoutPage.layout :custom1
         LayoutPage.layout :custom2, :default => true
         page = SubPage.new
-        assert_correct_template(page, 'layouts/custom2')
+        assert_correct_template(page, @template_root / 'layouts/custom2')
       end
 
       should "be able to overwrite inherited templates from superclass" do
@@ -69,17 +69,17 @@ class LayoutsTest < MiniTest::Spec
         SubPage.layout :custom3
         page = SubPage.new
         # page.layout.template.should == 'layouts/custom2'
-        assert_correct_template(page, 'layouts/custom2')
+        assert_correct_template(page, @template_root / 'layouts/custom2')
       end
 
       should "allow setting of style used" do
         LayoutPage.layout :custom1
         LayoutPage.layout :custom2
         page = LayoutPage.new
-        assert_correct_template(page, 'layouts/custom1')
+        assert_correct_template(page, @template_root / 'layouts/custom1')
         # page.layout.template.should == 'layouts/custom1'
         page.layout = :custom2
-        assert_correct_template(page, 'layouts/custom2')
+        assert_correct_template(page, @template_root / 'layouts/custom2')
         # page.layout.template.should == 'layouts/custom2'
       end
 
@@ -89,9 +89,9 @@ class LayoutsTest < MiniTest::Spec
         SubPage.layout :custom3
         SubPage.layout :custom4
         page = SubPage.new
-        assert_correct_template(page, 'layouts/custom3')
+        assert_correct_template(page, @template_root / 'layouts/custom3')
         page.layout = :custom2
-        assert_correct_template(page, 'layouts/custom2')
+        assert_correct_template(page, @template_root / 'layouts/custom2')
       end
 
       should "allow defining of default layout in sub-classes" do
@@ -100,11 +100,19 @@ class LayoutsTest < MiniTest::Spec
         SubPage.layout :custom3
         SubPage.layout :custom4, :default => true
         page = SubPage.new
-        assert_correct_template(page, 'layouts/custom4')
+        assert_correct_template(page, @template_root / 'layouts/custom4')
         page.layout = :custom3
-        assert_correct_template(page, 'layouts/custom3')
+        assert_correct_template(page, @template_root / 'layouts/custom3')
       end
 
+      should "support blocks to set simple templates" do
+        LayoutPage.field :title
+        LayoutPage.layout do
+          "${ title }!"
+        end
+        page = LayoutPage.new(:title => "john")
+        page.render.should == "john!"
+      end
       # should "raise error when setting unknown layout" do
       #   LayoutPage.layout :custom1
       #   LayoutPage.layout :custom2