facets-glimmer 3.2.0

data/lib/core/facets/exception/raised.rb

@@ -0,0 +1,14 @@
+class Exception
+
+  # Does a block raise an a given +exception+.
+  #
+  def self.raised? #:yeild:
+    begin
+      yield
+      false
+    rescue self
+      true
+    end
+  end
+
+end

data/lib/core/facets/exception/set_message.rb

@@ -0,0 +1,10 @@
+class Exception
+
+  # See exception message.
+  #
+  def set_message(string)
+    @mesg = string.to_s
+  end
+
+end
+

data/lib/core/facets/exception/suppress.rb

@@ -0,0 +1,22 @@
+class Exception
+
+  # Supress errors while executing a block, with execptions.
+  #
+  # CREDIT: David Heinemeier Hansson, Thomas Sawyer
+
+  def self.suppress(*exception_classes)
+    exception_classes.each do |e|
+      unless e < self
+        raise ArgumentError, "exception #{e} not a subclass of #{self}"
+      end
+    end
+    exception_classes = [self] | exception_classes
+    begin
+      yield
+    rescue Exception => e
+      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
+    end
+  end
+
+end
+

data/lib/core/facets/exception.rb

@@ -0,0 +1,4 @@
+require_relative 'exception/detail.rb'
+require_relative 'exception/raised.rb'
+require_relative 'exception/suppress.rb'
+

data/lib/core/facets/file/append.rb

@@ -0,0 +1,14 @@
+class File
+
+  # Append to a file.
+  #
+  # CREDIT: George Moschovitis
+
+  def self.append(file, str)
+    File.open(file, 'ab') { |f|
+      f << str
+    }
+  end
+
+end
+

data/lib/core/facets/file/atomic_id.rb

@@ -0,0 +1,9 @@
+class File
+
+  #
+  def self.atomic_id
+    @atomic_id ||= 0
+    @atomic_id += 1
+  end
+
+end

data/lib/core/facets/file/atomic_open.rb

@@ -0,0 +1,26 @@
+require 'tempfile' unless defined?(Tempfile)
+
+require 'facets/file/atomic_id'
+
+class File
+
+  # Same as `File.open`, but acts on a temporary copy of named
+  # file, copying the file back to the original on completion.
+  #
+  # @uncommon
+  #   require 'facets/fileutils/atomic_open'
+  #
+  def self.atomic_open(file_name, mode="r", temp_dir=nil, &block)
+    temp_dir  = temp_dir || Dir.tmpdir
+    temp_file = Tempfile.new("#{atomic_id}-" + basename(file_name), temp_dir)
+
+    if File.exist?(file_name)
+      FileUtils.cp(file_name, temp_file)
+    end
+
+    open(temp_file, mode, &block)
+
+    FileUtils.cp(temp_file, file_name)
+  end
+
+end

data/lib/core/facets/file/atomic_write.rb

