facets 1.1.0 → 1.2.0

data/lib/facets/core/fileutils/split_all.rb

@@ -0,0 +1,29 @@
+
+module FileUtils
+
+  module_function
+
+  # Splits a file path into an array of individual path components.
+  # This differs from <tt>File.split</tt>, which divides the path into
+  # only two parts, directory path and basename.
+  #
+  #   split_all("a/b/c") =>  ['a', 'b', 'c']
+  #
+  def split_all(path)
+    head, tail = File.split(path)
+    return [tail] if head == '.' || tail == '/'
+    return [head, tail] if head == '/'
+    return split_all(head) + [tail]
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO
+

data/lib/facets/core/fileutils/tail.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/fileutils/slice'

data/lib/facets/core/fileutils/wc.rb

@@ -0,0 +1,128 @@
+#--
+# Credit goes to Daniel J. Berger.
+#++
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  # With no arguments, returns a four element array consisting of the number
+  # of bytes, characters, words and lines in _filename_, respectively.
+  #
+  # Valid options are <tt>bytes</tt>, <tt>characters</tt> (or just 'chars'),
+  # <tt>words</tt> and <tt>lines</tt>.
+  #
+  #   # Return the number of words in 'myfile'
+  #   FileUtils.wc("myfile",'words')  
+  #
+  def wc(filename,option='all')
+    option.downcase!
+    valid = %w/all bytes characters chars lines words/
+
+    unless valid.include?(option)
+        raise "Invalid option: '#{option}'"
+    end
+
+    n = 0
+    if option == 'lines'
+        IO.foreach(filename){ n += 1 }
+        return n
+    elsif option == 'bytes'
+        File.open(filename){ |f|
+          f.each_byte{ n += 1 }
+        }
+        return n
+    elsif option == 'characters' || option == 'chars'
+        File.open(filename){ |f|
+          while f.getc
+              n += 1
+          end
+        }
+        return n
+    elsif option == 'words'
+        IO.foreach(filename){ |line|
+          n += line.split.length
+        }
+        return n
+    else
+        bytes,chars,lines,words = 0,0,0,0
+        IO.foreach(filename){ |line|
+          lines += 1
+          words += line.split.length
+          chars += line.split('').length
+        }
+        File.open(filename){ |f|
+          while f.getc
+              bytes += 1
+          end
+        }
+        return [bytes,chars,words,lines]
+    end
+  end # def
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  # FIND TEST DIRECTORY
+  paths = File.expand_path(File.dirname(__FILE__)).split('/')
+  paths.size.downto(1) do |i|
+    f = (paths.slice(0..i)+['test']).join('/')
+    $TESTDIR = File.join(f,'FIXTURE') if File.directory?(f)
+  end
+  raise unless $TESTDIR
+
+  class TC_FileUtils_WC < Test::Unit::TestCase
+
+    def setup
+      @workdir = Dir.getwd
+      @thisdir = $TESTDIR
+
+      @file = 'test_file.txt'
+    end
+
+    def test_method
+      assert_respond_to( FileUtils, :wc )
+    end
+
+    def test_wc
+      Dir.chdir @thisdir
+      begin
+        assert_nothing_raised{ FileUtils.wc(@file) }
+        assert_nothing_raised{ FileUtils.wc(@file,'bytes') }
+        assert_nothing_raised{ FileUtils.wc(@file,'chars') }
+        assert_nothing_raised{ FileUtils.wc(@file,'words') }
+        assert_nothing_raised{ FileUtils.wc(@file,'lines') }
+        assert_raises(RuntimeError){ FileUtils.wc(@file,'bogus') }
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+    def test_wc_results
+      Dir.chdir @thisdir
+      begin
+        assert_equal([166,166,25,25],FileUtils.wc(@file))
+        assert_equal(166,FileUtils.wc(@file,'bytes'),"Wrong number of bytes")
+        assert_equal(166,FileUtils.wc(@file,'chars'),"Wrong number of chars")
+        assert_equal(25,FileUtils.wc(@file,'words'),"Wrong number of words")
+        assert_equal(25,FileUtils.wc(@file,'lines'),"Wrong number of lines")
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+  end
+
+=end

