condensation 1.5.0 → 1.6.0

data/spec/condensation/filters/hmac_sha256_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe Condensation::Filters::HmacSha256 do
+  def render_with_filter(template, context)
+    template.render(context, filters: [Condensation::Filters::HmacSha256])
+  end
+
+  it 'should convert a string into a SHA-256 hash using a hash message authentication code' do
+    template = Liquid::Template.parse("{{ text | hmac_sha256: 'abcd' }}")
+
+    result = render_with_filter(template, 'text' => 'The foo to the bar')
+    result.must_equal 'ea8ffbac691e798b71e9604fd8cbd58a55618f5b29bb1dbd781aac769edb2901'
+  end
+
+  it 'should handle nil values' do
+    template = Liquid::Template.parse("{{ text | hmac_sha256: '' }}")
+
+    result = render_with_filter(template, 'text' => nil)
+    result.must_equal ''
+  end
+end

data/spec/condensation/filters/hyperlink_spec.rb

@@ -2,49 +2,49 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::Hyperlink do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::Hyperlink])
+    template.render(context, filters: [Condensation::Filters::Hyperlink])
   end
 
-  it "should use the URL as the anchor text if none provided" do
-    url = "http://www.example.com"
-    template = Liquid::Template.parse("{{ url | hyperlink }}")
-    result = render_with_filter(template, { "url" => url })
+  it 'should use the URL as the anchor text if none provided' do
+    url = 'http://www.example.com'
+    template = Liquid::Template.parse('{{ url | hyperlink }}')
+    result = render_with_filter(template, 'url' => url)
     result.must_equal "<a href='#{url}'>#{url}</a>"
   end
 
-  it "should use the provided anchor text" do
-    url = "http://www.example.com"
+  it 'should use the provided anchor text' do
+    url = 'http://www.example.com'
     template = Liquid::Template.parse("{{ url | hyperlink: 'Click here!' }}")
-    result = render_with_filter(template, { "url" => url })
+    result = render_with_filter(template, 'url' => url)
     result.must_equal "<a href='#{url}'>Click here!</a>"
   end
 
-  it "should escape HTML in the URL" do
-    url = "<script>attack.me()</script>"
-    escaped = "&lt;script&gt;attack.me()&lt;/script&gt;"
-    template = Liquid::Template.parse("{{ url | hyperlink }}")
-    result = render_with_filter(template, { "url" => url })
+  it 'should escape HTML in the URL' do
+    url = '<script>attack.me()</script>'
+    escaped = '&lt;script&gt;attack.me()&lt;/script&gt;'
+    template = Liquid::Template.parse('{{ url | hyperlink }}')
+    result = render_with_filter(template, 'url' => url)
     result.must_equal "<a href='#{escaped}'>#{escaped}</a>"
   end
 
-  it "should escape HTML in the anchor text" do
-    url = "http://www.example.com"
-    text = "<script>attack.me()</script>"
-    escaped = "&lt;script&gt;attack.me()&lt;/script&gt;"
+  it 'should escape HTML in the anchor text' do
+    url = 'http://www.example.com'
+    text = '<script>attack.me()</script>'
+    escaped = '&lt;script&gt;attack.me()&lt;/script&gt;'
     template = Liquid::Template.parse("{{ url | hyperlink: '#{text}' }}")
-    result = render_with_filter(template, { "url" => url })
+    result = render_with_filter(template, 'url' => url)
     result.must_equal "<a href='#{url}'>#{escaped}</a>"
   end
 
-  it "should return empty string if input is nil" do
-    template = Liquid::Template.parse("{{ url | hyperlink }}")
+  it 'should return empty string if input is nil' do
+    template = Liquid::Template.parse('{{ url | hyperlink }}')
     result = render_with_filter(template, {})
-    result.must_equal ""
+    result.must_equal ''
   end
 
-  it "should handle numeric input" do
+  it 'should handle numeric input' do
     template = Liquid::Template.parse("{{ url | hyperlink: 'Bar' }}")
-    result = render_with_filter(template, { "url" => 1 })
+    result = render_with_filter(template, 'url' => 1)
     result.must_equal "<a href='1'>Bar</a>"
   end
 end

data/spec/condensation/filters/in_time_zone_spec.rb

@@ -2,24 +2,24 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::InTimeZone do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::InTimeZone])
+    template.render(context, filters: [Condensation::Filters::InTimeZone])
   end
 
