padrino-helpers 0.16.0.pre4 → 0.16.0

data/lib/padrino-helpers/format_helpers.rb

@@ -53,7 +53,7 @@ module Padrino
       #   strip_tags("<b>Hey</b>") => "Hey"
       #
       def strip_tags(html)
-        html.gsub(/<\/?[^>]*>/, "") if html
+        html&.gsub(%r{</?[^>]*>}, '')
       end
 
       ##
@@ -72,9 +72,9 @@ module Padrino
       #
       # @example
       #   simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
-      #   simple_format("hello\nworld", :tag => :div, :class => :foo) # => "<div class="foo">hello<br/>world</div>"
+      #   simple_format("hello\nworld", tag: :div, class: :foo) # => "<div class="foo">hello<br/>world</div>"
       #
-      def simple_format(text, options={})
+      def simple_format(text, options = {})
         t = options.delete(:tag) || :p
         start_tag = tag(t, options, true)
         text = escape_html(text.to_s.dup) unless text.html_safe?
@@ -103,7 +103,7 @@ module Padrino
       #   pluralize(2, 'person') => '2 people'
       #
       def pluralize(count, singular, plural = nil)
-        "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
+        "#{count || 0} " + ([1, '1'].include?(count) ? singular : (plural || singular.pluralize))
       end
 
       ##
@@ -122,15 +122,15 @@ module Padrino
       # @return [String] The text truncated after the given number of characters.
       #
       # @example
