facets 3.0.0 → 3.2.0

data/demo/standard/03_enumargs.rdoc

@@ -1,75 +0,0 @@
-= Enumerable::Arguments
-
-Require the library.
-
-  require 'facets/enumargs'
-
-This will serve as our example class.
-
-  class PlusArray
-    include Enumerable::Arguments
-
-    def initialize(arr)
-      @arr = arr
-    end
-
-    def each(n=0)
-      @arr.each{ |e| yield(e+n) }
-    end
-  end
-
-Now Enumerable methods such as #map and #collect
-take an argument as well.
-
-  t = PlusArray.new([1,2,3])
-  t.collect(4){ |e| e }.assert == [5,6,7]
-
-Filtering methods such as #select and reject work
-as well.
-
-  t = PlusArray.new([1,2,3])
-  t.select(4){ |x| x == 6 }.assert == [6]
-
-  t = PlusArray.new([1,2,3])
-  t.reject(4){ |x| x == 6 }.assert == [5,7]
-
-We can covert to an array using #to_a with an argument.
-
-  t = PlusArray.new([1,2,3])
-  t.to_a(4).assert == [5,6,7]
-
-We can get the minimum value using #min.
-
-  t = PlusArray.new([1,2,3])
-  t.min(4).assert == 5
-
-And get the maximum value using #min.
-
-  t = PlusArray.new([1,2,3])
-  t.max(4).assert == 7
-
-Methods that already take and argument, now take two
-such as #include?
-
-  t = PlusArray.new([1,2,3])
-  t.assert.include?(7,4)
-
-And #each_slice.
-
-  t = PlusArray.new([1,2,3,4])
-  a = []
-  t.each_slice(2,4){ |e,f| a << [e,f] }
-  a.assert == [[5,6],[7,8]]
-
-The #find method has a slightly different interface
-than the original Enumerable.
-
-  t = PlusArray.new([1,2,3,4])
-  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
-  f.assert == :NOPE
-
-The #grep method should also work.
-
-  t = PlusArray.new(['a1','b2','a3','b4'])
-  t.grep(/^b/, 'x').assert == ['b2x','b4x']
-

data/demo/standard/04_equitable.rdoc

@@ -1,35 +0,0 @@
-= Equitqable
-
-Require the library.
-
-  require 'facets/equitable'
-
-We will use this simple class as an example.
-
-  class C
-    include Equitable(:a,:b)
-
-    attr_accessor :a, :b
-
-    def initialize(a,b)
-      @a = a
-      @b = b
-    end
-  end
-
-Now, if two instance of our sample class +C+ have
-equal attributes +@a+ and +@b+ then they will
-be equal.
-
-  c1 = C.new(10,20)
-  c2 = C.new(10,20)
-  c2.assert == c1
-
-Otherwise they will not be equal.
-
-  c1 = C.new(10, 10)
-  c2 = C.new(10, 20)
-  c2.refute == c1
-
-
-

data/demo/standard/05_instantiable.rdoc

@@ -1,42 +0,0 @@
-= Instantiable
-
-Require the library.
-
-  require 'facets/instantiable'
-
-We will use this module as an example.
-
-  module M
-    include Instantiable
-
-    attr :a
-
-    def initialize(a)
-      @a = a
-    end
-  end
-
-As we can see M is now fully instantiable, as any
-class would be.
-
-    m = M.new(1)
-    m.a.assert == 1
-
-We can also use #extend rather than #include and
-get the same result.
-
-  module N
-    extend Instantiable
-
-    attr :a
-
-    def initialize( a )
-      @a = a
-    end
-  end
-
-As we saw with +M+ so too with +N+.
-
-  n = N.new( 1 )
-  n.a.assert == 1
-

data/demo/standard/basic_object.rdoc

@@ -1,22 +0,0 @@
-== BasicObject
-
-  require 'facets/basicobject'
-
-  o = Class.new(BasicObject).new
-
-Should ignore new kernel methods.
-
-  Kernel.module_eval { def xxx ; end }
-
-  expect NoMethodError do
-    o.xxx
-  end
-
-Should ignore new object methods.
-
-  Object.class_eval { def yyy ; end }
-
-  expect NoMethodError do
-    o.yyy
-  end
-

data/demo/standard/memoizable.rdoc

