spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/test/unit/test_styles.rb

@@ -5,24 +5,16 @@ require File.expand_path('../../test_helper', __FILE__)
 
 class StylesTest < MiniTest::Spec
 
-
-  # context "template root" do
-  #   should "be settable" do
-  #     File.exists?(template_root).should be_true
-  #     Spontaneous.template_root = template_root
-  #     Spontaneous.template_root.should == template_root
-  #   end
-  # end
-
-
   def teardown
     teardown_site
   end
 
   def setup
     @site = setup_site
-    self.template_root = File.expand_path(File.join(File.dirname(__FILE__), "../fixtures/styles"))
-    Spontaneous::Render.use_development_renderer
+    @template_root = File.expand_path(File.join(File.dirname(__FILE__), "../fixtures/styles"))
+    @site.paths.add(:templates, @template_root)
+    @renderer = S::Output::Template::PreviewRenderer.new
+    S::Output.renderer = @renderer
   end
 
   context "styles for" do
@@ -33,6 +25,8 @@ class StylesTest < MiniTest::Spec
       class ::Piece < Spontaneous::Piece; end
       class ::Box < Spontaneous::Box; end
 
+      ::Page.box :box1
+
       class ::MissingClass < Piece; end
       class ::TemplateClass < Piece; end
       class ::TemplateSubClass1 < TemplateClass; end
@@ -41,6 +35,7 @@ class StylesTest < MiniTest::Spec
     end
 
     teardown do
+      Object.send(:remove_const, :Page)
       Object.send(:remove_const, :MissingClass)
       Object.send(:remove_const, :TemplateClass)
       Object.send(:remove_const, :TemplateSubClass1)
@@ -52,7 +47,9 @@ class StylesTest < MiniTest::Spec
 
       context "default styles" do
         setup do
+          @page  = ::Page.new
           @piece = TemplateClass.new
+          @page.box1 << @piece
         end
 
         should "return anonymous style if no templates are found" do
@@ -63,7 +60,7 @@ class StylesTest < MiniTest::Spec
         end
 
         should "derive path from owning class and name" do
-          assert_correct_template(@piece, 'template_class')
+          assert_correct_template(@piece, @template_root / 'template_class')
         end
 
         should "render using correct template" do
@@ -77,41 +74,44 @@ class StylesTest < MiniTest::Spec
 
         should "simply render an empty string if no templates are available" do
           piece = InvisibleClass.new
+          @page.box1 << piece
           piece.render.should == ""
         end
       end
 
 
       context "named styles" do
+        setup do
+          @page  = ::Page.new
+          @piece = TemplateClass.new
+          @page.box1 << @piece
+        end
+
         should "use template found in class directory if exists" do
           TemplateClass.style :named1
-          piece = TemplateClass.new
-          assert_correct_template(piece, 'template_class/named1')
-          piece.render.should == "template_class/named1.html.cut\n"
+          assert_correct_template(@piece, @template_root / 'template_class/named1')
+          @piece.render.should == "template_class/named1.html.cut\n"
         end
 
         should "use template in template root with correct name if it exists" do
           TemplateClass.style :named2
-          piece = TemplateClass.new
-          assert_correct_template(piece, 'named2')
-          piece.render.should == "named2.html.cut\n"
+          assert_correct_template(@piece, @template_root / 'named2')
+          @piece.render.should == "named2.html.cut\n"
         end
 
         should "allow passing of directory/stylename" do
           TemplateClass.style :'orange/apple'
-          piece = TemplateClass.new
           # piece.style.template.should == 'orange/apple'
-          assert_correct_template(piece, 'orange/apple')
-          piece.render.should == "orange/apple.html.cut\n"
+          assert_correct_template(@piece, @template_root / 'orange/apple')
+          @piece.render.should == "orange/apple.html.cut\n"
         end
 
         should "default to styles marked as 'default'" do
           TemplateClass.style :named1
           TemplateClass.style :named2, :default => true
-          piece = TemplateClass.new
-          assert_correct_template(piece, 'named2')
-          # piece.style.template.should == 'named2'
-          piece.render.should == "named2.html.cut\n"
+          assert_correct_template(@piece, @template_root / 'named2')
+          # @piece.style.template.should == 'named2'
+          @piece.render.should == "named2.html.cut\n"
         end
       end
 
