facets 0.6.3

data/lib/facet/integer/evenodd?.rb

@@ -0,0 +1,25 @@
+class Integer
+  
+  # Is an integer even?
+  #
+  #   require 'facet/integer/evenodd?'
+  #
+  #   2.even?  #=> true
+  #   3.even?  #=> false
+  #
+  def even?
+    self % 2 == 0
+  end
+  
+  # Is an integer odd?
+  #
+  #   require 'facet/integer/evenodd?'
+  #
+  #   2.odd?  #=> false
+  #   3.odd?  #=> true
+  #
+  def odd?
+    self % 2 == 1
+  end
+  
+end 

data/lib/facet/integer/factorial.rb

@@ -0,0 +1,27 @@
+class Integer
+  
+  # Calculate the factorial of _self_.
+  #
+  #   require 'facet/integer/factorial'
+  #
+  #   2.factorial  #=> 2
+  #   3.factorial  #=> 6
+  #   3.factorial  #=> 24
+  #
+  def factorial
+    return 1 if self == 0
+    #self == 0 ? 1 : ( self * (self-1).factorial )
+    f = (1..self.abs).inject { |state, item| state * item }
+    return self < 0 ? -f : f
+  end
+  
+  # Common alias for #factorial.
+  #
+  #   require 'facet/integer/factorial'
+  #
+  #   2.fact  #=> 2
+  #   3.fact  #=> 6
+  #   4.fact  #=> 24
+  #
+  alias_method( :fact, :factorial )
+end

data/lib/facet/integer/times_collect.rb

@@ -0,0 +1,13 @@
+class Integer
+  # Like #times but returns a collection of the yield results.
+  #
+  #   require 'facet/integer/times_collect'
+  #
+  #   a = 3.times_collect { |i| "#{i+1}" }
+  #   a => [ "1", "2", "3" ]
+  #
+  def times_collect(&yld)
+    a = []; self.times{ |i| a << yld.call(i) }
+    a
+  end
+end 

data/lib/facet/kernel.rb

@@ -0,0 +1,18 @@
+
+# base
+require "facet/kernel/fn"
+require "facet/kernel/called"
+require "facet/kernel/require_local"
+
+# common
+require "facet/kernel/call_stack"
+require "facet/kernel/require_local"
+require "facet/kernel/here"
+require "facet/kernel/maybe"
+
+# uncommon
+#require "facet/kernel/bug!"
+#require "facet/kernel/demo"
+#require 'facet/kernel/memoize'
+#require "facet/kernel/warn_with_line"
+#require 'facet/kernel/get_by_id'

data/lib/facet/kernel/bug!.rb

@@ -0,0 +1,25 @@
+#--
+# bug!.rb
+#
+#   Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU Lesser General Public License version 2 or later.
+#
+#   $Id: bug!.rb,v 1.10 2002/01/05 06:19:34 aamine Exp $
+#++
+class ScriptBug < Exception; end
+module Kernel
+  # Raises a ScritBug error with a message.
+  #
+  #   require 'facet/kernel/bug!'
+  #
+  #   if find_bug then
+  #     bug! "unknown bug found"
+  #   end
+  #
+  def bug!( message = 'must not happen' )
+    raise ScriptBug, "\n[SCRIPT BUG] " + message
+  end
+end

data/lib/facet/kernel/call_stack.rb

