mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/qua_class.rb

@@ -0,0 +1,19 @@
+module Kernel
+
+  # Easy access to an object qua class, otherwise
+  # known as the object's singleton class.
+  #
+  # Yes, another one.
+  #
+  #  CREDIT: Trans
+  #
+  def qua_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/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_all 'facets/time/*'
+  #
+  def require_all(pat)
+    $LOAD_PATH.each do |path|
+      fs = Dir[File.join(path,pat)]
+      unless fs.empty?
+        fs.each { |f|
+          Kernel.require( f ) unless File.directory?( f )
+        }
+        break;
+      end
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/require_local.rb

@@ -0,0 +1,24 @@
+module Kernel
+
+  # Require file from same dir as calling script.
+  #
+  #   require_local 'templib'
+  #
+  def require_local(fname)
+    #fdir = File.expand_path( File.dirname( caller[0] ) )
+    fdir = File.dirname( caller[0] )
+    require( File.join( fdir, fname ) )
+  end
+
+  # Load file from same dir as calling script.
+  #
+  #   load_local 'templib'
+  #
+  def load_local(fname, safe=nil)
+    #fdir = File.expand_path( File.dirname( caller[0] ) )
+    fdir = File.dirname( caller[0] )
+    load( File.join( fdir, fname ), safe )
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/resc.rb

@@ -0,0 +1,16 @@
+module Kernel
+
+  # Provides a shortcut to the Regexp.escape module method.
+  #
+  #   resc("H..LO")   #=> "H\\.\\.LO"
+  #
+  #   TODO: Should this be deprecated in favor of String#to_re/to_rx ?
+  #
+  #   CREDIT: Trans
+
+  def resc(str)
+    Regexp.escape(str.to_s)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/respond.rb

@@ -0,0 +1,23 @@
+module Kernel
+
+  # Like #respond_to? but returns the result of the call
+  # if it does indeed respond.
+  #
+  #   class X
+  #     def f; "f"; end
+  #   end
+  #
+  #   x = X.new
+  #   x.respond(:f)  #=> "f"
+  #   x.respond(:g)  #=> nil
+  #
+  #  CREDIT: Trans
+
+  def respond(sym, *args)
+    return nil if not respond_to?(sym)
+    send(sym, *args)
+  end
+
+  alias_method :respond_with_value, :respond
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/returning.rb

@@ -0,0 +1,23 @@
+module Kernel
+
+  # A Ruby-ized realization of the K combinator.
+  #
+  #   returning Book.new do |book|
+  #     book.title = "Imperium"
+  #     book.author = "Ulick Varange"
+  #   end
+  #
+  # Technically, #returning probably should force the return of
+  # the stated object irregardless of any return statements that
+  # might appear within it's block. This might differentiate
+  # #returning from #with, however it also would require
+  # implementation in Ruby itself.
+  #
+  #   CREDIT: Mikael Brockman
+
+  def returning(obj=self) #:yield:
+    yield obj
+    obj
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/silence.rb

@@ -0,0 +1,75 @@
+module Kernel
+
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  #
+  #   CREDIT: David Heinemeier Hansson
+
+  def silence_stream(*streams) #:yeild:
+    on_hold = streams.collect{ |stream| stream.dup }
+    streams.each do |stream|
+      stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+    end
+    yield
+  ensure
+    streams.each_with_index do |stream, i|
+      stream.reopen(on_hold[i])
+    end
+  end
+
+  #
+  def silence_stderr #:yeild:
+    silence_stream(STDERR) { yield }
+  end
+
+  #
+  def silence_stdout #:yeild:
+    silence_stream(STDOUT) { yield }
+  end
+
+  # Just like silence_stream, but will default to 
+  # STDOUT, STDERR if no streams are given.
+
+  def silently(*streams) #:yeild:
+    streams = [STDOUT, STDERR] if streams.empty?
+    silence_stream(*streams){ yield }
+  end
+
+  # Sets $VERBOSE to nil for the duration of the block
+  # and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call  # no warning is voiced
+  #
+  #  CREDIT: David Heinemeier Hansson
+
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  # Sets $VERBOSE to true for the duration of the block
+  # and back to its original value afterwards.
+  #
+  #  CREDIT: David Heinemeier Hansson
+
+  def enable_warnings
+    old_verbose, $VERBOSE = $VERBOSE, true
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/singleton_class.rb