@@ -119,16 +119,17 @@ class StylesTest < MiniTest::Spec
         setup do
           TemplateClass.style :named1
           TemplateClass.style :named2, :default => true
+          @page  = ::Page.new
           @piece = TemplateClass.new
-          assert_correct_template(@piece, 'named2')
+          @page.box1 << @piece
+          assert_correct_template(@piece, @template_root / 'named2')
           # @piece.style.template.should == 'named2'
           @piece.render.should == "named2.html.cut\n"
         end
 
         should "be possible" do
           @piece.style = :named1
-          # @piece.style.template.should == 'template_class/named1'
-          assert_correct_template(@piece, 'template_class/named1')
+          assert_correct_template(@piece, @template_root / 'template_class/named1')
           @piece.render.should == "template_class/named1.html.cut\n"
         end
 
@@ -137,26 +138,26 @@ class StylesTest < MiniTest::Spec
           @piece.save
           @piece = Content[@piece.id]
           # @piece.style.template.should == 'template_class/named1'
-          assert_correct_template(@piece, 'template_class/named1')
+          assert_correct_template(@piece, @template_root / 'template_class/named1')
         end
       end
 
       context "inheriting styles" do
         should "use default for sub class if it exists" do
           piece = TemplateSubClass1.new
-          assert_correct_template(piece, 'template_sub_class1')
+          assert_correct_template(piece, @template_root / 'template_sub_class1')
         end
 
         should "fall back to default style for superclass if default for class doesn't exist" do
           piece = TemplateSubClass2.new
-          assert_correct_template(piece, 'template_class')
+          assert_correct_template(piece, @template_root / 'template_class')
           # piece.style.template.should == 'template_class'
         end
         should "fall back to defined default style for superclass if default for class doesn't exist" do
           TemplateClass.style :named1
           piece = TemplateSubClass2.new
           # piece.style.template.should == 'template_class/named1'
-          assert_correct_template(piece, 'template_class/named1')
+          assert_correct_template(piece, @template_root / 'template_class/named1')
         end
       end
 
@@ -270,14 +271,17 @@ class StylesTest < MiniTest::Spec
 
       context "inline templates" do
         setup do
-          class ::InlineTemplateClass < Content
+          Page.add_output :pdf
+          class ::InlineTemplateClass < Piece
             field :title
 
             template 'html: {{title}}'
             template :pdf, 'pdf: {{title}}'
           end
 
+          @page = ::Page.new
           @a = InlineTemplateClass.new
+          @page.box1 << @a
           @a.title = "Total Title"
         end
 
@@ -289,7 +293,7 @@ class StylesTest < MiniTest::Spec
           @a.render.should ==  "html: Total Title"
         end
 
-        should "be used to render the content with the right format" do
+        should "be used to render the content with the right format xxx" do
           @a.render(:pdf).should ==  "pdf: Total Title"
         end
       end
@@ -353,21 +357,22 @@ class StylesTest < MiniTest::Spec
         setup do
           TemplateClass.box :results
           TemplateClass.box :entities
+          @page  = ::Page.new
+          @piece = TemplateClass.new
+          @page.box1 << @piece
         end
 
         should "use template with their name inside container class template dir if it exists" do
-          piece = TemplateClass.new
-          piece.results << TemplateClass.new
-          assert_correct_template(piece.results, 'template_class/results')
-          piece.results.render.should == "template_class/results.html.cut\n"
+          @piece.results << TemplateClass.new
+          assert_correct_template(@piece.results, @template_root / 'template_class/results')
+          @piece.results.render.should == "template_class/results.html.cut\n"
         end
 
         should "render a simple list of content if named template doesn't exist" do
-          piece = TemplateClass.new
-          piece.entities << TemplateClass.new
-          piece.entities << TemplateClass.new
-          piece.entities.render.should == "template_class.html.cut\n\ntemplate_class.html.cut\n"
-          piece.entities.style.template.call.should == '#{ render_content }'
+          @piece.entities << TemplateClass.new
+          @piece.entities << TemplateClass.new
+          @piece.entities.render.should == "template_class.html.cut\n\ntemplate_class.html.cut\n"
+          @piece.entities.style.template.call.should == '#{ render_content }'
         end
 
 
