mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/string/bytes.rb

@@ -0,0 +1,15 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class String
+
+    # Upacks string into bytes.
+    #
+    #
+    def bytes
+      self.unpack('C*')
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/camelcase.rb

@@ -0,0 +1,26 @@
+class String
+
+  # Converts a string to camelcase.
+  #
+  # By default camelcase convert to UpperCamelCase, If an argument
+  # is set to +false+, then camelcase will produce lowerCamelCase.
+  #
+  # +camelcase+ also converts '/' to '::' which is useful for converting
+  # paths to namespaces.
+  #
+  # Examples
+  #   "camel_case".camelcase                    #=> "CamelCase"
+  #   "camel/case".camelcase                    #=> "Camel::Case"
+  #   "camel_case".camelcase(false)             #=> "camelCase"
+  #
+  def camelcase(upcase_first_letter=true)
+    up = upcase_first_letter
+    str = dup
+    str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS -T
+    str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+    str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase } if up
+    str
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/capitalized.rb

@@ -0,0 +1,46 @@
+class String
+
+  # Return true if the string is capitalized, otherwise false.
+  #
+  #   "THIS".capitalized?  #=> true
+  #   "This".capitalized?  #=> true
+  #   "this".capitalized?  #=> false
+  #
+  #  CREDIT: Phil Tomson
+
+  def capitalized?
+    self =~ /^[A-Z]/
+  end
+
+  # Return true if the string is lowercase (downcase), otherwise false.
+  #
+  #   "THIS".downcase?  #=> false
+  #   "This".downcase?  #=> false
+  #   "this".downcase?  #=> true
+  #
+  #  CREDIT: Phil Tomson
+
+  def downcase?
+    downcase == self
+  end
+
+  # Alias for #downcase? method.
+  #alias_method :lowercase?, :downcase?
+
+  # Is the string upcase/uppercase?
+  #
+  #   "THIS".upcase?  #=> true
+  #   "This".upcase?  #=> false
+  #   "this".upcase?  #=> false
+  #
+  #  CREDIT: Phil Tomson
+
+  def upcase?
+    upcase == self
+  end
+
+  # Alias for #upcase? method.
+  #alias_method :uppercase?, :upcase?
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/chars.rb

