facets 1.7.46 → 1.8.0

data/work/core/array/at_rand.rb

@@ -0,0 +1,95 @@
+class Array
+
+  # Return an array element at random.
+  #
+  #   require 'facet/array/at_rand'
+  #
+  #   [1,2,3,4].at_rand     #=> 1
+  #   [1,2,3,4].at_rand     #=> 4
+  #   [1,2,3,4].at_rand(1)  #=> [4]
+  #   [1,2,3,4].at_rand(3)  #=> [2,2,1]
+  #   [1,2,3,4].at_rand(3)  #=> [3,2,4]
+  #
+#   def at_rand(n=nil, exclusive=false)
+#     if n
+#       n = n.to_i
+#       if exclusive
+#         return dup if n >= length
+#         return sort_by{Kernel.rand}[0..n]
+#       else
+#         idx = []
+#         n.times do
+#           idx << Kernel.rand(self.size)
+#         end
+#         return values_at(*idx)
+#       end
+#     else
+#       return at( Kernel.rand(self.size) )
+#     end
+#   end
+
+  def at_rand(n=nil, exclusive=false)
+    if n
+      return values_at(*rand_index(n, :exclusive))
+    else
+      return at(Kernel.rand(length))
+    end
+  end
+  alias_method(:at_random, :at_rand)
+
+
+  def pick(n)
+  
+  end
+
+
+  # Return random index or indexes of an array. If a number
+  # of indexes _n_ is given, an array of indexes is returned.
+  # This in non-exlusive and may pick the same index more than
+  # once.
+  #
+  #   ["a", "b", "c"].rand_index          #=> "a" (or "b", or "c")
+  #   ["a", "b", "c"].rand_index(2)       #=> ["a","b"]  
+  #   ["a", "b", "c"].rand_index(3)       #=> ["a","b","b"]
+  #
+  def rand_index(n=nil)
+    if n
+      n = n.to_i 
+      if exclusive
+        idx = (0...size).to_a
+        return idx if n >= length
+        return idx.sort_by{Kernel.rand}.slice(0,n)
+      else
+        idx = []
+        n.times{ idx << Kernel.rand(self.length) }
+        return idx
+      end
+    else
+      return Kernel.rand(size)
+    end
+  end
+
+  # Pick and return a random index or indexes of array.
+  # If a number of indexes _n_ is given, an array of indexes
+  # is returned. Unlike #rand_index, #pick_index is exclusive
+  # and will not pick the same index twice. If _n_ exceeds
+  # the size of the array, all elements are returned.
+  #
+  #   ["a", "b", "c"].pick_index          #=> "a" (or "b", or "c")
+  #   ["a", "b", "c"].pick_index(2)       #=> ["a","b"]  
+  #   ["a", "b", "c"].pick_index(3)       #=> ["a","b","c"]
+  #
+  #
+  def pick_index(n=nil)
+    if n
+      n = n.to_i
+      idx = (0...size).to_a
+      return idx if n >= length
+      return idx.sort_by{Kernel.rand}.slice(0,n)
+    else
+      return Kernel.rand(size)
+    end
+  end
+
+end
+

data/work/core/array/each_slice.rb

@@ -0,0 +1,23 @@
+# DEPRECATE. THIS IS INCLUDED IN ENUMERABLE NOW.
+class Array
+  # Iterates over +n+ elements at a time. If +n+ is
+  # not given then the arity of the block determines the 
+  # slicing quantity.
+  #
+  #   require 'facet/array/each_slice'
+  #
+  #   [1, 2, 3, 4].each_slice(2){ |a,b| ... }
+  #
+  # Enumerable#each_slice offers the same functionality 
+  # but this is a more efficient implementation specifically
+  # for the Array.
+  def each_slice(n=nil, &yld)
+    n = yld.arity.abs unless n
+    i=0
+    while i < self.length
+      yld.call(*self.slice(i,n))
+      i+=n
+    end
+  end
+  alias_method( :each_by, :each_slice )
+end

data/work/core/array/pick_values.rb

