core_ex 0.1.0

data/lib/core_ex/filelist.rb

@@ -0,0 +1,464 @@
+# Revision::  $Id: filelist.rb 249 2005-05-31 13:23:42Z ertai $
+
+#--
+# Copyright (c) 2003, 2004 Jim Weirich
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+#
+
+# Contributons by Nicolas Pouillard  <ertai@lrde.epita.fr>.
+
+# Some objects are dupable, some are not.  So we define a version of
+# dup (called rake_dup) that returns self on the handful of classes
+# that are not dupable.
+
+module Kernel
+  # Duplicate an object if it can be duplicated.  If it can not be
+  # cloned or duplicated, then just return the original object.
+  def rake_dup()
+    dup
+  end
+end
+
+[NilClass, FalseClass, TrueClass, Fixnum, Symbol].each do |clazz|
+  clazz.class_eval {
+    # Duplicate an object if it can be duplicated.  If it can not be
+    # cloned or duplicated, then just return the original object.
+    def rake_dup() self end
+  }
+end
+
+######################################################################
+# User defined methods to be added to String.
+#
+class String
+  unless instance_methods.include? "ext"
+    # Replace the file extension with +newext+.  If there is no
+    # extenson on the string, append the new extension to the end.  If
+    # the new extension is not given, or is the empty string, remove
+    # any existing extension.
+    #
+    # +ext+ is a user added method for the String class.
+    def ext(newext='')
+      return self.dup if ['.', '..'].include? self
+      if newext != ''
+ 	newext = (newext =~ /^\./) ? newext : ("." + newext)
+      end
+      dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext
+    end
+  end
+end
+
+
+####################################################################
+# A FileList is essentially an array with a few helper methods
+# defined to make file manipulation a bit easier.
+#
+# FileLists are lazy.  When given a list of glob patterns for
+# possible files to be included in the file list, instead of
+# searching the file structures to find the files, a FileList holds
+# the pattern for latter use.
+#
+# This allows us to define a number of FileList to match any number of
+# files, but only search out the actual files when then FileList
+# itself is actually used.  The key is that the first time an
+# element of the FileList/Array is requested, the pending patterns
+# are resolved into a real list of file names.
+#
+class FileList 
+
+  def clone
+    sibling = self.class.new
+    instance_variables.each do |ivar|
+      value = self.instance_variable_get(ivar)
+      sibling.instance_variable_set(ivar, value.rake_dup)
+    end
+    sibling
+  end
+  alias dup clone
+
+  # == Method Delegation
+  #
+  # The lazy evaluation magic of FileLists happens by implementing
+  # all the array specific methods to call +resolve+ before
+  # delegating the heavy lifting to an embedded array object
+  # (@items).
+  #
+  # In addition, there are two kinds of delegation calls.  The
+  # regular kind delegates to the @items array and returns the
+  # result directly.  Well, almost directly.  It checks if the
+  # returned value is the @items object itself, and if so will
+  # return the FileList object instead.
+  #
+  # The second kind of delegation call is used in methods that
+  # normally return a new Array object.  We want to capture the
+  # return value of these methods and wrap them in a new FileList
+  # object.  We enumerate these methods in the +SPECIAL_RETURN+ list
+  # below.
+
+  # List of array methods (that are not in +Object+) that need to be
+  # delegated.
+  ARRAY_METHODS = Array.instance_methods - Object.instance_methods
+
+  # List of additional methods that must be delegated.
+  MUST_DEFINE = %w[to_a inspect]
+
+  # List of methods that should not be delegated here (we define
+  # special versions of them explicitly below).
+  MUST_NOT_DEFINE = %w[to_a to_ary partition *]
+
+  # List of delegated methods that return new array values which
+  # need wrapping.
+  SPECIAL_RETURN = %w[
+    map collect sort sort_by select find_all reject grep
+    compact flatten uniq values_at
+    + - & |
+  ]
+  
+  DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).sort.uniq
+  
+  # Now do the delegation.
+  DELEGATING_METHODS.each_with_index do |sym, i|
+    if SPECIAL_RETURN.include?(sym)
+      ln = __LINE__+1
+      class_eval %{
+        def #{sym}(*args, &block)
+          resolve if @pending
+          result = @items.send(:#{sym}, *args, &block)
+          FileList.new.import(result)
+        end
+      }, __FILE__, ln
+    else
+      ln = __LINE__+1
+      class_eval %{
+        def #{sym}(*args, &block)
+          resolve if @pending
+          result = @items.send(:#{sym}, *args, &block)
+          result.object_id == @items.object_id ? self : result
+        end
+      }, __FILE__, ln
+    end
+  end
+
+  # Create a file list from the globbable patterns given.  If you
+  # wish to perform multiple includes or excludes at object build
+  # time, use the "yield self" pattern.
+  #
+  # Example:
+  #   file_list = FileList.new['lib/**/*.rb', 'test/test*.rb']
+  #
+  #   pkg_files = FileList.new['lib/**/*'] do |fl|
+  #     fl.exclude(/\bCVS\b/)
+  #   end
+  #
+  def initialize(*patterns)
+    @pending_add = []
+    @pending = false
+    @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+    @exclude_re = nil
+    @items = []
+    patterns.each { |pattern| include(pattern) }
+    yield self if block_given?
+  end
+
+  # Add file names defined by glob patterns to the file list.  If an
+  # array is given, add each element of the array.
+  #
+  # Example:
+  #   file_list.include("*.java", "*.cfg")
+  #   file_list.include %w( math.c lib.h *.o )
+  #
+  def include(*filenames)
+    # TODO: check for pending
+    filenames.each do |fn|
+      if fn.respond_to? :to_ary
+        include(*fn.to_ary)
+      else
+        @pending_add << fn
+      end
+    end
+    @pending = true
+    self
+  end
+  alias :add :include 
+  
+  # Register a list of file name patterns that should be excluded
+  # from the list.  Patterns may be regular expressions, glob
+  # patterns or regular strings.
+  #
+  # Note that glob patterns are expanded against the file system.
+  # If a file is explicitly added to a file list, but does not exist
+  # in the file system, then an glob pattern in the exclude list
+  # will not exclude the file.
+  #
+  # Examples:
+  #   FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
+  #   FileList['a.c', 'b.c'].exclude(/^a/)  => ['b.c']
+  #
+  # If "a.c" is a file, then ...
+  #   FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
+  #
+  # If "a.c" is not a file, then ...
+  #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
+  #
+  def exclude(*patterns)
+    patterns.each do |pat| @exclude_patterns << pat end
+    if ! @pending
+      calculate_exclude_regexp
+      reject! { |fn| fn.to_s =~ @exclude_re }
+    end
+    self
+  end
+
+
+
+  
+  # Clear all the exclude patterns so that we exclude nothing.
+  def clear_exclude
+    @exclude_patterns = []
+    calculate_exclude_regexp if ! @pending
+  end
+
+  # Define equality.
+  def ==(array)
+    to_ary == array
+  end
+
+  # Return the internal array object.
+  def to_a
+    resolve
+    @items
+  end
+
+  # Return the internal array object.
+  def to_ary
+    resolve
+    @items
+  end
+
+  # Redefine * to return either a string or a new file list.
+  def *(other)
+    result = @items * other
+    case result
+    when Array
+      FileList.new.import(result)
+    else
+      result
+    end
+  end
+
+  # Resolve all the pending adds now.
+  def resolve
+    if @pending
+      @pending = false
+      @pending_add.each do |fn| resolve_add(fn) end
+      @pending_add = []
+      resolve_exclude
+    end
+    self
+  end
+
+  def calculate_exclude_regexp
+    ignores = []
+    @exclude_patterns.each do |pat|
+      case pat
+      when Regexp
+        ignores << pat
+      when /[*.]/
+        Dir[pat].each do |p| ignores << p end
+      else
+        ignores << Regexp.quote(pat)
+      end
+    end
+    if ignores.empty?
+      @exclude_re = /^$/
+    else
+      re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|")
+      @exclude_re = Regexp.new(re_str)
+    end
+  end
+
+  def resolve_add(fn)
+    case fn
+    when Array
+      fn.each { |f| self.resolve_add(f) }
+    when %r{[*?]}
+      add_matching(fn)
+    else
+# >>>>
+      self << fn.to_path
+# <<<<
+    end
+  end
+
+  def resolve_exclude
+    @exclude_patterns.each do |pat|
+      case pat
+      when Regexp
+# <<<<
+        reject! { |fn| fn.to_s =~ pat }
+# >>>>
+      when /[*.]/
+# <<<<
+        reject_list = Pathname.glob(pat)
+# >>>>
+        reject! { |fn| reject_list.include?(fn) }
+      else
+# <<<<
+        reject! { |fn| fn.to_s == pat.to_s }
+# >>>>
+      end
+    end
+    self
+  end
+
+  # Return a new FileList with the results of running +sub+ against
+  # each element of the oringal list.
+  #
+  # Example:
+  #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
+  #
+  def sub(pat, rep)
+    inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
+  end
+
+  # Return a new FileList with the results of running +gsub+ against
+  # each element of the original list.
+  #
+  # Example:
+  #   FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
+  #      => ['lib\\test\\file', 'x\\y']
+  #
+  def gsub(pat, rep)
+    inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
+  end
+
+  # Same as +sub+ except that the oringal file list is modified.
+  def sub!(pat, rep)
+    each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
+    self
+  end
+
+  # Same as +gsub+ except that the original file list is modified.
+  def gsub!(pat, rep)
+    each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
+    self
+  end
+
+  # Return a new array with <tt>String#ext</tt> method applied to
+  # each member of the array.
+  #
+  # This method is a shortcut for:
+  #
+  #    array.collect { |item| item.ext(newext) }
+  #
+  # +ext+ is a user added method for the Array class.
+  def ext(newext='')
+    collect { |fn| fn.ext(newext) }
+  end
+
+
+  # FileList version of partition.  Needed because the nested arrays
+  # should be FileLists in this version.
+  def partition(&block)	# :nodoc:
+    resolve
+    result = @items.partition(&block)
+    [
+      FileList.new.import(result[0]),
+      FileList.new.import(result[1]),
+    ]
+  end
+  
+  # Convert a FileList to a string by joining all elements with a space.
+  def to_s
+    resolve if @pending
+    self.join(' ')
+  end
+
+  # Add matching glob patterns.
+  def add_matching(pattern)
+# <<<<
+    Pathname.glob(pattern) do |fn|
+# >>>>
+      self << fn unless exclude?(fn)
+    end
+  end
+  private :add_matching
+
+  # Should the given file name be excluded?
+  def exclude?(fn)
+    calculate_exclude_regexp unless @exclude_re
+# <<<<
+    fn.to_s =~ @exclude_re
+# >>>>
+  end
+
+
+  DEFAULT_IGNORE_PATTERNS = [
+    /(^|[\/\\])CVS([\/\\]|$)/,
+    /(^|[\/\\])\.svn([\/\\]|$)/,
+    /\.bak$/,
+    /~$/,
+    /(^|[\/\\])core$/
+  ]
+  @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+
+  def import(array)
+    @items = array
+    self
+  end
+
+  class << self
+    # Create a new file list including the files listed. Similar to:
+    #
+    #   FileList.new(*args)
+    def [](*args)
+      new(*args)
+    end
+
+    # Set the ignore patterns back to the default value.  The
+    # default patterns will ignore files 
+    # * containing "CVS" in the file path
+    # * containing ".svn" in the file path
+    # * ending with ".bak"
+    # * ending with "~"
+    # * named "core"
+    #
+    # Note that file names beginning with "." are automatically
+    # ignored by Ruby's glob patterns and are not specifically
+    # listed in the ignore patterns.
+    def select_default_ignore_patterns
+      @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+    end
+
+    # Clear the ignore patterns.  
+    def clear_ignore_patterns
+      @exclude_patterns = [ /^$/ ]
+    end
+  end
+
+# <<<<
+  def require
+    each { |x| x.require }
+  end
+# >>>>
+end
+

data/lib/core_ex/fileutils.rb

@@ -0,0 +1,44 @@
+# Copyright: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author: Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: fileutils.rb 249 2005-05-31 13:23:42Z ertai $
+
+require 'fileutils'
+
+module FileUtils
+
+  alias remove_dir_without_chmod remove_dir
+
+  def remove_dir (dir, force = false) #:nodoc:
+    dir = dir.sub(%r</\z>, '')
+    first_time_p = true
+    begin
+      Dir.foreach(dir) do |file|
+        next if /\A\.\.?\z/ =~ file
+        path = "#{dir}/#{file.untaint}"
+        if File.symlink?(path)
+          remove_file path, force
+        elsif File.directory?(path)
+          remove_dir path, force
+        else
+          remove_file path, force
+        end
+      end
+      begin
+        Dir.rmdir dir
+      rescue Errno::ENOENT
+        raise unless force
+      end
+    rescue
+      if first_time_p
+        first_time_p = false
+        File.chmod 0777, dir
+        retry
+      end
+      raise
+    end
+  end
+
+end

data/lib/core_ex/pathname.rb

@@ -0,0 +1,196 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: ertai $
+# $Id: pathname.rb 252 2005-05-31 23:41:42Z ertai $
+
+
+require 'pathname'
+require 'core_ex/embedded_tests'
+require 'core_ex/string'
+
+
+class Pathname
+
+  def ensure_mkdir
+    (mkdir) rescue Errno::EEXIST
+  end
+
+  def ensure_mkpath
+    (mkpath) rescue Errno::EEXIST
+  end
+
+  def extsplit ( aChar='.' )
+    raise ArgumentError, "#{aChar} is not just a char" if aChar.size != 1
+    aChar = Regexp.escape(aChar)
+    to_s =~ /^(.*?)(#{aChar}[^#{aChar}]*)?$/
+    [Pathname.new($1), $2 || '']
+  end
+
+  def cp ( aPath )
+    FileUtils.cp self.to_s, aPath.to_s
+  end
+
+  def cp_r ( aPath )
+    FileUtils.cp_r self.to_s, aPath.to_s
+  end
+
+  def rm
+    FileUtils.rm self.to_s
+  end
+
+  def rm_r
+    FileUtils.rm_r self.to_s
+  end
+
+  def rm_rf
+    FileUtils.rm_rf self.to_s
+  end
+
+  def rm_f
+    FileUtils.rm_f self.to_s
+  end
+
+  # The current ruby's unlink implementation has a bug.
+  def unlink()
+    if FileTest.directory? @path and not FileTest.symlink? @path
+      Dir.unlink @path
+    else
+      File.unlink @path
+    end
+  end
+
+  # Allow this kind of things:
+  #
+  #  root = Pathname.new('/tmp/test')
+  #  foo, bar = 'foo', 'bar'
+  #
+  #  ...
+  #
+  #  (root/foo/bar).each_line do |line|
+  #    ...
+  #  end
+  alias :/ :+
+
+  def to_io
+    @open_mode ||= 'r'
+    open(@open_mode)
+  end
+
+  def to_path
+    self
+  end
+
+  attr_accessor :open_mode
+
+  def require ( *a )
+    if a.empty?
+      RequireSystem.instance.require(self)
+    else
+      Kernel.__require__(*a)
+    end
+  end
+
+  def load ( *a )
+    if a.empty?
+      RequireSystem.instance.load(self)
+    else
+      Kernel.__load__(*a)
+    end
+  end
+
+  def expand_path_with ( directories, extensions=nil )
+    ext = extname
+    exts, dirs = [''], ['']
+    unless extensions.nil?
+      if ext.empty?
+        exts = extensions
+      else
+        unless extensions.include? ext
+          raise ArgumentError, "bad extension `#{ext}' for #{self}"
+        end
+      end
+    end
+   
+    dirs = directories unless absolute?
+      
+    exts.each do |ext|
+      dirs.each do |dir|
+        dir = dir.to_path
+        file = dir + "#{self}#{ext}"
+        return file.expand_path.cleanpath if file.exist?
+      end
+    end
+    return nil
+  end
+
+  module ShortCut
+
+    # Allow to use this sort of constructions:
+    #
+    #  `/path/to/a/file`.open do |f|
+    #    ...
+    #  end
+    def ` ( path )
+      Pathname.new(path)
+    end
+  end
+
+end # class Pathname
+
+
+
+#
+# Unit test suite
+#
+test_section __FILE__ do
+
+
+require 'tempfile'
+
+
+class PathnameExTest < Test::Unit::TestCase
+
+  #
+  # Tests
+  #
+  def test_ensure_dir
+    p = nil
+    begin
+      name = Tempfile.new('pathname')
+      p = Pathname.new(name.path)
+      name.delete
+      assert(! p.directory?, 'no directory')
+      assert_nothing_raised { p.ensure_mkdir }
+      assert(p.directory?, 'directory')
+      assert_nothing_raised { p.ensure_mkdir }
+      assert(p.directory?, 'still directory')
+    ensure
+      p.rmdir unless p.nil?
+    end
+  end
+
+  include Pathname::ShortCut
+
+  def test_simple
+    assert_equal([`path.ext1`, '.ext2'], `path.ext1.ext2`.extsplit)
+    assert_equal([`path`, ''], `path`.extsplit)
+    assert_equal([`path`, '.'], `path.`.extsplit)
+    assert_equal([`path`, '-ext'], `path-ext`.extsplit('-'))
+    assert_equal([`path-ext1`, '-ext2'], `path-ext1-ext2`.extsplit('-'))
+  end
+
+  def test_slash
+    assert_equal(`path/to/a/file`, `path`/'to'/'a'/'file')
+    path, to, a, file = `/path`, 'to', 'a', 'file'
+    assert_equal(`/path/to/a/file`, path/to/a/file)
+  end
+
+  # def test_expand_path_with
+  #   See core_ex/require RequireSystemTest#test_*_search
+  # end
+
+end # class PathnameExTest
+
+end