facets 0.6.3

data/lib/facet/ostruct.rb

@@ -0,0 +1,8 @@
+
+# base
+require "facet/ostruct/ostruct_update"
+
+# common
+require "facet/ostruct/[]"
+
+# uncommon

data/lib/facet/ostruct/[].rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+class OpenStruct
+  # Access a value in the OpenStruct by key, like a Hash.
+  # This increases OpenStruct's "duckiness".
+  #
+  #   require 'facet/ostruct/[]'
+  #
+  #   o = OpenStruct.new
+  #   o.t = 4
+  #   o['t']  #=> 4 
+  #
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+  # Set a value in the OpenStruct by key, like a Hash.
+  #
+  #   require 'facet/ostruct/[]'
+  #
+  #   o = OpenStruct.new
+  #   o['t'] = 4
+  #   o.t  #=> 4 
+  #
+  def []=(key,val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]=val
+  end
+end 

data/lib/facet/ostruct/ostruct_update.rb

@@ -0,0 +1,18 @@
+require 'ostruct'
+class OpenStruct
+  # Insert/update hash data on the fly.
+  #
+  #   require 'facet/ostruct/ostruct_update'
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def ostruct_update( hash )
+    if hash
+      for k,v in hash
+        @table[k.to_sym] = v
+      end
+    end
+  end
+end

data/lib/facet/proc.rb

@@ -0,0 +1,8 @@
+
+# base
+
+# common
+require "facet/proc/compose"
+require "facet/proc/to_method"
+
+# uncommon

data/lib/facet/proc/compose.rb

@@ -0,0 +1,22 @@
+#--
+# Thanks dave!
+#++
+class Proc
+  # Returns a new proc that is the functional
+  # compostion of two procs, in order.
+  #
+  #  require 'facet/proc/compose'
+  #
+  #  a = lambda { |x| x + 4 }
+  #  b = lambda { |y| y / 2 }
+  #
+  #  (a * b).call(4)  #=> 6
+  #  (b * a).call(4)  #=> 4
+  #
+  def compose(other)
+    raise ArgumentError, "arity count mismatch" unless arity == other.arity
+    #proc{ |*a| self.call(other.call(*a)) }
+    proc{ |*a| self.call(*other.call(*a)) }
+  end
+  alias_method( :*, :compose )
+end

data/lib/facet/proc/to_method.rb

@@ -0,0 +1,43 @@
+require 'thread'
+#--
+# Credit for #to_method goes to Forian Gross (flgr).
+#--
+class Proc
+  MethodMutexes = Hash.new do |hash, key|
+    hash[key] = Mutex.new
+  end
+  
+  # Creates a local method based on a Proc.
+  def to_method(name=nil)
+    name ||= "!to_method_temp#{self.id}"
+    recv = eval("self", self)
+    klass = recv.class
+    
+    MethodMutexes[klass => name].synchronize do
+      begin
+        klass.send(:define_method, name, &self)
+        return recv.method(name)
+      ensure
+        klass.send(:remove_method, name) if not name
+      end
+    end
+  end
+end
+
+=begin
+  # Alternate. I assume this is less "safe" then the above.
+  def to_method
+    # get the object that this proc is bound to
+    obj = eval 'self', self.binding
+    # get the virtual class for the object
+    obj_class = class << obj; self; end
+    proc = self
+    # define the method. A normally invalid method name was chosen to minimize
+    # the chance of a collision. Store the newly created method away.
+    obj_class.instance_eval{define_method(:" ", &proc)}
+    method = obj.method(:" ")
+    # remove the method, and return it.
+    obj_class.instance_eval{remove_method(:" ")}
+    method
+  end
+=end

data/lib/facet/rand.rb

@@ -0,0 +1,10 @@
+# Mixture of _random_ related methods.
+require 'facet/array/at_rand'
+require 'facet/array/shuffle'
+require 'facet/hash/at_rand'
+require 'facet/hash/shuffle'
+require 'facet/string/at_rand'
+require 'facet/string/shuffle'
+require 'facet/kernel/maybe'
+
+ 

data/lib/facet/range.rb

@@ -0,0 +1,9 @@
+
+# base
+require "facet/range/to_r"
+
+# common
+require "facet/range/umbrella"
+require "facet/range/within?"
+
+# uncommon

data/lib/facet/range/to_r.rb

@@ -0,0 +1,16 @@
+class Range
+  # A thing really should know itself.
+  # This simply returns _self_.
+  def to_r
+    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.
+  def to_range
+    self
+  end
+end

data/lib/facet/range/umbrella.rb

@@ -0,0 +1,37 @@
+class Range
+  # 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:
+  #
+  #   require 'facet/range/umbrella'
+  #
+  #   (0..3).umbrella(1..2)  #=>  [-1,-1]
+  #
+  def umbrella(r)
+    s = self.first <=> r.first
+    e = r.last <=> self.last
+    return s,e
+  end
+end

data/lib/facet/range/within?.rb

@@ -0,0 +1,19 @@
+require 'facet/range/umbrella'
+class Range
+  # Uses the Range#umbrella method to determine
+  # if another Range is _anywhere_ within this Range.
+  #
+  #   require 'facet/range/within?'
+  #
+  #   (1..3).within?(0..4)  #=> true
+  #
+  def within?(rng)
+    case rng.umbrella(self)
+    when [0,0], [-1,0], [0,-1], [-1,-1]
+      return true
+    else
+      return false
+    end
+  end
+end
+

data/lib/facet/regexp.rb

@@ -0,0 +1,9 @@
+
+# base
+require "facet/regexp/to_re"
+
+# common
+require "facet/regexp/arity"
+
+# uncommon
+