@@ -0,0 +1,32 @@
+
+class Array
+
+  # Pick out _n_ random elements from the array.
+  # If _n_ is not given then picks out a single 
+  # element.
+  #
+  #   require 'facet/array/pick'
+  #
+  #   a = ["a", "b", "c", "d", "e"]
+  #   a.pick             #=> "b"
+  #   a                  #=> ["a", "c", "d", "e"]
+  #   a.pick(2)          #=> ["a", "e"]
+  #   a                  #=> ["c", "d"]
+  #
+  def pick(n=nil)
+    if n
+      n = n.to_i
+      all = (0..size).to_a
+      idx = pick_indexes(n)
+      vals = values_at(*idx)
+      replace( values_at( *(all - idx) )
+      return vals
+    else
+      i = Kernel.rand(size)
+      v = at(i)
+      delete_at(i)
+      return v
+    end
+  end
+
+end 

data/work/core/array/rand_indexes.rb

@@ -0,0 +1,33 @@
+class Array
+
+  # Return random number indexes of an Array. If the _number_
+  # of elements is set to <tt>nil</tt>, the default, then
+  # returns a random number of indicies up to the size of the
+  # array.
+  #
+  # When _exclusive_ is <tt>true</tt> (the default) and the 
+  # _number_ given is greater than the size of the array,
+  # then all indexes are returned.
+  #
+  #   ["a", "b", "c", "d"].rand_indexes           #=> [1]
+  #   ["a", "b", "c", "d"].rand_indexes           #=> [2,4]
+  #   ["a", "b", "c", "d"].rand_indexes(2)        #=> [2,1]
+  #   ["a", "b", "c", "d"].rand_indexes(3)        #=> [1,3,2]
+  #   ["a", "b", "c", "d"].rand_indexes(3,false)  #=> [4,3,4]
+  #
+  def rand_indexes( number=nil, exclusive=true )
+    n = rand( size ) unless number
+    n = number.to_int
+    if exclusive
+      idx = (0...size).to_a
+      return idx if number >= size
+      return idx.sort_by{rand}.slice(0,n)
+    else
+      a = []
+      n.times{ a << rand(size) }
+      a
+    end
+  end
+  alias_method :rand_indicies, :rand_indexes
+
+end

data/work/core/binding/class.rb

@@ -0,0 +1,11 @@
+class Binding
+  # Returns the class in the binding context
+  # this is just a shortcut for self.class
+  # You can still get to the old class (of the binding)
+  # via #__class__. (NOTE: Is this really a good idea?)
+  alias_method( :__class__, :class ) unless respond_to?( :__class__ )
+  def class()
+    @class ||= eval( "self.class" )
+    @class
+  end
+end 

data/work/core/binding/delegate-binding.rb

@@ -0,0 +1,19 @@
+
+class Binding
+  # All missing methods delegate to binding's eval(self).
+  #--
+  # This is an expiremental idea.
+  #++
+  def delegate!
+    (class << self; self; end).class_eval {
+      #alias_method( :method_missing_without_delegate, :method_missing )
+      def method_missing(sym, *args, &blk)
+        if send(:self).respond_to?(sym)
+          send(:self).send(sym, *args, &blk)
+        else
+          super
+        end
+      end
+    }
+  end
+end

data/work/core/binding/delegate.rb

@@ -0,0 +1,15 @@
+require 'facet/binding/binding' # This comes with the whole nine yards.
+class Binding
+  # All missing methods delegate to binding's self.
+  #--
+  # (is this a good idea, or not?)
+  #++
+  alias_method( :method_missing_without_delegate, :method_missing )
+  def method_missing(sym, *args, &blk)
+    if send(:self).respond_to?(sym)
+      send(:self).send(sym, *args, &blk)
+    else
+      method_missing_without_delegate
+    end
+  end
+end

data/work/core/binding/proc.rb

@@ -0,0 +1,6 @@
+class Binding
+  # Returns the Proc that was active, if any, when the binding was created
+  #def proc() ... ??? ...
+end
+
+ 

data/work/core/class/to_module.rb

@@ -0,0 +1,3 @@
+# stub
+require 'facets/core/module/to_module.rb'
+

data/work/core/enumerable/op_fetch.rb

@@ -0,0 +1,30 @@
+
+module Enumerable
+  def [](*args)
+    arr = self.to_a
+    r = []    
+    args.each{ |arg|
+      case arg
+      when Proc
+        r.concat arr.find_all &arg
+      when Range
+        r.concat arr[arg]
+      when Numeric
+        r << arr[arg]
+      else
+        raise ArgumentError, "Invalid enumeration"
+        #super if defined? super
+      end
+    }
+    r
+  end
+end
+
+
+# --- test ---
+
+if $0 == __FILE__
+
+  p ("a".."z")[2,5,3..4]
+  
+end

data/work/core/fileutils/cptouch.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+from_dir = ARGV[0]
+to_dir = ARGV[1]
+
+from_files = []
+Dir.chdir(from_dir) do 
+  from_files = Dir.glob( '**/*' )
+end
+
+from_files.each{ |f|
+  ffile = File.join( from_dir, f )
+  tfile = File.join( to_dir, f )
+  if File.exist?( tfile )
+    #stmp = File.mtime( ffile ).strftime("%Y%m%d%H%M")
+    File.utime( File.atime(ffile), File.mtime(ffile), tfile )
+    #system %{touch -t #{stmp} #{tfile}}
+  end
+}
+

data/work/core/fileutils/nl_convert.rb

@@ -0,0 +1,133 @@
+
+# Credit goes to Daniel J. Berger, via PTools.
+# The nl_convert() method was adopted (somewhat) from the nlcvt program
+# found at http://www.perl.com/language/ppt/src/nlcvt/nlcvt, written by
+# Tom Christiansen.
+
+class FileUitls
+
+  # Converts a text file from one OS platform format to another, ala
+  # ((*dos2unix*)).  Valid values for ((*format*)), which are case insensitve,
+  # includes:
+  #
+  # * MS Windows -> dos, windows, win32
+  # * Unix/BSD   -> unix, linux, bsd
+  # * Mac        -> mac, macintosh, apple, osx
+  #
+  # Note that this method is only valid for an ftype of "file".  Otherwise a
+  # TypeError will be raised.  If an invalid format value is received,
+  # StandardError is raised.
+  #
+  #   # Creates a copy of 'myfile' called 'newfile', in DOS format
+  #   File.nl_convert("myfile","newfile","dos")
+  #
+  # (Note: Looking to improve.)
+
+  def self.nl_convert(old_file,new_file=old_file,platform="dos")
+
+    unless File.ftype(old_file) == "file"
+        raise TypeError, "Only valid for plain text files"
+    end
+
+    if platform =~ /dos|windows|win32/i
+        format = "\cM\cJ"
+    elsif platform =~ /unix|linux|bsd/i
+        format = "\cJ"
+    elsif platform =~ /mac|apple|macintosh|osx/i
+        format = "\cM"
+    else
+        raise StandardError, "Invalid platform string"
+    end
+
+    orig = $\
+    $\ = format
+
+    if old_file == new_file
+        require "ftools"
+        require "tempfile"
+        tf = Tempfile.new("temp")
+        tf.open
+        IO.foreach(old_file){ |line|
+          line.chomp!
+          tf.print line
+        }
+        tf.close
+        File.delete(old_file)
+        File.copy(tf.path,old_file)
+    else
+        nf = File.new(new_file,"w+")  
+        IO.foreach(old_file){ |line|
+          line.chomp!
+          nf.print line
+        }
+        nf.close
+    end
+
+    $\ = orig
+  end
+
+end
+
+
+
+=begin
+
+require 'test/unit'
+require 'ftools'
+
+class TC_FileNLConvert < Test::Unit::TestCase
+
+   @@tfile   = 'test_file.txt'
+   @@tfile2  = 'test_file2.txt'
+   @@dosfile = 'dos_test_file.txt'
+   @@macfile = 'mac_test_file.txt'
+   @@nixfile = 'nix_test_file.txt'
+
+   def test_01_method_responds
+      assert_respond_to( File, :nl_convert )
+   end
+
+   def test_02_constructor
+      assert_nothing_raised{ File.nl_convert(@@tfile2) }
+      assert_nothing_raised{ File.nl_convert(@@tfile2,@@tfile2) }
+      assert_nothing_raised{ File.nl_convert(@@tfile2,@@tfile2,"unix") }
+      File.copy(@@tfile,@@tfile2)
+   end
+
+   def test_03_dos
+      assert_nothing_raised{ File.nl_convert(@@tfile,@@dosfile,'dos') }
+      err = "dos file should be larger, but isn't"
+      assert_equal(true, File.size(@@dosfile) > File.size(@@tfile),err)
+   end
+   
+   def test_04_nix
+      assert_nothing_raised{ File.nl_convert(@@tfile,@@nixfile,'unix') }
+      err = "unix file should be the same size (or smaller), but isn't"
+      if File::ALT_SEPARATOR
+         assert_equal(true, File.size(@@nixfile) >= File.size(@@tfile),err)
+      else
+         assert_equal(true, File.size(@@nixfile) <= File.size(@@tfile),err)
+      end
+   end
+   
+   # May fail on MS Windows - no idea why
+   def test_05_mac
+      assert_nothing_raised{ File.nl_convert(@@tfile,@@macfile,'mac') }
+      err = "mac file should be the same size (or larger), but isn't"
+      assert_equal(true, File.size(@@macfile) >= File.size(@@tfile),err)
+   end
+
+   def test_06_exceptions
+      assert_raises(StandardError){ File.nl_convert(@@tfile,"bogus.txt","blah") }
+   end
+
+   def teardown
+      [@@dosfile,@@macfile,@@nixfile].each{ |f|
+         File.delete(f) if File.exists?(f)
+      }
+   end
+end
+
+=end
+
+

data/work/core/io/expect.rb

@@ -0,0 +1,127 @@
+
+require 'timeout'  # for TimeoutError
+
+class IO
+
+  #
+  #
+  #
+
+  def expect(pat,timeout=60000)
+    buf = ''
+
+    case pat
+    when String
+      e_pat = Regexp.new(Regexp.quote(pat))
+    when Regexp
+      e_pat = pat
+    end
+
+    while true
+      if IO.select([self],nil,nil,timeout).nil? then
+        raise TimeoutError #result = nil
+        break
+      end
+
+      c = getc.chr
+      buf << c
+      if $DEBUG
+        STDOUT.print c ; STDOUT.flush
+      end
+      if mat = e_pat.match(buf) then
+        result = [buf,*mat.to_a[1..-1]]
+        break
+      end
+    end
+
+    if block_given? then
+      yield result
+    else
+      return result
+    end
+
+    nil
+  end
+
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+  #require 'reactor/select_reactor'
+
+  class TCExpect < Test::Unit::TestCase
+
+    def setup
+      #@reactor = SelectReactor.new
+      @read, @write = IO.pipe
+      #@expect = Expect.new(@read, @reactor)
+      #@expect = Expect.new(@read, 1)
+      #@expect.timeout = 1
+    end
+
+    def test_simple
+      @write.puts "TESTING"
+      @read.expect "TESTING"
+    end
+
+    def test_regex
+      @write.puts "TESTING...1...2...3"
+      @read.expect /TESTING/
+    end
+
+    def test_regex2
+      @write.puts "TESTING...1...2...3"
+      @read.expect /\d/
+    end
+
+    def test_timeout
+      @write.puts "TESTING...1...2...3"
+      assert_nil( @read.expect 'X', 0 )
+    end
+
+    def test_unmatched_message
+      @write.puts "TESTING...1...2...3"
+      assert_nil( @read.expect("..........", 1) )
+    end
+
+  #   def test_ignore
+  #     @write.puts "testing"
+  #     @write.puts "ignore"
+  #     @expect.expect "testing"
+  #     @expect.ignore "ignore"
+  #     @expect.run
+  #   end
+  #
+  #   def test_reset
+  #     @write.puts "testing..."
+  #     @expect.expect "testing..."
+  #     @expect.run
+  #
+  #     @expect.reset
+  #     @expect.run
+  #
+  #     @write.puts "test2"
+  #     @expect.expect "test2"
+  #     @expect.run
+  #   end
+  #
+  #   def test_multiple_chains
+  #     @expect.expect "testing...", :chain1
+  #     @expect.expect "hmm...", :chain2
+  #     @write.puts "testing..."
+  #     @write.puts "hmm..."
+  #     @expect.run
+  # 
+  #     @expect.expect "testing...", :chain1
+  #     @expect.expect "hmm...", :chain2
+  #     @write.puts "hmm..."
+  #     @write.puts "testing..."
+  #     @expect.run
+  #   end
+
+  end
+
+=end