mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,28 @@
+class String
+
+  # Returns _n_ characters of the string. If _n_ is positive
+  # the characters are from the beginning of the string.
+  # If _n_ is negative from the end of the string.
+  #
+  # Alternatively a replacement string can be given, which will
+  # replace the _n_ characters.
+  #
+  #    str = "this is text"
+  #    str.nchar(4)            #=> "this"
+  #    str.nchar(4, 'that')    #=> "that"
+  #    str                     #=> "that is text"
+  #
+  #   CREDIT: ?
+
+  def nchar(n, replacement=nil)
+    if replacement
+      s = self.dup
+      n > 0 ? (s[0...n] = replacement) : (s[n..-1] = replacement)
+      return s
+    else
+      n > 0 ? self[0...n] : self[n..-1]
+    end
+  end
+
+end
+

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

@@ -0,0 +1,14 @@
+class String
+
+  # Removes occurances of a string or regexp.
+  #
+  #   "HELLO HELLO" - "LL"    #=> "HEO HEO"
+  #
+  #   CREDIT: Benjamin David Oakes
+
+  def -(pattern)
+    self.gsub(pattern, '')
+  end
+
+end
+

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

@@ -0,0 +1,16 @@
+class String
+
+  # Converts a (class or module) name to a unix path.
+  #
+  #   My::CoolClass.name.pathize  #=> "my/cool_class"
+  #
+  def pathize
+    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/range.rb