-      #   truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
-      #
-      def truncate(text, options={})
-        options = { :length => 30, :omission => "..." }.update(options)
-        if text
-          len = options[:length] - options[:omission].length
-          chars = text
-          (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
-        end
+      #   truncate('Once upon a time in a world far far away', length: 8) => "Once upon..."
+      #
+      def truncate(text, options = {})
+        options = { length: 30, omission: '...' }.update(options)
+        return unless text
+
+        len = options[:length] - options[:omission].length
+        chars = text
+        (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
       end
 
       ##
@@ -149,14 +149,14 @@ module Padrino
       # @return [String] The text truncated after the given number of words.
       #
       # @example
-      #   truncate_words("Once upon a time in a world far far away", :length => 8) => "Once upon a time in a world far..."
+      #   truncate_words('Once upon a time in a world far far away', length: 8) => "Once upon a time in a world far..."
       #
-      def truncate_words(text, options={})
-        options = { :length => 30, :omission => "..." }.update(options)
-        if text
-          words = text.split()
-          words[0..(options[:length]-1)].join(' ') + (words.length > options[:length] ? options[:omission] : '')
-        end
+      def truncate_words(text, options = {})
+        options = { length: 30, omission: '...' }.update(options)
+        return unless text
+
+        words = text.split
+        words[0..(options[:length] - 1)].join(' ') + (words.length > options[:length] ? options[:omission] : '')
       end
 
       ##
@@ -174,14 +174,12 @@ module Padrino
       # @return [String] The text with line wraps for lines longer then +line_width+.
       #
       # @example
-      #   word_wrap('Once upon a time', :line_width => 8) => "Once upon\na time"
+      #   word_wrap('Once upon a time', line_width: 8) => "Once upon\na time"
       #
       def word_wrap(text, *args)
         options = args.last.is_a?(Hash) ? args.pop : {}
-        unless args.empty?
-          options[:line_width] = args[0] || 80
-        end
-        options = { :line_width => 80 }.update(options)
+        options[:line_width] = args[0] || 80 unless args.empty?
+        options = { line_width: 80 }.update(options)
 
         text.split("\n").map do |line|
           line.length > options[:line_width] ? line.gsub(/(.{1,#{options[:line_width]}})(\s+|$)/, "\\1\n").strip : line
@@ -210,11 +208,11 @@ module Padrino
       #   highlight('Lorem ipsum dolor sit amet', 'dolor')
       #   # => Lorem ipsum <strong class="highlight">dolor</strong> sit amet
       #
-      #   highlight('Lorem ipsum dolor sit amet', 'dolor', :highlighter => '<span class="custom">\1</span>')
+      #   highlight('Lorem ipsum dolor sit amet', 'dolor', highlighter: '<span class="custom">\1</span>')
       #   # => Lorem ipsum <strong class="custom">dolor</strong> sit amet
       #
       def highlight(text, words, *args)
-        options = { :highlighter => '<strong class="highlight">\1</strong>' }.update(args.last.is_a?(Hash) ? args.pop : {})
+        options = { highlighter: '<strong class="highlight">\1</strong>' }.update(args.last.is_a?(Hash) ? args.pop : {})
 
         if text.empty? || words.empty?
           text
@@ -286,47 +284,47 @@ module Padrino
       def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false, options = {})
         from_time = from_time.to_time if from_time.respond_to?(:to_time)
         to_time = to_time.to_time if to_time.respond_to?(:to_time)
-        distance_in_minutes = (((to_time.to_i - from_time.to_i).abs)/60).round
-        distance_in_seconds = ((to_time.to_i - from_time.to_i).abs).round
+        distance_in_minutes = ((to_time.to_i - from_time.to_i).abs / 60).round
+        distance_in_seconds = (to_time.to_i - from_time.to_i).abs.round
 
         phrase, locals =
           case distance_in_minutes
-            when 0..1
-              if include_seconds
-                case distance_in_seconds
-                  when 0..4   then [:less_than_x_seconds, :count => 5 ]
-                  when 5..9   then [:less_than_x_seconds, :count => 10]
-                  when 10..19 then [:less_than_x_seconds, :count => 20]
-                  when 20..39 then [:half_a_minute                    ]
-                  when 40..59 then [:less_than_x_minutes, :count => 1 ]
-                  else             [:x_minutes,           :count => 1 ]
-                end
-              else
-                distance_in_minutes == 0 ?
-                  [:less_than_x_minutes, :count => 1] :
-                  [:x_minutes, :count => distance_in_minutes]
+          when 0..1
+            if include_seconds
+              case distance_in_seconds
+              when 0..4   then [:less_than_x_seconds, { count: 5 }]
+              when 5..9   then [:less_than_x_seconds, { count: 10 }]
+              when 10..19 then [:less_than_x_seconds, { count: 20 }]
+              when 20..39 then [:half_a_minute]
+              when 40..59 then [:less_than_x_minutes, { count: 1 }]
+              else             [:x_minutes,           { count: 1 }]
               end
-            when 2..44           then [:x_minutes,      :count => distance_in_minutes                       ]
-            when 45..89          then [:about_x_hours,  :count => 1                                         ]
-            when 90..1439        then [:about_x_hours,  :count => (distance_in_minutes.to_f / 60.0).round   ]
-            when 1440..2529      then [:x_days,         :count => 1                                         ]
-            when 2530..43199     then [:x_days,         :count => (distance_in_minutes.to_f / 1440.0).round ]
-            when 43200..86399    then [:about_x_months, :count => 1                                         ]
-            when 86400..525599   then [:x_months,       :count => (distance_in_minutes.to_f / 43200.0).round]
+            elsif distance_in_minutes.zero?
+              [:less_than_x_minutes, { count: 1 }]
             else
-              distance_in_years           = distance_in_minutes / 525600
-              minute_offset_for_leap_year = (distance_in_years / 4) * 1440
-              remainder                   = ((distance_in_minutes - minute_offset_for_leap_year) % 525600)
-              if remainder < 131400
-                [:about_x_years,  :count => distance_in_years]
-              elsif remainder < 394200
-                [:over_x_years,   :count => distance_in_years]
-              else
-                [:almost_x_years, :count => distance_in_years + 1]
-              end
+              [:x_minutes, { count: distance_in_minutes }]
+            end
+          when 2..44             then [:x_minutes,      { count: distance_in_minutes }]
+          when 45..89            then [:about_x_hours,  { count: 1 }]
+          when 90..1439          then [:about_x_hours,  { count: (distance_in_minutes.to_f / 60.0).round }]
+          when 1440..2529        then [:x_days,         { count: 1 }]
+          when 2530..43_199      then [:x_days,         { count: (distance_in_minutes.to_f / 1440.0).round }]
+          when 43_200..86_399    then [:about_x_months, { count: 1 }]
+          when 86_400..525_599   then [:x_months,       { count: (distance_in_minutes.to_f / 43_200.0).round }]
+          else
+            distance_in_years           = distance_in_minutes / 525_600
+            minute_offset_for_leap_year = (distance_in_years / 4) * 1440
+            remainder                   = ((distance_in_minutes - minute_offset_for_leap_year) % 525_600)
+            if remainder < 131_400
+              [:about_x_years,  { count: distance_in_years }]
+            elsif remainder < 394_200
+              [:over_x_years,   { count: distance_in_years }]
+            else
+              [:almost_x_years, { count: distance_in_years + 1 }]
+            end
           end
 
-        I18n.translate phrase, :count => locals[:count], :locale => options[:locale], :scope => :'datetime.distance_in_words'
+        I18n.translate phrase, count: locals[:count], locale: options[:locale], scope: :'datetime.distance_in_words'
       end
 
       ##
@@ -362,11 +360,11 @@ module Padrino
       def js_escape_html(html_content)
         return '' unless html_content
         javascript_mapping = { '\\' => '\\\\', '</' => '<\/', "\r\n" => '\n', "\n" => '\n', "\r" => '\n', '"' => '\\"', "'" => "\\'" }
-        escaped_content = html_content.gsub(/(\\|<\/|\r\n|[\n\r"'])/){ |m| javascript_mapping[m] }
+        escaped_content = html_content.gsub(%r{(\\|</|\r\n|[\n\r"'])}) { |m| javascript_mapping[m] }
         escaped_content = escaped_content.html_safe if html_content.html_safe?
         escaped_content
       end
-      alias :escape_javascript :js_escape_html
+      alias escape_javascript js_escape_html
     end
   end
 end

data/lib/padrino-helpers/number_helpers.rb

@@ -32,19 +32,19 @@ module Padrino
       # @return [String] The formatted representation of the currency.
       #
       # @example
-      #   number_to_currency(1234567890.50)                    # => $1,234,567,890.50
-      #   number_to_currency(1234567890.506)                   # => $1,234,567,890.51
-      #   number_to_currency(1234567890.506, :precision => 3)  # => $1,234,567,890.506
-      #   number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "")
+      #   number_to_currency(1234567890.50)                 # => $1,234,567,890.50
+      #   number_to_currency(1234567890.506)                # => $1,234,567,890.51
+      #   number_to_currency(1234567890.506, precision: 3)  # => $1,234,567,890.506
+      #   number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '')
       #   # => £1234567890,50
-      #   number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "", :format => "%n %u")
+      #   number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '', format: '%n %u')
       #   # => 1234567890,50 £
       #
       def number_to_currency(number, options = {})
         options = Utils.symbolize_keys(options)
 
-        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = I18n.translate(:'number.format', locale: options[:locale], raise: true) rescue {}
+        currency  = I18n.translate(:'number.currency.format', locale: options[:locale], raise: true) rescue {}
         defaults  = defaults.merge(currency)
 
         precision = options[:precision] || defaults[:precision]
@@ -52,15 +52,12 @@ module Padrino
         separator = options[:separator] || defaults[:separator]
         delimiter = options[:delimiter] || defaults[:delimiter]
         format    = options[:format]    || defaults[:format]
-        separator = '' if precision == 0
+        separator = '' if precision.zero?
 
         begin
-          format.gsub(/%n/, number_with_precision(number,
-            :precision => precision,
-            :delimiter => delimiter,
-            :separator => separator)
-          ).gsub(/%u/, unit)
-        rescue
+          value = number_with_precision(number, precision: precision, delimiter: delimiter, separator: separator)
+          format.gsub(/%n/, value).gsub(/%u/, unit)
+        rescue StandardError
           number
         end
       end
@@ -83,16 +80,16 @@ module Padrino
       # @return [String] The formatted representation of the percentage
       #
       # @example
-      #   number_to_percentage(100)                                        # => 100.000%
-      #   number_to_percentage(100, :precision => 0)                       # => 100%
-      #   number_to_percentage(1000, :delimiter => '.', :separator => ',') # => 1.000,000%
-      #   number_to_percentage(302.24398923423, :precision => 5)           # => 302.24399%
+      #   number_to_percentage(100)                                   # => 100.000%
+      #   number_to_percentage(100, precision: 0)                     # => 100%
+      #   number_to_percentage(1000, delimiter: '.', separator: ',')  # => 1.000,000%
+      #   number_to_percentage(302.24398923423, precision: 5)         # => 302.24399%
       #
       def number_to_percentage(number, options = {})
         options = Utils.symbolize_keys(options)
 
-        defaults   = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        percentage = I18n.translate(:'number.percentage.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults   = I18n.translate(:'number.format', locale: options[:locale], raise: true) rescue {}
+        percentage = I18n.translate(:'number.percentage.format', locale: options[:locale], raise: true) rescue {}
         defaults  = defaults.merge(percentage)
 
         precision = options[:precision] || defaults[:precision]
@@ -100,11 +97,13 @@ module Padrino
         delimiter = options[:delimiter] || defaults[:delimiter]
 
         begin
-          number_with_precision(number,
-            :precision => precision,
-            :separator => separator,
-            :delimiter => delimiter) + "%"
-        rescue
+          number_with_precision(
+            number,
+            precision: precision,
+            separator: separator,
+            delimiter: delimiter
+          ) + '%'
+        rescue StandardError
           number
         end
       end
@@ -113,7 +112,7 @@ module Padrino
       # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
       # customize the format in the +options+ hash.
       #
-      # @overload number_with_delimiter(number, options={})
+      # @overload number_with_delimiter(number, options = {})
       #   @param [Integer, Float] number
       #     Number value to format.
       #   @param [Hash] options
@@ -126,26 +125,26 @@ module Padrino
       # @return [String] The formatted representation of the number.
       #
       # @example
-      #   number_with_delimiter(12345678)                        # => 12,345,678
-      #   number_with_delimiter(12345678.05)                     # => 12,345,678.05
-      #   number_with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
-      #   number_with_delimiter(12345678, :separator => ",")     # => 12,345,678
-      #   number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
+      #   number_with_delimiter(12345678)                     # => 12,345,678
+      #   number_with_delimiter(12345678.05)                  # => 12,345,678.05
+      #   number_with_delimiter(12345678, delimiter: '.')     # => 12.345.678
+      #   number_with_delimiter(12345678, separator: ',')     # => 12,345,678
+      #   number_with_delimiter(98765432.98, delimiter: ' ', separator: ',')
       #   # => 98 765 432,98
       #
       def number_with_delimiter(number, *args)
         options = args.last.is_a?(Hash) ? Utils.symbolize_keys(args.pop) : {}
 
-        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults = I18n.translate(:'number.format', locale: options[:locale], raise: true) rescue {}
 
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
-        separator ||= (options[:separator] || defaults[:separator])
+        delimiter ||= options[:delimiter] || defaults[:delimiter]
+        separator ||= options[:separator] || defaults[:separator]
 
         begin
           parts = number.to_s.split('.')
           parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
           parts.join(separator)
-        rescue
+        rescue StandardError
           number
         end
       end
@@ -154,7 +153,7 @@ module Padrino
       # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
       # You can customize the format in the +options+ hash.
       #
-      # @overload number_with_precision(number, options={})
+      # @overload number_with_precision(number, options = {})
       #   @param [Integer, Float] number
       #     Number value to format.
       #   @param [Hash] options
@@ -169,37 +168,39 @@ module Padrino
       # @return [String] The formatted representation of the number.
       #
       # @example
-      #   number_with_precision(111.2345)                    # => 111.235
-      #   number_with_precision(111.2345, :precision => 2)   # => 111.23
-      #   number_with_precision(13, :precision => 5)         # => 13.00000
-      #   number_with_precision(389.32314, :precision => 0)  # => 389
-      #   number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
+      #   number_with_precision(111.2345)                 # => 111.235
+      #   number_with_precision(111.2345, precision: 2)   # => 111.23
+      #   number_with_precision(13, precision: 5)         # => 13.00000
+      #   number_with_precision(389.32314, precision: 0)  # => 389
+      #   number_with_precision(1111.2345, precision: 2, separator: ',', delimiter: '.')
       #   # => 1.111,23
       #
       def number_with_precision(number, *args)
         options = args.last.is_a?(Hash) ? Utils.symbolize_keys(args.pop) : {}
 
-        defaults           = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale],
-                                                                        :raise => true) rescue {}
+        defaults           = I18n.translate(:'number.format', locale: options[:locale], raise: true) rescue {}
+        precision_defaults = I18n.translate(:'number.precision.format', locale: options[:locale],
+                                                                        raise: true) rescue {}
         defaults           = defaults.merge(precision_defaults)
 
-        precision ||= (options[:precision] || defaults[:precision])
-        separator ||= (options[:separator] || defaults[:separator])
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        precision ||= options[:precision] || defaults[:precision]
+        separator ||= options[:separator] || defaults[:separator]
+        delimiter ||= options[:delimiter] || defaults[:delimiter]
 
         begin
-          rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
-          number_with_delimiter("%01.#{precision}f" % rounded_number,
-            :separator => separator,
-            :delimiter => delimiter)
-        rescue
+          rounded_number = (Float(number) * (10**precision)).round.to_f / 10**precision
+          number_with_delimiter(
+            format("%01.#{precision}f", rounded_number),
+            separator: separator,
+            delimiter: delimiter
+          )
+        rescue StandardError
           number
         end
       end
 
       # The units available for storage formatting.
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
+      STORAGE_UNITS = %i[byte kb mb gb tb].freeze
 
       ##
       # Formats the bytes in +size+ into a more understandable representation
@@ -209,7 +210,7 @@ module Padrino
       # format in the +options+ hash.
       #
       #
-      # @overload number_to_human_size(number, options={})
+      # @overload number_to_human_size(number, options = {})
       #   @param [Integer] number
       #     Number value to format.
       #   @param [Hash] options
@@ -224,53 +225,56 @@ module Padrino
       # @return [String] The formatted representation of bytes
       #
       # @example
-      #   number_to_human_size(123)                                          # => 123 Bytes
-      #   number_to_human_size(1234)                                         # => 1.2 KB
-      #   number_to_human_size(12345)                                        # => 12.1 KB
-      #   number_to_human_size(1234567)                                      # => 1.2 MB
-      #   number_to_human_size(1234567890)                                   # => 1.1 GB
-      #   number_to_human_size(1234567890123)                                # => 1.1 TB
-      #   number_to_human_size(1234567, :precision => 2)                     # => 1.18 MB
-      #   number_to_human_size(483989, :precision => 0)                      # => 473 KB
-      #   number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
+      #   number_to_human_size(123)                                    # => 123 Bytes
+      #   number_to_human_size(1234)                                   # => 1.2 KB
+      #   number_to_human_size(12345)                                  # => 12.1 KB
+      #   number_to_human_size(1234567)                                # => 1.2 MB
+      #   number_to_human_size(1234567890)                             # => 1.1 GB
+      #   number_to_human_size(1234567890123)                          # => 1.1 TB
+      #   number_to_human_size(1234567, precision: 2)                  # => 1.18 MB
+      #   number_to_human_size(483989, precision: 0)                   # => 473 KB
+      #   number_to_human_size(1234567, precision: 2, separator: ',')  # => 1,18 MB
       #
       def number_to_human_size(number, *args)
         return nil if number.nil?
 
         options = args.last.is_a?(Hash) ? Utils.symbolize_keys(args.pop) : {}
 
-        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults = I18n.translate(:'number.format', locale: options[:locale], raise: true) rescue {}
+        human    = I18n.translate(:'number.human.format', locale: options[:locale], raise: true) rescue {}
         defaults = defaults.merge(human)
 
-        precision ||= (options[:precision] || defaults[:precision])
-        separator ||= (options[:separator] || defaults[:separator])
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        precision ||= options[:precision] || defaults[:precision]
+        separator ||= options[:separator] || defaults[:separator]
+        delimiter ||= options[:delimiter] || defaults[:delimiter]
 
-        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+        storage_units_format = I18n.translate(:'number.human.storage_units.format', locale: options[:locale], raise: true)
 
         if number.to_i < 1024
-          unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
+          unit = I18n.translate(:'number.human.storage_units.units.byte', locale: options[:locale], count: number.to_i, raise: true)
           storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
         else
           max_exp  = STORAGE_UNITS.size - 1
           number   = Float(number)
           exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
           exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-          number  /= 1024 ** exponent
+          number  /= 1024**exponent
 
           unit_key = STORAGE_UNITS[exponent]
-          unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
+          unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", locale: options[:locale], count: number, raise: true)
 
           begin
             escaped_separator = Regexp.escape(separator)
-            formatted_number = number_with_precision(number,
-              :precision => precision,
-              :separator => separator,
-              :delimiter => delimiter
-            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            formatted_number =
+              number_with_precision(
+                number,
+                precision: precision,
+                separator: separator,
+                delimiter: delimiter
+              ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+
             storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
-          rescue
+          rescue StandardError
             number
           end
         end

data/lib/padrino-helpers/output_helpers/abstract_handler.rb

@@ -16,6 +16,7 @@ module Padrino
         #   @handler.engine_matches?(block) => true
         #
         def engine_matches?(block)
+          false
         end
 
         ##
@@ -29,11 +30,12 @@ module Padrino
         #   @handler.capture_from_template(&block) => "...html..."
         #
         def capture_from_template(*args, &block)
-          self.output_buffer, _buf_was = SafeBuffer.new, self.output_buffer
+          self.output_buffer, buf_was = SafeBuffer.new, self.output_buffer
           raw = yield(*args)
           captured = template.instance_variable_get(:@_out_buf)
-          self.output_buffer = _buf_was
           engine_matches?(block) && !captured.empty? ? captured : raw.to_s
+        ensure
+          self.output_buffer = buf_was
         end
 
         ##
@@ -46,7 +48,7 @@ module Padrino
         # @example
         #   @handler.concat_to_template("This will be output to the template buffer")
         #
-        def concat_to_template(text="", context=nil)
+        def concat_to_template(text = '', context = nil)
           text
         end
 

data/lib/padrino-helpers/output_helpers/erb_handler.rb

@@ -8,8 +8,8 @@ module Padrino
         ##
         # Outputs the given text to the templates buffer directly.
         #
-        def concat_to_template(text="", context=nil)
-          return text if context && context.eval("@__in_ruby_literal")
+        def concat_to_template(text = '', context = nil)
+          return text if context&.eval('@__in_ruby_literal')
           output_buffer << text
           nil
         end

data/lib/padrino-helpers/output_helpers/haml_handler.rb

@@ -2,7 +2,7 @@ module Padrino
   module Helpers
     module OutputHelpers
       # Haml and Hamlit require different detection code
-      if defined?(Haml) && Tilt.template_for('.haml').to_s == "Padrino::Rendering::HamlTemplate"
+      if defined?(Haml) && Tilt.template_for('.haml').to_s == 'Padrino::Rendering::HamlTemplate'
         ##
         # Handler for Haml templates.
         #