facets 2.8.1 → 2.8.2

data/lib/core/facets/enumerable/collect.rb

@@ -1,4 +0,0 @@
-# to be deprecated
-require 'facets/enumerable/map_with_index'
-require 'facets/enumerable/compact_map'
-

data/lib/core/facets/enumerable/inject.rb

@@ -1,30 +0,0 @@
-module Enumerable
-
-  # A small variation of #Inject that save one from having to
-  # return the aggregating or memo argument.
-  #
-  # Say you want to count letters.
-  #
-  #    some_text.inject!(Hash.new(0)) {|h,l| h[l] += 1}
-  #
-  # vs
-  #
-  #    some_text.inject(Hash.new(0)) {|h,l| h[l] +=1; h}
-  #
-  # CREDIT: David Black, Louis J Scoras
-
-  def inject!(s)
-    k = s
-    each { |i| yield(k, i) }
-    k
-  end
-
-  # HERE AS BACKUP, TO ENSURE THE ABOVE HAS THE SAME FUNCTIONALITY.
-  #def injecting(s)
-  #  inject(s) do |k, i|
-  #    yield(k, i); k
-  #  end
-  #end
-
-end
-

data/lib/core/facets/numeric/size.rb

@@ -1,10 +0,0 @@
-class Numeric
-
-  # Returns +self+.
-
-  def size
-    self
-  end
-
-end
-

data/lib/more/facets/enumerator.rb

@@ -1,62 +0,0 @@
-begin
-  require 'enumerator' #if RUBY_VERSION < 1.9
-  # for Ruby 1.8 -> 1.9 transition
-  Enumerator = Enumerable::Enumerator unless defined? ::Enumerator
-rescue LoadError # Ruby 1.9 already has it built-in.
-end
-
-class Enumerator
-
-  alias :old_initialize :initialize
-
-  # Provides the ruby-1.9 block form of Enumerator, where you can write:
-  #
-  #    obj = Enumerator.new do |yielder|
-  #       .. do stuff
-  #       yielder.yield data      # or: yielder << data
-  #       .. etc
-  #    end
-  #
-  # When obj.each is called, the block is run once. It should call
-  # yielder.yield with each item it wishes to generate.
-  #
-  # Example:
-  #
-  #   fib = Enumerator.new { |y|
-  #     a = b = 1
-  #     loop {   
-  #       y << a
-  #       a, b = b, a + b
-  #     }
-  #   }  
-  #
-  #   assert_equal [1, 1, 2, 3, 5, 8, 13, 21, 34, 55], fib.take(10)
-                                                
-  def initialize(*args, &block)
-    if block_given?
-      @body = block
-      old_initialize(self, :_start)
-    else
-      old_initialize(*args)
-    end
-  end
-
-  def _start(*args,&receiver) #:nodoc:
-    @body.call(Yielder.new(receiver), *args)
-  end
-
-  # Wrapper to allow yielder.yield(output) or yielder << output
-  # in the same way as ruby-1.9
-
-  class Yielder #:nodoc:
-    def initialize(proc)
-      @proc = proc
-    end
-    def yield(*args)
-      @proc[*args]
-    end
-    alias :<< :yield
-  end
-
-end
-

data/lib/more/facets/tracepoint.rb

