mini-pro-pkg 0.0.1

data/stringex-2.8.6/lib/stringex/localization/converter.rb

@@ -0,0 +1,129 @@
+# 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 normalize_currency!
+        string.gsub!(/(\d+),(\d+)/, '\1\2')
+      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 unreadable_control_characters
+        string.gsub! expressions.unreadable_control_characters, ''
+      end
+
+      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 replacement == '' || 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/stringex-2.8.6/lib/stringex/localization/default_conversions.rb

@@ -0,0 +1,89 @@
+# 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 = {
+        generic: '\1 dollars',
+        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/stringex-2.8.6/lib/stringex/localization.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+require 'stringex/localization/converter'
+require 'stringex/localization/default_conversions'
+require 'stringex/localization/backend/base'
+require 'stringex/localization/backend/internal'
+require 'stringex/localization/backend/i18n'
+
+module Stringex
+  module Localization
+    include DefaultConversions
+
+    class << self
+      def backend
+        @backend ||= i18n_present? ? Backend::I18n : Backend::Internal
+      end
+
+      def backend=(sym_or_class)
+        if sym_or_class.is_a?(Symbol)
+          @backend = case sym_or_class
+          when :internal
+            Backend::Internal
+          when :i18n
+            ensure_i18n!
+            Backend::I18n
+          else
+            raise "Invalid backend :#{sym_or_class}"
+          end
+        else
+          @backend = sym_or_class
+        end
+      end
+
+      def store_translations(locale, scope, data)
+        backend.store_translations(locale, scope, data)
+      end
+
+      def translate(scope, key, options = {})
+        return if key == "." # I18n doesn't support dots as translation keys so we don't either
+
+        locale = options[:locale] || self.locale
+
+        translation = initial_translation(scope, key, locale)
+
+        return translation unless translation.nil?
+
+        if locale != default_locale
+          translate scope, key, options.merge(locale: default_locale)
+        else
+          default_conversion(scope, key) || options[:default]
+        end
+      end
+
+      def locale
+        backend.locale
+      end
+
+      def locale=(new_locale)
+        backend.locale = new_locale
+      end
+
+      def default_locale
+        backend.default_locale
+      end
+
+      def default_locale=(new_locale)
+        backend.default_locale = new_locale
+      end
+
+      def with_locale(new_locale, &block)
+        new_locale = default_locale if new_locale == :default
+        backend.with_locale new_locale, &block
+      end
+
+      def with_default_locale(&block)
+        with_locale default_locale, &block
+      end
+
+      def reset!
+        backend.reset!
+        @backend = nil
+      end
+
+      def convert(string, options = {}, &block)
+        converter = Converter.new(string, options)
+        converter.instance_exec(&block)
+        converter.smart_strip!
+        converter.string
+      end
+
+    private
+
+      def initial_translation(scope, key, locale)
+        backend.initial_translation(scope, key, locale)
+      end
+
+      def default_conversion(scope, key)
+        return unless DefaultConversions.respond_to?(scope)
+        DefaultConversions.send(scope)[key]
+      end
+
+      def i18n_present?
+        defined?(I18n) && I18n.respond_to?(:translate)
+      end
+
+      def ensure_i18n!
+        raise Backend::I18nNotDefined unless defined?(I18n)
+        raise Backend::I18nMissingTranslate unless I18n.respond_to?(:translate)
+      end
+    end
+  end
+end

data/stringex-2.8.6/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/stringex-2.8.6/lib/stringex/string_extensions.rb

