spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/render.rb

@@ -1,214 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous
-  module Render
-
-    class << self
-      def output_path(revision, page, format, extension = nil, template_dynamic = false)
-        output_path_with_root(revision_root(revision), revision, page, format, extension, template_dynamic)
-      end
-
-      def output_path_with_root(root, revision, page, format, extension = nil, template_dynamic = false)
-        ext = ".#{format}"
-        ext += ".#{extension}" if extension && template_dynamic
-        segment = template_dynamic ? "dynamic" : (page.dynamic? ? "protected" : "static")
-        dir = root / segment / page.path
-        path = dir / "/index#{ext}"
-        path
-      end
-
-      def redirect_path(revision, page, format)
-        output_path_with_root(Spontaneous.revision_dir(revision, "/"), revision, page, format)
-      end
-
-
-      def revision_root(revision)
-        Spontaneous.revision_dir(revision)
-      end
-
-      def cache_templates?
-        @cache_templates ||= Spontaneous.production?
-      end
-
-      def cache_templates=(value)
-        @cache_templates = value
-      end
-
-      def render_pages(revision, pages, format, progress=nil)
-        klass = Format.const_get("#{format.to_s.camelize}")
-        renderer = klass.new(revision, pages, progress)
-        renderer.render
-      end
-
-      def render_page(revision, page, format, progress=nil)
-        render_pages(revision, [page], format, progress)
-      end
-
-      def renderer_class
-        @renderer_class ||= PublishingRenderer
-      end
-
-      def renderer_class=(klass)
-        @renderer_class = klass
-        @renderer = nil
-      end
-
-      def renderer
-        @renderer ||= renderer_class.new(template_root)
-      end
-
-
-      def with_preview_renderer(&block)
-        with_renderer(PreviewRenderer, &block)
-      end
-
-      def with_publishing_renderer(&block)
-        with_render_cache {
-          with_renderer(PublishingRenderer, &block)
-        }
-      end
-
-      def with_published_renderer(&block)
-        with_renderer(PublishedRenderer, &block)
-      end
-
-      def use_development_renderer
-        self.renderer_class = DevelopmentRenderer
-      end
-
-      def use_preview_renderer
-        self.renderer_class = PreviewRenderer
-      end
-
-      def use_publishing_renderer
-        self.renderer_class = PublishingRenderer
-      end
-
-      def use_published_renderer
-        self.renderer_class = PublishedRenderer
-      end
-
-      @@renderer_stack = []
-
-      def with_renderer(new_renderer, &block)
-        @@renderer_stack.push(self.renderer_class)
-        self.renderer_class = new_renderer
-        yield if block_given?
-      ensure
-        self.renderer_class = @@renderer_stack.pop
-      end
-
-
-      def with_render_cache
-        Thread.current[:_render_cache] = {}
-        yield if block_given?
-      ensure
-        Thread.current[:_render_cache] = nil
-      end
-
-      def render_cache
-        Thread.current[:_render_cache]
-      end
-
-      def render_cache_active?
-        !render_cache.nil?
-      end
-
-      def render_cache_key?(key)
-        return false unless render_cache_active?
-        render_cache.key?(key)
-      end
-
-      def render_cache_value(key)
-        return nil unless render_cache_active?
-        render_cache[key]
-      end
-
-      def render_cache_set_value(key, value)
-        return value unless render_cache_active?
-        render_cache[key] = value
-      end
-
-      def template_root
-        @template_root ||= Spontaneous.root / "templates"
-      end
-
-      def template_path(*path)
-        ::File.join(template_root, *path)
-      end
-
-      # def template_root=(root)
-      #   @template_root = root
-      #   @renderer = nil
-      # end
-
-      def extension
-        Spontaneous.template_ext
-      end
-
-      def exists?(root, template, format)
-        File.exists?(template_file(root, template, format))
-      end
-
-      def template_file(root, filename, format)
-        ::File.join(root, template_name(filename, format))
-      end
-
-      def template_file_with_root(template_root, filename, format)
-        ::File.join(template_root, template_name(filename, format))
-      end
-
-      # converts relative paths into absolute template paths
-      # e.g. layouts/standard -> /example_com/templates/layouts/standard.html.cut
-      # searches through all available template roots
-      def find_template(filename, format)
-        template_name = template_name(filename, format)
-        return template_name if File.file?(template_name)
-        Spontaneous.template_paths.each do |root|
-          path = root / template_name
-          return path if File.file?(path)
-        end
-        nil
-      end
-
-      def template_name(filename, format)
-        "#{filename}.#{format}.#{Spontaneous.template_ext}"
-      end
-
-
-
-      def formats(style)
-        glob = "#{template_path(style.path)}.*.#{extension}"
-        Dir[glob].map do |file|
-          file.split('.')[-2].to_sym
-        end
-      end
-
-      def render(content, format=:html, params={}, *args)
-        Content.with_visible do
-          renderer.render_content(content, format || :html, params, *args)
-        end
-      end
-      def render_string(template_string, content, format=:html, params={}, *args)
-        Content.with_visible do
-          renderer.render_string(template_string, content, format || :html, params, *args)
-        end
-      end
-    end
-
-    autoload :Engine,               "spontaneous/render/engine"
-    autoload :ContextBase,          "spontaneous/render/context_base"
-    autoload :PreviewContext,       "spontaneous/render/preview_context"
-    autoload :PublishContext,       "spontaneous/render/publish_context"
-    autoload :RequestContext,       "spontaneous/render/request_context"
-    autoload :RenderCache,          "spontaneous/render/render_cache"
-    autoload :Renderer,             "spontaneous/render/renderer"
-    autoload :PreviewRenderer,      "spontaneous/render/preview_renderer"
-    autoload :PublishingRenderer,   "spontaneous/render/publishing_renderer"
-    autoload :PublishedRenderer,    "spontaneous/render/published_renderer"
-    autoload :DevelopmentRenderer,  "spontaneous/render/development_renderer"
-    autoload :Format,               "spontaneous/render/format"
-    autoload :Helpers,              "spontaneous/render/helpers"
-  end
-end