@@ -375,21 +380,21 @@ class StylesTest < MiniTest::Spec
           TemplateClass.box :things do
             style :named1
           end
-          piece = TemplateClass.new
-          assert_correct_template(piece.things, 'template_class/named1')
-          piece.things.render.should == "template_class/named1.html.cut\n"
+          @piece = TemplateClass.new
+          @page.box1 << @piece
+          assert_correct_template(@piece.things, @template_root / 'template_class/named1')
+          @piece.things.render.should == "template_class/named1.html.cut\n"
 
           TemplateClass.box :dongles do
             style :named2
           end
-          piece = TemplateClass.new
-          assert_correct_template(piece.dongles, 'named2')
-          piece.dongles.render.should == "named2.html.cut\n"
+          @piece = TemplateClass.new
+          @page.box1 << @piece
+          assert_correct_template(@piece.dongles, @template_root / 'named2')
+          @piece.dongles.render.should == "named2.html.cut\n"
         end
 
         should "use styles assigned in a subclass" do
-          saved_template_root = self.template_root
-          self.template_root = Spontaneous.template_root
           ::TemplateSubClass = Class.new(TemplateClass)
           ::TemplateSubSubClass = Class.new(TemplateSubClass)
 
@@ -399,30 +404,36 @@ class StylesTest < MiniTest::Spec
             style :oranges
           end
 
-          # FileUtils.mkdir_p(Spontaneous.template_root)
+          Dir.mktmpdir do |template_root|
+            @site.paths.add(:templates, template_root / "templates")
+
+
+            piece = TemplateSubSubClass.new
+            @page.box1 << piece
 
-          piece = TemplateSubSubClass.new
-          assert Proc === piece.bananas.template
+            # make sure we're running in a 'virgin' template dir
+            assert Proc === piece.bananas.template, "Expected Proc not #{piece.bananas.template}"
 
-          [[piece.bananas, %w(template_sub_sub_class/bananas template_sub_class/bananas)],
-           [piece.apples, %w(template_sub_sub_class/apples template_sub_class/apples apples)],
-           [piece.oranges, %w(template_sub_sub_class/oranges template_sub_class/oranges oranges)]
-          ].each do |box, test_templates|
-            test_templates.each do |test_template|
-              FileUtils.mkdir_p(File.dirname(Spontaneous.template_root(test_template)))
-              FileUtils.touch(Spontaneous.template_root(test_template) + '.html.cut')
 
-              assert_correct_template(box, test_template)
+            [[piece.bananas, %w(template_sub_sub_class/bananas template_sub_class/bananas)],
+             [piece.apples, %w(template_sub_sub_class/apples template_sub_class/apples apples)],
+             [piece.oranges, %w(template_sub_sub_class/oranges template_sub_class/oranges oranges)]
+            ].each do |box, test_templates|
+              test_templates.each do |test_template|
+                path = template_root / "templates" / test_template
+                FileUtils.mkdir_p(File.dirname(path))
+                FileUtils.touch(path + '.html.cut')
 
-              FileUtils.rm_r(::File.dirname(Spontaneous.template_root(test_template)))
+                assert_correct_template(box, template_root / "templates" / test_template)
+
+                FileUtils.rm_r(template_root / "templates")
+              end
             end
           end
 
 
           Object.send(:remove_const, :TemplateSubClass)
           Object.send(:remove_const, :TemplateSubSubClass)
-          FileUtils.rm_r(Spontaneous.template_root) rescue nil
-          self.template_root = saved_template_root
         end
       end
 
@@ -430,18 +441,19 @@ class StylesTest < MiniTest::Spec
         setup do
           TemplateClass.box :entities, :type => :BoxA
           TemplateClass.box :results, :type => :BoxB
+          @page  = ::Page.new
+          @piece = TemplateClass.new
+          @page.box1 << @piece
         end
 
         should "use the box name template if it exists" do
-          piece = TemplateClass.new
-          assert_correct_template(piece.results, 'template_class/results')
-          piece.results.render.should == "template_class/results.html.cut\n"
+          assert_correct_template(@piece.results, @template_root / 'template_class/results')
+          @piece.results.render.should == "template_class/results.html.cut\n"
         end
 
         should "use the box classes default template if box name template is missing" do