@@ -0,0 +1,228 @@
+# encoding: UTF-8
+
+module Stringex
+  module StringExtensions
+    def self.configure(&block)
+      Stringex::Configuration::StringExtensions.configure(&block)
+    end
+
+    def self.unconfigure!
+      Stringex::Configuration::StringExtensions.unconfigure!
+    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
+
+      # 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
+      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(options) do
+          normalize_currency!
+          translate! :ellipses, :currencies, :abbreviations, :characters, :apostrophes
+          cleanup_characters!
+        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_miscellaneous_html_entities
+        stringex_convert do
+          translate! :html_entities
+          cleanup_html_entities!
+        end
+      end
+
+      # Converts MS Word 'smart punctuation' to ASCII
+      #
+      def convert_smart_punctuation
+        stringex_convert do
+          cleanup_smart_punctuation!
+        end
+      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
+
+      def convert_unreadable_control_characters
+        stringex_convert do
+          translate! :unreadable_control_characters
+        end
+      end
+
+      # Returns the string limited in size to the value of limit.
+      def limit(limit = nil, truncate_words = true, whitespace_replacement_token = "-")
+        if limit.nil?
+          self
+        else
+          truncate_words == false ? self.whole_word_limit(limit, whitespace_replacement_token) : self[0...limit]
+        end
+      end
+
+      def whole_word_limit(limit, whitespace_replacement_token = "-")
+        whole_words = []
+        words = self.split(whitespace_replacement_token)
+
+        words.each do |word|
+          if word.size > limit
+            break
+          else
+            whole_words << word
+            limit -= (word.size + 1)
+          end
+        end
+
+        whole_words.join(whitespace_replacement_token)
+      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_html_entities.
+          convert_vulgar_fractions.
+          convert_unreadable_control_characters.
+          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
+
+      # 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
+
+      # 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
+
+      # 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
+
+      # 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(whitespace_replacement_token).
+                  limit(options[:limit], options[:truncate_words], whitespace_replacement_token)
+        dummy.downcase! unless options[:force_downcase] == false
+        dummy
+      end
+
+    private
+
+      def stringex_convert(options = {}, &block)
+        Localization.convert self, options, &block
+      end
+
+      def stringex_default_options
+        Stringex::Configuration::StringExtensions.new.settings.marshal_dump
+      end
+    end
+
+    # 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)
+        strong_alphanumerics = %w{
+          a b c d e f g h i j k l m n o p q r s t u v w x y z
+          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+          1 2 3 4 5 6 7 8 9
+        }
+        Array.new(limit, "").collect{strong_alphanumerics[rand(61)]}.join
+      end
+    end
+  end
+end

data/stringex-2.8.6/lib/stringex/unidecoder.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+require 'yaml'
+require 'stringex/localization'
+
+module Stringex
+  module Unidecoder
+    # Contains Unicode codepoints, loading as needed from YAML files
+    CODEPOINTS = Hash.new{|h, k|
+      h[k] = ::YAML.load_file(File.join(File.expand_path(File.dirname(__FILE__)), "unidecoder_data", "#{k}.yml"))
+    } unless defined?(CODEPOINTS)
+
+    class << self
+      # Returns string with its UTF-8 characters transliterated to ASCII ones
+      #
+      # You're probably better off just using the added String#to_ascii
+      def decode(string)
+        string.chars.map{|char| decoded(char)}.join
+      end
+
+      # Returns character for the given Unicode codepoint
+      def encode(codepoint)
+        ["0x#{codepoint}".to_i(16)].pack("U")
+      end
+
+      # Returns Unicode codepoint for the given character
+      def get_codepoint(character)
+        "%04x" % character.unpack("U")[0]
+      end
+
+      # Returns string indicating which file (and line) contains the
+      # transliteration value for the character
+      def in_yaml_file(character)
+        unpacked = character.unpack("U")[0]
+        "#{code_group(unpacked)}.yml (line #{grouped_point(unpacked) + 2})"
+      end
+
+    private
+
+      def decoded(character)
+        localized(character) || from_yaml(character)
+      end
+
+      def localized(character)
+        Localization.translate(:transliterations, character)
+      end
+
+      def from_yaml(character)
+        return character unless character.ord > 128
+        unpacked = character.unpack("U")[0]
+        CODEPOINTS[code_group(unpacked)][grouped_point(unpacked)]
+      rescue
+        # Hopefully this won't come up much
+        # TODO: Make this note something to the user that is reportable to me perhaps
+        "?"
+      end
+
+      # Returns the Unicode codepoint grouping for the given character
+      def code_group(unpacked_character)
+        "x%02x" % (unpacked_character >> 8)
+      end
+
+      # Returns the index of the given character in the YAML file for its codepoint group
+      def grouped_point(unpacked_character)
+        unpacked_character & 255
+      end
+    end
+  end
+end
+
+module Stringex
+  module StringExtensions
+    module PublicInstanceMethods
+      # Returns string with its UTF-8 characters transliterated to ASCII ones. Example:
+      #
+      #   "⠋⠗⠁⠝⠉⠑".to_ascii #=> "france"
+      def to_ascii
+        Stringex::Unidecoder.decode(self)
+      end
+    end
+  end
+end