mack-facets 0.8.2 → 0.8.3

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

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,238 +0,0 @@
-# = 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