stringex 1.3.0 → 1.3.1

data/lib/lucky_sneaks/acts_as_url.rb

@@ -1,105 +0,0 @@
-# encoding: UTF-8
-module LuckySneaks
-  module ActsAsUrl # :nodoc:
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods # :doc:
-      # Creates a callback to automatically create an url-friendly representation
-      # of the <tt>attribute</tt> argument. Example:
-      #
-      #   act_as_url :title
-      #
-      # will use the string contents of the <tt>title</tt> attribute
-      # to create the permalink. <strong>Note:</strong> you can also use a non-database-backed
-      # method to supply the string contents for the permalink. Just use that method's name
-      # as the argument as you would an attribute.
-      #
-      # The default attribute <tt>acts_as_url</tt> uses to save the permalink is <tt>url</tt>
-      # but this can be changed in the options hash. Available options are:
-      #
-      # <tt>:url_attribute</tt>:: The name of the attribute to use for storing the generated url string.
-      #                           Default is <tt>:url</tt>
-      # <tt>:scope</tt>:: The name of model attribute to scope unique urls to. There is no default here.
-      # <tt>:only_when_blank</tt>:: If true, the url generation will only happen when <tt>:url_attribute</tt> is
-      #                             blank. Default is false (meaning url generation will happen always)
-      # <tt>:sync_url</tt>:: If set to true, the url field will be updated when changes are made to the
-      #                      attribute it is based on. Default is false.
-      def acts_as_url(attribute, options = {})
-        cattr_accessor :attribute_to_urlify
-        cattr_accessor :scope_for_url
-        cattr_accessor :url_attribute # The attribute on the DB
-        cattr_accessor :only_when_blank
-        cattr_accessor :duplicate_count_separator
-
-        if options[:sync_url]
-          before_validation(:ensure_unique_url)
-        else
-          if defined?(ActiveModel::Callbacks)
-            before_validation(:ensure_unique_url, :on => :create)
-          else
-            before_validation_on_create(:ensure_unique_url)
-          end
-        end
-
-        self.attribute_to_urlify = attribute
-        self.scope_for_url = options[:scope]
-        self.url_attribute = options[:url_attribute] || "url"
-        self.only_when_blank = options[:only_when_blank] || false
-        self.duplicate_count_separator = options[:duplicate_count_separator] || "-"
-
-        class_eval <<-"END"
-          def #{url_attribute}
-            if !new_record? && errors[attribute_to_urlify].present?
-              self.class.find(id).send(url_attribute)
-            else
-              read_attribute(url_attribute)
-            end
-          end
-        END
-      end
-
-      # Initialize the url fields for the records that need it. Designed for people who add
-      # <tt>acts_as_url</tt> support once there's already development/production data they'd
-      # like to keep around.
-      #
-      # Note: This method can get very expensive, very fast. If you're planning on using this
-      # on a large selection, you will get much better results writing your own version with
-      # using pagination.
-      def initialize_urls
-        find(:all, :conditions => {self.url_attribute => nil}).each do |instance|
-          instance.send :ensure_unique_url
-          instance.save
-        end
-      end
-    end
-
-  private
-
-    def ensure_unique_url
-      url_attribute = self.class.url_attribute
-      separator = self.class.duplicate_count_separator
-      base_url = self.send(url_attribute)
-      base_url = self.send(self.class.attribute_to_urlify).to_s.to_url if base_url.blank? || !self.only_when_blank
-      conditions = ["#{url_attribute} LIKE ?", base_url+'%']
-      unless new_record?
-        conditions.first << " and id != ?"
-        conditions << id
-      end
-      if self.class.scope_for_url
-        conditions.first << " and #{self.class.scope_for_url} = ?"
-        conditions << send(self.class.scope_for_url)
-      end
-      url_owners = self.class.find(:all, :conditions => conditions)
-      write_attribute url_attribute, base_url
-      if url_owners.any?{|owner| owner.send(url_attribute) == base_url}
-        n = 1
-        while url_owners.any?{|owner| owner.send(url_attribute) == "#{base_url}#{separator}#{n}"}
-          n = n.succ
-        end
-        write_attribute url_attribute, "#{base_url}#{separator}#{n}"
-      end
-    end
-  end
-end

data/lib/lucky_sneaks/string_extensions.rb