data/lib/facets/core/fileutils/whereis.rb

@@ -0,0 +1,76 @@
+#--
+# Credit goes to Daniel J. Berger, via PTools.
+#++
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  if defined?(Win32Exts)
+    Win32Exts ||= %w{.exe .com .bat}
+  else
+    Win32Exts = %w{.exe .com .bat}
+  end
+
+  # In block form, yields each ((*program*)) within ((*path*)).  In non-block
+  # form, returns an array of each ((*program*)) within ((*path*)).  Returns
+  # (({nil})) if not found.
+  #
+  # On the MS Windows platform, it looks for executables ending with .exe,
+  # .bat and .com, which you may optionally include in the program name.
+  #
+  #    File.whereis("ruby") -> ['/usr/local/bin/ruby','/opt/bin/ruby']
+  #
+  def whereis(prog, path=ENV['PATH']) #:yield:
+    dirs = []
+    path.split(File::PATH_SEPARATOR).each{|dir|
+        # Windows checks against specific extensions
+        if File::ALT_SEPARATOR
+          if prog.include?('.')
+              f = File.join(dir,prog)
+              if File.executable?(f) && !File.directory?(f)
+                if block_given?
+                    yield f.gsub(/\//,'\\')
+                else
+                    dirs << f.gsub(/\//,'\\')
+                end
+              end
+          else
+              Win32Exts.find_all{|ext|
+                f = File.join(dir,prog+ext)
+                if File.executable?(f) && !File.directory?(f)
+                    if block_given?
+                      yield f.gsub(/\//,'\\')
+                    else
+                      dirs << f.gsub(/\//,'\\')
+                    end
+                end
+              }
+          end
+        else
+          f = File.join(dir,prog)
+          # Avoid /usr/lib/ruby, for example
+          if File.executable?(f) && !File.directory?(f)
+              if block_given?
+                yield f
+              else
+                dirs << f
+              end
+          end
+        end
+    }
+    dirs.empty? ? nil : dirs
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/facets/core/fileutils/which.rb

@@ -0,0 +1,117 @@
+#--
+# Credit goes to Daniel J. Berger, via PTools.
+#++
+
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  if defined?(Win32Exts)
+    Win32Exts ||= %w{.exe .com .bat}
+  else
+    Win32Exts = %w{.exe .com .bat}
+  end
+
+  # Looks for the first occurrence of _program_ within _path_.
+  #
+  # On the MS Windows platform, it looks for executables ending with .exe,
+  # .bat and .com, which you may optionally include in the program name.
+  # Returns <tt>nil</tt> if not found.
+  #
+  #--
+  # The which() method was adopted from Daniel J. Berger, via PTools 
+  # which in in turn was adopted fromt the FileWhich code posted by 
+  # Michael Granger on http://www.rubygarden.org.
+  #++
+  def which(prog, path=ENV['PATH'])
+    path.split(File::PATH_SEPARATOR).each {|dir|
+      # Windows checks against specific extensions
+      if File::ALT_SEPARATOR
+        ext = Win32Exts.find{|ext|
+          if prog.include?('.') # Assume extension already included
+            f = File.join(dir,prog)
+          else
+            f = File.join(dir,prog+ext)
+          end
+          File.executable?(f) && !File.directory?(f) 
+        }
+        if ext
+          # Use backslashes, not forward slashes
+          if prog.include?('.') # Assume extension already included
+            f = File.join( dir, prog ).gsub(/\//,'\\')
+          else
+            f = File.join( dir, prog + ext ).gsub(/\//,'\\')
+          end
+          return f
+        end
+      else
+        f = File.join(dir,prog)
+        # Avoid /usr/lib/ruby, for example
+        if File.executable?(f) && !File.directory?(f)
+          return File::join( dir, prog )
+        end
+      end
+    }
+    nil
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+  require 'rbconfig'
+
+  # FIND TEST DIRECTORY
+  paths = File.expand_path(File.dirname(__FILE__)).split('/')
+  paths.size.downto(1) do |i|
+    f = (paths.slice(0..i)+['test']).join('/')
+    $TESTDIR = File.join(f,'FIXTURE') if File.directory?(f)
+  end
+  raise unless $TESTDIR
+
+  class TC_FileUtils_Which < Test::Unit::TestCase
+    include Config
+
+    def setup
+      @workdir = Dir.getwd
+      @thisdir = $TESTDIR
+
+      @expected_ruby_exe = File.join( CONFIG['bindir'], CONFIG['ruby_install_name'] )
+      if File::ALT_SEPARATOR
+          @expected_ruby_exe.gsub!(/\//,'\\')
+          @expected_ruby_exe += ".exe"
+      end
+    end
+
+    def test_method
+      assert_respond_to( FileUtils, :which )
+    end
+
+    # which
+
+    def test_which
+      Dir.chdir @thisdir
+      begin
+        ruby_exe = nil
+        assert_nothing_raised { ruby_exe = FileUtils.which(CONFIG['ruby_install_name']) }
+        assert_equal(@expected_ruby_exe, ruby_exe)
+        assert_equal(nil, FileUtils.which("blahblah"))
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+  end
+
+=end

data/lib/facets/core/float.rb

@@ -0,0 +1,3 @@
+require 'facets/core/float/approx'
+require 'facets/core/float/round_at'
+require 'facets/core/float/round_to'

data/lib/facets/core/float/approx.rb

@@ -0,0 +1,42 @@
+require 'facet/float/round_to'
+
+class Float
+  # Determines if another number is approximately equal
+  # within a given _n_th degree. Defaults to 100ths
+  # if the degree is not specified.
+  def approx?( x, n=0.01 )
+    return(self == x) if n == 0
+    self.round_to(n) == x.to_f.round_to(n)
+  end
+end
+
+class Numeric
+  # To properly support Float#approx?,
+  # Numeric must also be augmented.
+  def approx?(*args)
+    self.to_f.approx?(*args)
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCFloat < Test::Unit::TestCase
+
+    def test_approx?
+      f = 10.006
+      assert( f.approx?(10.01) )
+      assert( f.approx?(10, 0.1) )
+    end
+
+  end
+
+=end

data/lib/facets/core/float/round_at.rb

@@ -0,0 +1,72 @@
+
+class Float
+  alias_method :round_off, :round
+
+  # Rounds to the given decimal position.
+  #
+  #   4.555.round_at(0)  #=> 5.0
+  #   4.555.round_at(1)  #=> 4.6
+  #   4.555.round_at(2)  #=> 4.56
+  #   4.555.round_at(3)  #=> 4.555
+  #
+  def round_at( d ) #d=0
+    (self * (10.0 ** d)).round_off.to_f / (10.0 ** d)
+  end
+end
+
+class Numeric
+  # To properly support Float's rounding methods,
+  # Numeric must also be augmented.
+  def round_at(*args)
+    self.to_f.round_at(*args)
+  end
+end
+
+class Integer
+  # To properly support Float's rounding methods,
+  # Integer must also be augmented.
+  def round_at(*args)
+    self.to_f.round_at(*args)
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCFloat < Test::Unit::TestCase
+
+    def setup
+      @f0 = [ 0, 10, 15, 105 ]
+      @f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+    end
+
+    def test_round_at_arg1
+      fr = @f0.collect{ |f| f.round_at(1) }
+      assert_equal( [0,10,15,105], fr )
+      fr = @f1.collect { |f| f.round_at(1) }
+      assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+    end
+
+    def test_round_at_arg2
+      fr = @f0.collect { |f| f.round_at(2) }
+      assert_equal( [0,10,15,105], fr )
+      fr = @f1.collect { |f| f.round_at(2) }
+      assert_equal( [10.1,10.01,10.9,10.09,10.5,10.05,10.49], fr )
+    end
+
+    def test_round_off
+      assert_equal( 1.0, 1.2.round_off )
+      assert_equal( 2.0, 1.8.round_off )
+    end
+
+  end
+
+=end