tennpipes-helper 3.6.6

data/lib/tennpipes-helper/form_helpers/errors.rb

@@ -0,0 +1,138 @@
+module Tennpipes
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate form errors.
+      #
+      module Errors
+        ##
+        # Constructs list HTML for the errors for a given symbol.
+        #
+        # @overload error_messages_for(*objects, options = {})
+        #   @param [Array<Object>]  object   Splat of objects to display errors for.
+        #   @param [Hash]           options  Error message display options.
+        #   @option options [String] :header_tag ("h2")
+        #     Used for the header of the error div.
+        #   @option options [String] :id ("field-errors")
+        #     The id of the error div.
+        #   @option options [String] :class ("field-errors")
+        #     The class of the error div.
+        #   @option options [Array<Object>]  :object
+        #     The object (or array of objects) for which to display errors,
+        #     if you need to escape the instance variable convention.
+        #   @option options [String] :object_name
+        #     The object name to use in the header, or any text that you prefer.
+        #     If +:object_name+ is not set, the name of the first object will be used.
+        #   @option options [String] :header_message ("X errors prohibited this object from being saved")
+        #     The message in the header of the error div. Pass +nil+ or an empty string
+        #     to avoid the header message altogether.
+        #   @option options [String] :message ("There were problems with the following fields:")
+        #     The explanation message after the header message and before
+        #     the error list.  Pass +nil+ or an empty string to avoid the explanation message
+        #     altogether.
+        #
+        # @return [String] The html section with all errors for the specified +objects+
+        #
+        # @example
+        #   error_messages_for :user
+        #
+        def error_messages_for(*objects)
+          options = objects.extract_options!.symbolize_keys
+          objects = objects.map{ |obj| resolve_object(obj) }.compact
+          count   = objects.inject(0){ |sum, object| sum + object.errors.count }
+          return ActiveSupport::SafeBuffer.new if count.zero?
+
+          content_tag(:div, error_contents(objects, count, options), error_html_attributes(options))
+        end
+
+        ##
+        # Returns a string containing the error message attached to the
+        # +method+ on the +object+ if one exists.
+        #
+        # @param [Object] object
+        #   The object to display the error for.
+        # @param [Symbol] field
+        #   The field on the +object+ to display the error for.
+        # @param [Hash] options
+        #   The options to control the error display.
+        # @option options [String] :tag ("span")
+        #   The tag that encloses the error.
+        # @option options [String] :prepend ("")
+        #   The text to prepend before the field error.
+        # @option options [String] :append ("")
+        #   The text to append after the field error.
+        #
+        # @example
+        #   # => <span class="error">can't be blank</div>
+        #   error_message_on :post, :title
+        #   error_message_on @post, :title
+        #
+        #   # => <div class="custom" style="border:1px solid red">can't be blank</div>
+        #   error_message_on :post, :title, :tag => :id, :class => :custom, :style => "border:1px solid red"
+        #
+        #   # => <div class="error">This title can't be blank (or it won't work)</div>
+        #   error_message_on :post, :title, :prepend => "This title", :append => "(or it won't work)"
+        #
+        # @return [String] The html display of an error for a particular +object+ and +field+.
+        #
+        # @api public
+        def error_message_on(object, field, options={})
+          error = Array(resolve_object(object).errors[field]).first
+          return ActiveSupport::SafeBuffer.new unless error
+          options = { :tag => :span, :class => :error }.update(options)
+          tag   = options.delete(:tag)
+          error = [options.delete(:prepend), error, options.delete(:append)].compact.join(" ")
+          content_tag(tag, error, options)
+        end
+
+        private
+
+        def error_contents(objects, count, options)
+          object_name = options[:object_name] || objects.first.class.to_s.underscore.gsub(/\//, ' ')
+
+          contents = ActiveSupport::SafeBuffer.new
+          contents << error_header_tag(options, object_name, count)
+          contents << error_body_tag(options)
+          contents << error_list_tag(objects, object_name)
+        end
+
+        def error_list_tag(objects, object_name)
+          errors = objects.inject({}){ |all,object| all.update(object.errors) }
+          error_messages = errors.inject(ActiveSupport::SafeBuffer.new) do |all, (field, message)|
+            field_name = I18n.t(field, :default => field.to_s.humanize, :scope => [:models, object_name, :attributes])
+            all << content_tag(:li, "#{field_name} #{message}")
+          end
+          content_tag(:ul, error_messages)
+        end
+
+        def error_header_tag(options, object_name, count)
+          header_message = options[:header_message] || begin
+            model_name = I18n.t(:name, :default => object_name.humanize, :scope => [:models, object_name], :count => 1)
+            I18n.t :header, :count => count, :model => model_name, :locale => options[:locale], :scope => [:models, :errors, :template]
+          end
+          content_tag(options[:header_tag] || :h2, header_message) if header_message.present?
+        end
+
+        def error_body_tag(options)
+          body_message = options[:message] || I18n.t(:body, :locale => options[:locale], :scope => [:models, :errors, :template])
+          content_tag(:p, body_message) if body_message.present?
+        end
+
+        def error_html_attributes(options)
+          [:id, :class, :style].each_with_object({}) do |key,all|
+            if options.include?(key)
+              value = options[key]
+              all[key] = value unless value.blank?
+            else
+              all[key] = 'field-errors' unless key == :style
+            end
+          end
+        end
+
+        def resolve_object(object)
+          object.is_a?(Symbol) ? instance_variable_get("@#{object}") : object
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-helper/form_helpers/options.rb

@@ -0,0 +1,98 @@
+module Tennpipes
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate options list for select tag.
+      #
+      module Options
+        def extract_option_tags!(options)
+          state = extract_option_state!(options)
+          option_tags = if options[:grouped_options]
+            grouped_options_for_select(options.delete(:grouped_options), state)
+          else
+            options_for_select(extract_option_items!(options), state)
+          end
+          if prompt = options.delete(:include_blank)
+            option_tags.unshift(blank_option(prompt))
+          end
+          option_tags
+        end
+
+        private
+
+        ##
+        # Returns the blank option serving as a prompt if passed.
+        #
+        def blank_option(prompt)
+          case prompt
+          when nil, false
+            nil
+          when String
+            content_tag(:option, prompt,       :value => '')
+          when Array
+            content_tag(:option, prompt.first, :value => prompt.last)
+          else
+            content_tag(:option, '',           :value => '')
+          end
+        end
+
+        ##
+        # Returns whether the option should be selected or not.
+        #
+        # @example
+        #   option_is_selected?("red", "Red", ["red", "blue"])   => true
+        #   option_is_selected?("red", "Red", ["green", "blue"]) => false
+        #
+        def option_is_selected?(value, caption, selected_values)
+          Array(selected_values).any? do |selected|
+            [value.to_s, caption.to_s].include?(selected.to_s)
+          end
+        end
+
+        ##
+        # Returns the options tags for a select based on the given option items.
+        #
+        def options_for_select(option_items, state = {})
+          return [] if option_items.blank?
+          option_items.map do |caption, value, attributes|
+            html_attributes = { :value => value ||= caption }.merge(attributes||{})
+            html_attributes[:selected] ||= option_is_selected?(value, caption, state[:selected])
+            html_attributes[:disabled] ||= option_is_selected?(value, caption, state[:disabled])
+            content_tag(:option, caption, html_attributes)
+          end
+        end
+
+        ##
+        # Returns the optgroups with options tags for a select based on the given :grouped_options items.
+        #
+        def grouped_options_for_select(collection, state = {})
+          collection.map do |item|
+            caption = item.shift
+            attributes = item.last.kind_of?(Hash) ? item.pop : {}
+            value = item.flatten(1)
+            attributes = value.pop if value.last.kind_of?(Hash)
+            html_attributes = { :label => caption }.merge(attributes||{})
+            content_tag(:optgroup, options_for_select(value, state), html_attributes)
+          end
+        end
+
+        def extract_option_state!(options)
+          {
+            :selected => Array(options.delete(:value))|Array(options.delete(:selected))|Array(options.delete(:selected_options)),
+            :disabled => Array(options.delete(:disabled_options))
+          }
+        end
+
+        def extract_option_items!(options)
+          if options[:collection]
+            fields = options.delete(:fields)
+            collection = options.delete(:collection)
+            collection.map{ |item| [ item.send(fields.first), item.send(fields.last) ] }
+          else
+            options.delete(:options) || []
+          end        
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-helper/form_helpers/security.rb

@@ -0,0 +1,70 @@
+require 'securerandom'
+
+module Tennpipes
+  module Helpers
+    module FormHelpers
+      ##
+      # Helpers to generate form security tags for csrf protection.
+      #
+      module Security
+        ##
+        # Constructs a hidden field containing a CSRF token.
+        #
+        # @param [String] token
+        #   The token to use. Will be read from the session by default.
+        #
+        # @return [String] The hidden field with CSRF token as value.
+        #
+        # @example
+        #   csrf_token_field
+        #
+        def csrf_token_field
+          hidden_field_tag csrf_param, :value => csrf_token
+        end
+
+        ##
+        # Constructs meta tags `csrf-param` and `csrf-token` with the name of the
+        # cross-site request forgery protection parameter and token, respectively.
+        #
+        # @return [String] The meta tags with the CSRF token and the param your app expects it in.
+        #
+        # @example
+        #   csrf_meta_tags
+        #
+        def csrf_meta_tags
+          if is_protected_from_csrf?
+            meta_tag(csrf_param, :name => 'csrf-param') <<
+            meta_tag(csrf_token, :name => 'csrf-token')
+          end
+        end
+
+        protected
+
+        ##
+        # Returns whether the application is being protected from CSRF. Defaults to true.
+        #
+        def is_protected_from_csrf?
+          defined?(settings) ? settings.protect_from_csrf : true
+        end
+
+        ##
+        # Returns the current CSRF token (based on the session). If it doesn't exist,
+        # it will create one and assign it to the session's `csrf` key.
+        #
+        def csrf_token
+          session[:csrf] ||= SecureRandom.hex(32) if defined?(session)
+        end
+
+        ##
+        # Returns the param/field name in which your CSRF token should be expected by your
+        # controllers. Defaults to `authenticity_token`.
+        #
+        # Set this in your application with `set :csrf_param, :something_else`.
+        #
+        def csrf_param
+          defined?(settings) && settings.respond_to?(:csrf_param) ? settings.csrf_param : :authenticity_token
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-helper/format_helpers.rb

@@ -0,0 +1,372 @@
+# -*- coding: utf-8 -*-
+module Tennpipes
+  module Helpers
+    ###
+    # Helpers related to formatting or manipulating text within templates.
+    #
+    module FormatHelpers
+      ##
+      # Returns escaped text to protect against malicious content.
+      #
+      # @param [String] text
+      #   Unsanitized HTML string that needs to be escaped.
+      #
+      # @return [String] HTML with escaped characters.
+      #
+      # @example
+      #   escape_html("<b>Hey<b>") => "&lt;b&gt;Hey&lt;b;gt;"
+      #   h("Me & Bob") => "Me &amp; Bob"
+      #
+      def escape_html(text)
+        Rack::Utils.escape_html(text).html_safe
+      end
+      alias h escape_html
+      alias sanitize_html escape_html
+
+      ##
+      # Returns escaped text to protect against malicious content.
+      #
+      # @param [String] text
+      #   Unsanitized HTML string that needs to be escaped.
+      # @param [String] blank_text
+      #   Text to return if escaped text is blank.
+      #
+      # @return [String] HTML with escaped characters or the value specified if blank.
+      #
+      # @example
+      #   h!("Me & Bob") => "Me &amp; Bob"
+      #   h!("", "Whoops") => "Whoops"
+      #
+      def h!(text, blank_text = '&nbsp;')
+        return blank_text.html_safe if text.nil? || text.empty?
+        h(text)
+      end
+
+      ##
+      # Strips all HTML tags from the html.
+      #
+      # @param [String] html
+      #   The HTML for which to strip tags.
+      #
+      # @return [String] HTML with tags stripped.
+      #
+      # @example
+      #   strip_tags("<b>Hey</b>") => "Hey"
+      #
+      def strip_tags(html)
+        html.gsub(/<\/?[^>]*>/, "") if html
+      end
+
+      ##
+      # Returns text transformed into HTML using simple formatting rules. Two or more consecutive newlines(\n\n) are considered
+      # as a paragraph and wrapped in <p> or your own tags. One newline (\n) is considered as a linebreak and a <br /> tag is appended.
+      # This method does not remove the newlines from the text.
+      #
+      # @param [String] text
+      #   The simple text to be formatted.
+      # @param [Hash] options
+      #   Formatting options for the text. Can accept html options for the wrapper tag.
+      # @option options [Symbol] :tag (p)
+      #   The html tag to use for formatting newlines.
+      #
+      # @return [String] The text formatted as simple HTML.
+      #
+      # @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>"
+      #
+      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?
+        text.gsub!(/\r\n?/, "\n")                      # \r\n and \r -> \n
+        text.gsub!(/\n\n+/, "</#{t}>\n\n#{start_tag}") # 2+ newline  -> paragraph
+        text.gsub!(/([^\n]\n)(?=[^\n])/, '\1<br />')   # 1 newline   -> br
+        text.insert 0, start_tag
+        text << "</#{t}>"
+        text.html_safe
+      end
+
+      ##
+      # Attempts to pluralize the singular word unless count is 1. If plural is supplied, it will use that when count is > 1,
+      # otherwise it will use inflector to determine the plural form.
+      #
+      # @param [Fixnum] count
+      #   The count which determines pluralization.
+      # @param [String] singular
+      #   The word to be pluralized if appropriate based on +count+.
+      # @param [String] plural
+      #   Explicit pluralized word to be used; if not specified uses inflector.
+      #
+      # @return [String] The properly pluralized word.
+      #
+      # @example
+      #   pluralize(2, 'person') => '2 people'
+      #
+      def pluralize(count, singular, plural = nil)
+        "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
+      end
+
+      ##
+      # Truncates a given text after a given :length if text is longer than :length (defaults to 30).
+      # The last characters will be replaced with the :omission (defaults to "…") for a total length not exceeding :length.
+      #
+      # @param [String] text
+      #   The text to be truncated.
+      # @param [Hash] options
+      #   Formatting options for the truncation.
+      # @option options [Fixnum] :length (30)
+      #   The number of characters before truncation occurs.
+      # @option options [String] :omission ("...")
+      #   The characters that are placed after the truncated text.
+      #
+      # @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.reverse_merge!(:length => 30, :omission => "...")
+        if text
+          len = options[:length] - options[:omission].length
+          chars = text
+          (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
+        end
+      end
+
+      ##
+      # Truncates words of a given text after a given :length if number of words in text is more than :length (defaults to 30).
+      # The last words will be replaced with the :omission (defaults to "…") for a total number of words not exceeding :length.
+      #
+      # @param [String] text
+      #   The text to be truncated.
+      # @param [Hash] options
+      #   Formatting options for the truncation.
+      # @option options [Fixnum] :length (30)
+      #   The number of words before truncation occurs.
+      # @option options [String] :omission ("...")
+      #   The characters that are placed after the truncated text.
+      #
+      # @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..."
+      #
+      def truncate_words(text, options={})
+        options.reverse_merge!(:length => 30, :omission => "...")
+        if text
+          words = text.split()
+          words[0..(options[:length]-1)].join(' ') + (words.length > options[:length] ? options[:omission] : '')
+        end
+      end
+
+      ##
+      # Wraps the text into lines no longer than line_width width.
+      # This method breaks on the first whitespace character that does not exceed line_width (which is 80 by default).
+      #
+      # @overload word_wrap(text, options={})
+      #   @param [String] text
+      #     The text to be wrapped.
+      #   @param [Hash] options
+      #     Formatting options for the wrapping.
+      #   @option options [Fixnum] :line_width (80)
+      #     The line width before a wrap should occur.
+      #
+      # @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"
+      #
+      def word_wrap(text, *args)
+        options = args.extract_options!
+        unless args.blank?
+          options[:line_width] = args[0] || 80
+        end
+        options.reverse_merge!(:line_width => 80)
+
+        text.split("\n").map do |line|
+          line.length > options[:line_width] ? line.gsub(/(.{1,#{options[:line_width]}})(\s+|$)/, "\\1\n").strip : line
+        end * "\n"
+      end
+
+      ##
+      # Highlights one or more words everywhere in text by inserting it into a :highlighter string.
+      #
+      # The highlighter can be customized by passing :+highlighter+ as a single-quoted string
+      # with \1 where the phrase is to be inserted.
+      #
+      # @overload highlight(text, words, options={})
+      #   @param [String] text
+      #     The text that will be searched.
+      #   @param [String] words
+      #     The words to be highlighted in the +text+.
+      #   @param [Hash] options
+      #     Formatting options for the highlight.
+      #   @option options [String] :highlighter ('<strong class="highlight">\1</strong>')
+      #     The html pattern for wrapping the highlighted words.
+      #
+      # @return [String] The text with the words specified wrapped with highlighted spans.
+      #
+      # @example
+      #   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>')
+      #   # => Lorem ipsum <strong class="custom">dolor</strong> sit amet
+      #
+      def highlight(text, words, *args)
+        options = args.extract_options!
+        options.reverse_merge!(:highlighter => '<strong class="highlight">\1</strong>')
+
+        if text.blank? || words.blank?
+          text
+        else
+          match = Array(words).map { |p| Regexp.escape(p) }.join('|')
+          text.gsub(/(#{match})(?!(?:[^<]*?)(?:["'])[^<>]*>)/i, options[:highlighter])
+        end
+      end
+
+      ##
+      # Reports the approximate distance in time between two Time or Date objects or integers as seconds.
+      # Set +include_seconds+ to true if you want more detailed approximations when distance < 1 min, 29 secs
+      # Distances are reported based on the following table:
+      #
+      #   0 <-> 29 secs                                                           # => less than a minute
+      #   30 secs <-> 1 min, 29 secs                                              # => 1 minute
+      #   1 min, 30 secs <-> 44 mins, 29 secs                                     # => [2..44] minutes
+      #   44 mins, 30 secs <-> 89 mins, 29 secs                                   # => about 1 hour
+      #   89 mins, 29 secs <-> 23 hrs, 59 mins, 29 secs                           # => about [2..24] hours
+      #   23 hrs, 59 mins, 29 secs <-> 47 hrs, 59 mins, 29 secs                   # => 1 day
+      #   47 hrs, 59 mins, 29 secs <-> 29 days, 23 hrs, 59 mins, 29 secs          # => [2..29] days
+      #   29 days, 23 hrs, 59 mins, 30 secs <-> 59 days, 23 hrs, 59 mins, 29 secs # => about 1 month
+      #   59 days, 23 hrs, 59 mins, 30 secs <-> 1 yr minus 1 sec                  # => [2..12] months
+      #   1 yr <-> 1 yr, 3 months                                                 # => about 1 year
+      #   1 yr, 3 months <-> 1 yr, 9 months                                       # => over 1 year
+      #   1 yr, 9 months <-> 2 yr minus 1 sec                                     # => almost 2 years
+      #   2 yrs <-> max time or date                                              # => (same rules as 1 yr)
+      #
+      # With +include_seconds+ = true and the difference < 1 minute 29 seconds:
+      #   0-4   secs      # => less than 5 seconds
+      #   5-9   secs      # => less than 10 seconds
+      #   10-19 secs      # => less than 20 seconds
+      #   20-39 secs      # => half a minute
+      #   40-59 secs      # => less than a minute
+      #   60-89 secs      # => 1 minute
+      #
+      # @param [Time] from_time
+      #   The time to be compared against +to_time+ in order to approximate the distance.
+      # @param [Time] to_time
+      #   The time to be compared against +from_time+ in order to approximate the distance.
+      # @param [Boolean] include_seconds
+      #   Set true for more detailed approximations.
+      # @param [Hash] options
+      #   Flags for the approximation.
+      # @option options [String] :locale
+      #   The translation locale to be used for approximating the time.
+      #
+      # @return [String] The time formatted as a relative string.
+      #
+      # @example
+      #   from_time = Time.now
+      #   distance_of_time_in_words(from_time, from_time + 50.minutes)        # => about 1 hour
+      #   distance_of_time_in_words(from_time, 50.minutes.from_now)           # => about 1 hour
+      #   distance_of_time_in_words(from_time, from_time + 15.seconds)        # => less than a minute
+      #   distance_of_time_in_words(from_time, from_time + 15.seconds, true)  # => less than 20 seconds
+      #   distance_of_time_in_words(from_time, 3.years.from_now)              # => about 3 years
+      #   distance_of_time_in_words(from_time, from_time + 60.hours)          # => about 3 days
+      #   distance_of_time_in_words(from_time, from_time + 45.seconds, true)  # => less than a minute
+      #   distance_of_time_in_words(from_time, from_time - 45.seconds, true)  # => less than a minute
+      #   distance_of_time_in_words(from_time, 76.seconds.from_now)           # => 1 minute
+      #   distance_of_time_in_words(from_time, from_time + 1.year + 3.days)   # => about 1 year
+      #   distance_of_time_in_words(from_time, from_time + 3.years + 6.months) # => over 3 years
+      #   distance_of_time_in_words(from_time, from_time + 4.years + 9.days + 30.minutes + 5.seconds) # => about 4 years
+      #   to_time = Time.now + 6.years + 19.days
+      #   distance_of_time_in_words(from_time, to_time, true)     # => about 6 years
+      #   distance_of_time_in_words(to_time, from_time, true)     # => about 6 years
+      #   distance_of_time_in_words(Time.now, Time.now)           # => less than a minute
+      #
+      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
+
+        I18n.with_options :locale => options[:locale], :scope => :'datetime.distance_in_words' do |locale|
+          case distance_in_minutes
+            when 0..1
+              return distance_in_minutes == 0 ?
+                     locale.t(:less_than_x_minutes, :count => 1) :
+                     locale.t(:x_minutes, :count => distance_in_minutes) unless include_seconds
+
+              case distance_in_seconds
+                when 0..4   then locale.t :less_than_x_seconds, :count => 5
+                when 5..9   then locale.t :less_than_x_seconds, :count => 10
+                when 10..19 then locale.t :less_than_x_seconds, :count => 20
+                when 20..39 then locale.t :half_a_minute
+                when 40..59 then locale.t :less_than_x_minutes, :count => 1
+                else             locale.t :x_minutes,           :count => 1
+              end
+
+            when 2..44           then locale.t :x_minutes,      :count => distance_in_minutes
+            when 45..89          then locale.t :about_x_hours,  :count => 1
+            when 90..1439        then locale.t :about_x_hours,  :count => (distance_in_minutes.to_f / 60.0).round
+            when 1440..2529      then locale.t :x_days,         :count => 1
+            when 2530..43199     then locale.t :x_days,         :count => (distance_in_minutes.to_f / 1440.0).round
+            when 43200..86399    then locale.t :about_x_months, :count => 1
+            when 86400..525599   then locale.t :x_months,       :count => (distance_in_minutes.to_f / 43200.0).round
+            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
+                locale.t(:about_x_years,  :count => distance_in_years)
+              elsif remainder < 394200
+                locale.t(:over_x_years,   :count => distance_in_years)
+              else
+                locale.t(:almost_x_years, :count => distance_in_years + 1)
+              end
+          end
+        end
+      end
+
+      ##
+      # Like distance_of_time_in_words, but where <tt>to_time</tt> is fixed to <tt>Time.now</tt>.
+      #
+      # @param [Time] from_time
+      #   The time to be compared against now in order to approximate the distance.
+      # @param [Boolean] include_seconds
+      #   Set true for more detailed approximations.
+      #
+      # @return [String] The time formatted as a relative string.
+      #
+      # @example
+      #   time_ago_in_words(3.minutes.from_now)  # => 3 minutes
+      #   time_ago_in_words(Time.now - 15.hours) # => 15 hours
+      #   time_ago_in_words(Time.now)            # => less than a minute
+      #
+      def time_ago_in_words(from_time, include_seconds = false)
+        distance_of_time_in_words(from_time, Time.now, include_seconds)
+      end
+
+      ##
+      # Used in xxxx.js.erb files to escape html so that it can be passed to javascript from Tennpipes.
+      #
+      # @param [String] html
+      #   The HTML content to be escaped into javascript compatible format.
+      #
+      # @return [String] The html escaped for javascript passing.
+      #
+      # @example
+      #   js_escape_html("<h1>Hey</h1>")
+      #
+      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 = escaped_content.html_safe if html_content.html_safe?
+        escaped_content
+      end
+      alias :escape_javascript :js_escape_html
+    end
+  end
+end