@@ -1,196 +0,0 @@
-# encoding: UTF-8
-
-module LuckySneaks
-  # These methods are all added on String class.
-  module StringExtensions
-    def self.included(base) # :nodoc:
-      base.extend(ClassMethods)
-    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/LuckySneaks/ActsAsUrl/ClassMethods.html#M000012]
-    # but can be called manually in order to generate an URI-friendly version of any string.
-    def to_url
-      remove_formatting.downcase.replace_whitespace("-").collapse("-")
-    end
-
-    # Performs multiple text manipulations. Essentially a shortcut for typing them all. View source
-    # below to see which methods are run.
-    def remove_formatting
-      strip_html_tags.convert_smart_punctuation.convert_accented_entities.convert_misc_entities.convert_misc_characters.to_ascii.collapse
-    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')
-    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",
-        "(#176|deg)" => " degrees"
-      }.each do |textiled, normal|
-        dummy.gsub!(/&#{textiled};/, normal)
-      end
-      dummy.gsub(/&[^;]+;/, "")
-    end
-
-    # Converts MS Word 'smart punctuation' to ASCII
-    #
-    def convert_smart_punctuation
-      dummy = dup
-      {
-
-        "(“|”|\302\223|\302\224)" => '"',
-        "(‘|’|\302\221|\302\222)" => "'",
-        "…" => "...",
-      }.each do |smart, normal|
-        dummy.gsub!(/#{smart}/, normal)
-      end
-      dummy
-    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
-      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)
-      end
-      # Back to normal rules
-      {
-        /\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*/ => "slash",
-        /(\s*=\s*)/ => " equals ",
-        /\s*\+\s*/ => "plus"
-      }.each do |found, replaced|
-        replaced = " #{replaced} " unless replaced =~ /\\1/
-        dummy.gsub!(found, replaced)
-      end
-      dummy = dummy.gsub(/(^|\w)'(\w|$)/, '\1\2').gsub(/[\.,:;()\[\]\/\?!\^'"_]/, " ")
-    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
-
-    # 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
-
-    module ClassMethods
-      # 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/lib/lucky_sneaks/unidecoder.rb

@@ -1,62 +0,0 @@
-# encoding: UTF-8
-require "yaml"
-
-module LuckySneaks
-  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.gsub(/[^\x00-\x7f]/u) do |codepoint|
-          begin
-            unpacked = codepoint.unpack("U")[0]
-            CODEPOINTS[code_group(unpacked)][grouped_point(unpacked)]
-          rescue
-            # Hopefully this won't come up much
-            "?"
-          end
-        end
-      end
-
-      # Returns character for the given Unicode codepoint
-      def encode(codepoint)
-        ["0x#{codepoint}".to_i(16)].pack("U")
-      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
-      # 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 LuckySneaks
-  module StringExtensions
-    # Returns string with its UTF-8 characters transliterated to ASCII ones. Example:
-    #
-    #   "⠋⠗⠁⠝⠉⠑".to_ascii #=> "braille"
-    def to_ascii
-      LuckySneaks::Unidecoder.decode(self)
-    end
-  end
-end

data/lib/lucky_sneaks/unidecoder_data/x00.yml

@@ -1,257 +0,0 @@
----
-- "\x00"
-- "\x01"
-- "\x02"
-- "\x03"
-- "\x04"
-- "\x05"
-- "\x06"
-- "\a"
-- "\x08"
-- '  '
-- "\n"
-- "\v"
-- "\f"
-- "\r"
-- "\x0e"
-- "\x0f"
-- "\x10"
-- "\x11"
-- "\x12"
-- "\x13"
-- "\x14"
-- "\x15"
-- "\x16"
-- "\x17"
-- "\x18"
-- "\x19"
-- "\x1a"
-- "\e"
-- "\x1c"
-- "\x1d"
-- "\x1e"
-- "\x1f"
-- ' '
-- '!'
-- '"'
-- '#'
-- $
-- '%'
-- '&'
-- "'"
-- (
-- )
-- '*'
-- +
-- ','
-- '-'
-- .
-- /
-- 0
-- 1
-- 2
-- 3
-- 4
-- 5
-- 6
-- 7
-- 8
-- 9
-- ':'
-- ;
-- <
-- '='
-- '>'
-- '?'
-- '@'
-- 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
-- '{'
-- '|'
-- '}'
-- '~'
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- "'"
-- "'"
-- '"'
-- '"'
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ''
-- ' '
-- ''
-- C/
-- PS
-- $?
-- Y=
-- '|'
-- SS
-- '"'
-- (c)
-- a
-- '<<'
-- '!'
-- ''
-- (r)
-- '-'
-- deg
-- +-
-- 2
-- 3
-- "'"
-- u
-- P
-- '*'
-- ','
-- 1
-- o
-- '>>'
-- 1/4
-- 1/2
-- 3/4
-- ''
-- A
-- A
-- A
-- A
-- A
-- A
-- AE
-- C
-- E
-- E
-- E
-- E
-- I
-- I
-- I
-- I
-- D
-- N
-- O
-- O
-- O
-- O
-- O
-- x
-- O
-- U
-- U
-- U
-- U
-- Y
-- Th
-- ss
-- a
-- a
-- a
-- a
-- a
-- a
-- ae
-- c
-- e
-- e
-- e
-- e
-- i
-- i
-- i
-- i
-- d
-- n
-- o
-- o
-- o
-- o
-- o
-- /
-- o
-- u
-- u
-- u
-- u
-- y
-- th
-- y