facets 1.8.54 → 2.0.0

data/lib/facets/more/elementor.rb

@@ -1,136 +0,0 @@
-# = elementor.rb
-#
-# == Copyright (c) 2006 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.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2006 Thomas Sawyer
-# License::   Ruby License
-
-require 'facets/core/kernel/object_class'
-
-# = Elementor
-#
-# Elementor is an Array which applies calls elementwise.
-# Depending on the mode the call will return a
-# new elementor, the same elementor, a new array,
-# or the orignal array transformed.
-
-class Elementor
-
-  private :to_s  #*( instance_methods - [ 'object_class' ] )
-
-  def initialize( an_array, mode=nil )
-    @array = an_array
-    @mode = mode
-  end
-
-  def to_a ; p @array ; @array ; end
-  def to_ary ; p @array; @array ; end
-
-  def each( *args, &block )
-    @array.each( *args, &block )
-  end
-
-  def ==( other )
-    @array == other.to_ary
-  end
-
-  def method_missing( sym, *args, &block )
-    c = @array.collect { |e| e.send( sym, *args, &block ) }
-    case @mode
-    when :array
-      c
-    when :inplace_array
-      @array.replace( c )
-      #@array.collect! { |e| e.send( sym, *args, &block ) }
-      @array
-    when :inplace
-      @array.replace( c )
-      self
-    else
-      object_class.new( c )
-    end
-  end
-
-end
-
-
-class Array
-
-  def to_elementor
-    Elementor.new( self )
-  end
-
-  def to_elementor!
-    Elementor.new( self, :inplace )
-  end
-
-  def every
-    Elementor.new( self, :array )
-  end
-
-  def every!
-    Elementor.new( self, :inplace_array )
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCElementor < Test::Unit::TestCase
-
-    def test_to_elementor
-      e = [1,2,3].to_elementor
-      assert_equal( [4,5,6], e + 3 )
-      assert_equal( [0,1,2], e - 1 )
-    end
-
-    def test_to_elementor_str
-      e = [1,2,3].to_elementor
-      assert_equal( ['1','2','3'], e.to_s )
-    end
-
-    def test_to_elementor!
-      e = [1,2,3].to_elementor!
-      e + 3
-      assert_equal( [4,5,6], e )
-    end
-
-    def test_every
-      a = [1,2,3]
-      assert_equal( [4,5,6], a.every + 3 )
-      assert_equal( [0,1,2], a.every - 1 )
-      assert_equal( ['1','2','3'], a.every.to_s )
-    end
-
-    def test_every!
-      a = [1,2,3]
-      a.every! + 3
-      assert_equal( [4,5,6], a )
-    end
-
-  end
-
-=end

data/lib/facets/more/enumerablepass.rb