@@ -0,0 +1,16 @@
+class String
+
+  unless defined?(chars) or defined?(::ActiveSupport) # 1.9 & ActiveSupport
+
+    # Returns an array of characters.
+    #
+    #   "abc".chars  #=> ["a","b","c"]
+
+    def chars
+      split(//)
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/chomp.rb

@@ -0,0 +1,33 @@
+class String
+
+  # Left chomp.
+  #
+  #   "help".lchomp("h")  #=> "elp"
+  #   "help".lchomp("k")  #=> "help"
+  #
+  #   CREDIT: Trans
+
+  def lchomp(match)
+    if index(match) == 0
+      self[match.size..-1]
+    else
+      self.dup
+    end
+  end
+
+  # In-place left chomp.
+  #
+  #   "help".lchomp("h")  #=> "elp"
+  #   "help".lchomp("k")  #=> "help"
+  #
+  #   CREDIT: Trans
+
+  def lchomp!(match)
+    if index(match) == 0
+      self[0...match.size] = ''
+      self
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/cleave.rb

@@ -0,0 +1,36 @@
+class String
+
+  # Cleave a string. Break a string in two parts at
+  # the nearest whitespace.
+  #
+  #  CREDIT: Trans
+
+  def cleave(threshold=nil, len=nil)
+    l = (len || size / 2)
+    t = threshold || size
+
+    h1 = self[0...l]
+    h2 = self[l..-1]
+
+    i1 = h1.rindex(/\s/) || 0
+    d1 = (i1 - l).abs
+
+    d2 = h2.index(/\s/) || l
+    i2 = d2 + l
+
+    d1 = (i1-l).abs
+    d2 = (i2-l).abs
+
+    if [d1, d2].min > t
+      i = t
+    elsif d1 < d2
+      i = i1
+    else
+      i = i2
+    end
+
+    #dup.insert(l, "\n").gsub(/^\s+|\s+$/, '')
+    return self[0..i].to_s.strip, self[i+1..-1].to_s.strip
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/string/divide.rb

@@ -0,0 +1,21 @@
+class String
+
+  # Breaks a string up into an array based on a regular expression.
+  # Similar to scan, but includes the matches.
+  #
+  #   s = "<p>This<b>is</b>a test.</p>"
+  #   s.divide( /\<.*?\>/ )
+  #
+  # _produces_
+  #
+  #   ["<p>This", "<b>is", "</b>a test.", "</p>"]
+  #
+  #   CREDIT: Trans
+
+  def divide( re )
+    re2 = /#{re}.*?(?=#{re}|\Z)/
+    scan(re2) #{re}(?=#{re})/)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/each_char.rb

@@ -0,0 +1,29 @@
+class String
+
+  unless defined? each_char # 1.9
+
+    require 'strscan'
+
+    # Iterates through each character. This is a little faster than
+    # using #chars b/c it does not create the intermediate array.
+    #
+    #    a = ''
+    #   "HELLO".each_character{ |c| a << #{c.downcase} }
+    #    a  #=> 'hello'
+
+    #def each_char  # :yield:
+    #  size.times do |i|
+    #    yield(self[i,1])
+    #  end
+    #end
+
+    # Yields a single-character string for each character in the string.
+    # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
+    def each_char
+      scanner, char = StringScanner.new(self), /./mu
+      loop { yield(scanner.scan(char) || break) }
+    end
+
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/string/each_word.rb

@@ -0,0 +1,13 @@
+require 'facets/string/words'
+
+class String
+
+  # Iterate through each word of a string.
+  #
+  #   "a string".each_word { |word, range| ... }
+  #
+  def each_word(&block)
+    words.each(&block)
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/string/end_with.rb

@@ -0,0 +1 @@
+require 'facets/string/start_with'

data/lib/gems/facets-2.4.5/lib/core/facets/string/fold.rb

@@ -0,0 +1,39 @@
+class String
+
+  # Returns a new string with all new lines removed from
+  # adjacent lines of text.
+  #
+  #   s = "This is\na test.\n\nIt clumps\nlines of text."
+  #   s.fold
+  #
+  # _produces_
+  #
+  #   "This is a test.\n\nIt clumps lines of text. "
+  #
+  # One arguable flaw with this, that might need a fix:
+  # if the given string ends in a newline, it is replaced with
+  # a single space.
+  #
+  #   CREDIT: Trans
+
+  def fold(ignore_indented=false)
+    ns = ''
+    i = 0
+    br = self.scan(/(\n\s*\n|\Z)/m) do |m|
+      b = $~.begin(1)
+      e = $~.end(1)
+      nl = $&
+      tx = slice(i...b)
+      if ignore_indented and slice(i...b) =~ /^[ ]+/
+        ns << tx
+      else
+        ns << tx.gsub(/[ ]*\n+/,' ')
+      end
+      ns << nl
+      i = e
+    end
+    ns
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/interpolate.rb

@@ -0,0 +1,20 @@
+class String
+
+  # Interpolate. Provides a means of extenally using
+  # Ruby string interpolation mechinism.
+  #
+  #   try = "hello"
+  #   str = "\#{try}!!!"
+  #   String.interpolate{ str }    #=> "hello!!!"
+  #
+  #   NOTE: The block neccessary in order to get
+  #         then binding of the caller.
+  #
+  #   CREDIT: Trans
+
+  def self.interpolate(&str)
+    eval "%{#{str.call}}", str.binding
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/line_wrap.rb

@@ -0,0 +1,21 @@
+class String
+
+  # Line wrap at width.
+  #
+  #   puts "1234567890".line_wrap(5)
+  #
+  # _produces_
+  #
+  #   12345
+  #   67890
+  #
+  #  CREDIT: Trans
+
+  def line_wrap(width, tabs=4)
+    s = gsub(/\t/,' ' * tabs) # tabs default to 4 spaces
+    s = s.gsub(/\n/,' ')
+    r = s.scan( /.{1,#{width}}/ )
+    r.join("\n") << "\n"
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/string/lines.rb

@@ -0,0 +1,16 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class String
+
+    # Returns an array of characters.
+    #
+    #   "abc\n123".lines  #=> ["abc","123"]
+
+    def lines
+      self.split(/\n/)
+    end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/methodize.rb

@@ -0,0 +1,17 @@
+class String
+
+  # Translate a (class or module) name to a suitable method name.
+  #
+  #   My::CoolClass.name.methodize => "my__cool_class"
+  #
+  def methodize
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').
+    gsub(/([a-z])([A-Z])/,'\1_\2').
+    gsub('/','__').
+    gsub('::','__').
+    downcase
+  end
+
+end
+
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/modulize.rb

@@ -0,0 +1,21 @@
+class String
+
+  # Converts a string to module name representation.
+  #
+  # This is essentially #camelcase. It also converts
+  # '/' to '::' which is useful for converting
+  # paths to namespaces.
+  #
+  # Examples
+  #   "method_name".modulize    #=> "MethodName"
+  #   "method/name".modulize    #=> "Method::Name"
+  #
+  def modulize
+    gsub('__','/').
+    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+    gsub(/(?:_+|-+)([a-z])/){ $1.upcase }.
+    gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/mscan.rb

@@ -0,0 +1,19 @@
+class String
+
+  # Like #scan but returns MatchData ($~) rather
+  # then matched string ($&).
+  #
+  #   CREDIT: Trans
+
+  def mscan(re) #:yield:
+    if block_given?
+      scan(re) { yield($~) }
+    else
+      m = []
+      scan(re) { m << $~ }
+      m
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/natcmp.rb

@@ -0,0 +1,88 @@
+class String
+
+  # 'Natural order' comparison of strings, e.g.
+  #
+  #   "my_prog_v1.1.0" < "my_prog_v1.2.0" < "my_prog_v1.10.0"
+  #
+  # which does not follow alphabetically. A secondary
+  # parameter, if set to _true_, makes the comparison
+  # case insensitive.
+  #
+  #   "Hello.10".natcmp("Hello.1")  #=> -1
+  #
+  #   TODO: Invert case flag?
+  #
+  #   CREDIT: Alan Davies
+  #   CREDIT: Martin Pool
+  #
+  #--
+  # Adapted from:
+  #
+  #   http://sourcefrog.net/projects/natsort/natcmp.rb
+  #
+  # Based on Martin Pool's "Natural Order String Comparison" originally
+  # written in C. (see http://sourcefrog.net/projects/natsort/)
+  #
+  # This implementation is Copyright (C) 2003 by Alan Davies
+  # <cs96and_AT_yahoo_DOT_co_DOT_uk>
+  #
+  # This software is provided 'as-is', without any express or implied
+  # warranty.  In no event will the authors be held liable for any damages
+  # arising from the use of this software.
+  #
+  # Permission is granted to anyone to use this software for any purpose,
+  # including commercial applications, and to alter it and redistribute it
+  # freely, subject to the following restrictions:
+  #
+  # 1. The origin of this software must not be misrepresented; you must not
+  #    claim that you wrote the original software. If you use this software
+  #    in a product, an acknowledgment in the product documentation would be
+  #    appreciated but is not required.
+  # 2. Altered source versions must be plainly marked as such, and must not be
+  #    misrepresented as being the original software.
+  # 3. This notice may not be removed or altered from any source distribution.
+  #
+  #++
+
+  def natcmp(str2, caseInsensitive=false)
+    str1 = self.dup
+    str2 = str2.dup
+    compareExpression = /^(\D*)(\d*)(.*)$/
+
+    if caseInsensitive
+      str1.downcase!
+      str2.downcase!
+    end
+
+    # remove all whitespace
+    str1.gsub!(/\s*/, '')
+    str2.gsub!(/\s*/, '')
+
+    while (str1.length > 0) or (str2.length > 0) do
+      # Extract non-digits, digits and rest of string
+      str1 =~ compareExpression
+      chars1, num1, str1 = $1.dup, $2.dup, $3.dup
+      str2 =~ compareExpression
+      chars2, num2, str2 = $1.dup, $2.dup, $3.dup
+      # Compare the non-digits
+      case (chars1 <=> chars2)
+        when 0 # Non-digits are the same, compare the digits...
+          # If either number begins with a zero, then compare alphabetically,
+          # otherwise compare numerically
+          if (num1[0] != 48) and (num2[0] != 48)
+            num1, num2 = num1.to_i, num2.to_i
+          end
+          case (num1 <=> num2)
+            when -1 then return -1
+            when 1 then return 1
+          end
+        when -1 then return -1
+        when 1 then return 1
+      end # case
+    end # while
+
+    # strings are naturally equal.
+    return 0
+  end
+
+end