@@ -1,209 +0,0 @@
-# = TracePoint
-#
-# A TracePoint is a Binding with the addition event information.
-# And it's a better way to use set_trace_func.
-#
-# A TracePoint is a Binding with the addition of event information.
-# Among other things, it functions very well as the join-point for
-# Event-based AOP.
-#
-# == Usage
-#
-#   TracePoint.trace { |tp|
-#     puts "#{tp.self.class}\t#{tp.called}\t#{tp.event}\t#{tp.return?}\t#{tp.back == tp.bind}"
-#   }
-#
-#   1 + 1
-#
-# produces
-#
-#   Class   trace   return     true    false
-#   Object          line       false   false
-#   Fixnum  +       c-call     false   false
-#   Fixnum  +       c-return   false   false
-#
-# == Notes
-#
-# You can't subclass Binding, so we delegate (which is better anyway).
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2005 Thomas Sawyer
-#
-# 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.
-
-require 'facets/binding'
-
-# = CodePoint
-#
-# This is the same as a Binding. Not really needed, but I like consistency :)
-
-CodePoint = Binding
-
-# = TracePoint
-#
-# A TracePoint is a Binding with the addition of event information.
-# Among other things, it functions very well as the join-point for
-# Event-based AOP.
-#
-# == Usage
-#
-#   TracePoint.trace { |tp|
-#     puts "#{tp.self.class}\t#{tp.called}\t#{tp.event}\t#{tp.return?}\t#{tp.back == tp.bind}"
-#   }
-#
-#   1 + 1
-#
-# produces
-#
-#   Class   trace   return     true    false
-#   Object          line       false   false
-#   Fixnum  +       c-call     false   false
-#   Fixnum  +       c-return   false   false
-#
-# == Notes
-#
-# You can't subclass Binding, so we delegate (which is better anyway).
-
-class TracePoint  #< Codepoint
-
-  # -- class ---------------------
-  class << self
-
-    @@active = false
-
-    def active ; @@active ; end
-
-    def active=(x)
-      @@active = x ? true : false
-      unless @@active
-        set_trace_func nil
-      end
-    end
-
-    # Trace execution using a TracePoint.
-    def trace # :yield:
-      if active
-        bb_stack = []
-        set_trace_func proc{ |e, f, l, m, b, k|
-          #(p e, f, l, m, b, k, @@bb_stack; puts "---") if $DEBUG
-          if ['call','c-call','class'].include?(e)
-            bb_stack << b
-          elsif ['return','c-return','end'].include?(e)
-            bb = bb_stack.pop
-          end
-          b = bb if ! b    # this sucks!
-          tp = TracePoint.new(e,m,b,bb)
-          yield(tp)
-        }
-      end
-    end
-
-  end #class
-
-  # -- instance -------------------
-
-  attr_accessor :event, :binding, :back_binding
-
-  # Until Ruby has a built-in way to get the name of the calling method
-  # that information must be passed into the TracePoint.
-  def initialize( event, method, bind, back_binding=bind )
-    @event = event
-    @method = method
-    @binding = bind
-    @back_binding = back_binding
-  end
-
-  # shorthand for binding
-  def bind ; @binding ; end
-
-  # shorthand for back_binding
-  def back ; @back_binding ; end
-
-  # Delegates "self" to the binding which
-  # in turn delegates the binding object.
-  def self ; @binding.self ; end
-
-  # Returns the name of the event's method.
-  # This could delegate to the binding if Ruby had
-  # an internal way to retrieve the current method name.
-  def callee ; @method ; end
-  #def method ; @method ; end            # TODO Conflict with Kernel#method?
-  alias_method( :called, :callee )       # TODO deprecate
-  alias_method( :method_name, :called )  # TODO deprecate
-
-  # delegate to binding
-  #def method_missing(meth, *args, &blk)
-  #  @binding.send(meth, *args, &blk)
-  #end
-
-  ### methods for working with events
-
-  EVENT_MAP = {
-    :all     => ['call', 'c-call', 'return', 'c-return', 'line', 'class', 'end', 'raise'],
-    :before  => ['call', 'c-call'],
-    :after   => ['return', 'c-return'],
-    :call    => ['call'],
-    :return  => ['return'],
-    :ccall   => ['c-call'],
-    :creturn => ['c-return'],
-    :line    => ['line'],
-    :class   => ['class'],
-    :end     => ['end'],
-    :raise   => ['raise']
-  }
-  def event_map(e) ; EVENT_MAP[e] ; end
-
-  # Is the trace point defined or undefined?
-  def event? ; !! @event ; end
-  def eventless? ; ! @event ; end
-
-  # For use in case conditions
-  def ===(e)
-    EVENT_MAP[e].include?(@event)
-  end
-
-  # Creates an <event>? method for each of the above event mappings.
-  EVENT_MAP.each_pair { |m,v|
-    define_method( "#{m}?" ){ v.include?(@event) }
-  }
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin #test
-
-  # Note: TracePoint will probably prove tricky to test, since
-  # manipulating set_trace_func tends to wreak havoc on errors,
-  # the call stack, and so on.
-
-  TracePoint.active = true
-
-  TracePoint.trace { |tp|
-    puts "#{tp.self.class}\t#{tp.called}\t#{tp.event}\t#{tp.return?}\t#{tp.back == tp.bind}"
-  }
-
-  1 + 1
-
-=end

data/test/core/enumerable/test_map_detect.rb

@@ -1,75 +0,0 @@
-require 'facets/enumerable/map_detect'
-require 'test/unit'
-
-class TestEnumerable < Test::Unit::TestCase
-  
-  def test_map_detects_a_value
-    assert_equal true, [true].map_detect { |value| value }
-  end
-
-  def test_map_detect_detects_correct_value
-    assert_equal 1, [1].map_detect { |value| value }
-  end
-
-  def test_map_detect_returns_value_of_block
-    assert_equal 4, [1].map_detect { |v| v + 3 }
-  end
-
-  def test_map_detect_detects_first_truthy_value
-    assert_equal 1, [false, false, 1].map_detect { |value| value }
-  end
-
-  def test_map_detect_returns_value_when_block_is_true
-    assert_equal true, [false].map_detect { |value| true }
-  end
-
-  def test_map_detect_returns_early_when_block_is_true
-    val1 = lambda { :something }
-    val2 = lambda { raise "This shouldn't be called" }
-
-    assert_equal :something, [val1, val2].map_detect { |obj| obj.call }
-  end
-
-  def test_map_detect_returns_nil_when_block_returns_false_for_all_elements
-    assert_equal nil, [1,2,3,4].map_detect { |value| false }
-  end
-
-  def test_map_detect_returns_nil_when_no_elements_in_collection
-    assert_equal nil, [].map_detect { |v| }
-  end
-
-  def test_map_detect_can_have_return_value_specified_when_block_isnt_true
-    assert_equal :a_value, [1,2,3].map_detect(:a_value) { |value| false }
-  end
-
-  def test_map_detect_documentation_correct
-    obj1, obj2 = Object.new, Object.new
-
-    class << obj1
-      def foo?
-        false
-      end
-
-      def foo
-        raise
-      end
-    end
-
-    class << obj2
-      def foo?
-        true
-      end
-
-      def foo
-        "a value"
-      end
-    end
-
-    assert_equal false, obj1.foo?
-    assert_equal true, obj2.foo?
-    assert_equal "a value", obj2.foo
-
-    result = [obj1, obj2].map_detect { |obj| obj.foo if obj.foo? }
-    assert_equal result, "a value"
-  end
-end