facets-glimmer 3.2.0

data/lib/core/facets/string/linear.rb

@@ -0,0 +1,19 @@
+require 'facets/functor'
+
+class String
+
+  # TODO: Should String#linear be moved to separate functor gem?
+
+  # Like `#newlines` but returns a Functor instead.
+  #
+  #   "a \n b \n c".linear.strip   #=> "a\nb\nc"
+  #
+  def linear
+    Functor.new do |op, *a, &b|
+      lines.map { |line|
+        line.chomp.public_send(op, *a, &b)
+      }.join("\n")
+    end
+  end
+
+end

data/lib/core/facets/string/lowercase.rb

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

data/lib/core/facets/string/margin.rb

@@ -0,0 +1,55 @@
+require 'facets/string/indent'
+
+class String
+
+  # Preserve relative tabbing such that the line with the least amount 
+  # of white space ends up with the given number of spaces before non-space
+  # and all other lines move relative to it.
+  #
+  # Because of the nature of this method, leading tab characters (`\t`) must
+  # be converted to spaces. The size of a tab can be set via the `:tab` option.
+  # The default size is 2.
+  #
+  # If the `:lead` option is set, then the relative margin is determined
+  # by the first non-blank line, instead of the minimum white-space for all
+  # lines.
+  #
+  # Arguments
+  #
+  #   num   - The size of the desired margin. [Integer]
+  #   opts  - Margin options. [Hash]
+  #
+  # Options
+  #
+  #   :tab  - Size of tab character in spaces. [Integer]
+  #   :lead - Use first non-blank line as relative marker. [Boolean] 
+  #
+  # Returns a new String with adjusted margin. [String]
+  #
+  # Author: Gavin Sinclair
+  # Author: Trans
+
+  def margin(num=nil, opts={})
+    # TODO: temporary to help people transition
+    raise ArgumentError, "String#margin has been renamed to #trim." unless num
+
+    tab = opts[:tab] || 2
+    str = gsub("\t", " " * tab)  # TODO: only leading tabs ?
+
+    if opts[:lead]
+      if self =~ /^( *)\S/
+        indent(num - $1.length)
+      else
+        self
+      end
+    else
+      min = []
+      str.each_line do |line|
+        next if line.strip.empty?
+        min << line.index(/\S/)
+      end
+      min = min.min
+      str.indent(num - min)
+    end
+  end
+end

data/lib/core/facets/string/methodize.rb

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

data/lib/core/facets/string/modulize.rb

@@ -0,0 +1,31 @@
+class String
+
+  # Converts a string to module name representation.
+  #
+  # This is essentially #camelcase, but 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('__','/').  # why was this ever here?
+    gsub(/__(.?)/){ "::#{$1.upcase}" }.
+    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+    gsub(/(?:_+|-+)([a-z])/){ $1.upcase }.
+    gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+  end
+
+  # Compare to ActiveSupport's definition:
+  #
+  #    gsub(/__(.?)/){ "::#{$1.upcase}" }.
+  #    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+  #    gsub(/(?:_+)([a-z])/){ $1.upcase }.
+  #    gsub(/(^|\s+)([a-z])/){ $1 + $2.upcase }
+  #
+
+end
+

data/lib/core/facets/string/mscan.rb

@@ -0,0 +1,22 @@
+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
+
+  # Alias for #mscan.
+  alias each_match mscan
+
+end
+

data/lib/core/facets/string/natcmp.rb

@@ -0,0 +1,88 @@
+#--
+# 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.
+#++
+
+#
+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.1".natcmp("Hello.10")  #=> -1
+  #
+  # TODO: Invert case flag?
+  #
+  # @author Alan Davies
+  # @author Martin Pool
+
+  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

data/lib/core/facets/string/nchar.rb

@@ -0,0 +1,32 @@
+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.
+  #
+  #    str = "this is text"
+  #
+  #    str.nchar(4)            #=> "this"
+  #    str.nchar(-4)           #=> "text"
+  #
+  # Alternatively a replacement string can be given, which will
+  # replace the _n_ characters.
+  #
+  #    str.nchar(4, 'that')    #=> "that is text"
+  #
+  # The original string remains unaffected.
+  #
+  #    str  #=> "this is text"
+  #
+  def nchar(n, replacement=nil)
+    if replacement
+      s = self.dup
+      n > 0 ? (s[0...n] = replacement) : (s[n..-1] = replacement)
+      s
+    else
+      n > 0 ? self[0...n] : self[n..-1]
+    end
+  end
+
+end
+

data/lib/core/facets/string/newlines.rb

@@ -0,0 +1,32 @@
+require "facets/enumerator"
+
+class String
+
+  # Returns an Enumerator for iterating over each
+  # line of the string, void of the termining newline
+  # character, in contrast to #lines which retains it.
+  #
+  #   "a\nb\nc".newlines.class.assert == Enumerator
+  #   "a\nb\nc".newlines.to_a.assert == %w{a b c}
+  #
+  #   a = []
+  #   "a\nb\nc".newlines{|nl| a << nl}
+  #   a.assert == %w{a b c}
+  #
+  def newlines(&block)
+    if block
+      scan(/^.*?$/) do |line|
+        block.call(line.chomp)
+      end
+    else
+      str = self
+      Enumerator.new do |output|
+        str.scan(/^.*?$/) do |line|
+          output.yield(line.chomp)
+        end
+      end
+    end
+  end
+
+end
+