@@ -0,0 +1,77 @@
+class String
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> 10..13
+  #
+  #   CREDIT: Trans
+
+  def range(s, offset=0)
+    if index(s, offset)
+      return ($~.begin(0))..($~.end(0)-1)
+    end
+    nil
+  end
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  #   TODO: Add offset, perhaps ?
+  #
+  #   CREDIT: Trans
+
+  def range_all(s, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(s, i)
+      if rng
+        r << rng
+        i += reuse ? 1 : rng.end + 1
+      else
+        break
+      end
+    end
+    r.uniq
+  end
+
+  # Returns an array of ranges mapping
+  # the characters per line.
+  #
+  #   "this\nis\na\ntest".range_of_line
+  #   #=> [0..4, 5..7, 8..9, 10..13]
+  #
+  #   CREDIT: Trans
+
+  def range_of_line
+    offset=0; charmap = []
+    self.each do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+
+  # Like index but returns an array of all index locations.
+  # The reuse flag allows the trailing portion of a match to be
+  # reused for subsquent matches.
+  #
+  #   "abcabcabc".index_all('a')  #=> [0,3,6]
+  #
+  #   "bbb".index_all('bb', false)  #=> [0]
+  #   "bbb".index_all('bb', true)   #=> [0,1]
+  #
+  #   TODO: Culd probably be defined for Indexable in general too.
+
+  def index_all(s, reuse=false)
+    s = Regexp.new(Regexp.escape(s)) unless Regexp===s
+    ia = []; i = 0
+    while (i = index(s,i))
+      ia << i
+      i += (reuse ? 1 : $~[0].size)
+    end
+    ia
+  end
+
+end
+

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

@@ -0,0 +1,28 @@
+class String
+
+  # Apply a set of rules (regular expression matches) to the string.
+  #
+  # === Requirements:
+  # The rules must be applied in order! So we cannot use a
+  # hash because the ordering is not guaranteed! we use an
+  # array instead.
+  #
+  # === Input:
+  # The array containing rule-pairs (match, write).
+  #
+  # === Output:
+  # The rewritten string.
+  #
+  #   CREDIT: George Moschovitis
+
+  def rewrite(rules)
+    raise ArgumentError.new('The rules parameter is nil') unless rules
+    rewritten_string = dup
+    rules.each do |match,write|
+      rewritten_string.gsub!(match,write)
+    end
+    return rewritten_string
+  end
+
+end
+

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

@@ -0,0 +1,22 @@
+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.shatter( /\<.*?\>/ )
+  #
+  # _produces_
+  #
+  #   ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+  #
+  #   CREDIT: Trans
+
+  def shatter( re )
+    r = self.gsub( re ){ |s| "\1" + s + "\1" }
+    while r[0,1] == "\1" ; r[0] = '' ; end
+    while r[-1,1] == "\1" ; r[-1] = '' ; end
+    r.split("\1")
+  end
+
+end

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

@@ -0,0 +1,21 @@
+class String
+
+  # The reverse of +camelcase+. Makes an underscored of a camelcase string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "SnakeCase".snakecase           #=> "snake_case"
+  #   "Snake-Case".snakecase          #=> "snake_case"
+  #   "SnakeCase::Errors".underscore  #=> "snake_case/errors"
+
+  def snakecase
+    gsub(/::/, '/').  # NOT SO SURE ABOUT THIS -T
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+end
+

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

@@ -0,0 +1,37 @@
+class String
+
+  # This is basically the same as #store,
+  # but it acts like slice! when given only
+  # one argument.
+  #
+  # Essentlay #slice, but writes rather than
+  # reads.
+  #
+  #   a = "HELLO"
+  #   a.splice("X", 1)
+  #   a                #=> "HXLLO"
+  #
+  #   a = "HELLO"
+  #   a.splice(1)    #=> "E"
+  #   a              #=> "HLLO"
+  #
+  #   CREDIT: Trans
+
+  def splice(idx, sub=nil)
+    if sub
+      store(idx, sub)
+    else
+      case idx
+      when Range
+        slice!(idx) 
+      else
+        slice!(idx,1)
+      end
+    end
+  end
+
+  # Alias for []=.
+  alias_method :store, :[]=
+
+end
+

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

@@ -0,0 +1,32 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class String
+
+    # Does a string start with the given prefix.
+    #
+    #   "hello".starts_with?("he")    #=> true
+    #   "hello".starts_with?("to")    #=> false
+    #
+    #  CREDIT: Lucas Carlson
+    #  CREDIT: Blaine Cook
+
+    def start_with?(prefix)
+      self.index(prefix) == 0
+    end
+
+    # Does a string end with the given suffix?
+    #
+    #   "hello".ends_with?("lo")    #=> true
+    #   "hello".ends_with?("to")    #=> false
+    #
+    #  CREDIT: Lucas Carlson
+    #  CREDIT: Blaine Cook
+
+    def end_with?(suffix)
+      self.rindex(suffix) == size - suffix.size
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1,4 @@
+# TODO: Deprecate string/subtract file.
+#
+require 'facets/string/op_sub'
+

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

@@ -0,0 +1,103 @@
+class String
+
+  # LOG: DEPRECATED #whitespace?, alias of #blank?
+  #alias whitespace? blank?
+
+  # Aligns each line n spaces.
+  #
+  #  CREDIT: Gavin Sinclair
+
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Alias of tab that will be deprecated.
+  alias_method :taballto, :tab
+
+  # Expands tabs to +n+ spaces.  Non-destructive.  If +n+ is 0, then tabs are
+  # simply removed.  Raises an exception if +n+ is negative.
+  #
+  # Thanks to GGaramuno for a more efficient algorithm.  Very nice.
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Noah Gibbs
+  #  CREDIT: GGaramuno
+
+  def expand_tabs(n=8)
+    n = n.to_int
+    raise ArgumentError, "n must be >= 0" if n < 0
+    return gsub(/\t/, "") if n == 0
+    return gsub(/\t/, " ") if n == 1
+    str = self.dup
+    while
+      str.gsub!(/^([^\t\n]*)(\t+)/) { |f|
+        val = ( n * $2.size - ($1.size % n) )
+        $1 << (' ' * val)
+      }
+    end
+    str
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  #  CREDIT: Gavin Sinclair
+
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Trans
+
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+
+  # Outdent just indents a negative number of spaces.
+  #
+  #  CREDIT: Noah Gibbs
+
+  def outdent(n)
+    indent(-n)
+  end
+
+  # Provides a margin controlled string.
+  #
+  #   x = %Q{
+  #         | This
+  #         |   is
+  #         |     margin controlled!
+  #         }.margin
+  #
+  #
+  #   NOTE: This may still need a bit of tweaking.
+  #
+  #  CREDIT: Trans
+
+  def margin(n=0)
+    #d = /\A.*\n\s*(.)/.match( self )[1]
+    #d = /\A\s*(.)/.match( self)[1] unless d
+    d = ((/\A.*\n\s*(.)/.match(self)) ||
+        (/\A\s*(.)/.match(self)))[1]
+    return '' unless d
+    if n == 0
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+    else
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,15 @@
+class String
+
+  # Title case.
+  #
+  #   "this is a string".titlecase
+  #   => "This Is A String"
+  #
+  #  CREDIT: Eliazar Parra
+
+  def titlecase
+    gsub(/\b\w/){$&.upcase}
+  end
+
+end
+

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

@@ -0,0 +1,26 @@
+class String
+
+  # Turns a string into a regular expression.
+  #
+  #   "a?".to_re  #=> /a?/
+  #
+  #  CREDIT: Trans
+
+  def to_re(esc=false)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+  # Turns a string into a regular expression.
+  # By default it will escape all characters.
+  # Use <tt>false</tt> argument to turn off escaping.
+  #
+  #   "[".to_rx  #=> /\[/
+  #
+  #  CREDIT: Trans
+
+  def to_rx(esc=true)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+end
+

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

@@ -0,0 +1,13 @@
+class String
+
+  # Prepend an "@" to the beginning of a string
+  # to make a instance variable name. This also replaces
+  # non-valid characters with underscores.
+
+  def variablize
+    v = gsub(/\W/, '_')
+    "@#{v}"
+  end
+
+end
+