-  it "should handle UTC ISO 8601 dates" do
-    created_at = "2015-01-01T10:00:00Z"
+  it 'should handle UTC ISO 8601 dates' do
+    created_at = '2015-01-01T10:00:00Z'
     template = Liquid::Template.parse("{{ created_at | in_time_zone: 'America/Los_Angeles' }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "2015-01-01 02:00:00 -0800"
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '2015-01-01 02:00:00 -0800'
 
     template = Liquid::Template.parse("{{ created_at | in_time_zone: 'Indian/Maldives' }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "2015-01-01 15:00:00 +0500"
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '2015-01-01 15:00:00 +0500'
   end
 
-  it "should handle Time input" do
+  it 'should handle Time input' do
     created_at = Time.utc(2015, 1, 1, 10, 0, 0)
     template = Liquid::Template.parse("{{ created_at | in_time_zone: 'America/Los_Angeles' }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "2015-01-01 02:00:00 -0800"
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '2015-01-01 02:00:00 -0800'
   end
 end

data/spec/condensation/filters/md5_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe Condensation::Filters::MD5 do
+  def render_with_filter(template, context)
+    template.render(context, filters: [Condensation::Filters::MD5])
+  end
+
+  it 'should return a MD5 hash of the input' do
+    template = Liquid::Template.parse('{{ text | md5 }}')
+
+    result = render_with_filter(template, 'text' => 'The foo to the bar')
+    result.must_equal '9dd755a53b119d3e8d7106aafe7d9d44'
+  end
+
+  it 'should handle nil values' do
+    template = Liquid::Template.parse('{{ text | md5 }}')
+
+    result = render_with_filter(template, 'text' => nil)
+    result.must_equal ''
+  end
+end

data/spec/condensation/filters/replace_inner_html_spec.rb

@@ -2,17 +2,17 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::ReplaceInnerHTML do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::ReplaceInnerHTML])
+    template.render(context, filters: [Condensation::Filters::ReplaceInnerHTML])
   end
 
-  it "should replace the inner content of a given HTML tag" do
+  it 'should replace the inner content of a given HTML tag' do
     tag = "<a href='http://www.example.com'>Foo</a>"
     template = Liquid::Template.parse("{{ example_link | replace_inner_html: 'Bar' }}")
-    result = render_with_filter(template, { "example_link" => tag })
+    result = render_with_filter(template, 'example_link' => tag)
     result.must_equal "<a href='http://www.example.com'>Bar</a>"
   end
 
-  it "should not alter malformed input" do
+  it 'should not alter malformed input' do
     tags = [
       "< a href='http://www.example.com'>Foo</a>",
       "<a href='http://www.example.com'>Foo< /a>",
@@ -22,20 +22,20 @@ describe Condensation::Filters::ReplaceInnerHTML do
 
     tags.each do |tag|
       template = Liquid::Template.parse("{{ example_link | replace_inner_html: 'Bar' }}")
-      result = render_with_filter(template, { "example_link" => tag })
+      result = render_with_filter(template, 'example_link' => tag)
       result.must_equal tag
     end
   end
 
-  it "should return empty string if input is nil" do
+  it 'should return empty string if input is nil' do
     template = Liquid::Template.parse("{{ example_link | replace_inner_html: 'Bar' }}")
     result = render_with_filter(template, {})
-    result.must_equal ""
+    result.must_equal ''
   end
 
-  it "should handle numeric input" do
+  it 'should handle numeric input' do
     template = Liquid::Template.parse("{{ example_link | replace_inner_html: 'Bar' }}")
-    result = render_with_filter(template, { "example_link" => 1 })
-    result.must_equal "1"
+    result = render_with_filter(template, 'example_link' => 1)
+    result.must_equal '1'
   end
 end

data/spec/condensation/filters/strip_commas_spec.rb

@@ -2,20 +2,20 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::StripCommas do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::StripCommas])
+    template.render(context, filters: [Condensation::Filters::StripCommas])
   end
 
-  it "remove commas" do
-    tag = "foo, bar, bop"
-    template = Liquid::Template.parse("{{ tag | strip_commas }}")
-    result = render_with_filter(template, { "tag" => tag })
-    result.must_equal "foo bar bop"
+  it 'remove commas' do
+    tag = 'foo, bar, bop'
+    template = Liquid::Template.parse('{{ tag | strip_commas }}')
+    result = render_with_filter(template, 'tag' => tag)
+    result.must_equal 'foo bar bop'
   end
 
-  it "should handle nil values" do
+  it 'should handle nil values' do
     tag = nil
-    template = Liquid::Template.parse("{{ tags | strip_commas }}")
-    result = render_with_filter(template, { "tag" => tag })
-    result.must_equal ""
+    template = Liquid::Template.parse('{{ tags | strip_commas }}')
+    result = render_with_filter(template, 'tag' => tag)
+    result.must_equal ''
   end
 end

data/spec/condensation/filters/timestamp_spec.rb

@@ -2,63 +2,63 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::Timestamp do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::Timestamp])
+    template.render(context, filters: [Condensation::Filters::Timestamp])
   end
 
-  it "should handle UTC ISO 8601 dates" do
-    created_at = "2015-06-11T10:00:00Z" # a Thursday
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
+  it 'should handle UTC ISO 8601 dates' do
+    created_at = '2015-06-11T10:00:00Z' # a Thursday
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
     result.must_equal Time.parse(created_at).to_i.to_s
   end
 
-  it "should handle non-UTC ISO 8601 dates" do
-    created_at = "2015-06-11T20:00:00-07:00" # a Thursday
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
+  it 'should handle non-UTC ISO 8601 dates' do
+    created_at = '2015-06-11T20:00:00-07:00' # a Thursday
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
     result.must_equal Time.parse(created_at).to_i.to_s
   end
 
