facets 1.0.2 → 1.0.3

data/packages/core/lib/facet/enumerable/uniq_by.rb

@@ -0,0 +1,39 @@
+
+module Enumerable
+
+  # Like #uniq, but determines uniqueness based on a given block.
+  #
+  #   (-5..5).to_a.uniq_by {|i| i*i }
+  #
+  # produces
+  #
+  #   [-5, -4, -3, -2, -1, 0]
+  #
+  def uniq_by #:yield:
+    h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x}
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCEnumerable < Test::Unit::TestCase
+
+    def test_uniq_by
+      a = [-5, -4, -3, -2, -1, 0]
+      r = (-5..5).to_a.uniq_by{|i| i*i }
+      assert_equal( a, r )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/enumerable/where.rb

@@ -0,0 +1,12 @@
+#--
+# :credit: Sean O'Halpin
+#++
+
+module Enumerable
+
+  def where(&block)
+    self.select{|x| x.instance_eval(&block) }
+  end
+
+end
+

data/packages/core/lib/facet/file.rb

@@ -0,0 +1,5 @@
+require 'facet/file/self/create'
+require 'facet/file/self/open_as_string'
+require 'facet/file/self/read_list'
+require 'facet/file/self/sanitize'
+require 'facet/file/self/split_all'

data/packages/core/lib/facet/file/self/create.rb

@@ -0,0 +1,52 @@
+#--
+# Copyright (c) 2005 George Moschovitis <gm@navel.gr>
+#++
+
+# Creates a new file, or overwrites an existing file,
+# and writes a string into it. Can also take a block
+# just like File#open, which is yielded _after_ the
+# string is writ.
+#
+#   str = 'The content for the file'
+#   File.create('myfile.txt', str)
+#
+def File.create(path, str='', &blk)
+  File.open(path, 'w') { |f|
+    f << str
+    blk.call(f) if blk
+  }
+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_CREATE < Test::Unit::TestCase
+
+    def test_create
+      f = File.join( $TESTDIR, 'create_file' )
+      t = 'This is a test'
+      File.create( f, t )
+      assert( File.exists?( f ) )
+      s = File.read( f )
+      assert_equal( t, s )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/file/self/open_as_string.rb

@@ -0,0 +1,81 @@
+
+# Opens a file as a string and writes back the string to the file at
+# the end of the block.
+#
+# Returns the number of written bytes or +nil+ if the file wasn't
+# modified.
+#
+# Note that the file will even be written back in case the block
+# raises an exception.
+#
+# Mode can either be "b" or "+" and specifies to open the file in
+# binary mode (no mapping of the plattform's newlines to "\n" is
+# done) or to append to it.
+#
+# Usage:
+#   # Reverse contents of "message"
+#   File.open_as_string("message") { |str| str.reverse! }
+#
+#   # Replace "foo" by "bar" in "binary"
+#   File.open_as_string("binary", "b") { |str| str.gsub!("foo", "bar") }
+#
+def File.open_as_string(name, mode = "")
+  unless block_given?
+    raise(ArgumentError, "Need to supply block to File.open_as_string")
+  end
+
+  if mode.is_a?(Numeric) then
+    flag, mode = mode, ""
+    mode += "b" if flag & File::Constants::BINARY != 0
+    mode += "+" if flag & File::Constants::APPEND != 0
+  else
+    mode.delete!("^b+")
+  end
+
+  str = File.open(name, "r#{mode}") { |file| file.read } rescue ""
+  old_str = str.clone
+
+  begin
+    yield str
+  ensure
+    if str != old_str then
+      File.open(name, "w#{mode}") { |file| file.write(str) }
+    end
+  end
+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_OPEN_AS_STRING < Test::Unit::TestCase
+
+    def test_open_as_string
+      f = File.join( $TESTDIR, 'open_as_string_file' )
+      t = 'This is a test'
+      File.open( f, 'w' ) { |s| s << t }
+      assert( File.exists?( f ) )
+      File.open_as_string(f) { |s| s.reverse! }
+      s = File.read( f )
+      assert_equal( t.reverse, s )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/file/self/read_list.rb

@@ -0,0 +1,47 @@
+
+# Reads in a file, removes blank lines and remarks
+# (lines starting with '#') and then returns
+# an array of all the remaining lines.
+#
+def File.read_list(filepath, chomp_string='')
+  farr = nil
+  farr = File.read(filepath).split("\n")
+  farr.collect! { |line|
+    l = line.strip.chomp(chomp_string)
+    (l.empty? or l[0,1] == '#') ? nil : l
+  }
+  farr.compact
+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_READ_LIST < Test::Unit::TestCase
+
+    def test_read_list
+      f = File.join( $TESTDIR, 'read_list_file' )
+      s = File.read_list( f )
+      r = ['A','B','C']
+      assert_equal( r, s )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/file/self/sanitize.rb

@@ -0,0 +1,50 @@
+
+# Cleans up a filename to ensure it will work on filesystem.
+def File.sanitize(filename)
+  filename = File.basename(filename.gsub("\\", "/")) # work-around for IE
+  filename.gsub!(/[^a-zA-Z0-9\.\-\+_]/,"_")
+  filename = "_#{filename}" if filename =~ /^\.+$/
+  filename
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TCFile < Test::Unit::TestCase
+
+    def test_01_001
+      assert_equal( "This_is_a_test", File.sanitize('This is a test') )
+    end
+
+    def test_01_001
+      assert_equal( "test", File.sanitize('This\is\test') )
+    end
+
+    def test_01_001
+      assert_equal( "test", File.sanitize('This/is/test') )
+    end
+
+    def test_01_001
+      assert_equal( "te_____st", File.sanitize('This/te#$#@!st') )
+    end
+
+    def test_01_001
+      assert_equal( "_.", File.sanitize('.') )
+    end
+
+    def test_01_001
+      assert_equal( "_....", File.sanitize('....') )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/file/self/split_all.rb