data/lib/core/facets/string/number.rb

@@ -0,0 +1,14 @@
+class String
+
+  # Returns true if it's a decimal digits.
+  #
+  #   "123_456_789_123_456_789.123_456_000_111".number?  # => true
+  #   "1.23".number?  # => true
+  #   "1.23a".number? # => false
+  #
+  # CREDIT: u2
+
+  def number?
+    !!self.match(/\A[+-]?\d+?(_?\d+?)*?(\.\d+(_?\d+?)*?)?\Z/)
+  end
+end

data/lib/core/facets/string/op_div.rb

@@ -0,0 +1,14 @@
+class String
+
+  # Treats +self+ and +path+ as representations
+  # of pathnames, joining thme together as a
+  # single path.
+  #
+  #   ('home' / 'trans')  #=> 'home/trans'
+  #
+  def /(path)
+    File.join(self, path.to_s)
+  end
+
+end
+

data/lib/core/facets/string/op_sub.rb

@@ -0,0 +1 @@
+require_relative 'remove'

data/lib/core/facets/string/outdent.rb

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

data/lib/core/facets/string/pathize.rb

@@ -0,0 +1,32 @@
+class String
+
+  # Transforms a namespace, i.e. a class or module name, into a viable 
+  # file path.
+  #
+  #   "ExamplePathize".pathize           #=> "example_pathize"
+  #   "ExamplePathize::Example".pathize  #=> "example_pathize/example"
+  #
+  # Compare this method to {String#modulize) and {String#methodize).
+  #
+  def pathize
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').
+    gsub(/([a-z])([A-Z])/,'\1_\2').
+    gsub('__','/').
+    gsub('::','/').
+    gsub(/\s+/, '').                # spaces are bad form
+    gsub(/[?%*:|"<>.]+/, '').   # reserved characters
+    downcase
+  end
+
+  # Compare to Rails definition:
+  #
+  #    gsub(/__/, '/').
+  #    gsub(/::/, '/').
+  #    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+  #    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+  #    tr("-", "_").
+  #    downcase
+  #
+
+end
+

data/lib/core/facets/string/quote.rb

@@ -0,0 +1,93 @@
+class String
+
+  # Return a new string embraced by given +type+ and +count+
+  # of quotes. The arguments can be given in any order.
+  #
+  # If no type is given, double quotes are assumed.
+  #
+  #   "quote me".quote     #=> '"quote me"'
+  #
+  # If no type but a count is given then :mixed is assumed.
+  #
+  #   "quote me".quote(1)  #=> %q{'quote me'}
+  #   "quote me".quote(2)  #=> %q{"quote me"}
+  #   "quote me".quote(3)  #=> %q{'"quote me"'}
+  #
+  # Symbols can be used to describe the type.
+  #
+  #   "quote me".quote(:single)    #=> %q{'quote me'}
+  #   "quote me".quote(:double)    #=> %q{"quote me"}
+  #   "quote me".quote(:back)      #=> %q{`quote me`}
+  #   "quote me".quote(:bracket)   #=> %q{`quote me'}
+  #
+  # Or the character itself.
+  #
+  #   "quote me".quote("'")     #=> %q{'quote me'}
+  #   "quote me".quote('"')     #=> %q{"quote me"}
+  #   "quote me".quote("`")     #=> %q{`quote me`}
+  #   "quote me".quote("`'")    #=> %q{`quote me'}
+  #
+  # CREDIT: Trans
+
+  def quote(type=:double, count=nil)
+    if Integer === type
+      tmp   = count
+      count = type
+      type  = tmp || :mixed
+    else
+      count ||= 1
+    end
+
+    type = type.to_s unless Integer===type
+
+    case type
+    when "'", 'single', 's', 1
+      f = "'" * count
+      b = f
+    when '"', 'double', 'd', 2
+      f = '"' * count
+      b = f
+    when '`', 'back', 'b', -1
+      f = '`' * count
+      b = f
+    when "`'", 'bracket', 'sb'
+      f = "`" * count
+      b = "'" * count
+    when "'\"", 'mixed', "m", Integer
+      c = (count.to_f / 2).to_i
+      f = '"' * c
+      b = f
+      if count % 2 != 0
+        f = "'" + f
+        b = b + "'"
+      end
+    else
+      raise ArgumentError, "unrecognized quote type -- #{type}"
+    end
+    "#{f}#{self}#{b}"
+  end
+
+  # Remove quotes from string.
+  #
+  #   "'hi'".unquote    #=> "hi"
+  #
+  # CREDIT: Trans
+
+  def unquote
+    s = self.dup
+
+    case self[0,1]
+    when "'", '"', '`'
+      s[0] = ''
+    end
+
+    case self[-1,1]
+    when "'", '"', '`'
+      s[-1] = ''
+    end
+
+    return s
+  end
+
+end
+

data/lib/core/facets/string/random.rb

@@ -0,0 +1,44 @@
+class String
+
+  # Create a random String of given length, using given character set
+  #
+  # Character set is an Array which can contain Ranges, Arrays, Characters
+  #
+  # Examples
+  #
+  #     String.random
+  #     => "D9DxFIaqR3dr8Ct1AfmFxHxqGsmA4Oz3"
+  #
+  #     String.random(10)
+  #     => "t8BIna341S"
+  #
+  #     String.random(10, ['a'..'z'])
+  #     => "nstpvixfri"
+  #
+  #     String.random(10, ['0'..'9'] )
+  #     => "0982541042"
+  #
+  #     String.random(10, ['0'..'9','A'..'F'] )
+  #     => "3EBF48AD3D"
+  #
+  #     BASE64_CHAR_SET =  ["A".."Z", "a".."z", "0".."9", '_', '-']
+  #     String.random(10, BASE64_CHAR_SET)
+  #     => "xM_1t3qcNn"
+  #
+  #     SPECIAL_CHARS = ["!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "|", "/", "?", ".", ",", ";", ":", "~", "`", "[", "]", "{", "}", "<", ">"]
+  #     BASE91_CHAR_SET =  ["A".."Z", "a".."z", "0".."9", SPECIAL_CHARS]
+  #     String.random(10, BASE91_CHAR_SET)
+  #      => "S(Z]z,J{v;"
+  #
+  # CREDIT: Tilo Sloboda
+  #
+  # SEE: https://gist.github.com/tilo/3ee8d94871d30416feba
+  #
+  # TODO: Move to random.rb in standard library?
+
+  def self.random(len=32, character_set = ["A".."Z", "a".."z", "0".."9"])
+    chars = character_set.map{|x| x.is_a?(Range) ? x.to_a : x }.flatten
+    Array.new(len){ chars.sample }.join
+  end
+
+end

data/lib/core/facets/string/range.rb

@@ -0,0 +1,60 @@
+class String
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> (10..13)
+  #
+  # CREDIT: Trans
+
+  def range(pattern, offset=0)
+    unless Regexp === pattern
+      pattern = Regexp.new(Regexp.escape(pattern.to_s))
+    end
+    string = self[offset..-1]
+    if md = pattern.match(string)
+      return (md.begin(0)+offset)..(md.end(0)+offset-1)
+    end
+    nil
+  end
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  # TODO: Add offset ?
+  #
+  # CREDIT: Trans
+
+  def range_all(pattern, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(pattern, 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 = []
+    each_line do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+
+end
+

data/lib/core/facets/string/range_all.rb

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

data/lib/core/facets/string/range_of_line.rb

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

data/lib/core/facets/string/remove.rb

@@ -0,0 +1,30 @@
+class String
+
+  # Removes all occurrences of a pattern in a string.
+  #
+  # Returns a new [String] with all occurrences of the pattern removed.
+  def remove(pattern)
+    gsub(pattern, '')
+  end
+
+  # Removes all occurrences of a pattern in a string.
+  #
+  # Returns the [String] with all occurrences of the pattern removed.
+  def remove!(pattern)
+    gsub!(pattern, '')
+  end
+
+  # Removes occurances of a string or regexp. This is an operator
+  # form for the #remove method.
+  #
+  #   ("HELLO HELLO" - "LL")    #=> "HEO HEO"
+  #   ("HELLO PERL" - /L\S/)    #=> "HEO PERL"
+  #
+  # Returns a new [String] with all pattern matches removed.
+  #
+  # CREDIT: Benjamin David Oakes
+  def -(pattern)
+    gsub(pattern, '')
+  end
+
+end

data/lib/core/facets/string/rewrite.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Apply a set of rules in the form of regular expression matches
+  # to the string.
+  #
+  # * rules - The array containing rule-pairs (match, write).
+  #
+  # Keep in mind that the order of rules is significant.
+  #
+  # Returns 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/core/facets/string/roman.rb

@@ -0,0 +1 @@
+require 'facets/roman'

data/lib/core/facets/string/rotate.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Rotate string to the left with count.
+  # Specifying negative number indicates rotation to the right.
+  #
+  #   'abcdefgh'.rotate(2)  #=> 'cdefghab'
+  #   'abcdefgh'.rotate(-2) #=> 'ghabcdef'
+  #
+  # CREDIT: T. Yamada
+  def rotate(count=1)
+    count+=self.length if count<0
+    self.slice(count,self.length-count)+self.slice(0,count)
+  end
+
+  # Destructive version of String#rotate
+  #
+  #   s='abcdefgh'
+  #   s.rotate!(2)
+  #   s.should eq 'cdefghab'
+  #
+  # CREDIT: T. Yamada
+  def rotate!(count=1) replace(rotate(count)) end
+
+end