@@ -1,134 +0,0 @@
-= Memoizable
-
-Memoizable allows
-
-  require 'facets/memoizable'
-
-The classic example is calculating the Fibonacci sequence.
-
-  class Fibonacci
-    include Memoizable
-
-    def fib( num )
-      return num if num < 2
-      fib(num - 1) + fib(num - 2)
-    end
-
-    memoize :fib
-  end
-
-The first time will take a moment to calculate.
-
-  f = Fibonacci.new
-  f.fib(100)
-
-The second time will be returned almost instantly.
-
-  f = Fibonacci.new
-  f.fib(100)
-
-The following example makes if very clear what memoize is doing.
-
-  class MemoExample
-    include Memoizable
-    attr_accessor :a
-    memoize :a
-  end
-
-  m = MemoExample.new
-  m.a = 10
-  m.a         #=> 10
-  m.a = 20
-  m.a         #=> 10
-
-Even though @a is assigned to 20, the method #a continues to return 10.
-
-Memoizable is designed to handle a number of typically problematic aspects
-of memoization implementations. First a memoizable object can be frozen.
-
-  f = Fibonacci.new
-  f.freeze
-  f.fib(100)
-
-Memoizable objects are freezable because it does not use an instance variable
-to store the memoized return values. Instead it uses a global class instance
-variable in +Memoizable.cache+.
-
-However, this also means the memoization cache is not preserved when an object
-is duplicated. If this behavior is desired an aditional module is provided
-called `Memoizable::Copy`. When the `Memoiazble::Copy` module is included into
-a class it not only adds the #memoize class methods but also includes
-an #initialize_copy method, which copies the appropriate cache entries when
-#dup or #clone is used. Keep this in mind. It is important to call #super if you
-override the #initialize_copy method in a class that uses `Memoizable::Copy`.
-
-  class MemoExample2
-    include Memoizable::Copy
-    attr_accessor :a
-    memoize :a
-  end
-
-  m = MemoExample2.new
-  m.a = 10
-  m.a         #=> 10
-
-  n = m.dup
-  n.a = 20
-  n.a         #=> 10
-
-The `#memoize` method also accepts a few options that can be used to modify
-the behvior of the memoizaiton. To memoize a method across all objects
-of the same class and not just per-object, set the `:class` option to true.
-
-  class MemoExample3
-    include Memoizable
-    attr_accessor :a
-    memoize :a, :class=>true
-  end
-
-  m = MemoExample3.new
-  m.a = 10
-  m.a         #=> 10
-
-  n = MemoExample3.new
-  n.a         #=> 10
-
-Memoization is indexed based on arguments passed to the method, as can be seen 
-in the Fibonacci example. Methods can also be memoized by name only, forgoing
-any indexing based on arguments passed. To do this, set the `:arguments`
-option to +false+.
-
-  class MemoExample4
-    include Memoizable
-    def f(n)
-      n + n
-    end
-    memoize :f, :arguments=>false
-  end
-
-  m = MemoExample4.new
-  m.f(1)
-  m.f(2)      #=> 2
-  m.f(3)      #=> 2
-
-Blocks passed to a method normally have only a present vs. non-present effect
-on the memoization index. In other words the return value of a method will be
-cached under one key if a block is passed to it and under a different index
-if not. It doesn't matter if blocks passed in actually differ, since
-the only way to compare blocks is by their +object_id+ and it is very rare
-for the exact same block object to be reused.
-
-Finally, the `:freeze` option can be used to freeze the memoized results.
-
-  class MemoExample5
-    include Memoizable
-    def f(n)
-      (n + n).to_s
-    end
-    memoize :f, :freeze=>true
-  end
-
-  m = MemoExample5.new
-  m.f(1).frozen?      #=> true
-  m.f(2).frozen?      #=> true
-

data/demo/standard/mulititon.rdoc

