/
filters_test.rb
269 lines (232 loc) · 8.1 KB
/
filters_test.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
# frozen_string_literal: true
require 'test_helper'
class FiltersTest < Haml::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.remove_filter "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.remove_filter "Foo"
end
end
test "should raise error when a Tilt filters dependencies are unavailable for extension" do
begin
assert_raises Haml::Error do
# ignore warnings from Tilt
silence_warnings do
Haml::Filters.register_tilt_filter "Textile"
Haml::Filters.defined["textile"].template_class
end
end
ensure
Haml::Filters.remove_filter "Textile"
end
end
test "should raise error when a Tilt filters dependencies are unavailable for filter without extension" do
begin
assert_raises Haml::Error do
Haml::Filters.register_tilt_filter "Maruku"
Haml::Filters.defined["maruku"].template_class
end
ensure
Haml::Filters.remove_filter "Maruku"
end
end
test "should raise informative error about Maruku being moved to haml-contrib" do
begin
render(":maruku\n # foo")
flunk("Should have raised error with message about the haml-contrib gem.")
rescue Haml::Error => e
assert_equal e.message, Haml::Error.message(:install_haml_contrib, "maruku")
end
end
test "should raise informative error about Textile being moved to haml-contrib" do
begin
render(":textile\n h1. foo")
flunk("Should have raised error with message about the haml-contrib gem.")
rescue Haml::Error => e
assert_equal e.message, Haml::Error.message(:install_haml_contrib, "textile")
end
end
test "should respect escaped newlines and interpolation" do
html = "\\n\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 ":plain with content" do
expectation = "foo\n"
assert_equal(expectation, render(":plain\n foo"))
end
test "should pass options to Tilt filters that precompile" do
begin
orig_erb_opts = Haml::Filters::Erb.options
haml = ":erb\n <%= 'foo' %>"
refute_match('test_var', Haml::Engine.new(haml).compiler.precompiled)
Haml::Filters::Erb.options = {:outvar => 'test_var'}
assert_match('test_var', Haml::Engine.new(haml).compiler.precompiled)
ensure
Haml::Filters::Erb.options = orig_erb_opts
end
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.remove_filter "Foo"
end
end
test "interpolated code should be escaped if escape_html is set" do
assert_equal "<script>evil</script>\n\n",
render(":plain\n \#{'<script>evil</script>'}", :escape_html => true)
end
end
class ErbFilterTest < Haml::TestCase
test "multiline expressions should work" do
html = "foobarbaz\n\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\n"
scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
assert_equal(html, render(haml, :scope => scope))
end
end
class JavascriptFilterTest < Haml::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 non-interpolated ampersands" do
html = "<script>\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 foo bar\n</script>\n"
haml = ":javascript\n foo bar"
assert_equal(html, render(haml, :format => :html5))
end
test "should always include CDATA when format is xhtml" do
html = "<script type='text/javascript'>\n //<![CDATA[\n foo bar\n //]]>\n</script>\n"
haml = ":javascript\n foo bar"
assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
end
test "should omit CDATA when cdata option is false" do
html = "<script>\n foo bar\n</script>\n"
haml = ":javascript\n foo bar"
assert_equal(html, render(haml, :format => :html5, :cdata => false))
end
test "should include CDATA when cdata option is true" do
html = "<script>\n //<![CDATA[\n foo bar\n //]]>\n</script>\n"
haml = ":javascript\n foo bar"
assert_equal(html, render(haml, :format => :html5, :cdata => true))
end
test "should default to no CDATA when format is html5" do
haml = ":javascript\n foo bar"
out = render(haml, :format => :html5)
refute_match('//<![CDATA[', out)
refute_match('//]]>', out)
end
end
class CSSFilterTest < Haml::TestCase
test "should wrap output in CDATA and a CSS tag when output is XHTML" do
html = "<style type='text/css'>\n /*<![CDATA[*/\n foo\n /*]]>*/\n</style>\n"
haml = ":css\n foo"
assert_equal(html, render(haml, :format => :xhtml))
end
test "should not include type in HTML 5 output" do
html = "<style>\n foo bar\n</style>\n"
haml = ":css\n foo bar"
assert_equal(html, render(haml, :format => :html5))
end
test "should always include CDATA when format is xhtml" do
html = "<style type='text/css'>\n /*<![CDATA[*/\n foo bar\n /*]]>*/\n</style>\n"
haml = ":css\n foo bar"
assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
end
test "should omit CDATA when cdata option is false" do
html = "<style>\n foo bar\n</style>\n"
haml = ":css\n foo bar"
assert_equal(html, render(haml, :format => :html5, :cdata => false))
end
test "should include CDATA when cdata option is true" do
html = "<style>\n /*<![CDATA[*/\n foo bar\n /*]]>*/\n</style>\n"
haml = ":css\n foo bar"
assert_equal(html, render(haml, :format => :html5, :cdata => true))
end
test "should default to no CDATA when format is html5" do
haml = ":css\n foo bar"
out = render(haml, :format => :html5)
refute_match('<![CDATA[', out)
refute_match(']]>', out)
end
end
class CDATAFilterTest < Haml::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 < Haml::TestCase
test "should escape ampersands" do
html = "&\n"
haml = ":escaped\n &"
assert_equal(html, render(haml))
end
end
class RubyFilterTest < Haml::TestCase
test "can write to haml_io" do
haml = ":ruby\n haml_io.puts 'hello'\n"
html = "hello\n"
assert_equal(html, render(haml))
end
test "haml_io appends to output" do
haml = "hello\n:ruby\n haml_io.puts 'hello'\n"
html = "hello\nhello\n"
assert_equal(html, render(haml))
end
test "can create local variables" do
haml = ":ruby\n a = 7\n=a"
html = "7\n"
assert_equal(html, render(haml))
end
test "can render empty filter" do
haml = ":ruby\n%foo"
html = "<foo></foo>\n"
assert_equal(html, render(haml))
end
end