stringex 1.5.1 → 2.0.0

data/lib/stringex/localization/conversion_expressions.rb

@@ -0,0 +1,148 @@
+# encoding: UTF-8
+
+module Stringex
+  module Localization
+    module ConversionExpressions
+      ABBREVIATION = /(\s|^)([[:alpha:]](\.[[:alpha:]])+(\.?)[[:alpha:]]*(\s|$))/
+
+      ACCENTED_HTML_ENTITY = /&([A-Za-z])(grave|acute|circ|tilde|uml|ring|cedil|slash);/
+
+      APOSTROPHE = /(^|[[:alpha:]])'|`([[:alpha:]]|$)/
+
+      CHARACTERS =  {
+        :and           => /\s*&\s*/,
+        :at            => /\s*@\s*/,
+        :degrees       => /\s*°\s*/,
+        :divide        => /\s*÷\s*/,
+        :dot           => /(\S|^)\.(\S)/,
+        :ellipsis      => /\s*\.{3,}\s*/,
+        :equals        => /\s*=\s*/,
+        :number        => /\s*#/,
+        :percent       => /\s*%\s*/,
+        :plus          => /\s*\+\s*/,
+        :slash         => /\s*(\\|\/|／)\s*/,
+        :star          => /\s*\*\s*/,
+      }
+
+      # Things that just get converted to spaces
+      CLEANUP_CHARACTERS = /[\.,:;(){}\[\]\/\?!\^'ʼ"_\|]/
+      CLEANUP_HTML_ENTITIES = /&[^;]+;/
+
+      CURRENCIES_SUPPORTED_SIMPLE = {
+        :dollars => /\$/,
+        :euros   => /€/,
+        :pounds  => /£/,
+        :yen     => /¥/,
+      }
+      CURRENCIES_SUPPORTED_COMPLEX = {
+        :dollars => :dollars_cents,
+        :euros   => :euros_cents,
+        :pounds  => :pounds_pence,
+      }
+      CURRENCIES_SUPPORTED = Regexp.new(CURRENCIES_SUPPORTED_SIMPLE.values.join('|'))
+      CURRENCIES_SIMPLE = CURRENCIES_SUPPORTED_SIMPLE.inject({}) do |hash, content|
+        key, expression = content
+        hash[key] = /(?:\s|^)#{expression}(\d*)(?:\s|$)/
+        hash
+      end
+      CURRENCIES_COMPLEX = CURRENCIES_SUPPORTED_SIMPLE.inject({}) do |hash, content|
+        key, expression = content
+        # Do we really need to not worry about complex currencies if there are none for the currency?
+        complex_key = CURRENCIES_SUPPORTED_COMPLEX[key]
+        if complex_key
+          hash[complex_key] = /(?:\s|^)#{expression}(\d+)\.(\d+)(?:\s|$)/
+        end
+        hash
+      end
+      CURRENCIES = CURRENCIES_SIMPLE.merge(CURRENCIES_COMPLEX)
+
+      HTML_ENTITIES = Proc.new(){
+        base = {
+          :amp          => %w{#38 amp},
+          :cent         => %w{#162 cent},
+          :copy         => %w{#169 copy},
+          :deg          => %w{#176 deg},
+          :divide       => %w{#247 divide},
+          :double_quote => %w{#34 #822[012] quot ldquo rdquo dbquo},
+          :ellipsis     => %w{#8230 hellip},
+          :en_dash      => %w{#8211 ndash},
+          :em_dash      => %w{#8212 mdash},
+          :frac14       => %w{#188 frac14},
+          :frac12       => %w{#189 frac12},
+          :frac34       => %w{#190 frac34},
+          :gt           => %w{#62 gt},
+          :lt           => %w{#60 lt},
+          :nbsp         => %w{#160 nbsp},
+          :pound        => %w{#163 pound},
+          :reg          => %w{#174 reg},
+          :single_quote => %w{#39 #821[678] apos lsquo rsquo sbquo},
+          :times        => %w{#215 times},
+          :trade        => %w{#8482 trade},
+          :yen          => %w{#165 yen},
+        }
+        base.inject({}) do |hash, content|
+          key, expression = content
+          hash[key] = /&(#{expression.join('|')});/
+          hash
+        end
+      }.call
+
+      HTML_TAG = Proc.new(){
+        name = /[\w:_-]+/
+        value = /([A-Za-z0-9]+|('[^']*?'|"[^"]*?"))/
+        attr = /(#{name}(\s*=\s*#{value})?)/
+        /<[!\/?\[]?(#{name}|--)(\s+(#{attr}(\s+#{attr})*))?\s*([!\/?\]]+|--)?>/
+      }.call
+
+      SMART_PUNCTUATION = {
+        /(“|”|\302\223|\302\224|\303\222|\303\223)/ => '"',
+        /(‘|’|\302\221|\302\222|\303\225)/ => "'",
+        /…/ => "...",
+      }
+
+      # Ordered by denominator then numerator of the value
+      VULGAR_FRACTIONS = {
+        :half          => /(&#189;|&frac12;|½)/,
+        :one_third     => /(&#8531;|⅓)/,
+        :two_thirds    => /(&#8532;|⅔)/,
+        :one_fourth    => /(&#188;|&frac14;|¼)/,
+        :three_fourths => /(&#190;|&frac34;|¾)/,
+        :one_fifth     => /(&#8533;|⅕)/,
+        :two_fifths    => /(&#8534;|⅖)/,
+        :three_fifths  => /(&#8535;|⅗)/,
+        :four_fifths   => /(&#8536;|⅘)/,
+        :one_sixth     => /(&#8537;|⅙)/,
+        :five_sixths   => /(&#8538;|⅚)/,
+        :one_eighth    => /(&#8539;|⅛)/,
+        :three_eighths => /(&#8540;|⅜)/,
+        :five_eighths  => /(&#8541;|⅝)/,
+        :seven_eighths => /(&#8542;|⅞)/,
+      }
+
+      WHITESPACE = /\s+/
+
+      class << self
+        %w{
+          abbreviation
+          accented_html_entity
+          apostrophe
+          characters
+          cleanup_characters
+          cleanup_html_entities
+          currencies
+          currencies_simple
+          currencies_complex
+          html_entities
+          html_tag
+          smart_punctuation
+          vulgar_fractions
+          whitespace
+        }.each do |conversion_type|
+          define_method conversion_type do
+            const_get conversion_type.upcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stringex/localization/converter.rb

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+
+require 'stringex/localization/conversion_expressions'
+
+module Stringex
+  module Localization
+    class Converter
+      include ConversionExpressions
+
+      attr_reader :ending_whitespace, :options, :starting_whitespace, :string
+
+      def initialize(string, options = {})
+        @string = string.dup
+        @options = Stringex::Configuration::StringExtensions.default_settings.merge(options)
+        string =~ /^(\s+)/
+        @starting_whitespace = $1 unless $1 == ''
+        string =~ /(\s+)$/
+        @ending_whitespace = $1 unless $1 == ''
+      end
+
+      def cleanup_accented_html_entities!
+        string.gsub! expressions.accented_html_entity, '\1'
+      end
+
+      def cleanup_characters!
+        string.gsub! expressions.cleanup_characters, ' '
+      end
+
+      def cleanup_html_entities!
+        string.gsub! expressions.cleanup_html_entities, ''
+      end
+
+      def cleanup_smart_punctuation!
+        expressions.smart_punctuation.each do |expression, replacement|
+          string.gsub! expression, replacement
+        end
+      end
+
+      def smart_strip!
+        string.strip!
+        @string = "#{starting_whitespace}#{string}#{ending_whitespace}"
+      end
+
+      def strip!
+        string.strip!
+      end
+
+      def strip_html_tags!
+        string.gsub! expressions.html_tag, ''
+      end
+
+      def translate!(*conversions)
+        conversions.each do |conversion|
+          send conversion
+        end
+      end
+
+    protected
+
+      def abbreviations
+        string.gsub! expressions.abbreviation do |x|
+          x.gsub '.', ''
+        end
+      end
+
+      def apostrophes
+        string.gsub! expressions.apostrophe, '\1\2'
+      end
+
+      def characters
+        expressions.characters.each do |key, expression|
+          next if key == :slash && options[:allow_slash]
+          replacement = translate(key)
+          replacement = " #{replacement} " unless key == :dot
+          string.gsub! expression, replacement
+        end
+      end
+
+      def currencies
+        if has_currencies?
+          [:currencies_complex, :currencies_simple].each do |type|
+            expressions.send(type).each do |key, expression|
+              string.gsub! expression, " #{translate(key, :currencies)} "
+            end
+          end
+        end
+      end
+
+      def ellipses
+        string.gsub! expressions.characters[:ellipsis], " #{translate(:ellipsis)} "
+      end
+
+      def html_entities
+        expressions.html_entities.each do |key, expression|
+          string.gsub! expression, translate(key, :html_entities)
+        end
+        string.squeeze! ' '
+      end
+
+      def vulgar_fractions
+        expressions.vulgar_fractions.each do |key, expression|
+          string.gsub! expression, translate(key, :vulgar_fractions)
+        end
+      end
+
+    private
+
+      def expressions
+        ConversionExpressions
+      end
+
+      def has_currencies?
+        string =~ CURRENCIES_SUPPORTED
+      end
+
+      def translate(key, scope = :characters)
+        Localization.translate scope, key
+      end
+    end
+  end
+end

data/lib/stringex/localization/default_conversions.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+module Stringex
+  module Localization
+    module DefaultConversions
+      CHARACTERS =  {
+        :and           => "and",
+        :at            => "at",
+        :degrees       => "degrees",
+        :divide        => "divided by",
+        :dot           => '\1 dot \2',
+        :ellipsis      => "dot dot dot",
+        :equals        => "equals",
+        :number        => "number",
+        :percent       => "percent",
+        :plus          => "plus",
+        :slash         => "slash",
+        :star          => "star",
+      }
+
+      CURRENCIES_SIMPLE = {
+        :dollars       => '\1 dollars',
+        :euros         => '\1 euros',
+        :pounds        => '\1 pounds',
+        :yen           => '\1 yen',
+      }
+      CURRENCIES_COMPLEX = {
+        :dollars_cents => '\1 dollars \2 cents',
+        :euros_cents   => '\1 euros \2 cents',
+        :pounds_pence  => '\1 pounds \2 pence',
+      }
+      CURRENCIES = CURRENCIES_SIMPLE.merge(CURRENCIES_COMPLEX)
+
+      HTML_ENTITIES = {
+        :amp          => "and",
+        :cent         => " cents",
+        :copy         => "(c)",
+        :deg          => " degrees ",
+        :divide       => " divided by ",
+        :double_quote => '"',
+        :ellipsis     => "...",
+        :en_dash      => "-",
+        :em_dash      => "--",
+        :frac14       => "one fourth",
+        :frac12       => "half",
+        :frac34       => "three fourths",
+        :gt           => ">",
+        :lt           => "<",
+        :nbsp         => " ",
+        :pound        => " pounds ",
+        :reg          => "(r)",
+        :single_quote => "'",
+        :times        => "x",
+        :trade        => "(tm)",
+        :yen          => " yen "
+      }
+
+      TRANSLITERATIONS = {}
+
+      # Ordered by denominator then numerator of the value
+      VULGAR_FRACTIONS = {
+        :half          => "half",
+        :one_third     => "one third",
+        :two_thirds    => "two thirds",
+        :one_fourth    => "one fourth",
+        :three_fourths => "three fourths",
+        :one_fifth     => "one fifth",
+        :two_fifths    => "two fifths",
+        :three_fifths  => "three fifths",
+        :four_fifths   => "four fifths",
+        :one_sixth     => "one sixth",
+        :five_sixths   => "five sixths",
+        :one_eighth    => "one eighth",
+        :three_eighths => "three eighths",
+        :five_eighths  => "five eighths",
+        :seven_eighths => "seven eighths",
+      }
+
+      class << self
+        %w{characters currencies html_entities transliterations vulgar_fractions}.each do |conversion_type|
+          define_method conversion_type do
+            const_get conversion_type.upcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stringex/rails/railtie.rb

@@ -0,0 +1,10 @@
+module Stringex
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer "stringex" do |app|
+      locales = app.config.i18n.available_locales
+      pattern = locales.blank? ? "*" : "{#{locales.join(',')}}"
+      files = Dir[File.join(Stringex::Localization::Backend::I18n::LOAD_PATH_BASE, "#{pattern}.yml")]
+      I18n.load_path.concat(files)
+    end
+  end
+end

data/lib/stringex/string_extensions.rb

@@ -1,236 +1,181 @@
 # encoding: UTF-8
 
 module Stringex
-  # These methods are all added on String class.
   module StringExtensions
-    def self.included(base) # :nodoc:
-      base.extend(ClassMethods)
-    end
+    # These methods are all included into the String class.
+    module PublicInstanceMethods
+      # Removes specified character from the beginning and/or end of the string and then performs
+      # <tt>String#squeeze(character)</tt>, condensing runs of the character within the string.
+      #
+      # Note: This method has been superceded by ActiveSupport's squish method.
+      def collapse(character = " ")
+        sub(/^#{character}*/, "").sub(/#{character}*$/, "").squeeze(character)
+      end
 
-    # Returns the string converted (via Textile/RedCloth) to HTML format
-    # or self [with a friendly warning] if Redcloth is not available.
-    #
-    # Using <tt>:lite</tt> argument will cause RedCloth to not wrap the HTML in a container
-    # P element, which is useful behavior for generating header element text, etc.
-    # This is roughly equivalent to ActionView's <tt>textilize_without_paragraph</tt>
-    # except that it makes RedCloth do all the work instead of just gsubbing the return
-    # from RedCloth.
-    def to_html(lite_mode = false)
-      if defined?(RedCloth)
-        if lite_mode
-          RedCloth.new(self, [:lite_mode]).to_html
-        else
-          if self =~ /<pre>/
-            RedCloth.new(self).to_html.tr("\t", "")
-          else
-            RedCloth.new(self).to_html.tr("\t", "").gsub(/\n\n/, "")
-          end
+      # Converts HTML entities into the respective non-accented letters. Examples:
+      #
+      #   "&aacute;".convert_accented_entities # => "a"
+      #   "&ccedil;".convert_accented_entities # => "c"
+      #   "&egrave;".convert_accented_entities # => "e"
+      #   "&icirc;".convert_accented_entities # => "i"
+      #   "&oslash;".convert_accented_entities # => "o"
+      #   "&uuml;".convert_accented_entities # => "u"
+      #
+      # Note: This does not do any conversion of Unicode/ASCII accented-characters. For that
+      # functionality please use <tt>to_ascii</tt>.
+      def convert_accented_html_entities
+        stringex_convert do
+          cleanup_accented_html_entities!
         end
-      else
-        warn "String#to_html was called without RedCloth being successfully required"
-        self
       end
-    end
 
-    # Create a URI-friendly representation of the string. This is used internally by
-    # acts_as_url[link:classes/Stringex/ActsAsUrl/ClassMethods.html#M000012]
-    # but can be called manually in order to generate an URI-friendly version of any string.
-    def to_url(options = {})
-      return self if options[:exclude] && options[:exclude].include?(self)
-      remove_formatting(options).downcase.replace_whitespace("-").collapse("-").limit(options[:limit])
-    end
+      # Converts various common plaintext characters to a more URI-friendly representation.
+      # Examples:
+      #
+      #   "foo & bar".convert_misc_characters # => "foo and bar"
+      #   "Chanel #9".convert_misc_characters # => "Chanel number nine"
+      #   "user@host".convert_misc_characters # => "user at host"
+      #   "google.com".convert_misc_characters # => "google dot com"
+      #   "$10".convert_misc_characters # => "10 dollars"
+      #   "*69".convert_misc_characters # => "star 69"
+      #   "100%".convert_misc_characters # => "100 percent"
+      #   "windows/mac/linux".convert_misc_characters # => "windows slash mac slash linux"
+      #
+      # It allows localization of conversions so you can use it to convert characters into your own language.
+      # Example:
+      #
+      #   I18n.backend.store_translations :de, { :stringex => { :characters => { :and => "und" } } }
+      #   I18n.locale = :de
+      #   "ich & dich".convert_misc_characters # => "ich und dich"
+      #
+      # Note: Because this method will convert any & symbols to the string "and",
+      # you should run any methods which convert HTML entities (convert_accented_html_entities and convert_miscellaneous_html_entities)
+      # before running this method.
+      def convert_miscellaneous_characters(options = {})
+        stringex_convert do
+          translate! :ellipses, :currencies, :abbreviations, :characters, :apostrophes
+          cleanup_characters!
+        end
+      end
 
-    # Returns the string limited in size to the value of limit.
-    def limit(limit = nil)
-      limit.nil? ? self : self[0...limit]
-    end
+      # Converts HTML entities (taken from common Textile/RedCloth formattings) into plain text formats.
+      #
+      # Note: This isn't an attempt at complete conversion of HTML entities, just those most likely
+      # to be generated by Textile.
+      def convert_miscellaneous_html_entities
+        stringex_convert do
+          translate! :html_entities
+          cleanup_html_entities!
+        end
+      end
 
-    # Performs multiple text manipulations. Essentially a shortcut for typing them all. View source
-    # below to see which methods are run.
-    def remove_formatting(options = {})
-      strip_html_tags.
-        convert_smart_punctuation.
-        convert_accented_entities.
-        convert_vulgar_fractions.
-        convert_misc_entities.
-        convert_misc_characters(options).
-        to_ascii.
-        # NOTE: String#to_ascii may convert some Unicode characters to ascii we'd already transliterated
-        # so we need to do it again just to be safe
-        convert_misc_characters(options).
-        collapse
-    end
+      # Converts MS Word 'smart punctuation' to ASCII
+      #
+      def convert_smart_punctuation
+        stringex_convert do
+          cleanup_smart_punctuation!
+        end
+      end
 
-    # Removes HTML tags from text. This code is simplified from Tobias Luettke's regular expression
-    # in Typo[http://typosphere.org].
-    def strip_html_tags(leave_whitespace = false)
-      name = /[\w:_-]+/
-      value = /([A-Za-z0-9]+|('[^']*?'|"[^"]*?"))/
-      attr = /(#{name}(\s*=\s*#{value})?)/
-      rx = /<[!\/?\[]?(#{name}|--)(\s+(#{attr}(\s+#{attr})*))?\s*([!\/?\]]+|--)?>/
-      (leave_whitespace) ?  gsub(rx, "").strip : gsub(rx, "").gsub(/\s+/, " ").strip
-    end
-    # Converts HTML entities into the respective non-accented letters. Examples:
-    #
-    #   "&aacute;".convert_accented_entities # => "a"
-    #   "&ccedil;".convert_accented_entities # => "c"
-    #   "&egrave;".convert_accented_entities # => "e"
-    #   "&icirc;".convert_accented_entities # => "i"
-    #   "&oslash;".convert_accented_entities # => "o"
-    #   "&uuml;".convert_accented_entities # => "u"
-    #
-    # Note: This does not do any conversion of Unicode/ASCII accented-characters. For that
-    # functionality please use <tt>to_ascii</tt>.
-    def convert_accented_entities
-      gsub(/&([A-Za-z])(grave|acute|circ|tilde|uml|ring|cedil|slash);/, '\1').strip
-    end
+      # Converts vulgar fractions from supported HTML entities and Unicode to plain text formats.
+      def convert_vulgar_fractions
+        stringex_convert do
+          translate! :vulgar_fractions
+        end
+      end
 
-    # Converts HTML entities (taken from common Textile/RedCloth formattings) into plain text formats.
-    #
-    # Note: This isn't an attempt at complete conversion of HTML entities, just those most likely
-    # to be generated by Textile.
-    def convert_misc_entities
-      dummy = dup
-      {
-        "#822[01]" => "\"",
-        "#821[67]" => "'",
-        "#8230" => "...",
-        "#8211" => "-",
-        "#8212" => "--",
-        "#215" => "x",
-        "gt" => ">",
-        "lt" => "<",
-        "(#8482|trade)" => "(tm)",
-        "(#174|reg)" => "(r)",
-        "(#169|copy)" => "(c)",
-        "(#38|amp)" => "and",
-        "nbsp" => " ",
-        "(#162|cent)" => " cent",
-        "(#163|pound)" => " pound",
-        "(#188|frac14)" => "one fourth",
-        "(#189|frac12)" => "half",
-        "(#190|frac34)" => "three fourths",
-        "(#247|divide)" => "divide",
-        "(#176|deg)" => " degrees "
-      }.each do |textiled, normal|
-        dummy.gsub!(/&#{textiled};/, normal)
+      # Returns the string limited in size to the value of limit.
+      def limit(limit = nil)
+        limit.nil? ? self : self[0...limit]
       end
-      dummy.gsub(/&[^;]+;/, "").strip
-    end
 
-    # Converts vulgar fractions from supported html entities and unicode to
-    # plain text formats.
-    def convert_vulgar_fractions
-      dummy = dup
-      {
-        "(&#188;|&frac14;|¼)" => "one fourth",
-        "(&#189;|&frac12;|½)" => "half",
-        "(&#190;|&frac34;|¾)" => "three fourths",
-        "(&#8531;|⅓)" => "one third",
-        "(&#8532;|⅔)" => "two thirds",
-        "(&#8533;|⅕)" => "one fifth",
-        "(&#8534;|⅖)" => "two fifths",
-        "(&#8535;|⅗)" => "three fifths",
-        "(&#8536;|⅘)" => "four fifths",
-        "(&#8537;|⅙)" => "one sixth",
-        "(&#8538;|⅚)" => "five sixths",
-        "(&#8539;|⅛)" => "one eighth",
-        "(&#8540;|⅜)" => "three eighths",
-        "(&#8541;|⅝)" => "five eighths",
-        "(&#8542;|⅞)" => "seven eighths"
-      }.each do |textiled, normal|
-        dummy.gsub!(/#{textiled}/, normal)
+      # Performs multiple text manipulations. Essentially a shortcut for typing them all. View source
+      # below to see which methods are run.
+      def remove_formatting(options = {})
+        strip_html_tags.
+          convert_smart_punctuation.
+          convert_accented_html_entities.
+          convert_vulgar_fractions.
+          convert_miscellaneous_html_entities.
+          convert_miscellaneous_characters(options).
+          to_ascii.
+          # NOTE: String#to_ascii may convert some Unicode characters to ascii we'd already transliterated
+          # so we need to do it again just to be safe
+          convert_miscellaneous_characters(options).
+          collapse
       end
-      dummy
-    end
 
-    # Converts MS Word 'smart punctuation' to ASCII
-    #
-    def convert_smart_punctuation
-      dummy = dup
-      {
-
-        "(“|”|\302\223|\302\224|\303\222|\303\223)" => '"',
-        "(‘|’|\302\221|\302\222|\303\225)" => "'",
-        "…" => "...",
-      }.each do |smart, normal|
-        dummy.gsub!(/#{smart}/, normal)
+      # Replace runs of whitespace in string. Defaults to a single space but any replacement
+      # string may be specified as an argument. Examples:
+      #
+      #   "Foo       bar".replace_whitespace # => "Foo bar"
+      #   "Foo       bar".replace_whitespace("-") # => "Foo-bar"
+      def replace_whitespace(replacement = " ")
+        gsub(/\s+/, replacement)
       end
-      dummy.strip
-    end
 
-    # Converts various common plaintext characters to a more URI-friendly representation.
-    # Examples:
-    #
-    #   "foo & bar".convert_misc_characters # => "foo and bar"
-    #   "Chanel #9".convert_misc_characters # => "Chanel number nine"
-    #   "user@host".convert_misc_characters # => "user at host"
-    #   "google.com".convert_misc_characters # => "google dot com"
-    #   "$10".convert_misc_characters # => "10 dollars"
-    #   "*69".convert_misc_characters # => "star 69"
-    #   "100%".convert_misc_characters # => "100 percent"
-    #   "windows/mac/linux".convert_misc_characters # => "windows slash mac slash linux"
-    #
-    # Note: Because this method will convert any & symbols to the string "and",
-    # you should run any methods which convert HTML entities (convert_html_entities and convert_misc_entities)
-    # before running this method.
-    def convert_misc_characters(options = {})
-      dummy = dup.gsub(/\.{3,}/, " dot dot dot ") # Catch ellipses before single dot rule!
-      # Special rules for money
-      {
-        /(\s|^)\$(\d+)\.(\d+)(\s|$)/ => '\2 dollars \3 cents',
-        /(\s|^)£(\d+)\.(\d+)(\s|$)/u => '\2 pounds \3 pence',
-      }.each do |found, replaced|
-        replaced = " #{replaced} " unless replaced =~ /\\1/
-        dummy.gsub!(found, replaced)
+      # Removes HTML tags from text.
+      # NOTE: This code is simplified from Tobias Luettke's regular expression in Typo[http://typosphere.org].
+      def strip_html_tags(leave_whitespace = false)
+        string = stringex_convert do
+          strip_html_tags!
+        end
+        leave_whitespace ? string : string.replace_whitespace(' ')
       end
-      # Special rules for abbreviations
-      dummy.gsub!(/(\s|^)([[:alpha:]](\.[[:alpha:]])+(\.?)[[:alpha:]]*(\s|$))/) do |x|
-        x.gsub(".", "")
+
+      # Returns the string converted (via Textile/RedCloth) to HTML format
+      # or self [with a friendly warning] if Redcloth is not available.
+      #
+      # Using <tt>:lite</tt> argument will cause RedCloth to not wrap the HTML in a container
+      # P element, which is useful behavior for generating header element text, etc.
+      # This is roughly equivalent to ActionView's <tt>textilize_without_paragraph</tt>
+      # except that it makes RedCloth do all the work instead of just gsubbing the return
+      # from RedCloth.
+      def to_html(lite_mode = false)
+        if defined?(RedCloth)
+          if lite_mode
+            RedCloth.new(self, [:lite_mode]).to_html
+          else
+            if self =~ /<pre>/
+              RedCloth.new(self).to_html.tr("\t", "")
+            else
+              RedCloth.new(self).to_html.tr("\t", "").gsub(/\n\n/, "")
+            end
+          end
+        else
+          warn "String#to_html was called without RedCloth being successfully required"
+          self
+        end
       end
-      # Back to normal rules
-      misc_characters =
-      {
-        /\s*&\s*/ => "and",
-        /\s*#/ => "number",
-        /\s*@\s*/ => "at",
-        /(\S|^)\.(\S)/ => '\1 dot \2',
-        /(\s|^)\$(\d*)(\s|$)/ => '\2 dollars',
-        /(\s|^)£(\d*)(\s|$)/u => '\2 pounds',
-        /(\s|^)¥(\d*)(\s|$)/u => '\2 yen',
-        /\s*\*\s*/ => "star",
-        /\s*%\s*/ => "percent",
-        /(\s*=\s*)/ => " equals ",
-        /\s*\+\s*/ => "plus",
-        /\s*÷\s*/ => "divide",
-        /\s*°\s*/ => "degrees"
-      }
-      misc_characters[/\s*(\\|\/|／)\s*/] = 'slash' unless options[:allow_slash]
-      misc_characters.each do |found, replaced|
-        replaced = " #{replaced} " unless replaced =~ /\\1/
-        dummy.gsub!(found, replaced)
+
+      # Create a URI-friendly representation of the string. This is used internally by
+      # acts_as_url[link:classes/Stringex/ActsAsUrl/ClassMethods.html#M000012]
+      # but can be called manually in order to generate an URI-friendly version of any string.
+      def to_url(options = {})
+        return self if options[:exclude] && options[:exclude].include?(self)
+        options = stringex_default_options.merge(options)
+        whitespace_replacement_token = options[:replace_whitespace_with]
+        dummy = remove_formatting(options).
+                  replace_whitespace(whitespace_replacement_token).
+                  collapse("-").
+                  limit(options[:limit])
+        dummy.downcase! unless options[:force_downcase] == false
+        dummy
       end
-      dummy = dummy.gsub(/(^|[[:alpha:]])'|`([[:alpha:]]|$)/, '\1\2').gsub(/[\.,:;()\[\]\/\?!\^'ʼ"_\|]/, " ").strip
-    end
 
-    # Replace runs of whitespace in string. Defaults to a single space but any replacement
-    # string may be specified as an argument. Examples:
-    #
-    #   "Foo       bar".replace_whitespace # => "Foo bar"
-    #   "Foo       bar".replace_whitespace("-") # => "Foo-bar"
-    def replace_whitespace(replace = " ")
-      gsub(/\s+/, replace)
-    end
+    private
+
+      def stringex_convert(options = {}, &block)
+        Localization.convert self, options, &block
+      end
 
-    # Removes specified character from the beginning and/or end of the string and then performs
-    # <tt>String#squeeze(character)</tt>, condensing runs of the character within the string.
-    #
-    # Note: This method has been superceded by ActiveSupport's squish method.
-    def collapse(character = " ")
-      sub(/^#{character}*/, "").sub(/#{character}*$/, "").squeeze(character)
+      def stringex_default_options
+        Stringex::Configuration::StringExtensions.default_settings
+      end
     end
 
-    module ClassMethods
+    # These methods are extended onto the String class itself.
+    module PublicClassMethods
       # Returns string of random characters with a length matching the specified limit. Excludes 0
       # to avoid confusion between 0 and O.
       def random(limit)