@@ -0,0 +1,58 @@
+# This is a precursor to the possibility of a more extensive Atomic File I/O
+# system. For now it simply provides a means for atomic file writing.
+
+require 'thread'    unless defined?(Thread)
+require 'tempfile'  unless defined?(Tempfile)
+require 'fileutils' unless defined?(FileUtils)
+
+class File
+
+  # Write to a file atomically. Useful for situations where you don't
+  # want other processes or threads to see half-written files.
+  #
+  #   File.atomic_write("important.txt") do |file|
+  #     file.write("hello")
+  #   end
+  #
+  # If your temporary directory is not on the same filesystem as the file you're
+  # trying to write, you can provide a different temporary directory.
+  #
+  #   File.atomic_write("important.txt", "tmp") do |file|
+  #     file.write("hello")
+  #   end
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/fileutils/atomic_write'
+  #
+  def self.atomic_write(file_name, temp_dir=nil)
+    temp_dir  = temp_dir || Dir.tmpdir
+    temp_file = Tempfile.new(basename(file_name), temp_dir)
+
+    yield temp_file
+    temp_file.close
+
+    begin
+      ## Get original file permissions
+      old_stat = stat(file_name)
+    rescue Errno::ENOENT
+      ## No old permissions, write a temp file to determine the defaults
+      check_name = join(dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
+      open(check_name, "w") { }
+      old_stat = stat(check_name)
+      unlink(check_name)
+    end
+
+    ## Overwrite original file with temp file
+    FileUtils.mv(temp_file.path, file_name)
+
+    ## Set correct permissions on new file
+    chown(old_stat.uid, old_stat.gid, file_name)
+    chmod(old_stat.mode, file_name)
+  end
+
+end

data/lib/core/facets/file/common_path.rb

@@ -0,0 +1,17 @@
+class File
+
+  # Given an array of path strings, find the longest common prefix path.
+  #
+  # @author Aaron Gibralter
+  def self.common_path(*paths)
+    return paths.first if paths.length <= 1
+
+    arr = paths.sort
+    f = arr.first.split('/')
+    l = arr.last.split('/')
+    i = 0
+    i += 1 while f[i] == l[i] && i <= f.length
+    f.slice(0, i).join('/')
+  end
+
+end

data/lib/core/facets/file/create.rb

@@ -0,0 +1,21 @@
+class File
+
+  # 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)
+  #
+  # CREDIT: George Moschovitis
+
+  def self.create(path, str='', &blk)
+    open(path, 'wb') do |f|
+      f << str
+      blk.call(f) if blk
+    end
+  end
+
+end
+

data/lib/core/facets/file/ext.rb

@@ -0,0 +1,36 @@
+class File
+
+  # Takes a file name string and returns or changes its extension.
+  #
+  # Without a new extension argument, returns the extension of the
+  # file name. In this respect #ext is like #extname, but unlike
+  # #extname it does not include the dot prefix.
+  #
+  # With a new extension argument, changes the exension of the file
+  # name to the new extension and returns it.
+  #
+  # Examples
+  #
+  #   File.ext('file.rb')          # => 'rb'
+  #   File.ext('file.rb', 'txt')   # => 'file.txt'
+  #   File.ext('file.rb', '.txt')  # => 'file.txt'
+  #   File.ext('file.rb', '')      # => 'file'
+  #
+  # This method can be used with String#file for more object-oriented notation:
+  #
+  #   'file.rb'.file.ext('txt')    # => 'file.txt'
+  #
+  # CREDIT: Lavir the Whiolet
+
+  def self.ext(filename, new_ext=nil)
+    old_ext = extname(filename)
+    if new_ext == nil
+      old_ext.sub(/^\./, '')
+    else
+      new_ext = '.' + new_ext unless (new_ext.empty? || new_ext[0,1] == '.')
+      filename.chomp(old_ext) + new_ext
+    end
+  end
+
+end
+

data/lib/core/facets/file/null.rb

@@ -0,0 +1,21 @@
+class File
+
+  # Platform dependent null device.
+  #
+  # CREDIT: Daniel Burger
+
+  def self.null
+    case RUBY_PLATFORM
+    when /mswin/i
+      'NUL'
+    when /amiga/i
+      'NIL:'
+    when /openvms/i
+      'NL:'
+    else
+      '/dev/null'
+    end
+  end
+
+end
+

data/lib/core/facets/file/read_binary.rb

@@ -0,0 +1,18 @@
+class File
+
+  # Read in a file as binary data.
+  #
+  # Assuming we had a binary file 'binary.dat'.
+  #
+  #   File.read_binary('binary.dat')
+  #
+  # CREDIT: George Moschovitis
+
+  def self.read_binary(fname)
+    open(fname, 'rb') do |f|
+      return f.read
+    end
+  end
+
+end
+

data/lib/core/facets/file/read_list.rb

@@ -0,0 +1,34 @@
+class File
+
+  # Reads in a file, removes blank lines and removes lines starting
+  # with '#' and then returns an array of all the remaining lines.
+  #
+  # Thr remark indicator can be overridden via the +:omit:+ option, which
+  # can be a regualar expression or a string that is match against the
+  # start of a line.
+  #
+  # CREDIT: Trans
+
+  def self.read_list(filepath, options={})
+    chomp = options[:chomp]
+    omit  = case options[:omit]
+            when Regexp
+              omit
+            when nil
+              /^\s*\#/
+            else
+              /^\s*#{Regexp.escape(omit)}/
+            end
+
+    list = []
+    readlines(filepath).each do |line|
+      line = line.strip.chomp(chomp)
+      next if line.empty?
+      next if omit === line
+      list << line
+    end
+    list
+  end
+
+end
+

data/lib/core/facets/file/rewrite.rb

@@ -0,0 +1,90 @@
+class File
+
+  # 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.
+  #
+  # Assuming we had a file 'message.txt' and had a binary file 'binary.dat'.
+  #
+  #   # Reverse contents of "message.txt"
+  #   File.rewrite("message.txt") { |str| str.reverse }
+  #
+  #   # Replace "foo" by "bar" in "binary.dat".
+  #   File.rewrite("binary.dat", "b") { |str| str.gsub("foo", "bar") }
+  #
+  # IMPORTANT: The old version of this method required in place modification
+  # of the file string. The new version will write whatever the block
+  # returns instead!!!
+  #
+  # CREDIT: George Moschovitis
+  #
+  def self.rewrite(name, mode = "") #:yield:
+    unless block_given?
+      raise(ArgumentError, "Need to supply block to File.rewrite")
+    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
+
+    old_str = open(name, "r#{mode}") { |file| file.read } #rescue ""
+    old_str = old_str.clone
+
+    begin
+      new_str = yield(old_str)
+    ensure
+      if old_str != new_str
+        open(name, "w#{mode}") { |file| file.write(new_str) }
+      end
+    end
+  end
+
+  # In place version of #rewrite. This version of method requires that the
+  # string be modified in place within the block.
+  #
+  #   # Reverse contents of "message"
+  #   File.rewrite("message.txt") { |str| str.reverse! }
+  #
+  #   # Replace "foo" by "bar" in "binary"
+  #   File.rewrite("binary.dat", "b") { |str| str.gsub!("foo", "bar") }
+  #
+  def self.rewrite!(name, mode = "") #:yield:
+    unless block_given?
+      raise(ArgumentError, "Need to supply block to File.rewrite")
+    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
+
+    old_str = open(name, "r#{mode}") { |file| file.read } #rescue ""
+    new_str = old_str.clone
+
+    begin
+      yield(new_str)
+    ensure
+      if old_str != new_str
+        open(name, "w#{mode}") { |file| file.write(new_str) }
+      end
+    end
+  end
+
+end
+

data/lib/core/facets/file/rootname.rb

@@ -0,0 +1,23 @@
+class File
+
+  # Returns only the first portion of the directory of
+  # a file path name.
+  #
+  #   File.rootname('lib/jump.rb')  #=> 'lib'
+  #   File.rootname('/jump.rb')     #=> '/'
+  #   File.rootname('jump.rb')      #=> '.'
+  #
+  # CREDIT: Trans
+  #
+  def self.rootname(path)
+    # -- this should be fairly robust
+    path_re = Regexp.new('[' + Regexp.escape(File::Separator + %q{\/}) + ']')
+
+    head, _ = path.split(path_re, 2)
+    return '.' if path == head
+    return '/' if head.empty?
+    return head
+  end
+
+end
+

data/lib/core/facets/file/sanitize.rb

@@ -0,0 +1,18 @@
+class File
+
+  # Cleans up a filename to ensure it will work on a filesystem.
+  #
+  #   File.sanitize("yo+baby!")   #=> 'yo+baby_'
+  #   File.sanitize(".what&up")  #=> '.what_up'
+  #
+  # CREDIT: George Moschovitis
+
+  def self.sanitize(filename)
+    filename = File.basename(filename.gsub("\\", "/")) # work-around for IE
+    filename.gsub!(/[^a-zA-Z0-9\.\-\+_]/,"_")
+    filename = "_#{filename}" if filename =~ /^\.+$/
+    filename
+  end
+
+end
+

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

@@ -0,0 +1,19 @@
+class File
+
+  # 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.
+  #
+  #   File.split_all("a/b/c")  #=> ['a', 'b', 'c']
+  #
+  # CREDIT: Trans
+
+  def self.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
+

data/lib/core/facets/file/split_root.rb

@@ -0,0 +1,13 @@
+class File
+
+  # Return the head of path from the rest of the path.
+  #
+  #   File.split_root('etc/xdg/gtk')  #=> ['etc', 'xdg/gtk']
+  #
+  def self.split_root(path)
+    path_re = Regexp.new('[' + Regexp.escape(File::Separator + %q{\/}) + ']')
+    path.split(path_re, 2)
+  end
+
+end
+

data/lib/core/facets/file/write.rb

@@ -0,0 +1,24 @@
+class File
+
+  unless defined?(write)  # 1.9+
+
+    # Writes the given data to the given path and closes the file.  This is
+    # done in binary mode, complementing <tt>IO.read</tt> in standard Ruby.
+    #
+    #   str = 'The content for the file'
+    #   File.write('write.txt', str)
+    #
+    # Returns the number of bytes written.
+    #
+    # CREDIT: Gavin Sinclair
+
+    def self.write(path, data)
+      File.open(path, "wb") do |file|
+        return file.write(data)
+      end
+    end
+
+  end
+
+end
+

data/lib/core/facets/file/writelines.rb

@@ -0,0 +1,27 @@
+class File
+
+  # Writes the given array of data to the given path and closes the file.
+  # This is done in binary mode, complementing <tt>IO.readlines</tt> in
+  # standard Ruby.
+  #
+  # Note that +readlines+ (the standard Ruby method) returns an array of lines
+  # <em>with newlines intact</em>, whereas +writelines+ uses +puts+, and so
+  # appends newlines if necessary.  In this small way, +readlines+ and
+  # +writelines+ are not exact opposites.
+  #
+  #   data = ['The content', ['for the file']]
+  #   File.writelines('writelines.txt', data)
+  #
+  # Returns number of lines written.
+  #
+  # CREDIT: Noah Gibbs, Gavin Sinclair
+
+  def self.writelines(path, data)
+    File.open(path, "wb") do |file|
+      file.puts(data)
+    end
+    data.size
+  end
+
+end
+

data/lib/core/facets/file.rb

@@ -0,0 +1,16 @@
+require_relative 'file/append.rb'
+#require_relative 'file/atomic_write.rb'    # uncommon
+require_relative 'file/common_path.rb'
+require_relative 'file/create.rb'
+require_relative 'file/ext.rb'
+require_relative 'file/null.rb'
+require_relative 'file/read_binary.rb'
+require_relative 'file/read_list.rb'
+require_relative 'file/rewrite.rb'
+require_relative 'file/rootname.rb'
+require_relative 'file/sanitize.rb'
+require_relative 'file/split_all.rb'
+require_relative 'file/split_root.rb'
+require_relative 'file/write.rb'
+require_relative 'file/writelines.rb'
+

data/lib/core/facets/filetest/absolute.rb

@@ -0,0 +1 @@
+require 'facets/filetest/relative'

data/lib/core/facets/filetest/contains.rb

@@ -0,0 +1,12 @@
+module FileTest
+
+  module_function
+
+  # Does the +parent+ contain the +child+?
+  def contains?(child, parent=Dir.pwd)
+    parent = File.expand_path(parent)
+    child = File.expand_path(child)
+    child.sub(parent,'') != child
+  end
+
+end

data/lib/core/facets/filetest/relative.rb

@@ -0,0 +1,38 @@
+require 'facets/filetest/separator_pattern'
+
+module FileTest
+
+  module_function
+
+  # Predicate method for testing whether a path is absolute.
+  # It returns +true+ if the pathname begins with a slash.
+  def absolute?(path)
+    !relative?(path)
+  end
+
+  # The opposite of #absolute?
+  def relative?(path)
+    while r = chop_basename(path.to_s)
+      path, _ = r
+    end
+    path == ''
+  end
+
+  # List File.split, but preserves the file separators.
+  #
+  #   FileTest.chop_basename('/usr/lib') #=> ['/usr/', 'lib']
+  #   FileTest.chop_basename('/') #=> nil
+  #
+  # Returns Array of `[pre-basename, basename]` or `nil`.
+  #
+  # This method is here simply to support the #relative? and #absolute? methods.
+  def chop_basename(path)
+    base = File.basename(path)
+    if /\A#{SEPARATOR_PATTERN}?\z/ =~ base
+      return nil
+    else
+      return path[0, path.rindex(base)], base
+    end
+  end
+
+end

data/lib/core/facets/filetest/root.rb

@@ -0,0 +1,17 @@
+module FileTest
+
+  module_function
+
+  # Is the specified directory the root directory?
+  #
+  # CREDIT: Jeffrey Schwab
+
+  def root?(dir=nil)
+    pth = File.expand_path(dir||Dir.pwd)
+    return true if pth == '/'
+    return true if pth =~ /^(\w:)?\/$/
+    false
+  end
+
+end
+

data/lib/core/facets/filetest/safe.rb

@@ -0,0 +1,24 @@
+require 'facets/filetest/separator_pattern'
+
+module FileTest
+
+  module_function
+
+  # Is a path considered reasonably "safe"?
+  #
+  # Do not mistake this for a perfect solution!
+  # Please help improve if you know how!
+  #
+  # Returns [Boolean]
+
+  def safe?(path)
+    case path
+    when /\A(#{SEPARATOR_PATTERN}|\~)(#{SEPARATOR_PATTERN}|\*)+/
+      false
+    else
+      true
+    end
+  end
+
+end
+

data/lib/core/facets/filetest/separator_pattern.rb

@@ -0,0 +1,19 @@
+module FileTest
+
+  #
+  SEPARATOR_PATTERN = (
+    if File::ALT_SEPARATOR
+      /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/
+    else
+      /#{Regexp.quote File::SEPARATOR}/
+    end
+  ).freeze
+
+  #module_function
+  #
+  #  #
+  #  def separator_pattern
+  #    SEPARATOR_PATTERN
+  #  end
+
+end