facets-glimmer 3.2.0

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

@@ -0,0 +1,45 @@
+class Range
+
+  # Subtract one range from another producing a range array.
+  #
+  # Examples
+  #
+  #     (1..10) - (4..6)  => [1..3, 7..10]
+  #
+  #     (1..10) - (9..12) => [1..8]
+  #
+  # Returns [Array]
+  #
+  # CREDIT: monocle
+
+	def -(value)
+		if value.class == first.class
+			minus_obj(value)
+		else
+			[minus_obj(value.first)[0], minus_obj(value.last)[1]].compact
+		end
+	end
+
+	private
+
+    # TODO: Better name? Maybe make public?
+	  def minus_obj(value)
+		  f = case value <=> first.succ
+		      when -1 then nil
+       		when  0 then first
+	       	else
+       		  #value < last.succ ? first...value : self
+       		  value < last.succ ? first..(value.pred) : self
+          end
+
+		  s = case last <=> value.succ
+          when -1 then nil
+          when  0 then last
+          else
+            value.succ > first ? (value.succ)..last : self
+          end
+
+		  [f, s]
+	  end
+
+end

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

@@ -0,0 +1,12 @@
+class Range
+
+  # Do two ranges overlap?
+  #
+  # CREDIT: Daniel Schierbeck, Brandon Keepers
+
+  def overlap?(other)
+    include?(other.first) or other.include?(first)
+  end
+
+end
+

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

@@ -0,0 +1,18 @@
+class Range
+
+  # Calculate the kth n-tile in a range.
+  #
+  # If n=4 the quantity is called a quartile, and if n=100
+  # it is called a percentile.
+  #
+  # @uncommon
+  #   require 'facets/range/quantile'
+  #
+  # @return [Integer] the kth n-tile
+  def quantile(k, n=100)
+    return 1 if k < first
+    return n if k >= last
+    ((k - first) / ((last - first) / n.to_f)).to_i + 1
+  end
+
+end

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

@@ -0,0 +1,26 @@
+class Range
+
+  # A thing really should know itself.
+  # This simply returns _self_.
+  #
+  # CREDIT: Trans
+
+  def to_rng
+    self
+  end
+
+  # A thing really should know itself.
+  # This simply returns _self_.
+  #
+  # Note: This does not internally effect the Ruby
+  # interpretor such that it can coerce Range-like
+  # objects into a Range.
+  #
+  # CREDIT: Trans
+
+  def to_range
+    self
+  end
+
+end
+

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

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

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

@@ -0,0 +1,64 @@
+class Range
+
+  # Uses the Range#umbrella method to determine
+  # if another Range is _anywhere_ within this Range.
+  #
+  #   (1..3).within?(0..4)  #=> true
+  #
+  # CREDIT: Trans
+
+  def within?(rng)
+    case rng.umbrella(self)
+    when [0,0], [-1,0], [0,-1], [-1,-1]
+      return true
+    else
+      return false
+    end
+  end
+
+  # Returns a two element array of the relationship
+  # between two Ranges.
+  #
+  # Diagram ...
+  #
+  #     Relationship     Returns
+  #
+  #   self |-----------|
+  #   r    |-----------|    [0,0]
+  #
+  #   self |-----------|
+  #   r     |---------|     [-1,-1]
+  #
+  #   self  |---------|
+  #   r    |-----------|    [1,1]
+  #
+  #   self |-----------|
+  #   r     |----------|    [-1,0]
+  #
+  #   self |-----------|
+  #   r     |-----------|   [-1,1]
+  #
+  #   etc.
+  #
+  # Example:
+  #
+  #   (0..3).umbrella(1..2)  #=>  [-1,-1]
+  #
+  # CREDIT: Trans, Chris Kappler
+
+  def umbrella(r)
+    s = first <=> r.first
+    e = r.last <=> last
+
+    if e == 0
+      if r.exclude_end? and exclude_end?
+        e = r.max <=> max
+      else
+        e = (r.exclude_end? ? 0 : 1) <=> (exclude_end? ? 0 : 1)
+      end
+    end
+
+    return s,e
+  end
+
+end

data/lib/core/facets/range.rb

@@ -0,0 +1,9 @@
+require_relative 'range/combine.rb'
+require_relative 'range/overlap.rb'
+#require_relative 'range/quantile.rb'     # uncommon
+#require_relative 'range/op_add.rb'       # too new
+#require_relative 'range/op_sub.rb'       # too new
+require_relative 'range/to_rng.rb'
+require_relative 'range/umbrella.rb'
+require_relative 'range/within.rb'
+