@@ -0,0 +1,19 @@
+module Kernel
+
+  # Easy access to an object's "special" class,
+  #
+  # One day these names must be reconciled!
+
+  def singleton_class(&block)
+    if block_given?
+      (class << self; self; end).class_eval(&block)
+    else
+      (class << self; self; end)
+    end
+  end
+
+  # Deprecate?
+  alias_method :singleton, :singleton_class
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/tap.rb

@@ -0,0 +1,32 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  module Kernel
+
+    # The tap K-Combinator. This yields self -and- returns self.
+
+    def tap(&b)
+      if block_given?
+        b.arity == 1 ? yield(self) : instance_eval(&b)
+      end
+      self
+    end
+
+    # This is just an off-the-cuff consideration for #tap using Functor:
+    #
+    #   require 'facets/functor'
+    #
+    #   # Yield self -and- return self.
+    #
+    #   def tap(&b)
+    #     if block_given?
+    #       b.arity == 1 ? yield(self) : instance_eval(&b)
+    #       self
+    #     else
+    #       Functor.new{ |op, *args| self.send(op, *args); self }
+    #     end
+    #   end
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/try.rb

@@ -0,0 +1,23 @@
+module Kernel
+
+  # Try a method.
+  #   @person ? @person.name : nil
+  # vs
+  #   @person.try(:name)
+  #
+  #  CREDIT: Chris Wanstrath
+
+  def try(method, default=nil)
+    if respond_to? method
+      send method 
+    else
+      default
+    end
+  end
+
+end
+
+
+
+
+ 

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/val.rb

@@ -0,0 +1,19 @@
+module Kernel
+
+  # Tests to see if something has value. An object
+  # is considered to have value if it is not nil?
+  # and if it responds to #empty?, is not empty.
+  #
+  #   nil.val?     #=> false
+  #   [].val?      #=> false
+  #   10.val?      #=> true
+  #   [nil].val?   #=> true
+
+  def val?
+    return false if nil?
+    return false if empty? if respond_to?(:empty?)
+    true
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/with.rb

@@ -0,0 +1,20 @@
+module Kernel
+
+  # Like returning but exectures the block
+  # via instance_eval.
+  #
+  #   def foo
+  #     with values = [] do
+  #       self << 'bar'
+  #       self << 'baz'
+  #     end
+  #   end
+  #
+  #   foo # => ['bar', 'baz']
+  #
+  def with(obj=self, &block)
+    obj.instance_eval(&block)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/lazy.rb