@@ -1,156 +0,0 @@
-= Multiton
-
-The Multion pattern is essentially the same as the Singleton pattern, but
-unlike it's fully unique brethren Multiton's are identical if their
-initialization parameters are identical.
-
-To demontrate we first need to load the Facets multiton.rb script.
-
-  require 'facets/multiton'
-
-Now for the various exmples.
-
-
-== EXAMPLE A - STANDARD USAGE
-
-    class SomeMultitonClass
-      include Multiton
-
-      attr :arg
-      def initialize(arg)
-        @arg = arg
-      end
-    end
-
-    a = SomeMultitonClass.instance(4)
-    b = SomeMultitonClass.instance(4)     # a and b are same object
-    c = SomeMultitonClass.instance(2)     # c is a different object
-
-    a.assert == b 
-
-    x = [a.arg, b.arg].max * 10 + c.arg
-    x.assert == 42
-
-
-== EXAMPLE B - MODIFY AN EXISTING CLASS
-
-We can modify an existing class (if we are so bold), for example we can
-add shared filehandles to the File class.
-
-    class ::File
-      include Multiton
-    end
-
-    lineno = __LINE__
-    # HERE1
-    # HERE2
-
-    a = File.instance(__FILE__)
-    b = File.instance(__FILE__)
-
-    b.assert == a
-
-    lineno.times{ a.gets }
-
-    a.gets.strip.assert == "# HERE1"
-    b.gets.strip.assert == "# HERE2"
-
-
-== EXAMPLE C - INHERITENCE
-
-  class A < String
-    include Multiton
-  end
-
-  # B is also a multiton - with it's OWN object cache
-  class B < A; end
-
-  # w is the same object as x, y is the same object as z
-  w,x,y,z = A.instance('A'), A.instance('A'), B.instance('B'), B.instance('B')
-
-  x.object_id.assert == w.object_id
-  z.object_id.assert == y.object_id
-
-  a = B.instance('A')
-  b = B.instance('A')
-
-  w.object_id.refute == a.object_id   # (each class has it's own pool)
-  b.object_id.assert == a.object_id
-
-
-== EXAMPLE D - MULTIPLE MODULE INCLUSION (does nothing)
-
-  class A < String
-    include Multiton
-  end
-
-  # B is also a multiton - with it's OWN object cache
-  class B < A; end
-
-
-  # w is the same object as x, y is the same object as z
-  w,x,y,z = A.instance('A'), A.instance('A'), B.instance('B'), B.instance('B')
-
-  yz_id = y.object_id || z.object_id
-
-If we include Multiton again, it will have to effect.
-
-  B.class_eval {
-    include Multiton
-  }
-
-  # y is not only the same object as z, but they are both the same object(s)
-  # as from EXAMPLE C
-
-  y,z = B.instance('B'), B.instance('B')
-
-  yz_id.assert == y.object_id
-  yz_id.assert == z.object_id
-
-
-== EXAMPLE E - SO YOU WANNA USE NEW INSTEAD OF INSTANCE
-
-  module K
-    # use an inner class which is itself a multiton
-    class K < String; include Multiton; end
-
-    # define a new which returns a mutltion using #instance...
-    class << self
-      def new(*args, &block)
-        K.instance(*args, &block)
-      end
-    end
-  end
-
-  the = K.new '4'
-  answer = K.new '2'
-
-  x = sprintf( "%s%s", the, answer )
-  x.assert == "42"
-  the.class.assert == K::K
-
-
-== EXAMPLE F - using Klass.multiton_id
-
-  class Klass
-    include Multiton
-
-    def initialize( important, not_important )
-      @important, @not_important = important, not_important
-    end
-
-    def Klass.multiton_id(*args, &block)
-      # we consider only the first arg
-      important, not_important = *args
-      important
-    end
-  end
-
-  a = Klass.instance( :a, :b )
-  b = Klass.instance( :a, :c )
-  c = Klass.instance( :b, :b )
-
-  a.assert == b
-  c.refute == a
-  c.refute == b
-

data/lib/core/facets/applique/file_helpers.rb