@@ -1,277 +0,0 @@
-# = enumerablepass.rb
-#
-# == Copyright (c) 2004 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.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2006 Thomas Sawyer
-# License::   Ruby License
-
-require 'enumerator'
-
-# = EnumerablePass
-#
-# This is a simple reimplementation of the core Enumerable module
-# to allow the methods to take and pass-on arbitrary arguments to the
-# underlying #each call. This library uses Enumerator and scans
-# Enumerable so it can alwasy stay in sync.
-#
-# NOTE Any Enumerable method with a negative arity cannot do pass arguments
-# due to ambiguity in the argument count. So the methods #inject and #zip
-# do NOT work this way, but simply work as they do in Enumerable.
-# The method #find (and #detect) though has been made to work by removing
-# its rarely used optional parameter and providing instead an optional
-# keyword parameter (:ifnone => ...). Please keep these difference in mind.
-#
-# == Synopsis
-#
-#   class T
-#     include EnumerablePass
-#     def initialize(arr)
-#       @arr = arr
-#     end
-#     def each(n)
-#       arr.each{ |e| yield(e+n) }
-#     end
-#   end
-#
-#   t = T.new([1,2,3])
-#   t.collect(4)
-#   #=> [5,6,7]
-#
-
-module EnumerablePass
-
-  def self.wrap_enumerable_method( methodname )
-
-    m = methodname
-    meth = Enumerable.instance_method(m)
-    arity = meth.arity
-
-    case arity <=> 0
-    when 0
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each, *args).#{m}( &yld )
-        end
-      }
-    when 1
-      class_eval %{
-        def #{m}( *args, &yld )
-          args, each_args = args[0...#{arity}], args[#{arity}..-1]
-          enum_for(:each, *each_args).#{m}( *args, &yld )
-        end
-      }
-    else
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each).#{m}( *args, &yld )
-        end
-      }
-    end
-  end
-
-  Enumerable.instance_methods(false).each do |m|
-    wrap_enumerable_method( m )
-  end
-
-  # Make exception for #find (a negative arity method) to accept
-  # keyword argument.
-  #
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #
-  def find(*args, &yld)  # future use **keys ?
-    if Hash === args.last and args.last.key?(:ifnone)
-      ifnone = args.last.delete(:ifnone)
-      args.pop if args.last.empty?
-      enum_for(:each, *args).find( ifnone, &yld )
-    else
-      enum_for(:each, *args).find( &yld )
-    end
-  end
-  alias_method :detect, :find
-
-end
-
-
-=begin  OLD CODE
-module EnumerableArgs
-
-  def collect(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << yield(n) }
-    a
-  end
-  alias_method( :map, :collect )
-
-  def detect(*args)  # :yield:
-    each(*args){ |n| return n if yield(n) }
-    nil
-  end
-  alias_method( :find, :detect )
-
-  def each_with_index(*args)
-    i=0
-    each(*args){ |*n| n << i; yield(*n); i+=1 }
-    self
-  end
-
-  def to_a(*args)
-    a = []
-    each(*args){ |n| a << n }
-    a
-  end
-  alias_method( :entries, :to_a )
-
-  # An additional method not part of standard Enumerable.
-  # The regular version of this method can be found in Facets,
-  # but it is a bit more advanced then this one.
-  # At some point they need to be put into sync.
-  def each_slice(*args, &yld)
-    a = []; s = []
-    ar = yld.arity.abs
-    each(*args){ |n|
-      s << n
-      if s.length >= ar
-        yld.call(*s)
-        s = []
-      end
-    }
-    a
-  end
-  alias_method( :each_by, :each_slice ) 
-
-  def select(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << n if yield(n) }
-    a
-  end
-  alias_method( :find_all, :select )
-
-  def grep(pattern, *args)
-    a = []
-    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
-    a
-  end
-
-  def include?(anObj, *args)
-    each(*args){ |n| return true if anObj == n }
-    false
-  end
-  alias_method( :member?, :include? )
-
-  def max(*args)
-    to_a(*args).max
-  end
-
-  def min(*args)
-    to_a(*args).min
-  end
-
-  def reject(*args)
-    a = []
-    each(*args){ |n| a << n if ! yield(n) }
-    a
-  end
-
-  def sort(*args)
-    # TODO
-  end
-
-end
-=end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  # fixture
-
-  class PlusArray
-    include EnumerablePass
-    def initialize(arr)
-      @arr = arr
-    end
-    def each(n=0)
-      @arr.each{ |e| yield(e+n) }
-    end
-  end
-
-  class TC_Enumerable < Test::Unit::TestCase
-
-    def test_collect
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,6,7], t.collect(4){ |e| e } )
-    end
-
-    #def test_each_slice
-    #  t = PlusArray.new([1,2,3,4])
-    #  a = []
-    #  t.each_slice(2,4){ |e,f| a << [e,f] }
-    #  assert_equal( [[5,6],[7,8]], a )
-    #end
-
-    #def test_find
-    #  t = PlusArray.new([1,2,3,4])
-    #  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
-    #  assert_equal(:NOPE, f)
-    #end
-
-    def test_grep
-      # TODO
-    end
-
-    def test_to_a
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,6,7], t.to_a(4) )  
-    end
-
-    def test_min
-      t = PlusArray.new([1,2,3])
-      assert_equal( 5, t.min(4) )
-    end
-
-    def test_max
-      t = PlusArray.new([1,2,3])
-      assert_equal( 7, t.max(4) )
-    end
-
-    def test_include?
-      t = PlusArray.new([1,2,3])
-      assert( t.include?(7,4) )
-    end
-
-    def test_select
-      t = PlusArray.new([1,2,3])
-      assert_equal( [6], t.select(4){ |x| x == 6 } )
-    end
-
-    def test_reject
-      t = PlusArray.new([1,2,3])
-      assert_equal( [5,7], t.reject(4){ |x| x == 6 } )
-    end
-
-  end
-
-=end

data/lib/facets/more/eventhook.rb

@@ -1,113 +0,0 @@
-######################################
-# WARNING! Highly expiremental code! #
-######################################
-# = eventhook.rb
-#
-# == Copyright (c) 2004 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.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-#
-
-# =  Exception-based Event Hooks
-#
-# Provides an Event Hooks system designed on top of
-# Ruby's built-in Exception system.
-#
-# == Example
-#
-#   def dothis2
-#     puts 'pre'
-#     hook :quitit
-#     puts 'post'
-#   end
-#
-#   def tryit2
-#     begin
-#       puts "BEFORE"
-#       dothis2
-#       puts "AFTER"
-#     rescue EventHook
-#       event :quitit do
-#         puts "HERE"
-#       end
-#     end
-#   end
-#
-#   tryit2
-#
-
-class EventHook < Exception
-  attr_reader :name, :cc
-  def initialize(name, cc)
-    @name = name
-    @cc = cc
-  end
-  def call
-    @cc.call
-  end
-end
-
-module Kernel
-  def hook(sym)
-    callcc{ |c| raise EventHook.new(sym, c) }
-  end
-  def event(sym)
-    if $!.name == sym
-      yield
-      $!.call
-    end
-  end
-end
-
-
-#
-# Test
-#
-
-=begin
-
-  require 'test/unit'
-
-  class TestEventHook < Test::Unit::TestCase
-
-    class T
-      attr_reader :a
-      def dothis
-        @a << '{'
-        hook :here
-        @a << '}'
-      end
-      def tryit
-        @a = ''
-        begin
-          @a << "["
-          dothis
-          @a << "]"
-        rescue EventHook
-          event :here do
-            @a << "HERE"
-          end
-        end
-      end
-    end
-
-    def test_run
-      t = T.new
-      t.tryit
-      assert_equal('[{HERE}]', t.a)
-    end
-
-  end
-
-=end