@@ -0,0 +1,35 @@
+module Kernel
+  # Parse a caller string and break it into its components,
+  # returning an array. Returns:
+  # * file (String)
+  # * lineno (Integer)
+  # * method (Symbol)
+  #
+  # For example, from irb,
+  #
+  #   require 'facet/kernel/call_stack'
+  #   call_stack(1)
+  #
+  # _produces_
+  #
+  # [["(irb)", 2, :irb_binding],
+  #  ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, :irb_binding], 
+  #  ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, nil]]
+  #
+  # Note: If the user decides to redefine caller() to output data
+  # in a different format, prior to requiring this, then the 
+  # results will indeterminate.
+  alias_method :pp_call_stack, :caller
+  def call_stack(level=1)
+    call_str_array = pp_call_stack(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
+end

data/lib/facet/kernel/called.rb

@@ -0,0 +1,20 @@
+require 'facet/kernel/method_name'
+module Kernel
+  # Retreive the current running method.
+  # There is a lot of debate on what to call this.
+  # #called differs from #method_name only by the fact
+  # that it returns a symbol, rather then a string.
+  #
+  #   require 'facet/main/called'
+  #
+  #   def tester; p called; end
+  #   tester  #=> :tester
+  #
+  def called
+    name = /\`([^\']+)\'/.match(caller(1).first)[1]
+    return name.to_sym
+  end
+  private :called
+end
+
+

data/lib/facet/kernel/demo.rb

@@ -0,0 +1,25 @@
+module Kernel
+  module_function
+  # For debugging and showing examples. Currently this
+  # takes an argument of a string in a block.
+  #
+  #   require 'facet/kernel/demo'
+  #
+  #   demo {%{ a = [1,2,3] }}
+  #   demo {%{ a.slice(1,2) }}
+  #   demo {%{ a.map { |x| x**3 } }}
+  #
+  # Produces:
+  #
+  #   a = [1,2,3]             #=>  [1, 2, 3]
+  #   a.slice(1,2)            #=>  [2, 3]
+  #   a.map { |x| x**3 }      #=>  [1, 8, 27]
+  #
+  #--
+  # Is there a way to do this without the eval string in block?
+  # Preferably just a block and no string.
+  #++
+  def demo(out=$stdout,&block)
+    out << sprintf("%-25s#=>  %s\n", expr = block.call, eval(expr, block.binding).inspect)
+  end 
+end 

data/lib/facet/kernel/fn.rb

@@ -0,0 +1,10 @@
+module Kernel
+  # A nicer shorthand for lambda/proc method.
+  #
+  #   require 'facet/kernel/fn'
+  #
+  #   adder = fn { |x,y| x + y }
+  #   adder[1,2]  #=> 3
+  #
+  alias_method( :fn, :lambda )
+end 

data/lib/facet/kernel/get_by_id.rb

@@ -0,0 +1,7 @@
+module Kernel
+  module_function
+  def get_by_id( id )
+    ObjectSpace._id2ref( id )
+  end
+end
+

data/lib/facet/kernel/here.rb

@@ -0,0 +1,11 @@
+module Kernel
+  # A shorthand pronoun for binding().
+  #
+  #   require 'facet/kernel/here'
+  #
+  #   a = 3
+  #   b = here
+  #   eval( "a", b )  #=> 3
+  #
+  alias_method( :here, :binding )
+end

data/lib/facet/kernel/maybe.rb

@@ -0,0 +1,17 @@
+module Kernel
+  # Random generator that returns true or false. 
+  # Can also take a block that has a 50/50 chance to being executed.
+  #
+  #   requrie 'facet/kernel/maybe'
+  #
+  #   maybe  #=> true
+  #   maybe  #=> false
+  #
+  def maybe(chance = 0.5, &block)
+    if block then
+      yield if rand < chance
+    else
+      rand < chance
+    end
+  end
+end

data/lib/facet/kernel/method_name.rb

@@ -0,0 +1,18 @@
+require 'facet/kernel/called'
+module Kernel
+  # Retreive the current running method.
+  # There is a lot of debate on what to call this.
+  # #method_name differs from #called only by the fact
+  # that it returns a string, rather then a symbol.
+  #
+  #   require 'facet/main/called'
+  #
+  #   def tester; p method_name; end
+  #   tester  #=> "tester"
+  #
+  def method_name
+    name = /\`([^\']+)\'/.match(caller(1).first)[1]
+    return name
+  end
+  private :method_name
+end

data/lib/facet/kernel/require_all.rb

@@ -0,0 +1,21 @@
+
+module Kernel
+
+  # Require a pattern of files. This make is easy
+  # to require an entire directory, for instance.
+  #
+  #   require 'facet/kernel/require_all'
+  #
+  #   require_all 'facet/time/*'
+  #
+  def require_all( pat, *args )
+    $LOAD_PATH.each do |path|
+      fs = Dir[File.join(path,pat)]
+      unless fs.empty? 
+        fs.each { |f| require( f, *args ) }
+        break;
+      end
+    end
+  end
+  
+end

data/lib/facet/kernel/require_local.rb

@@ -0,0 +1,26 @@
+module Kernel
+  # Require file from same dir as calling script.
+  #
+  #   require 'facet/kernel/require_local'
+  #
+  def require_local( fname )
+    #fdir = File.expand_path( File.dirname( caller[0] ) )
+    fdir = File.dirname( caller[0] )
+    require File.join( fdir, fname )
+  end
+  
+  #--
+  # This version allowd multiple file 
+  # on one line, but that isn't congruent
+  # with require behavior.
+  #
+  #def import(*args)
+  #  fd = File.dirname(caller[0])
+  #  args.each do |file_name|
+  #    require File.join(fd, file_name)
+  #  end
+  #end
+  #++
+end
+
+ 

data/lib/facet/kernel/resc.rb

@@ -0,0 +1,7 @@
+
+module Kernel
+  # Provides a shortcut to the Regexp.escape module method.
+  def resc(x)
+    Regexp.escape(x)
+  end 
+end

data/lib/facet/kernel/warn_with_line.rb

@@ -0,0 +1,19 @@
+module Kernel
+  # Like #warn produces the current line number as well.
+  #
+  #   require 'facet/kernel/warn_with_line'
+  #
+  #   warn_wtih_line("You have been warned.")
+  #
+  # _produces_
+  #
+  #   3: Warning: You have been warned.
+  #
+  # Note that this method depends on the output of #caller.
+  def warn_with_line(msg="", fulltrace=nil)
+    trace = caller(1)
+    where = trace[0].sub(/:in.*/,'')
+    STDERR.puts "#{where}: Warning: #{msg}"
+    STDERR.puts trace.map { |t| "\tfrom #{t}" } if fulltrace
+  end  
+end

data/lib/facet/matchdata.rb

@@ -0,0 +1,8 @@
+
+# base
+
+# common
+require 'facet/matchdata/match'
+require 'facet/matchdata/match_from'
+
+# uncommon

data/lib/facet/matchdata/match.rb

@@ -0,0 +1,12 @@
+class MatchData
+  # Return the primary match, equivalent to +md[0]+.
+  #
+  #   require 'facet/matchdata/match'
+  #
+  #   md = /123/.match "123456"
+  #   md.match  #=> "123"
+  #
+  def match
+    self[0]
+  end
+end

data/lib/facet/matchdata/match_from.rb

@@ -0,0 +1,38 @@
+require 'facet/matchdata/match'
+class MatchData
+  # Returns the pre_match from subexpression n.
+  #
+  #   require 'facet/matchdate/match_from'
+  #
+  #   md = /x(a)(b)(c)z/.match "123xabcz789"
+  #   md.pre_match_from(0)   #=> 123
+  #   md.pre_match_from(1)   #=> 123x
+  #   md.pre_match_from(2)   #=> 123xa
+  #   md.pre_match_from(3)   #=> 123xab
+  #   md.pre_match_from(-1)  #=> 123xab
+  #
+  def pre_match_from(n=0)
+    return pre_match if n == 0
+    n = length + n if n < 0
+    upto = offset(n)[0] - 1
+    "#{pre_match}#{match[0...upto]}" #.to_s
+  end
+  
+  # Returns the post_match from subexpression n.
+  #
+  #   require 'facet/matchdate/match_from'
+  #
+  #   md = /x(a)(b)(c)z/.match "123xabcz789"
+  #   md.post_match_from(0)   #=> 789
+  #   md.post_match_from(1)   #=> z789
+  #   md.post_match_from(2)   #=> cz789
+  #   md.post_match_from(3)   #=> bcz789
+  #   md.post_match_from(-1)  #=> bcz789
+  #
+  def post_match_from(n=0)
+    return post_match if n == 0
+    n = length + n if n < 0
+    downfrom = offset(n)[1] - 1
+    "#{match[downfrom..-1]}#{post_match}"
+  end
+end

data/lib/facet/module.rb

@@ -0,0 +1,14 @@
+
+# base
+require "facet/module/basename"
+
+# common
+require "facet/module/by_name"
+require "facet/module/methods"
+
+# uncommon (not required)
+#require "facet/module/alias_module_function"
+#require "facet/module/initializer"
+#require "facet/module/memoize"
+#require "facet/module/redefine_method"
+#require "facet/module/wrap_method"

data/lib/facet/module/abstract.rb

@@ -0,0 +1,20 @@
+# Creates a method that requires to be overridding.
+# If it not overridden and called upon a TypeError
+# will be raised.
+#
+#  require 'facet/module/abstract'
+#
+#  class C
+#    abstract :a
+#  end
+#
+#  c = C.new
+#  c.a  #=> Error: undefined abstraction #a
+#
+class Module
+  def abstract( *sym )
+    sym.each { |s|
+      define_method( s ) { raise TypeError, "undefined abstraction ##{s}" }
+    }
+  end
+end