-  it "should handle YMD formatted dates" do
-    created_at = "2015-06-11" # a Thursday
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
+  it 'should handle YMD formatted dates' do
+    created_at = '2015-06-11' # a Thursday
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
     result.must_equal Time.parse(created_at).to_i.to_s
   end
 
-  it "should handle UTC Time input" do
+  it 'should handle UTC Time input' do
     created_at = Time.utc(2015, 6, 11, 10, 0, 0) # a Thursday
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
     result.must_equal created_at.to_i.to_s
   end
 
-  it "should handle non-UTC ActiveSupport::TimeWithZone input" do
-    zone = ActiveSupport::TimeZone["Indian/Maldives"] # UTC+05:00
+  it 'should handle non-UTC ActiveSupport::TimeWithZone input' do
+    zone = ActiveSupport::TimeZone['Indian/Maldives'] # UTC+05:00
     created_at = Time.utc(2015, 6, 11, 10, 0, 0).in_time_zone(zone) # Thu, 11 Jun 2015 15:00:00 MVT +05:00
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
     result.must_equal created_at.to_i.to_s
   end
 
-  it "should render an error given an invalid date" do
-    created_at = "foo"
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "Liquid error: cannot convert foo to timestamp"
+  it 'should render an error given an invalid date' do
+    created_at = 'foo'
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal 'Liquid error: cannot convert foo to timestamp'
   end
 
-  it "should handle empty string input" do
-    created_at = ""
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal ""
+  it 'should handle empty string input' do
+    created_at = ''
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal ''
   end
 
-  it "should handle nil input" do
+  it 'should handle nil input' do
     created_at = nil
-    template = Liquid::Template.parse("{{ created_at | timestamp }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal ""
+    template = Liquid::Template.parse('{{ created_at | timestamp }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal ''
   end
 end

data/spec/condensation/filters/url_encode_spec.rb

@@ -2,20 +2,20 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::UrlEncode do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::UrlEncode])
+    template.render(context, filters: [Condensation::Filters::UrlEncode])
   end
 
-  it "encode the input" do
-    email = "derrick+1@example.com"
-    template = Liquid::Template.parse("{{ email | url_encode }}")
-    result = render_with_filter(template, { "email" => email })
-    result.must_equal "derrick%2B1%40example.com"
+  it 'encode the input' do
+    email = 'derrick+1@example.com'
+    template = Liquid::Template.parse('{{ email | url_encode }}')
+    result = render_with_filter(template, 'email' => email)
+    result.must_equal 'derrick%2B1%40example.com'
   end
 
-  it "should handle nil values" do
+  it 'should handle nil values' do
     email = nil
-    template = Liquid::Template.parse("{{ email | url_encode }}")
-    result = render_with_filter(template, { "email" => email })
-    result.must_equal ""
+    template = Liquid::Template.parse('{{ email | url_encode }}')
+    result = render_with_filter(template, 'email' => email)
+    result.must_equal ''
   end
 end

data/spec/condensation/filters/weeks_since_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe Condensation::Filters::WeeksSince do
   def render_with_filter(template, context)
-    template.render(context, :filters => [Condensation::Filters::WeeksSince])
+    template.render(context, filters: [Condensation::Filters::WeeksSince])
   end
 
   let(:now) do
@@ -17,52 +17,52 @@ describe Condensation::Filters::WeeksSince do
     Timecop.return
   end
 
-  it "should handle UTC ISO 8601 dates" do
-    created_at = "2014-05-15T10:00:00Z"
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "2"
+  it 'should handle UTC ISO 8601 dates' do
+    created_at = '2014-05-15T10:00:00Z'
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '2'
   end
 
-  it "should handle non-UTC ISO 8601 dates" do
-    created_at = "2014-05-15T20:00:00-07:00"
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "1"
+  it 'should handle non-UTC ISO 8601 dates' do
+    created_at = '2014-05-15T20:00:00-07:00'
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '1'
   end
 
-  it "should handle Time input" do
+  it 'should handle Time input' do
     created_at = Time.utc(2014, 5, 1, 0, 0, 0)
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "4"
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '4'
   end
 
-  it "should handle malformed dates" do
-    created_at = "foo"
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal ""
+  it 'should handle malformed dates' do
+    created_at = 'foo'
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal ''
   end
 
-  it "should be zero for times in the future" do
-    created_at = "2014-06-01T20:00:00Z"
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal "0"
+  it 'should be zero for times in the future' do
+    created_at = '2014-06-01T20:00:00Z'
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal '0'
   end
 
-  it "should handle empty string input" do
-    created_at = ""
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal ""
+  it 'should handle empty string input' do
+    created_at = ''
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal ''
   end
 
-  it "should handle nil input" do
+  it 'should handle nil input' do
     created_at = nil
-    template = Liquid::Template.parse("{{ created_at | weeks_since }}")
-    result = render_with_filter(template, { "created_at" => created_at })
-    result.must_equal ""
+    template = Liquid::Template.parse('{{ created_at | weeks_since }}')
+    result = render_with_filter(template, 'created_at' => created_at)
+    result.must_equal ''
   end
 end