data/lib/facet/regexp/arity.rb

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

data/lib/facet/regexp/to_re.rb

@@ -0,0 +1,25 @@
+class Regexp
+  
+  # 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.
+  #
+  #   require 'facet/regexp/to_re'
+  #
+  #   /abc/.to_re  #=> /abc/
+  #
+  def to_re( esc=false )
+    self  # Of course, things really should know how to say "I" ;)
+  end
+  
+  # Like #to_re, but following Ruby's formal definitions,
+  # only a Regular expression like object will respond to this.
+  #
+  # Note: To be of much real use this should be defined in core Ruby.
+  def to_regexp
+    self
+  end
+
+end

data/lib/facet/string.rb

@@ -0,0 +1,38 @@
+
+# base
+require "facet/string/blank?"
+require "facet/string/cmp"
+require "facet/string/to_re"
+
+# common
+require "facet/string/chars"
+require "facet/string/first&last"
+require "facet/string/index_all"
+require "facet/string/margin"
+require "facet/string/range"
+require "facet/string/tab"
+
+# uncommon
+#require "facet/string/at_rand"
+#require "facet/string/braket"
+#require "facet/string/camelcase"
+#require "facet/string/case?"
+#require "facet/string/center_lines"
+#require "facet/string/clump"
+#require "facet/string/dresner"
+#require "facet/string/each_word'
+#require "facet/string/fuzzy_match"
+#require "facet/string/line_to_char_map"
+#require "facet/string/line_wrap"
+#require "facet/string/mscan"
+#require "facet/string/natcmp"
+#require "facet/string/rand_letter"
+#require "facet/string/shuffle"
+#require "facet/string/succ"
+#require "facet/string/to_b"
+#require "facet/string/to_const"
+#require "facet/string/to_proc"
+#require "facet/string/unix_crypt"
+#require "facet/string/unpack"
+#require "facet/string/word_filter!"
+#require "facet/string/word_wrap"

data/lib/facet/string/at_rand.rb

@@ -0,0 +1,99 @@
+require 'facet/array/at_rand'
+class String
+
+  # Return a random separation of the string.
+  # Default separator is <tt>$/</tt>.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   "Ruby rules".at_rand(1, ' ')  #=> ["Ruby"]
+  #
+  def at_rand(n=nil, separator=$/)
+    separator = /\n+/ if separator == ''
+    separator = /\s+/ unless separator
+    n = n.to_i
+    self.split(separator,-1).at_rand(n)
+  end
+
+  # Return a random separation while removing it
+  # from the string. Default separator is <tt>$/</tt>.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   "Ruby rules".at_rand(1, ' ')  #=> ["Ruby"]
+  #
+  def at_rand!(n=nil)
+    separator = /\n+/ if separator == ''
+    separator = /\s+/ unless separator
+    n = n.to_i
+    s,e = 0,0
+    n.times { e = index( separator, s ) ;  s = e+1 }
+    r = self[s...e]
+    self[s...e] = ''
+    return r
+  end
+
+  # Return a random byte of _self_.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   "Ruby rules".rand_byte  #=> 121
+  #
+  def rand_byte
+    self[rand_index]
+  end
+
+  # Destructive pick_byte.  Delete a random byte of _self_ and return it.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   s = "Ruby rules"
+  #   s.pick_byte!  #=> 121
+  #   s             #=> "Rub rules"
+  #
+  def rand_byte!
+    i = rand_index
+    rv = self[i,1]
+    self[i,1] = ''
+    rv
+  end
+
+  # Return a single-character string of a random character in _self_.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   "Ruby rules".rand_char  #=> "y"
+  #
+  def rand_char
+    split(//,-1).at_rand
+  end
+
+  # Destructive pick_char.  Delete a random character of the string
+  # and return it as a single-character string.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   s = "Ruby rules"
+  #   s.pick_char!  #=> "y"
+  #   s             #=> "Rub rules"
+  #
+  def rand_char!
+    c = split(//,-1)
+    i = c.rand_index
+    r = c[ri]
+    c[ri] = ''
+    self.replace( c.join('') )
+    return r
+  end
+
+  # Return a random string index.
+  #
+  #   require 'facet/string/at_rand'
+  #
+  #   "Ruby rules".rand_index  #=> 3
+  #
+  def rand_index
+    rand(size)
+  end
+  
+end

data/lib/facet/string/blank?.rb

@@ -0,0 +1,14 @@
+class String
+  # Is this string just whitespace?
+  #
+  #   require 'facet/string/blank?'
+  #
+  #   "abc".blank?  #=> false
+  #   "   ".blank?  #=> true
+  #   
+  def blank?
+    self !~ /\S/
+  end
+  alias whitespace? blank?
+end
+

data/lib/facet/string/braket.rb

@@ -0,0 +1,27 @@
+class String
+
+  BRA_KET = { '['=>']', '('=>')', '{'=>'}', '<'=>'>' }
+  
+  # Return a new string embraced by given brakets.
+  # If only one bracket char is given it will be placed
+  # on either side. 
+  #
+  #   require 'facet/string/braket'
+  #
+  #   "wrap me".braket('{')        #=> "{wrap me}"
+  #   "wrap me".braket('--','!')   #=> "--wrap me!"
+  #
+  # And yes, I know, it's spelled "wrong"! ;)
+  def braket(bra, ket=nil)
+    if ! ket && /^[\[({<]$/ =~ bra
+      ket = BRA_KET[$&]
+    end
+    return "#{bra}#{self}#{ket ? ket : bra}"
+  end
+
+  # Inplace version of #braket.
+  def braket!(bra, ket=nil)
+    self.replace( self.braket(bra, ket) )
+  end
+  
+end