spontaneous 0.1.0.alpha1

data/test/unit/test_styles.rb

@@ -0,0 +1,417 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+
+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 setup
+    self.template_root = File.expand_path(File.join(File.dirname(__FILE__), "../fixtures/styles"))
+    Spontaneous::Render.use_development_renderer
+  end
+
+  context "styles for" do
+
+    setup do
+      Spot::Schema.reset!
+      class ::MissingClass < Piece; end
+      class ::TemplateClass < Piece; end
+      class ::TemplateSubClass1 < TemplateClass; end
+      class ::TemplateSubClass2 < TemplateClass; end
+      class ::InvisibleClass < Piece; end
+    end
+
+    teardown do
+      Object.send(:remove_const, :MissingClass)
+      Object.send(:remove_const, :TemplateClass)
+      Object.send(:remove_const, :TemplateSubClass1)
+      Object.send(:remove_const, :TemplateSubClass2)
+    end
+
+    context "pieces" do
+
+
+      context "default styles" do
+        setup do
+          @piece = TemplateClass.new
+        end
+
+        should "return anonymous style if no templates are found" do
+          piece = MissingClass.new
+          piece.style.class.should == Spontaneous::Style::Default
+          # piece.style.template.must_be_instance_of(Proc)
+          piece.style.template.call.should == ""
+        end
+
+        should "derive path from owning class and name" do
+          assert_correct_template(@piece, 'template_class')
+        end
+
+        should "render using correct template" do
+          @piece.render.should == "template_class.html.cut\n"
+        end
+
+        # should "be able to give a list of available formats" do
+        #   skip("Need to re-implement the format functionality")
+        #   @piece.style.formats.should == [:epub, :html, :pdf]
+        # end
+
+        should "simply render an empty string if no templates are available" do
+          piece = InvisibleClass.new
+          piece.render.should == ""
+        end
+      end
+
+
+      context "named styles" do
+        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"
+        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"
+        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"
+        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"
+        end
+      end
+
+      context "switching styles" do
+        setup 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"
+        end
+
+        should "be possible" do
+          @piece.style = :named1
+          # @piece.style.template.should == 'template_class/named1'
+          assert_correct_template(@piece, 'template_class/named1')
+          @piece.render.should == "template_class/named1.html.cut\n"
+        end
+
+        should "persist" do
+          @piece.style = :named1
+          @piece.save
+          @piece = Content[@piece.id]
+          # @piece.style.template.should == 'template_class/named1'
+          assert_correct_template(@piece, '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')
+        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')
+          # 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')
+        end
+      end
+
+
+
+
+      # context "inline templates" do
+      #   setup do
+      #     @class = Class.new(Content)
+      #   end
+      #   should "be definiable" do
+      #     @class.style :simple
+      #     @class.styles.length.should == 1
+      #     t = @class.styles.first
+      #     t.name.should == :simple
+      #   end
+
+      #   should "have configurable filenames" do
+      #     @class.style :simple, :filename => "funky"
+      #     t = @class.styles.first
+      #     t.filename.should == "funky.html.cut"
+      #   end
+
+      #   should "have sane default titles" do
+      #     @class.style :simple_style
+      #     t = @class.styles.first
+      #     t.title.should == "Simple Style"
+      #   end
+
+      #   should "have configurable titles" do
+      #     @class.style :simple, :title => "A Simple Style"
+      #     t = @class.styles.first
+      #     t.title.should == "A Simple Style"
+      #   end
+
+      #   should "be accessable by name" do
+      #     @class.style :simple
+      #     @class.style :complex
+      #     @class.styles[:simple].should == @class.styles.first
+      #   end
+
+      #   should "have #styles as a shortcut for #inliine_styles" do
+      #     @class.style :simple
+      #     @class.styles.should == @class.styles
+      #   end
+
+      #   should "take the first style as the default" do
+      #     @class.style :simple
+      #     @class.style :complex
+      #     @class.styles.default.should == @class.styles[:simple]
+      #   end
+
+      #   should "honour the :default flag" do
+      #     @class.style :simple
+      #     @class.style :complex, :default => true
+      #     @class.styles.default.should == @class.styles[:complex]
+      #   end
+      # end
+
+      # context "assigned styles" do
+      #   setup do
+      #     class ::StyleTestClass < Content
+      #       style :first_style
+      #       style :default_style, :default => true
+      #     end
+
+      #     @a = StyleTestClass.new
+      #     @b = StyleTestClass.new
+      #     @a << @b
+      #   end
+
+      #   teardown do
+      #     Object.send(:remove_const, :StyleTestClass)
+      #   end
+
+      #   should "assign the default style" do
+      #     @a.pieces.first.style.should == ::StyleTestClass.styles.default
+      #   end
+
+      #   should "persist" do
+      #     @a.save
+      #     @b.save
+      #     @a = StyleTestClass[@a.id]
+      #     @a.pieces.first.style.should == ::StyleTestClass.styles.default
+      #   end
+
+      #   should "be settable" do
+      #     @a.pieces.first.style = StyleTestClass.styles[:first_style]
+      #     @a.save
+      #     @a = StyleTestClass[@a.id]
+      #     @a.pieces.first.style.should == ::StyleTestClass.styles[:first_style]
+      #   end
+
+      #   context "direct piece access" do
+      #     setup do
+      #       @a.pieces.first.style = StyleTestClass.styles[:first_style]
+      #       @a.save
+      #       piece_id = @a.pieces.first.target.id
+      #       @piece = StyleTestClass[piece_id]
+      #     end
+
+      #     should "be accessible directly for pieces" do
+      #       @piece.style.should == ::StyleTestClass.styles[:first_style]
+      #     end
+
+      #     should "not be settable directly on bare pieces" do
+      #       lambda { @piece.style = ::StyleTestClass.styles.default }.must_raise(NoMethodError)
+      #     end
+      #   end
+      # end
+
+      context "inline templates" do
+        setup do
+          class ::InlineTemplateClass < Content
+            field :title
+
+            template 'html: {{title}}'
+            template :pdf, 'pdf: {{title}}'
+          end
+
+          @a = InlineTemplateClass.new
+          @a.title = "Total Title"
+        end
+
+        teardown do
+          Object.send(:remove_const, :InlineTemplateClass)
+        end
+
+        should "be used to render the content" do
+          @a.render.should ==  "html: Total Title"
+        end
+
+        should "be used to render the content with the right format" do
+          @a.render(:pdf).should ==  "pdf: Total Title"
+        end
+      end
+
+      # context "default styles" do
+      #   class ::DefaultStyleClass < Spontaneous::Box
+      #     field :title
+      #   end
+
+      #   class ::WithDefaultStyleClass < Content
+      #     field :title
+      #   end
+      #   class ::WithoutDefaultStyleClass < Content
+      #     field :title
+      #     box :with_style, :type => :DefaultStyleClass
+      #   end
+      #   setup do
+      #     Content.delete
+
+      #     @with_default_style = WithDefaultStyleClass.new
+      #     @with_default_style.title = "Total Title"
+      #     @without_default_style = WithoutDefaultStyleClass.new
+      #     @without_default_style.title = "No Title"
+      #     @without_default_style.with_style.title = "Box Title"
+      #     # @without_default_style.with_style.path = "Box Title"
+      #   end
+
+      #   teardown do
+      #     Content.delete
+      #     # Object.send(:remove_const, :DefaultStyleClass)
+      #     # Object.send(:remove_const, :WithDefaultStyleClass)
+      #     # Object.send(:remove_const, :WithoutDefaultStyleClass)
+      #   end
+
+      #   should "be used when available" do
+      #     @with_default_style.render.should == "Title: Total Title\\n"
+      #   end
+
+      #   should "be used by boxes too" do
+      #     @without_default_style.with_style.render.should == "Title: Box Title\\n"
+      #   end
+
+      #   should "fallback to anonymous style when default style template doesn't exist" do
+      #     @without_default_style.render.should == "Title: Box Title\\n"
+      #   end
+      # end
+    end
+
+    context "boxes" do
+      setup do
+        class ::BoxA < Spontaneous::Box; end
+        class ::BoxB < Spontaneous::Box; end
+      end
+
+      teardown do
+        Object.send(:remove_const, :BoxA)
+        Object.send(:remove_const, :BoxB)
+      end
+
+      context "anonymous boxes" do
+        setup do
+          TemplateClass.box :results
+          TemplateClass.box :entities
+        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"
+        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 }}"
+        end
+
+
+        should "use a named template if given" do
+          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"
+
+          TemplateClass.box :dongles do
+            style :named2
+          end
+          piece = TemplateClass.new
+          assert_correct_template(piece.dongles, 'named2')
+          piece.dongles.render.should == "named2.html.cut\n"
+        end
+      end
+
+      context "boxes with a specified class" do
+        setup do
+          TemplateClass.box :entities, :type => :BoxA
+          TemplateClass.box :results, :type => :BoxB
+        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"
+        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"
+        end
+
+        context "with configured styles" do
+          setup do
+            BoxA.style :runny
+            BoxA.style :walky
+          end
+
+          should "be configurable to use a specific style" do
+            TemplateClass.box :sprinters, :type => :BoxA, :style => :runny
+            TemplateClass.box :strollers, :type => :BoxA, :style => :walky
+            piece = TemplateClass.new
+            assert_correct_template(piece.strollers, 'template_class/walky')
+            assert_correct_template(piece.sprinters, 'box_a/runny')
+          end
+        end
+      end
+    end
+  end
+end
+