-          piece = TemplateClass.new
-          assert_correct_template(piece.entities, 'box_a')
-          piece.entities.render.should == "box_a.html.cut\n"
+          assert_correct_template(@piece.entities, @template_root / 'box_a')
+          @piece.entities.render.should == "box_a.html.cut\n"
         end
 
         should "find templates for box subclasses with specified types defined in a supertype" do
@@ -452,7 +464,8 @@ class StylesTest < MiniTest::Spec
           class ::TemplateSubClass < TemplateClass
           end
           piece = TemplateSubClass.new
-          assert_correct_template(piece.lastly, 'box_a')
+          @page.box1 << piece
+          assert_correct_template(piece.lastly, @template_root / 'box_a')
           Object.send(:remove_const, :BoxASubclass)
           Object.send(:remove_const, :TemplateSubClass)
         end
@@ -466,9 +479,11 @@ class StylesTest < MiniTest::Spec
           should "be configurable to use a specific style" do
             TemplateClass.box :sprinters, :type => :BoxA, :style => :runny
             TemplateClass.box :strollers, :type => :BoxA, :style => :walky
+            page = ::Page.new
             piece = TemplateClass.new
-            assert_correct_template(piece.strollers, 'template_class/walky')
-            assert_correct_template(piece.sprinters, 'box_a/runny')
+            page.box1 << piece
+            assert_correct_template(piece.strollers, @template_root / 'template_class/walky')
+            assert_correct_template(piece.sprinters, @template_root / 'box_a/runny')
           end
         end
       end

data/test/unit/test_table_scoping.rb

@@ -12,24 +12,28 @@ class TableScopingTest < MiniTest::Spec
     teardown_site
   end
 
+  def ident(ident)
+    Spontaneous.database.dataset.quote_identifier(ident)
+  end
+
   context "Tablename scoping" do
     should "correctly change the table name within a scope" do
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
       Content.with_table("new_content_table") do
-        Content.dataset.sql.should == "SELECT * FROM `new_content_table`"
+        Content.dataset.sql.should == "SELECT * FROM #{ident "new_content_table"}"
       end
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
     end
 
     should "allow the nesting of scopes" do
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
       Content.with_table("content_1") do
         Content.with_table("content_2") do
-          Content.dataset.sql.should == "SELECT * FROM `content_2`"
+          Content.dataset.sql.should == "SELECT * FROM #{ident "content_2"}"
         end
-        Content.dataset.sql.should == "SELECT * FROM `content_1`"
+        Content.dataset.sql.should == "SELECT * FROM #{ident "content_1"}"
       end
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
     end
 
     should "preserve single table inheritance" do
@@ -49,28 +53,28 @@ class TableScopingTest < MiniTest::Spec
     end
 
     should "restore original state if an exception is raised" do
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
       begin
         Content.with_table("new_content_table") do
-          Content.dataset.sql.should == "SELECT * FROM `new_content_table`"
+          Content.dataset.sql.should == "SELECT * FROM #{ident "new_content_table"}"
           raise "havoc"
         end
       rescue; end
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
     end
 
     should "Be able to handle scoping multiple models at once" do
-      Spontaneous::Change.plugin :scoped_table_name
-      Content.dataset.sql.should == "SELECT * FROM `content`"
+      Spontaneous::State.plugin :scoped_table_name
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
       Content.with_table("content_1") do
-        Change.with_table("change_1") do
-          Content.dataset.sql.should == "SELECT * FROM `content_1`"
-          Change.dataset.sql.should == "SELECT * FROM `change_1`"
+        State.with_table("state_1") do
+          Content.dataset.sql.should == "SELECT * FROM #{ident "content_1"}"
+          State.dataset.sql.should == "SELECT * FROM #{ident "state_1"}"
         end
       end
 
-      Content.dataset.sql.should == "SELECT * FROM `content`"
-      Change.dataset.sql.should == "SELECT * FROM `changes`"
+      Content.dataset.sql.should == "SELECT * FROM #{ident "content"}"
+      State.dataset.sql.should == "SELECT * FROM #{ident "spontaneous_state"}"
     end
   end
 end