@@ -0,0 +1,238 @@
+# = Lazy
+#
+# Everything you need for Lazy evaluation in Ruby.
+#
+# == Authors
+#
+# * MenTaLguY
+#
+# == Copying
+#
+# Copyright (c) 2005 MenTaLguY <mental@rydia.net>
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+# = Lazy
+#
+# Everything you need for Lazy evaluation in Ruby.
+#
+module Lazy
+
+  # Raised when a demanded computation diverges (e.g. if it tries to directly
+  # use its own result)
+
+  class DivergenceError < Exception #:nodoc:
+    def initialize( message="Computation diverges" )
+      super( message )
+    end
+  end
+
+  # Wraps an exception raised by a lazy computation.
+  #
+  # The reason we wrap such exceptions in LazyException is that they need to
+  # be distinguishable from similar exceptions which might normally be raised
+  # by whatever strict code we happen to be in at the time.
+
+  class LazyException < DivergenceError #:nodoc:
+    # the original exception
+    attr_reader :reason
+
+    def initialize( reason )
+      @reason = reason
+      super( "Exception in lazy computation: #{ reason } (#{ reason.class })" )
+      set_backtrace( reason.backtrace.dup ) if reason
+    end
+  end
+
+  # = Promise
+  #
+  # A handle for a promised computation.  They are transparent, so that in
+  # most cases, a promise can be used as a proxy for the computation's result
+  # object.  The one exception is truth testing -- a promise will always look
+  # true to Ruby, even if the actual result object is nil or false.
+  #
+  # If you want to test the result for truth, get the unwrapped result object
+  # via Kernel.demand.
+
+  class Promise
+
+    alias __class__ class #:nodoc:
+    instance_methods.each { |m| undef_method m unless m =~ /^(__|object_|instance_)/ }
+
+    def initialize( &computation ) #:nodoc:
+      @computation = computation
+    end
+    def __synchronize__ #:nodoc:
+      yield
+    end
+
+    # create this once here, rather than creating a proc object for
+    # every evaluation
+    diverges = lambda { raise DivergenceError.new }
+    def diverges.inspect
+      "DIVERGES"
+    end
+    DIVERGES = diverges
+
+    def __result__ #:nodoc:
+      __synchronize__ do
+        if @computation
+          raise LazyException.new( @exception ) if @exception
+
+          computation = @computation
+          @computation = DIVERGES # trap divergence due to over-eager recursion
+
+          begin
+            @result = demand( computation.call( self ) )
+            @computation = nil
+          rescue DivergenceError
+            raise
+          rescue Exception => exception
+            # handle exceptions
+            @exception = exception
+            raise LazyException.new( @exception )
+          end
+        end
+
+        @result
+      end
+    end
+
+    def inspect #:nodoc:
+      __synchronize__ do
+        if @computation
+          "#<#{ __class__ } computation=#{ @computation.inspect }>"
+        else
+          @result.inspect
+        end
+      end
+    end
+
+    def respond_to?( message ) #:nodoc:
+      message = message.to_sym
+      message == :__result__ or
+      message == :inspect or
+      __result__.respond_to? message
+    end
+
+    def method_missing( *args, &block ) #:nodoc:
+      __result__.__send__( *args, &block )
+    end
+  end
+
+  # = PromiseSafe
+  #
+  # Thread safe version of Promise class.
+
+  class PromiseSafe < Promise
+    def __synchronize__ #:nodoc:
+      current = Thread.current
+
+      Thread.critical = true
+      unless @computation
+        # fast path for evaluated thunks
+        Thread.critical = false
+        yield
+      else
+        if @owner == current
+          Thread.critical = false
+          raise DivergenceError.new
+        end
+        while @owner # spinlock
+          Thread.critical = false
+          Thread.pass
+          Thread.critical = true
+        end
+        @owner = current
+        Thread.critical = false
+
+        begin
+          yield
+        ensure
+          @owner = nil
+        end
+      end
+    end
+  end
+
+  # = Future
+  #
+  # Future class subclasses PromiseSafe.
+
+  class Future < PromiseSafe
+    def initialize( &computation ) #:nodoc:
+      result = nil
+      exception = nil
+
+      thread = Thread.new do
+        begin
+          result = computation.call( self )
+        rescue Exception => exception
+        end
+      end
+
+      super() do
+        raise DivergenceError.new if Thread.current == thread
+        thread.join
+        raise exception if exception
+        result
+      end
+    end
+  end
+
+end
+
+
+module Kernel
+
+  # The promise() function is used together with demand() to implement
+  # lazy evaluation.  It returns a promise to evaluate the provided
+  # block at a future time.  Evaluation can be demanded and the block's
+  # result obtained via the demand() function.
+  #
+  # Implicit evaluation is also supported: the first message sent to it will
+  # demand evaluation, after which that message and any subsequent messages
+  # will be forwarded to the result object.
+  #
+  # As an aid to circular programming, the block will be passed a promise
+  # for its own result when it is evaluated.  Be careful not to force
+  # that promise during the computation, lest the computation diverge.
+  #
+  def promise( &computation ) #:yields: result
+    Lazy::Promise.new(&computation)
+  end
+
+  # Forces the result of a promise to be computed (if necessary) and returns
+  # the bare result object.  Once evaluated, the result of the promise will
+  # be cached.  Nested promises will be evaluated together, until the first
+  # non-promise result.
+  #
+  # If called on a value that is not a promise, it will simply return it.
+  #
+  def demand( promise )
+    if promise.respond_to? :__result__
+      promise.__result__
+    else # not really a promise
+      promise
+    end
+  end
+
+  # Schedules a computation to be run asynchronously in a background thread
+  # and returns a promise for its result.  An attempt to demand the result of
+  # the promise will block until the computation finishes.
+  #
+  # As with Kernel.promise, this passes the block a promise for its own result.
+  # Use wisely.
+  #
+  def future( &computation ) #:yields: result
+    Lazy::Future.new(&computation)
+  end
+
+end