data/test/unit/test_templates.rb

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+
+class TemplatesTest < MiniTest::Spec
+  def first_pass(base_dir, filename, context=nil)
+    render_with_renderer(Cutaneous::FirstPassRenderer, base_dir, filename, context)
+  end
+
+  def second_pass(base_dir, filename, context=nil)
+    render_with_renderer(Cutaneous::SecondPassRenderer, base_dir, filename, context)
+  end
+
+  def render_with_renderer(renderer_class, base_dir, filename, context = nil)
+    context ||= @context
+    renderer = renderer_class.new(make_template_root(base_dir))
+    path = template_root / filename
+    renderer.render(path, context)
+  end
+
+  def make_template_root(base_dir)
+    @template_root = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/templates', base_dir))
+    self.template_root = @template_root
+    @template_root
+  end
+
+  def setup
+    @klass = Class.new(Object) do
+      include Cutaneous::ContextHelper
+
+      def escape(val)
+        CGI.escapeHTML(val)
+      end
+      def title
+        "THE TITLE"
+      end
+
+      def unsafe
+        "<script>alert('bad')</script>"
+      end
+
+      def bell
+        'ding'
+      end
+    end
+    @context = @klass.new(nil, :html)
+  end
+
+  context "First render" do
+    setup do
+      @template = Cutaneous::FirstPassParser.new
+    end
+
+    should "ignore second level statements" do
+      input = '<html><title>#{title}</title>#{unsafe}</html>'
+      @template.convert(input)
+      output = @template.render(@context)
+      output.should ==  '<html><title>#{title}</title>#{unsafe}</html>'
+    end
+
+    should "evaluate first level expressions" do
+      @template.convert('<html><title>{{title}}</title>#{unsafe}</html>')
+      output = @template.render(@context)
+      output.should == '<html><title>THE TITLE</title>#{unsafe}</html>'
+    end
+
+    should "evaluate first level statements" do
+      @template.convert("<html><title>{{title}}</title>{% 2.times do %}\#{unsafe}{% end %}</html>")
+      output = @template.render(@context)
+      output.should == '<html><title>THE TITLE</title>#{unsafe}#{unsafe}</html>'
+    end
+
+    should "generate 2nd render templates" do
+      @template.convert("<html><title>{{title}}</title>{% 2.times do %}\#{bell}\n{% end %}</html>")
+      output = @template.render(@context)
+      second = Cutaneous::SecondPassParser.new
+      second.convert(output)
+      output = second.render(@context)
+      output.should == "<html><title>THE TITLE</title>ding\nding\n</html>"
+    end
+  end
+
+  context "Second render" do
+    setup do
+      @template = Cutaneous::SecondPassParser.new
+    end
+
+    should "a render unescaped expressions" do
+      @template.convert('<html><title>#{title}</title>#{unsafe}</html>')
+      output = @template.render(@context)
+      output.should == "<html><title>THE TITLE</title><script>alert('bad')</script></html>"
+    end
+
+    should "render escaped expressions" do
+      @template.convert('<html><title>${unsafe}</title></html>')
+      output = @template.render(@context)
+      output.should == "<html><title>&lt;script&gt;alert('bad')&lt;/script&gt;</title></html>"
+    end
+
+    should "evaluate expressions" do
+      @template.convert('<html>%{ 2.times do }<title>#{title}</title>%{ end }</html>')
+      output = @template.render(@context)
+      output.should == "<html><title>THE TITLE</title><title>THE TITLE</title></html>"
+    end
+  end
+
+  context "Content rendering" do
+    # setup do
+    #   @saved_template_root = Spontaneous.template_root
+    #   Spontaneous.template_root = File.join(File.dirname(__FILE__), '../fixtures/templates/content')
+    # end
+
+    # teardown do
+    #   Spontaneous.template_root = @saved_template_root
+    # end
+
+    should "render" do
+      output = first_pass('content', 'template')
+      output.should == "<html><title>THE TITLE</title></html>\n"
+    end
+
+    should "preprocess" do
+      output = first_pass('content', 'preprocess')
+      output.should == "<html><title>THE TITLE</title>\#{bell}</html>\n"
+    end
+
+    should "include imports" do
+      output = first_pass('content', 'include')
+      output.should == "<html>\#{bell}ding\n</html>\n"
+    end
+
+    should "include imports in sub-directories" do
+      output = first_pass('content', 'include_dir')
+      output.should == "<html>\#{bell}ding\n</html>\n"
+    end
+
+    should "preserve the format across includes" do
+      context = @klass.new(nil, :epub)
+      context.format.should == :epub
+      output = first_pass('content', 'template', context)
+      output.should == "<epub><epub>\#{bell}ding</epub>\n</epub>\n"
+    end
+
+    should "render a second pass" do
+      output = second_pass('content', 'second')
+      output.should == "<html><title>THE TITLE</title>ding</html>\n"
+    end
+
+  end
+
+  context "Template hierarchy" do
+
+    setup do
+    end
+
+    should "work" do
+      output = first_pass('extended', 'main')
+      output.should == "Main Title \#{page.title}\nGrandparent Nav\nMain Body\nParent Body\nGrandparent Body\nGrandparent Footer\nParent Footer\n"
+    end
+  end
+
+  context "Output conversion" do
+    setup do
+
+      @context_class = Class.new(Object) do
+        include Cutaneous::ContextHelper
+
+        def escape(val)
+          CGI.escapeHTML(val)
+        end
+
+        def monkey
+          "magic"
+        end
+
+        def field
+          @klass ||= Class.new(Object) do
+            attr_accessor :format
+            def to_html
+              "(#{format})"
+            end
+
+            def to_s
+              "'#{format}'"
+            end
+          end
+          @klass.new.tap { |i| i.format = format }
+        end
+
+        def slot
+          @klass ||= Class.new(Object) do
+            def render(format)
+              "(#{format})"
+            end
+          end
+          @klass.new
+        end
+      end
+      @template = Cutaneous::FirstPassParser.new
+    end
+
+    should "call #render(format) if context responds to it" do
+      context = @context_class.new(nil, :html)
+      @template.convert('{{slot}} {{ monkey }}')
+      output = @template.render(context)
+      output.should == "(html) magic"
+    end
+
+    should "call to_format on non-strings" do
+      context = @context_class.new(nil, :html)
+      @template.convert('{{field}} {{ monkey }}')
+      output = @template.render(context)
+      output.should == "(html) magic"
+    end
+
+    should "call to_s on non-strings that have no specific handler" do
+      context = @context_class.new(nil, :weird)
+      @template.convert('{{field}} {{ monkey }}')
+      output = @template.render(context)
+      output.should == "'weird' magic"
+    end
+  end
+end

data/test/unit/test_type_hierarchy.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+
+class TypeHierarchyTest < MiniTest::Spec
+
+
+  context "Content" do
+    should "have an empty supertype" do
+      S::Content.supertype.should be_nil
+      S::Content.supertype?.should be_false
+    end
+  end
+  context "Schema classes" do
+    setup do
+      class SchemaClass < Spontaneous::Piece
+      end
+    end
+    should "have a reference to their super type" do
+      SchemaClass.supertype.should == Spontaneous::Piece
+    end
+
+    should "know what file they were defined in" do
+      SchemaClass.__source_file.should == File.expand_path(__FILE__)
+    end
+  end
+end