haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/test/{haml/erb → erb}/_av_partial_1.erb

@@ -6,7 +6,7 @@
       <li>
         <strong>Partial:</strong>
         <% @nesting = 5 %>
-        <%= render :partial => 'haml/erb/av_partial_2' %>
+        <%= render :partial => 'erb/av_partial_2' %>
     <% end %>
   </ul>
 </div>

data/test/{haml/erb → erb}/_av_partial_2.erb

@@ -3,6 +3,6 @@
   <h3>This is a crazy deep-nested partial.</h3>
   <p>Nesting level <%= @nesting %></p>
   <% if @nesting > 0 %>
-    <%= render :partial => 'haml/erb/av_partial_2' %>
+    <%= render :partial => 'erb/av_partial_2' %>
   <% end %>
 </div>

data/test/{haml/erb → erb}/action_view.erb

@@ -11,7 +11,7 @@
       It's only used for benchmarking.
     </h1>
     <div class="crazy_partials">
-      <%= render :partial => 'haml/erb/av_partial_1' %>
+      <%= render :partial => 'erb/av_partial_1' %>
     </div>
     <!-- You're In my house now! -->
     <div class='header'>

data/test/filters_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class FiltersTest < MiniTest::Unit::TestCase
+  test "should be registered as filters when including Haml::Filters::Base" do
+    begin
+      refute Haml::Filters.defined.has_key? "bar"
+      Module.new {def self.name; "Foo::Bar"; end; include Haml::Filters::Base}
+      assert Haml::Filters.defined.has_key? "bar"
+    ensure
+      Haml::Filters.defined.delete "bar"
+    end
+  end
+
+  test "should raise error when attempting to register a defined Tilt filter" do
+    begin
+      assert_raises RuntimeError do
+        2.times do
+          Haml::Filters.register_tilt_filter "Foo"
+        end
+      end
+    ensure
+      Haml::Filters.defined.delete "foo"
+      Haml::Filters.send :remove_const, :Foo
+    end
+  end
+
+  test "should respect escaped newlines and interpolation" do
+    html = "\\n\n"
+    haml = ":plain\n  \\n\#{""}"
+    assert_equal(html, render(haml))
+  end
+
+  test "should process an filter with no content" do
+    assert_equal("\n", render(':plain'))
+  end
+
+  test "should be compatible with ugly mode" do
+    expectation = "foo\n"
+    assert_equal(expectation, render(":plain\n  foo", :ugly => true))
+  end
+
+  test "should pass options to Tilt filters that precompile" do
+    haml  = ":erb\n  <%= 'foo' %>"
+    refute_match('TEST_VAR', Haml::Engine.new(haml).precompiled)
+    Haml::Filters::Erb.options = {:outvar => 'TEST_VAR'}
+    assert_match('TEST_VAR', Haml::Engine.new(haml).precompiled)
+  end
+
+  test "should pass options to Tilt filters that don't precompile" do
+    begin
+      filter = Class.new(Tilt::Template) do
+        def self.name
+          "Foo"
+        end
+
+        def prepare
+          @engine = {:data => data, :options => options}
+        end
+
+        def evaluate(scope, locals, &block)
+          @output = @engine[:options].to_a.join
+        end
+      end
+      Haml::Filters.register_tilt_filter "Foo", :template_class => filter
+      Haml::Filters::Foo.options[:foo] = "bar"
+      haml = ":foo"
+      assert_equal "foobar\n", render(haml)
+    ensure
+      Haml::Filters.defined.delete "foo"
+      Haml::Filters.send :remove_const, :Foo
+    end
+  end
+
+end
+
+class ErbFilterTest < MiniTest::Unit::TestCase
+  test "multiline expressions should work" do
+    html = "foobarbaz\n"
+    haml = %Q{:erb\n  <%= "foo" +\n      "bar" +\n      "baz" %>}
+    assert_equal(html, render(haml))
+  end
+
+
+  test "should evaluate in the same context as Haml" do
+    haml  = ":erb\n  <%= foo %>"
+    html  = "bar\n"
+    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
+    assert_equal(html, render(haml, :scope => scope))
+  end
+end
+
+class JavascriptFilterTest < MiniTest::Unit::TestCase
+  test "should interpolate" do
+    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
+    haml  = ":javascript\n  \#{foo}"
+    html  = render(haml, :scope => scope)
+    assert_match(/bar/, html)
+  end
+
+  test "should never HTML-escape ampersands" do
+    html = "<script type='text/javascript'>\n  //<![CDATA[\n    & < > &\n  //]]>\n</script>\n"
+    haml = %Q{:javascript\n  & < > \#{"&"}}
+    assert_equal(html, render(haml, :escape_html => true))
+  end
+
+  test "should not include type in HTML 5 output" do
+    html = "<script>\n  //<![CDATA[\n    foo bar\n  //]]>\n</script>\n"
+    haml = ":javascript\n  foo bar"
+    assert_equal(html, render(haml, :format => :html5))
+  end
+end
+
+class CSSFilterTest < MiniTest::Unit::TestCase
+  test "should wrap output in CDATA and a CSS tag" do
+    html = "<style type='text/css'>\n  /*<![CDATA[*/\n    foo\n  /*]]>*/\n</style>\n"
+    haml = ":css\n  foo"
+    assert_equal(html, render(haml))
+  end
+
+  test "should not include type in HTML 5 output" do
+    html = "<style>\n  /*<![CDATA[*/\n    foo bar\n  /*]]>*/\n</style>\n"
+    haml = ":css\n  foo bar"
+    assert_equal(html, render(haml, :format => :html5))
+  end
+end
+
+class CDATAFilterTest < MiniTest::Unit::TestCase
+  test "should wrap output in CDATA tag" do
+    html = "<![CDATA[\n    foo\n]]>\n"
+    haml = ":cdata\n  foo"
+    assert_equal(html, render(haml))
+  end
+end
+
+class EscapedFilterTest < MiniTest::Unit::TestCase
+  test "should escape ampersands" do
+    html = "&amp;\n"
+    haml = ":escaped\n  &"
+    assert_equal(html, render(haml))
+  end
+end

data/test/gemfiles/Gemfile.rails-3.0.x

@@ -1,8 +1,6 @@
-source :gemcutter
+source :rubygems
 
-gem 'json'
-gem 'ruby_parser'
-gem 'hpricot'
-gem 'erubis'
-gem 'sass'
 gem 'rails', '>= 3.0.0', '<  3.1.0'
+gemspec :path => "../.."
+gem "haml-contrib", :path => "../../vendor/haml-contrib"
+

data/test/gemfiles/Gemfile.rails-3.1.x

@@ -1,8 +1,7 @@
-source :gemcutter
+source :rubygems
 
-gem 'json'
-gem 'ruby_parser'
-gem 'hpricot'
-gem 'erubis'
-gem 'sass'
 gem 'rails', '>= 3.1.0', '< 3.2.0'
+gemspec :path => "../.."
+gem "haml-contrib", :path => "../../vendor/haml-contrib"
+
+

data/test/gemfiles/Gemfile.rails-3.2.x

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem 'rails', '>= 3.2.0', '< 3.3.0'
+gemspec :path => "../.."
+gem "haml-contrib", :path => "../../vendor/haml-contrib"
+

data/test/haml-spec/LICENSE

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

data/test/{haml/spec → haml-spec}/README.md

@@ -5,10 +5,12 @@ Haml Spec provides a basic suite of tests for Haml interpreters.
 It is intented for developers who are creating or maintaining an implementation
 of the [Haml](http://haml-lang.com) markup language.
 
-At the moment, there are test runners for the [original Haml](http://github.com/nex3/haml)
-in Ruby, and for [Lua Haml](http://github.com/norman/lua-haml). Support for
-other versions of Haml will be added if their developers/maintainers
-are interested in using it.
+At the moment, there are test runners for the [original
+Haml](http://github.com/nex3/haml) in Ruby, [Lua
+Haml](http://github.com/norman/lua-haml) and the
+[Text::Haml](http://github.com/vti/text-haml) Perl port. Support for other
+versions of Haml will be added if their developers/maintainers are interested in
+using it.
 
 ## The Tests ##
 
@@ -20,9 +22,11 @@ filters such as :markdown or :textile.
 
 The one major exception to this are the tests for interpolation, which you may
 need to modify with a regular expression to run under PHP or Perl, which
-require a symbol before variable names. These tests are included despite being
+require a sigil before variable names. These tests are included despite being
 less than 100% portable because interpolation is an important part of Haml and
-can be tricky to implement.
+can be tricky to implement. These tests are flagged as "optional" so that you
+can avoid running them if your implementation of Haml will not support this
+feature.
 
 ## Running the Tests ##
 
@@ -40,16 +44,19 @@ using Ruby 1.8.x, you'll also need to install `json`:
 
 Then, running the Ruby test suite is easy:
 
-    ruby ruby_haml_test.rb
+    ruby -rminitest/autorun ruby_haml_test.rb
+
+At the moment, running the tests with Ruby 1.8.7 fails because of issues with
+the JSON library. Please use 1.9.2 until this is resolved.
 
 ### Lua ###
 
-The Lua test depends on [Telescope](http://telescope.luaforge.net/),
+The Lua test depends on
+[Penlight](http://stevedonovan.github.com/Penlight/),
+[Telescope](http://github.com/norman/telescope),
 [jason4lua](http://json.luaforge.net/), and
-[Lua Haml](http://github.com/norman/lua-haml). Install and
-run `tsc lua_haml_spec.lua`.
-
-## Contributing ##
+[Lua Haml](http://github.com/norman/lua-haml). Install and run `tsc
+lua_haml_spec.lua`.
 
 ### Getting it ###
 
@@ -65,11 +72,12 @@ be very happy to add them.
 ### Test JSON format ###
 
     "test name" : {
-      "haml" : "haml input",
-      "html" : "expected html output",
-      "result" : "expected test result",
-      "locals" : "local vars",
-      "config" : "config params"
+      "haml"     : "haml input",
+      "html"     : "expected html output",
+      "result"   : "expected test result",
+      "locals"   : "local vars",
+      "config"   : "config params",
+      "optional" : true|false
     }
 
 * test name: This should be a *very* brief description of what's being tested. It can
@@ -86,6 +94,7 @@ be very happy to add them.
   names, you may need to process them to make them match your implementation.
   If your implementation has options that do not exist in Ruby's Haml, then you
   should add tests for this in your implementation's test rather than here.
+* optional: whether or not the test is optional
 
 ## License ##
 

data/test/haml-spec/lua_haml_spec.lua

@@ -0,0 +1,38 @@
+local dir       = require 'pl.dir'
+local haml      = require 'haml'
+local json      = require 'json'
+local path      = require 'pl.path'
+local telescope = require 'telescope'
+local assert    = assert
+local describe  = telescope.describe
+local getinfo   = debug.getinfo
+local it        = telescope.it
+local open      = io.open
+local pairs     = pairs
+
+module('hamlspec')
+
+local function get_tests(filename)
+  local me = path.abspath(getinfo(1).source:match("@(.*)$"))
+  return path.join(path.dirname(me), filename)
+end
+
+local json_file = get_tests("tests.json")
+local file      = assert(open(json_file))
+local input     = file:read '*a'
+file:close()
+
+local contexts = json.decode(input)
+
+describe("LuaHaml", function()
+   for context, expectations in pairs(contexts) do
+     describe("When handling " .. context, function()
+      for name, exp in pairs(expectations) do
+        it(("should correctly render %s"):format(name), function()
+          local engine = haml.new(exp.config)
+          assert_equal(engine:render(exp.haml, exp.locals), exp.html)
+        end)
+      end
+     end)
+   end
+end)

data/test/haml-spec/perl_haml_test.pl

@@ -0,0 +1,81 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+use Test::More 'no_plan';
+use Text::Haml;
+use FindBin;
+use JSON 'from_json';
+
+our $VERSION = 0.990101;
+
+my $tests;
+
+open FILE, "< $FindBin::Bin/tests.json" or die $!;
+$tests = from_json(join("\n", <FILE>));
+close FILE;
+
+while (my ($section_name, $section) = each %$tests) {
+    diag $section_name;
+
+    while (my ($test_name, $test) = each %$section) {
+        is( Text::Haml->new(%{$test->{config}}, vars_as_subs => 1)
+              ->render($test->{haml}, %{$test->{locals}}),
+            $test->{html}, $test_name
+        );
+    }
+}
+__END__
+
+=head1 NAME
+
+perl_haml_test.pl - Text::Haml spec tests runner
+
+=head1 SYNOPSIS
+
+    $ perl perl_haml_test.pl
+
+    # conditional comments
+    ok 1 - a conditional comment
+    # tags with nested content
+    ok 2 - a tag with CSS
+
+    ...
+
+    ok 81 - an inline comment
+    ok 82 - a nested comment
+    1..82
+
+=head1 DESCRIPTION
+
+This file is a part of Haml spec tests envorinment. It tests Perl
+implementation using <Text::Haml>.
+
+=head1 DEPENDENCIES
+
+=over
+
+    * Text::Haml (available via CPAN or http://github.com/vti/text-haml)
+    * JSON (available on CPAN)
+    * Test::More (included in Perl core)
+    * FindBin (included in Perl core)
+
+=back
+
+=head1 SEE ALSO
+
+L<Text::Haml>
+
+=head1 AUTHOR
+
+Viacheslav Tykhanovskyi, C<vti@cpan.org>.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2009, Viacheslav Tykhanovskyi
+
+This program is free software, you can redistribute it and/or modify it under
+the terms of the Artistic License version 2.0.
+
+=cut

data/test/haml-spec/ruby_haml_test.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+require "test/unit"
+require "json"
+require "haml"
+
+class HamlTest < Test::Unit::TestCase
+  contexts = JSON.parse(File.read(File.dirname(__FILE__) + "/tests.json"))
+  contexts.each do |context|
+    context[1].each do |name, test|
+      define_method("test_spec: #{name} (#{context[0]})") do
+        html             = test["html"]
+        haml             = test["haml"]
+        locals           = Hash[(test["locals"] || {}).map {|x, y| [x.to_sym, y]}]
+        options          = Hash[(test["config"] || {}).map {|x, y| [x.to_sym, y]}]
+        options[:format] = options[:format].to_sym if options.key?(:format)
+        engine           = Haml::Engine.new(haml, options)
+        result           = engine.render(Object.new, locals)
+
+        assert_equal html, result.strip
+      end
+    end
+  end
+end