@@ -1,33 +0,0 @@
-#
-def temporary_directory
-  @temporary_directory ||= 'tmp'
-end
-
-When /Given a directory '(.*?)' containing/ do |dir, text|
-  @temporary_directory = File.join(@temporary_directory, dir)
-  text.lines.each do |file|
-    next if file =~ /^\s*$/
-    file = File.join(@temporary_directory, file.strip)
-    dir  = File.dirname(file)
-    FileUtils.mkdir_p(dir)
-    File.open(file, 'w'){ |f| f << "SPINICH" }
-  end
-end
-
-Before :all do
-  if File.exist?(temporary_directory)
-    FileUtils.rm_r(temporary_directory)
-  end
-  FileUtils.mkdir_p(temporary_directory)
-end
-
-# Used for File extensions
-When "had a file '(((.*?)))'" do |name|
-  name = name.sub(/^tmp\//, '')  # b/c QED now runs from tmp/qed
-  File.open(name, 'w'){|f| f << "Hello World"}
-end
-
-When "had a binary file '(((.*?)))'" do |name|
-  name = name.sub(/^tmp\//, '')  # b/c QED now runs from tmp/qed
-  File.open(name, 'wb'){|f| f << "Hello\nWorld\n"}
-end

data/lib/core/facets/array/intersection.rb

@@ -1,25 +0,0 @@
-class Array
-
-	# Returns the values in common for an array set (nil, singe value/object, or range).
-  #
-  # CREDIT: monocle
-
-	def intersection
-		array = uniq.sort_by { |e| Range === e ? e.first : e }
-		array.inject() do |c, e|
-			f = (Range === c ? c.last  : c)
-			v = (Range === e ? e.first : e)
-			case f <=> v
-			when -1 then return nil
-			when  0 then f
-			else
-				if Range === e
-					v..([f, e.last].min)
-				else
-					v
-				end
-			end
-		end
-	end
-
-end

data/lib/core/facets/array/op_pow.rb

@@ -1,14 +0,0 @@
-require 'facets/array/product'
-
-class Array
-  # Array#** is an alias for Array#product.
-  #
-  # NOTE: This method is not a common core extension and is not
-  # loaded automatically when using <code>require 'facets'</code>.
-  #
-  # @uncommon
-  #   require 'facets/array/op_pow'
-  #
-  alias_method :**, :product
-end
-

data/lib/core/facets/array/to_h.rb

@@ -1,22 +0,0 @@
-class Array
-
-  # Convert an associative array to a Hash.
-  #
-  # Examples
-  #
-  #   [[:a, 1], [:b, 2]].to_h
-  #   #=> {:a=>1, :b=>2}
-  #
-  #   [[:a, 1], :b].to_h
-  #   #=> {:a=>1, :b=>nil}
-  #
-  # Returns [Hash].
-  #
-  def to_h
-    h = {}
-    each{ |(k,v)| h[k] = v }
-    h
-  end unless method_defined?(:to_h)
-
-end
-

data/lib/core/facets/binding/local_variables.rb

@@ -1,16 +0,0 @@
-class Binding
-
-  # Returns the local variables defined in the binding context:
-  #
-  #   a = 1
-  #   b = 2
-  #
-  #   binding.local_variables  #=> [:a, :b]
-  #
-  # TODO: Rename this to prevent name clash?
-  def local_variables()
-    eval("local_variables")
-  end
-
-end
-

data/lib/core/facets/class/singleton.rb

@@ -1 +0,0 @@
-require 'facets/class/singleton_class'

data/lib/core/facets/class/singleton_class.rb

@@ -1,16 +0,0 @@
-class Class 
-
-  # Return true if a class is the singleton class of
-  # an object.
-  #
-  # @uncommon
-  #   require 'facets/class/singleton_class'
-  #
-  def singleton_class? 
-    ! ancestors.include?( self ) rescue false 
-  end
-
-  # @deprecated
-  alias :singleton? :singleton_class?
-
-end 

data/lib/core/facets/class/subclasses.rb

@@ -1,28 +0,0 @@
-class Class
-
-  if defined?(Class.__subclasses__) # Rubinius
-
-    # Returns an array with the direct children of +self+.
-    #
-    #   Integer.subclasses # => [Fixnum, Bignum]
-    #
-    alias_method :subclasses, :__subclasses__
-
-  else
-
-    # Returns an array with the direct children of +self+.
-    #
-    #   Integer.subclasses # => [Fixnum, Bignum]
-    #
-    def subclasses
-      list = []
-      ObjectSpace.each_object(Class) do |c|
-        list.unshift c if c.superclass == self
-      end
-      list.uniq
-    end
-
-  end
-
-end
-

data/lib/core/facets/dir/each_child.rb

@@ -1,16 +0,0 @@
-class Dir
-
-  # Like #each, except the "." and ".." special files are ignored.
-  # You can use +ignore+ to override '.' and '..' and ignore 
-  # other entries via a exact match or regular expression.
-  #
-  # CREDIT: Tyler Rick
-  def each_child(*ignore)
-    ignore = ['.', '..'] if ignore.empty?
-    each do |file|
-      yield file unless ignore.any?{ |i| i === file }
-    end
-  end
-
-end
-

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

@@ -1,33 +0,0 @@
-module Enumerable
-
-  # The block acts as an arbitrary filter on the data. Unlike map,
-  # it can choose to drop elements from the result and/or add
-  # additional elements. The first object passed to the block is
-  # the receiver of the output.
-  #
-  #   x = (1..10000)
-  #   x = x.filter{ |out,i| out << i if i % 2 == 0 }   # like select
-  #   x = x.filter{ |out,i| out << i + 100 }           # like map
-  #   x = x.take(3)
-  #
-  #   x  #=> [102, 104, 106]
-  #
-  # This is very similar to #each_with_object, but #filter handles
-  # argument better by reversing their order and using the splat
-  # operator. (This was also once known as #injecting.)
-  #
-  # CREDIT: David Black, Louis J Scoras
-
-  def filter(output=[]) #:yeild:
-    if block_given?
-      each do |*input|
-        yield(output, *input)
-      end
-      output
-    else
-      to_enum(:filter)
-    end
-  end
-
-end
-