data/lib/core/facets/regexp/arity.rb

@@ -0,0 +1,17 @@
+class Regexp
+
+  # Returns the number of backreferencing subexpressions.
+  #
+  #   /(a)(b)(c)/.arity  #=> 3
+  #   /(a(b(c)))/.arity  #=> 3
+  #
+  # Note that this is not perfect, especially with regards to \x
+  # and embedded comments.
+  #
+  # CREDIT: Trans
+
+  def arity
+    source.scan( /(?!\\)[(](?!\?[#=:!>-imx])/ ).length
+  end
+
+end

data/lib/core/facets/regexp/multiline.rb

@@ -0,0 +1,13 @@
+class Regexp
+
+  # Is a regular expression multiline?
+  #
+  #   /x/.multiline?   #=> false
+  #   /x/m.multiline?  #=> true
+  #
+  def multiline?
+    options & MULTILINE == MULTILINE
+  end
+
+end
+

data/lib/core/facets/regexp/op_add.rb

@@ -0,0 +1,18 @@
+class Regexp
+
+  # Add regular expressions.
+  #
+  #   /a/ + /b/ == /(?-mix:a)(?-mix:b)/
+  #
+  # Functionally equivalent to:
+  #
+  #   /ab/
+  #
+  # CREDIT: Tyler Rick
+  def +(other)
+    other = Regexp.escape(other) if other.is_a?(String)
+    /#{self}#{other}/
+  end
+
+end
+

data/lib/core/facets/regexp/op_or.rb

@@ -0,0 +1,15 @@
+class Regexp
+
+  # Operator form of `Regexp.union`.
+  #
+  #   /a/ | /b/  #=> /(?-mix:a)|(?-mix:b)/
+  #
+  # If +other+ is not a Regexp it is passed to Regexp.escape.
+  #
+  def |(other)
+    other = Regexp.escape(other) unless Regexp === other
+    Regexp.union(self, other)
+  end
+
+end
+

data/lib/core/facets/regexp/to_proc.rb

@@ -0,0 +1,13 @@
+class Regexp
+
+  # Useful to pass a Regexp as a block that will match elements
+  #
+  # %w[ joe_the_dog mary_the_cat ].index &/cat/  #=> 1
+  #
+  # Returns [Proc] which passes it's argument to Regexp#match method.
+
+  def to_proc
+    proc { |x| match(x) }
+  end
+
+end

data/lib/core/facets/regexp/to_re.rb

@@ -0,0 +1,28 @@
+class Regexp
+
+  # Like #to_re, but following Ruby's formal definitions,
+  # only a Regular expression type object will respond to this.
+  #
+  # Note that to be of much real use this should be defined in core Ruby.
+  #
+  # CREDIT: Florian Gross
+
+  def to_regexp
+    self
+  end
+
+  # Simply returns itself. Helpful when converting
+  # strings to regular expressions, where regexp
+  # might occur as well --in the same vien as using
+  # #to_s on symbols. The parameter is actaully a
+  # dummy parameter to coincide with String#to_re.
+  #
+  #   /abc/.to_re  #=> /abc/
+  #
+  # CREDIT: Trans
+
+  def to_re(esc=false)
+    self  # Of course, things really should know how to say "I" ;)
+  end
+
+end

data/lib/core/facets/regexp.rb

@@ -0,0 +1,6 @@
+require_relative 'regexp/arity.rb'
+require_relative 'regexp/multiline.rb'
+require_relative 'regexp/op_add.rb'
+require_relative 'regexp/op_or.rb'
+require_relative 'regexp/to_re.rb'
+

data/lib/core/facets/roman.rb

@@ -0,0 +1,89 @@
+class Integer
+
+  #
+  ROMAN_MAX = 3999 unless const_defined?(:ROMAN_MAX)
+
+  #
+  ROMAN_VALUES = [
+    ["M", 1000],
+    ["CM", 900],
+    ["D",  500],
+    ["CD", 400],
+    ["C",  100],
+    ["XC",  90],
+    ["L",   50],
+    ["XL",  40],
+    ["X",   10],
+    ["IX",   9],
+    ["V",    5],
+    ["IV",   4],
+    ["I",    1]
+  ] unless const_defined?(:ROMAN_VALUES)
+
+  # Converts this integer to a roman numeral.
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # @uncommon
+  #   require 'facets/integer/roman'
+  #
+  def roman
+    int = self
+    #return nil if integer > ROMAN_MAX
+    return "-#{(-int).roman}" if int < 0
+    return "" if int == 0
+    ROMAN_VALUES.each do |(i, v)|
+      return(i + (int-v).roman) if v <= int 
+    end
+  end
+
+end
+
+
+class String
+
+  # Taken from O'Reilly's Perl Cookbook 6.23. Regular Expression Grabbag.
+  ROMAN = /^M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$/i unless const_defined?(:ROMAN)
+
+  ROMAN_VALUES = Integer::ROMAN_VALUES.inject({}) do |h,(r,a)|
+    h[r] = a; h
+  end unless const_defined?(:ROMAN_VALUES)
+
+  # Considers string a Roman numeral numeral,
+  # and converts it to the corresponding integer.
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # @uncommon
+  #   require 'facets/string/roman'
+  #
+  def roman
+    roman = upcase
+    raise unless roman?
+    last = roman[-1,1]
+    roman.reverse.split('').inject(0) do |result, c|
+      if ROMAN_VALUES[c] < ROMAN_VALUES[last]
+        result -= ROMAN_VALUES[c]
+      else
+        last = c
+        result += ROMAN_VALUES[c]
+      end
+    end
+  end
+
+  # Returns true iif the subject is a valid Roman numeral.
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # @uncommon
+  #   require 'facets/string/roman'
+  #
+  def roman?
+    ROMAN =~ upcase
+  end
+
+end
+

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

@@ -0,0 +1,11 @@
+class String
+
+  # Transform a string into an acronym.
+  #
+  # CREDIT: Robert Fey
+  #
+  def acronym
+	  gsub(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./,"\\2")
+  end
+
+end

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

@@ -0,0 +1,125 @@
+class String
+
+  # Alignment method dispatches to #align_right, #align_left
+  # or #align_center, accorging to the first +direction+ parameter.
+  #
+  #   s = <<-EOS
+  #   This is a test
+  #     and
+  #     so on
+  #   EOS
+  #
+  #   s.align(:right, 14)
+  #
+  # _produces_ ...
+  #
+  #   This is a test
+  #              and
+  #            so on
+  #
+  # Returns a String aligned right, left or center.
+  def align(direction, n, sep="\n", c=' ')
+    case direction
+    when :right
+      align_right(n, sep="\n", c=' ')
+    when :left
+      align_left(n, sep="\n", c=' ')
+    when :center
+      align_center(n, sep="\n", c=' ')
+    else
+      raise ArgumentError
+    end
+  end
+
+  # Align a string to the right.
+  #
+  # The default alignment separation is a new line ("\n").
+  # This can be changed as can be the padding string which
+  # defaults to a single space (' ').
+  #
+  #   s = <<-EOS
+  #   This is a test
+  #     and
+  #     so on
+  #   EOS
+  #
+  #   s.align_right(14)
+  #
+  # _produces_ ...
+  #
+  #   This is a test
+  #              and
+  #            so on
+  #
+  # CREDIT: Trans
+
+  def align_right(n, sep="\n", c=' ')
+    return rjust(n.to_i,c.to_s) if sep==nil
+    q = split(sep.to_s).map do |line|
+      line.rjust(n.to_i,c.to_s)
+    end
+    q.join(sep.to_s)
+  end
+
+  # Align a string to the left.
+  #
+  # The default alignment separation is a new line ("\n").
+  # This can be changed as can be the padding string which
+  # defaults to a single space (' ').
+  #
+  #   s = <<-EOS
+  #   This is a test
+  #     and
+  #     so on
+  #   EOS
+  #
+  #   s.align_left(20, "\n", '.')
+  #
+  # _produces_ ...
+  #
+  #   This is a test......
+  #   and.................
+  #   so on...............
+  #
+  # CREDIT: Trans
+
+  def align_left(n, sep="\n", c=' ')
+    return ljust(n.to_i,c.to_s) if sep==nil
+    q = split(sep.to_s).map do |line|
+      line.strip.ljust(n.to_i,c.to_s)
+    end
+    q.join(sep.to_s)
+  end
+
+  # Centers each line of a string.
+  #
+  # The default alignment separation is a new line ("\n").
+  # This can be changed as can be the padding string which
+  # defaults to a single space (' ').
+  #
+  #   s = <<-EOS
+  #     This is a test
+  #     and
+  #     so on
+  #   EOS
+  #
+  #   s.align_center(14)
+  #
+  # _produces_ ...
+  #
+  #   This is a test
+  #        and
+  #       so on
+  #
+  # CREDIT: Trans
+
+  def align_center(n, sep="\n", c=' ')
+    return center(n.to_i,c.to_s) if sep==nil
+    q = split(sep.to_s).collect { |line|
+      line.center(n.to_i,c.to_s)
+    }
+    q.join(sep.to_s)
+  end
+
+end
+

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

@@ -0,0 +1,52 @@
+class String
+  # Get a new string with non-ASCII characters removed.
+  #
+  # alt - String to replace non-ASCII characters with.
+  #       Defaults to a blank string (`''`).
+  #
+  # Examples
+  #
+  #   'abc'.ascii_only     #=> 'abc'
+  #   '中文123'.ascii_only  #=> '123'
+  #
+  # Returns a copy of [String] with ASCII characters only.
+  #
+  # CREDIT: Nathan Long
+  #
+  # SEE: http://stackoverflow.com/questions/1268289
+  def ascii_only(alt='')
+    encoding_options = {
+      :invalid                     => :replace,  # Replace invalid byte sequences
+      :undef                       => :replace,  # Replace anything not defined in ASCII
+      :replace                     => alt,       # Use a blank for those replacements
+      :UNIVERSAL_NEWLINE_DECORATOR => true       # Always break lines with \n
+    }
+    self.encode(Encoding.find('ASCII'), encoding_options)
+  end
+
+  # Modify string keeping only ASCII characters.
+  #
+  # alt - String to replace non-ASCII characters with.
+  #       Defaults to a blank string (`''`).
+  # 
+  # Examples
+  #
+  #   'abc'.ascii_only!     #=> 'abc'
+  #   '中文123'.ascii_only!  #=> '123'
+  #
+  # Returns [String]
+  #
+  # CREDIT: Nathan Long
+  #
+  # SEE: http://stackoverflow.com/questions/1268289
+  def ascii_only!(alt='')
+    encoding_options = {
+      :invalid                     => :replace,  # Replace invalid byte sequences
+      :undef                       => :replace,  # Replace anything not defined in ASCII
+      :replace                     => alt,       # Use a blank for those replacements
+      :UNIVERSAL_NEWLINE_DECORATOR => true       # Always break lines with \n
+    }
+    self.encode!(Encoding.find('ASCII'), encoding_options)
+  end
+
+end

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

@@ -0,0 +1,64 @@
+class String
+
+  BRA2KET = { '['=>']', '('=>')', '{'=>'}', '<'=>'>' }
+
+  # Return a new string embraced by given brackets.
+  # If only one bracket char is given it will be placed
+  # on either side.
+  #
+  #   "wrap me".bracket('{')        #=> "{wrap me}"
+  #   "wrap me".bracket('--','!')   #=> "--wrap me!"
+  #
+  # CREDIT: Trans
+
+  def bracket(bra, ket=nil)
+    #ket = String.bra2ket[$&] if ! ket && /^[\[({<]$/ =~ bra
+    ket = BRA2KET[bra] unless ket
+    "#{bra}#{self}#{ket ? ket : bra}"
+  end
+
+  # Inplace version of #bracket.
+  #
+  # CREDIT: Trans
+
+  def bracket!(bra, ket=nil)
+    self.replace(bracket(bra, ket))
+  end
+
+  # Return a new string with the given brackets removed.
+  # If only one bracket char is given it will be removed
+  # from either side.
+  #
+  #   "{unwrap me}".unbracket('{')        #=> "unwrap me"
+  #   "--unwrap me!".unbracket('--','!')  #=> "unwrap me"
+  #
+  # CREDIT: Trans
+
+  def unbracket(bra=nil, ket=nil)
+    if bra
+      ket = BRA2KET[bra] unless ket
+      ket = ket ? ket : bra
+      s = self.dup
+      s.gsub!(%r[^#{Regexp.escape(bra)}], '')
+      s.gsub!(%r[#{Regexp.escape(ket)}$], '')
+      return s
+    else
+      if m = BRA2KET[ self[0,1] ]
+        return self.slice(1...-1) if self[-1,1]  == m
+      end
+    end
+    return self.dup  # if nothing else
+  end
+
+  # Inplace version of #unbracket.
+  #
+  # CREDIT: Trans
+
+  def unbracket!(bra=nil, ket=nil)
+    self.replace( unbracket(bra, ket) )
+  end
+
+  # TODO: rename #bracket to #embrace ?
+
+end
+

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

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