data/test/experimental/test_cutaneous.rb

@@ -1,309 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path('../../test_helper', __FILE__)
-
-
-class CutaneousTest < MiniTest::Spec
-  PUBLISH_TEMPLATE = (<<-TEMPLATE)
-Text here {{ preview_tag }}
-
-
-!{ comment which should be ignored }
-Text `problem`
-${ "<div>" }
-$${ "<div>" }
-  %{
-  a = {:key => title}
-  b = a.map { |k, v| "\#{k}=\#{v}" }
-  }
-Text \\problem
-  ${ b }
-Text
-TEMPLATE
-
-  VIEW_TEMPLATE = (<<-TEMPLATE)
-<title>{{ title }}</title>
-
-!{ comment }
-Welome
-
-{% 2.times do |n| %}
-  {{ names[n] }}
-{% end %}
-
-TEMPLATE
-
-  context "publishing parser" do
-    setup do
-      @parser = Cutaneous::PublishTokenParser.new(PUBLISH_TEMPLATE)
-    end
-
-    should "tokenize a single statement" do
-      lexer = Cutaneous::PublishTokenParser.new("%{ a = {:a => \"a\" }}")
-      tokens = lexer.tokens
-      tokens.length.should == 1
-      tokens.first.should == [:statement, 'a = {:a => "a" }']
-    end
-
-    should "tokenize a single expression" do
-      lexer = Cutaneous::PublishTokenParser.new("${ a }")
-      tokens = lexer.tokens
-      tokens.length.should == 1
-      tokens.first.should == [:expression, 'a']
-    end
-
-    should "tokenize plain text" do
-      lexer = Cutaneous::PublishTokenParser.new("Hello there")
-      tokens = lexer.tokens
-      tokens.length.should == 1
-      tokens.first.should == [:text, 'Hello there']
-    end
-
-    should "tokenize a single comment" do
-      lexer = Cutaneous::PublishTokenParser.new("!{ comment }")
-      tokens = lexer.tokens
-      tokens.length.should == 1
-      tokens.first.should == [:comment,  ' comment ']
-    end
-
-    should "correctly tokenize tags within a comment" do
-      lexer = Cutaneous::PublishTokenParser.new("!{ %{ a = true } ${ value } !{ nested comment }}")
-      tokens = lexer.tokens
-      tokens.length.should == 1
-      tokens.first.should == [:comment,  ' %{ a = true } ${ value } !{ nested comment }']
-    end
-    should "correctly tokenize a complex template string" do
-      @parser.tokens.map { |token| token[0] }.should == [
-        :text,
-        :comment,
-        :text,
-        :expression,
-        :text,
-        :escaped_expression,
-        :text,
-        :statement,
-        :text,
-        :expression,
-        :text
-      ]
-    end
-
-    should "correctly post process the expressions" do
-      expressions = @parser.tokens
-      expected = [
-        [:text, "Text here {{ preview_tag }}\n\n\n"],
-        [:comment, " comment which should be ignored "],
-        [:text, "Text \\`problem\\`\n"],
-        [:expression, %("<div>")],
-        [:text, "\n"],
-        [:escaped_expression, %("<div>")],
-        [:text, "\n"],
-        [:statement, "a = {:key => title}\n  b = a.map { |k, v| \"\#{k}=\#{v}\" }"],
-        [:text, "Text \\\\problem\n  "],
-        [:expression, "b"],
-        [:text, "\nText\n"]
-      ]
-      expressions.each_with_index do |s, i|
-        s.should == expected[i]
-      end
-      expressions.should == expected
-    end
-
-    should "correctly generate the template script" do
-      expected = [
-        %(_buf << %Q`Text here {{ preview_tag }}\n\n\n`),
-        %(_buf << %Q`Text \\`problem\\`\n`),
-        %(_buf << _decode_params(("<div>"))),
-        %(_buf << %Q`\n`),
-        %(_buf << escape(_decode_params(("<div>")))),
-        %(_buf << %Q`\n`),
-        "a = {:key => title}\n  b = a.map { |k, v| \"\#{k}=\#{v}\" }",
-        %(_buf << %Q`Text \\\\problem\n  `),
-        "_buf << _decode_params((b))",
-        %(_buf << %Q`\nText\n`),
-      ].join("\n") + "\n"
-      script = @parser.script
-      script.should == expected
-    end
-  end
-
-  context "view parser" do
-    setup do
-    end
-    should "tokenize a single statement" do
-      parser = Cutaneous::RequestTokenParser.new("{% a = {:a => \"a\" } %}")
-      tokens = parser.tokens
-      tokens.length.should == 1
-      tokens.first[0].should == :statement
-      tokens.first[1].should == 'a = {:a => "a" }'
-    end
-
-    should "tokenize a single expression" do
-      parser = Cutaneous::RequestTokenParser.new("{{ a }}")
-      tokens = parser.tokens
-      tokens.length.should == 1
-      tokens.first[0].should == :expression
-      tokens.first[1].should == 'a'
-    end
-
-    should "tokenize a single escaped expression" do
-      parser = Cutaneous::RequestTokenParser.new("{$ a $}")
-      tokens = parser.tokens
-      tokens.length.should == 1
-      tokens.first[0].should == :escaped_expression
-      tokens.first[1].should == 'a'
-    end
-
-    should "tokenize plain text" do
-      parser = Cutaneous::RequestTokenParser.new("Hello there")
-      tokens = parser.tokens
-      tokens.length.should == 1
-      tokens.first[0].should == :text
-      tokens.first[1].should == 'Hello there'
-    end
-
-    should "tokenize a single comment" do
-      parser = Cutaneous::RequestTokenParser.new("!{ comment }")
-      tokens = parser.tokens
-      tokens.length.should == 1
-      tokens.first[0].should == :comment
-      tokens.first[1].should == ' comment '
-    end
-
-    should "tokenize a mixed template" do
-      parser = Cutaneous::RequestTokenParser.new("{% a = [1,2].map { |x| x } %}!{ comment }{{ a }}")
-      tokens = parser.tokens
-      tokens.length.should == 3
-      tokens[0][0].should == :statement
-      tokens[1][0].should == :comment
-      tokens[2][0].should == :expression
-      tokens[0][1].should == 'a = [1,2].map { |x| x }'
-      tokens[1][1].should == ' comment '
-      tokens[2][1].should == 'a'
-    end
-    should "tokenize a mixed publish & view template" do
-      parser = Cutaneous::RequestTokenParser.new(PUBLISH_TEMPLATE)
-      tokens = parser.tokens
-      tokens.length.should == 5
-      tokens.map { |t| t[0] }.should == [
-        :text,
-        :expression,
-        :text,
-        :comment,
-        :text
-      ]
-      tokens[1][1].should == 'preview_tag'
-    end
-  end
-
-
-  context "publish templates" do
-    context "from files" do
-      setup do
-        @tmp = Dir.mktmpdir
-        @template_path = File.join(@tmp, "template.html.cut")
-        File.open(@template_path, "w") do |file|
-          file.write(PUBLISH_TEMPLATE)
-        end
-      end
-      teardown do
-        FileUtils.rm_r(@tmp)
-      end
-
-      should "just be empty if created empty" do
-        template = Cutaneous::PublishTemplate.new
-        template.filename.should be_nil
-        template.script.should be_nil
-      end
-
-      should "convert a string" do
-        template = Cutaneous::PublishTemplate.new
-        template.convert("!{ comment }${ title }", "/path/to/template.html.cut")
-        template.filename.should == "/path/to/template.html.cut"
-        context = Cutaneous::PublishContext.new(nil, :html, {:title => "title"})
-        template.render(context).should == "title"
-      end
-
-      should "parse the file if created with one" do
-        template = Cutaneous::PublishTemplate.new(@template_path)
-        template.filename.should == @template_path
-        template.script.should =~ /^\s*_buf/
-        context = Cutaneous::PublishContext.new(nil, :html, {:title => "title"})
-        # puts template.render(context)
-        template.render(context).should == (<<-HTML)
-Text here {{ preview_tag }}
-
-
-Text `problem`
-<div>
-<div>
-Text \\problem
-  key=title
-Text
-        HTML
-      end
-
-      should "reset if given a different string" do
-        template = Cutaneous::PublishTemplate.new
-        template.convert("${ title }")
-        context = Cutaneous::PublishContext.new(nil, :html, {:title => "title"})
-        template.render(context).should == "title"
-        template.convert("${ title }!")
-        template.render(context).should == "title!"
-      end
-    end
-  end
-  context "view templates" do
-    context "from files" do
-      setup do
-        @tmp = Dir.mktmpdir
-        @template_path = File.join(@tmp, "template.html.cut")
-        File.open(@template_path, "w") do |file|
-          file.write(VIEW_TEMPLATE)
-        end
-      end
-      teardown do
-        FileUtils.rm_r(@tmp)
-      end
-
-      should "just be empty if created empty" do
-        template = Cutaneous::RequestTemplate.new
-        template.filename.should be_nil
-        template.script.should be_nil
-      end
-
-      should "convert a string" do
-        template = Cutaneous::RequestTemplate.new
-        template.convert("!{ comment }{{ title }}", "/path/to/template.html.cut")
-        template.filename.should == "/path/to/template.html.cut"
-        context = Cutaneous::RequestContext.new(nil, :html, {:title => "title"})
-        template.render(context).should == "title"
-      end
-
-      should "parse the file if created with one" do
-        template = Cutaneous::RequestTemplate.new(@template_path)
-        template.filename.should == @template_path
-        template.script.should =~ /^\s*_buf/
-        context = Cutaneous::RequestContext.new(nil, :html, {:title => "title", :names => ["george", "mary"]})
-        # puts template.render(context)
-        template.render(context).should == (<<-HTML)
-<title>title</title>
-
-Welome
-
-  george
-  mary
-        HTML
-      end
-
-      should "reset if given a different string" do
-        template = Cutaneous::RequestTemplate.new
-        template.convert("{{ title }}")
-        context = Cutaneous::RequestContext.new(nil, :html, {:title => "title"})
-        template.render(context).should == "title"
-        template.convert("{{ title }}!")
-        template.render(context).should == "title!"
-      end
-    end
-  end
-end

data/test/fixtures/application/css/test.less

@@ -1,5 +0,0 @@
-@brand_color: #4D926F;
-
-h1 {
-  color: @brand_color;
-}