@@ -0,0 +1,36 @@
+
+# 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 File.split_all(path)
+  head, tail = File.split(path)
+  return [tail] if head == '.' || tail == '/'
+  return [head, tail] if head == '/'
+  return split_all(head) + [tail]
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCFile < Test::Unit::TestCase
+
+    def test_split_all
+      fp = "this/is/test"
+      assert_equal( ['this', 'is', 'test'], File.split_all(fp) )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/fileutils/head.rb

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

data/packages/core/lib/facet/fileutils/safe_ln.rb

@@ -0,0 +1,38 @@
+#--
+# Credit goes to Jim Weirich
+#++
+
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  LINKING_SUPPORTED = [true]
+
+  # Attempt to do a normal file link, but fall back
+  # to a copy if the link fails.
+  def safe_ln(*args)
+    unless LINKING_SUPPORTED[0]
+      cp(*args)
+    else
+      begin
+        ln(*args)
+      rescue Errno::EOPNOTSUPP
+        LINKING_SUPPORTED[0] = false
+        cp(*args)
+      end
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/packages/core/lib/facet/fileutils/slice.rb

@@ -0,0 +1,152 @@
+
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  # In block form, yields the first number of ((*lines*)) of file ((*filename*)).
+  # In non-block form, it returns an array of the first number of ((*lines*)).
+  #
+  #   # Returns first 10 lines of 'myfile'
+  #   FileUtils.head("myfile")
+  #
+  def head(filename,lines=10) #:yield:
+    a = []
+    IO.foreach(filename){|line|
+        break if lines <= 0
+        lines -= 1
+        if block_given?
+          yield line
+        else
+          a << line
+        end
+    }
+    return a.empty? ? nil : a
+  end
+
+  # In block form, yields the last number of ((*lines*)) of file ((*filename*)).
+  # In non-block form, it returns the lines as an array.
+  #
+  # Note that this method slurps the entire file, so I don't recommend it
+  # for very large files.  If you want an advanced form of ((*tail*)), I
+  # suggest using file-tail, by Florian Frank (available on the RAA).
+  # And no tail -f.
+  #
+  #   # Returns last 3 lines of 'myfile'
+  #   FileUtils.tail("myfile",3)
+  #
+  def tail(filename,lines=10) #:yield
+    IO.readlines(filename).reverse[0..lines-1].reverse
+  end
+
+  # In block form, yields lines ((*from*))-((*to*)).  In non-block form,
+  # returns an array of lines ((*from*))-((*to*)).
+  #
+  #   # Returns lines 8-12 of 'myfile'
+  #   FileUtils.body("myfile",8,12)
+  #
+  #--
+  # Credit goes to Shashank Date, via Daniel Berger.
+  #++
+  def slice(filename,from,to) #:yield:
+    IO.readlines(filename)[from-1..to-1]
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO This test have been remarked out until such time
+#      as a mock FileSystem can be used to test it against.
+
+=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_HeadTail < Test::Unit::TestCase
+
+    def setup
+      @workdir = Dir.getwd
+      @thisdir = $TESTDIR
+
+      @tfile = 'test_file.txt'
+
+      @expected_head1 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+      @expected_head1.push("line6\n","line7\n","line8\n","line9\n","line10\n")
+      @expected_head2 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+
+      @expected_tail1 = ["line16\n","line17\n","line18\n","line19\n","line20\n"]
+      @expected_tail1.push("line21\n","line22\n","line23\n","line24\n","line25\n")
+      @expected_tail2 = ["line21\n","line22\n","line23\n","line24\n","line25\n"]
+
+      @expected_body1 = ["line10\n", "line11\n", "line12\n", "line13\n", "line14\n"]
+      @expected_body1.push("line15\n","line16\n", "line17\n", "line18\n", "line19\n","line20\n")
+      @expected_body2 = ["line14\n","line15\n","line16\n","line17\n","line18\n","line19\n","line20\n"]
+      @expected_body3 = ["line5\n","line6\n","line7\n","line8\n","line9\n","line10\n"]
+    end
+
+    def test_method
+      assert_respond_to( FileUtils, :head )
+      assert_respond_to( FileUtils, :tail )
+      assert_respond_to( FileUtils, :slice )
+    end
+
+    # head
+
+    def test_head
+      Dir.chdir @thisdir
+      begin
+      assert_nothing_raised{ FileUtils.head(@tfile) }
+      assert_nothing_raised{ FileUtils.head(@tfile,5) }
+      assert_equal(@expected_head1,FileUtils.head(@tfile))
+      assert_equal(@expected_head2,FileUtils.head(@tfile,5))
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+    # slice
+
+    def test_slice
+      Dir.chdir @thisdir
+      begin
+        assert_nothing_raised{ FileUtils.slice(@tfile,5,10) }
+        assert_equal(@expected_body3,FileUtils.slice(@tfile,5,10))
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+    # tail
+
+    def test_tail
+      Dir.chdir @thisdir
+      begin
+        assert_nothing_raised{ FileUtils.tail(@tfile) }
+        assert_nothing_raised{ FileUtils.tail(@tfile,5) }
+        assert_equal(@expected_tail1,FileUtils.tail(@tfile))
+        assert_equal(@expected_tail2,FileUtils.tail(@tfile,5))
+      ensure
+        Dir.chdir @workdir
+      end
+    end
+
+  end
+
+=end