facets-glimmer 3.2.0

data/lib/standard/facets/digest/salted_digest.rb

@@ -0,0 +1,44 @@
+require 'digest'
+require 'facets/string/random_binary'
+
+module Digest
+
+  module Instance
+    # CREDIT: Guido De Rosa
+    def salted_digest(str='', salt=:auto)
+      if salt == :auto
+        salt = String.random_binary(digest_length) 
+      end
+      digest(str + salt) + salt
+    end
+
+    # CREDIT: Guido De Rosa
+    def salted_hexdigest(str, salt)
+      Digest.hexencode(salted_digest(str, salt))
+    end
+
+    # CREDIT: Guido De Rosa
+    def salted_base64digest(str, salt)
+      [salted_digest(str, salt)].pack('m0')
+    end
+  end
+
+  class Class
+    # CREDIT: Guido De Rosa
+    def self.salted_digest(str, salt=:auto, *args)
+      new(*args).salted_digest(str, salt)
+    end 
+
+    # CREDIT: Guido De Rosa
+    def self.salted_hexdigest(str, salt=:auto, *args)
+      new(*args).salted_hexdigest(str, salt)
+    end
+
+    # CREDIT: Guido De Rosa
+    def self.salted_base64digest(str, salt=:auto, *args)
+      new(*args).salted_base64digest(str, salt)
+    end
+  end
+
+end
+

data/lib/standard/facets/digest.rb

@@ -0,0 +1,2 @@
+require 'facets/digest/base64digest'
+require 'facets/digest/salted_digest'

data/lib/standard/facets/enumargs.rb

@@ -0,0 +1,191 @@
+module Enumerable
+  # This is a simple reimplementation of the core Enumerable module
+  # to allow its methods to take and pass-on arbitrary arguments to the
+  # underlying #each call. This library uses Enumerator and scans
+  # Enumerable so it can alwasy stay in sync.
+  #
+  # NOTE: Any Enumerable method with a negative arity cannot pass arguments
+  # due to ambiguity in the argument count. So the methods #inject and #zip
+  # do NOT work this way, but simply work as they do in Enumerable. However,
+  # The methods #find and #detect have been made modified to work by removing
+  # its rarely used optional parameter and providing instead an optional
+  # keyword parameter (:ifnone => ...). Please keep these difference in mind.
+  #
+  # Example
+  #   require 'enumargs'
+  #
+  #   class T
+  #     include Enumerable::Argumentable
+  #     def initialize(arr)
+  #       @arr = arr
+  #     end
+  #     def each(n)
+  #       arr.each{ |e| yield(e+n) }
+  #     end
+  #   end
+  #
+  #   t = T.new([1,2,3])
+  #   t.collect(4)
+  #   #=> [5,6,7]
+  #
+  module Argumentable
+
+    # Helper method to wrap Enumerable methods.
+    def self.wrap_enumerable_method( methodname )
+      m = methodname
+      meth = Enumerable.instance_method(m)
+      arity = meth.arity
+
+      case arity <=> 0
+      when 0
+        class_eval %{
+          def #{m}( *args, &yld )
+            enum_for(:each, *args).#{m}( &yld )
+          end
+        }
+      when 1
+        class_eval %{
+          def #{m}( *args, &yld )
+            args, each_args = args[0...#{arity}], args[#{arity}..-1]
+            enum_for(:each, *each_args).#{m}( *args, &yld )
+          end
+        }
+      else
+        # this branch is used when the method has a variable number of arguments
+        #   resulting in an arity of -1.  Right now this is bugged as it does
+        #   not pass the argument to the each, and always passes the argument
+        #   to the method.  This makes methods like .min amdn .max to act
+        #   in an unexpected manner.
+        class_eval %{
+          def #{m}( *args, &yld )
+            enum_for(:each).#{m}( *args, &yld )
+          end
+        }
+      end
+    end
+
+    # Wrap all Enumerable's public instance methods
+    Enumerable.instance_methods(false).each do |m|
+      wrap_enumerable_method( m )
+    end
+
+    # Support for #to_a.
+    #
+    def to_a(*args)
+      #map(*args){ |x| x }
+      enum_for(:each, *args).to_a
+    end
+
+    # Make exception for #find (a negative arity method) to accept
+    # keyword argument.
+    #
+    #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+    #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+    #
+    def find(*args, &yld)  # future use **keys ?
+      if Hash === args.last and args.last.key?(:ifnone)
+        ifnone = args.last.delete(:ifnone)
+        args.pop if args.last.empty?
+        enum_for(:each, *args).find( ifnone, &yld )
+      else
+        enum_for(:each, *args).find( &yld )
+      end
+    end
+
+    alias_method :detect, :find
+
+  end
+
+  # DEPRECATED: Module alias for old name.
+  Arguments = Argumentable
+end
+
+
+=begin  OLD CODE
+  module EnumerableArgs
+
+    def collect(*args)  # :yield:
+      a = []
+      each(*args){ |n| a << yield(n) }
+      a
+    end
+    alias_method( :map, :collect )
+
+    def detect(*args)  # :yield:
+      each(*args){ |n| return n if yield(n) }
+      nil
+    end
+    alias_method( :find, :detect )
+
+    def each_with_index(*args)
+      i=0
+      each(*args){ |*n| n << i; yield(*n); i+=1 }
+      self
+    end
+
+    def to_a(*args)
+      a = []
+      each(*args){ |n| a << n }
+      a
+    end
+    alias_method( :entries, :to_a )
+
+    # An additional method not part of standard Enumerable.
+    # The regular version of this method can be found in Facets,
+    # but it is a bit more advanced then this one.
+    # At some point they need to be put into sync.
+    def each_slice(*args, &yld)
+      a = []; s = []
+      ar = yld.arity.abs
+      each(*args){ |n|
+        s << n
+        if s.length >= ar
+          yld.call(*s)
+          s = []
+        end
+      }
+      a
+    end
+    alias_method( :each_by, :each_slice )
+
+    def select(*args)  # :yield:
+      a = []
+      each(*args){ |n| a << n if yield(n) }
+      a
+    end
+    alias_method( :find_all, :select )
+
+    def grep(pattern, *args)
+      a = []
+      each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+      a
+    end
+
+    def include?(anObj, *args)
+      each(*args){ |n| return true if anObj == n }
+      false
+    end
+    alias_method( :member?, :include? )
+
+    def max(*args)
+      to_a(*args).max
+    end
+
+    def min(*args)
+      to_a(*args).min
+    end
+
+    def reject(*args)
+      a = []
+      each(*args){ |n| a << n if ! yield(n) }
+      a
+    end
+
+    def sort(*args)
+      # TODO
+    end
+
+  end
+=end
+
+# Copyright (c) 2004 Rubyworks (BSD-2-Clause)

data/lib/standard/facets/equitable.rb

@@ -0,0 +1,76 @@
+# = Equitable
+#
+# This mixin provides methods of equality based
+# on a single #identity method which must return
+# a list of accessors used as the identity keys.
+#
+# It also provides a "shortcut" for creating the
+# #identity method based on given accessors and returns
+# the Equitable module for inclusion.
+#
+#   include Equitable(:a, :b)
+#
+# is equivalent to including a module containing:
+#
+#   def ==(other)
+#     self.a == other.a && self.b == other.b
+#   end
+#
+#   def eql?(other)
+#     self.a.eql?(other.a) && self.b.eql?(other.b)
+#   end
+#
+#   def hash()
+#     self.a.hash ^ self.b.hash
+#   end
+#
+module Equitable
+
+  def self.identify(base, *accessors)
+    base.send(:define_method, :identity){ accessors }
+    self
+  end
+
+  def ==(o)
+    identity.all?{ |a| send(a) == o.send(a) }
+  end
+
+  def eql?(o)
+    identity.all?{ |a| send(a).eql?(o.send(a)) }
+  end
+
+  def hash
+    identity.inject(0){ |memo, a| memo ^ send(a).hash }
+  end
+
+end
+
+class Module
+
+  # This function provided a "shortcut" for creating the
+  # #identity method based on given accessors and returns
+  # the Equitable module for inclusion.
+  #
+  #  include Equitable(:a, :b)
+  #
+  # is equivalent to including a module containing:
+  #
+  #   def ==(other)
+  #     self.a == other.a && self.b == other.b
+  #   end
+  #
+  #   def eql?(other)
+  #     self.a.eql?(other.a) && self.b.eql?(other.b)
+  #   end
+  #
+  #   def hash()
+  #     self.a.hash ^ self.b.hash
+  #   end
+  #
+
+  def Equitable(*accessors)
+    Equitable.identify(self, *accessors)
+  end
+
+end
+

data/lib/standard/facets/erb.rb

@@ -0,0 +1,66 @@
+require 'erb'
+
+# = OpenTemplate
+#
+# The Erb OpenTemplate provides a quick and convenient way to
+# create a clean rendering space with the desired responses.
+#
+# Ruby 1.8.6 or less can't handle object scope methods with blocks.
+#
+# TODO: This might make a good addon library. Just add 
+# require 'erb' to the erb_result method? Call it OpenResponse?
+#
+class ERB::OpenTemplate
+
+  # TODO: Should we do this? Perhaps offer it as an option?
+  instance_methods.each do |m|
+    undef_method(m) unless /^(__|instance_|inspect$|extend$|object_id$)/ =~ m.to_s
+  end
+
+  #
+  def initialize(*objs_ioc)
+    ioc = Hash===objs_ioc.last ? objs_ioc.pop : {}
+    objs = objs_ioc
+
+    mods = []
+
+    objs.each do |obj|
+      mod = Module.new
+      obj.public_methods.each do |m|
+        mod.module_eval do
+          #define_method(m){ |*a,&b| obj.__send__(m,*a,&b) }
+          define_method(m, &obj.method(m).to_proc)
+        end
+      end
+      mods << mod
+    end
+
+    mod = Module.new
+    ioc.each do |k,v|
+      mod.module_eval do
+        define_method(k){ v }
+      end
+    end
+    mods << mod
+
+    extend *mods.reverse
+  end
+
+  #
+  def erb_result(str)
+    ERB.new(str).result(binding)
+  end
+
+  ##
+  ##def method_missing(sym, *args, &block)
+  ##  #if @ioc.key?(sym)
+  ##  #  @ioc[sym]
+  ##  if obj = @objs.find{ |o| o.respond_to?(sym) }
+  ##    obj.__send__(sym, *args, &block)
+  ##  else
+  ##    super
+  ##  end
+  ##end
+
+end
+

data/lib/standard/facets/fileutils/amass.rb

@@ -0,0 +1,34 @@
+module FileUtils
+
+  module_function
+
+  # An intergrated glob like method that takes a set of include globs,
+  # exclude globs and ignore globs to produce a collection of paths.
+  # 
+  # The ignore_globs differ from exclude_globs in that they match by
+  # the basename of the path rather than the whole pathname.
+  #
+  # TODO: Should ignore be based on any portion of the path, not just the basename?
+  #
+  def amass(include_globs, exclude_globs=[], ignore=[])
+
+    include_files = [include_globs].flatten.map{ |g| Dir.glob(g) }.flatten.uniq
+    exclude_files = [exclude_globs].flatten.map{ |g| Dir.glob(g) }.flatten.uniq
+
+    include_files = include_files.map{ |f| File.directory?(f) ? File.join(f, '**/*') : f } # Recursive!
+    exclude_files = exclude_files.map{ |f| File.directory?(f) ? File.join(f, '**/*') : f } # Recursive!
+
+    include_files = include_files.flatten.map{ |g| Dir.glob(g) }.flatten.uniq
+    exclude_files = exclude_files.flatten.map{ |g| Dir.glob(g) }.flatten.uniq
+
+    files = include_files - exclude_files
+
+    files = files.reject{ |f| [ignore].flatten.any?{ |x| File.fnmatch?(x, File.basename(f)) } }
+
+    files
+  end
+
+  # Make public (for all submodules too).
+  public :amass
+
+end

data/lib/standard/facets/fileutils/cp_rx.rb

@@ -0,0 +1,42 @@
+module FileUtils
+
+  module_function
+
+  # Both of these are modified from the implementations in fileutils.rb from Ruby 1.9.1p378.
+
+  # Like FileUtils.cp_r, but takes a filter proc that can return false to skip a file:
+  #
+  #   cp_rx "bigDirectoryTree", "dest", {:noop => true} do |name|
+  #      /dontCopyThis$/.match(name)
+  #   end
+  #
+  # Note that if the filter rejects a subdirectory then everything within that
+  # subdirectory is automatically skipped as well.
+
+  def cp_rx(src, dest, options = {}, &filter)
+    if options[:verbose]
+	    fu_output_message("cp -r#{options[:preserve] ? 'p' : ''}#{options[:remove_destination] ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}")
+    end
+	  return if options[:noop]
+	  fu_each_src_dest(src, dest) do |s, d|
+		  copy_entryx(s, d, filter, options[:preserve], options[:dereference_root], options[:remove_destination])
+	  end
+  end
+
+  # Like FileUtils.copy_entry, but takes a filter proc that can return false to skip a file.
+  #
+  # Note that if the filter rejects a subdirectory then everything within that
+  # subdirectory is automatically skipped as well.
+
+  def copy_entryx(src, dest, filter, preserve = false, dereference_root = false, remove_destination = false)
+	  Entry_.new(src, nil, dereference_root).traverse do |ent|
+		  if filter.call(ent.path) then
+			  destent = Entry_.new(dest, ent.rel, false)
+			  File.unlink destent.path if remove_destination && File.file?(destent.path)
+			  ent.copy destent.path
+			  ent.copy_metadata(destent.path) if preserve
+		  end
+	  end
+  end
+
+end

data/lib/standard/facets/fileutils/head.rb

@@ -0,0 +1 @@
+require 'facets/fileutils/slice'

data/lib/standard/facets/fileutils/ln_r.rb

@@ -0,0 +1,98 @@
+module FileUtils
+
+  unless method_defined?(:ln_r)
+
+    #
+    # Options: noop verbose dereference_root remove_destination
+    #
+    # Hard link +src+ to +dest+. If +src+ is a directory, this method links
+    # all its contents recursively. If +dest+ is a directory, links
+    # +src+ to +dest/src+.
+    #
+    # +src+ can be a list of files.
+    #
+    #   # Installing ruby library "mylib" under the site_ruby
+    #   FileUtils.rm_r site_ruby + '/mylib', :force
+    #   FileUtils.ln_r 'lib/', site_ruby + '/mylib'
+    #
+    #   # Examples of copying several files to target directory.
+    #   FileUtils.ln_r %w(mail.rb field.rb debug/), site_ruby + '/tmail'
+    #   FileUtils.ln_r Dir.glob('*.rb'), '/home/aamine/lib/ruby', :noop => true, :verbose => true
+    #
+    #   # If you want to copy all contents of a directory instead of the
+    #   # directory itself, c.f. src/x -> dest/x, src/y -> dest/y,
+    #   # use following code.
+    #   FileUtils.ln_r 'src/.', 'dest'     # cp_r('src', 'dest') makes src/dest,
+    #                                      # but this doesn't.
+    #
+    # TODO: Why --remove-destination and not just --force?
+    def ln_r(src, dest, options = {})
+      fu_output_message "ln -r#{options[:remove_destination] ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" if options[:verbose]
+      return if options[:noop]
+      options = options.dup
+      options[:dereference_root] = true unless options.key?(:dereference_root)
+      fu_each_src_dest(src, dest) do |s, d|
+        link_entry s, d, options[:dereference_root], options[:remove_destination]
+      end
+    end
+    module_function :ln_r
+
+    OPT_TABLE = {} unless const_defined?(:OPT_TABLE)
+    OPT_TABLE['ln_r'] = [:noop, :verbose, :dereference_root, :remove_destination]
+
+    #
+    # Hard links a file system entry +src+ to +dest+.
+    # If +src+ is a directory, this method links its contents recursively.
+    #
+    # Both of +src+ and +dest+ must be a path name.
+    # +src+ must exist, +dest+ must not exist.
+    #
+    # If +dereference_root+ is true, this method dereference tree root.
+    #
+    # If +remove_destination+ is true, this method removes each destination file before copy.
+    #
+    def link_entry(src, dest, dereference_root = false, remove_destination = false)
+      Entry_.new(src, nil, dereference_root).traverse do |ent|
+        destent = Entry_.new(dest, ent.rel, false)
+        File.unlink destent.path if remove_destination && File.file?(destent.path)
+        ent.link destent.path
+      end
+    end
+    module_function :link_entry
+
+    class Entry_ #:nodoc:
+      def link(dest)
+        case
+        when directory?
+          if !File.exist?(dest) and descendant_diretory?(dest, path)
+            raise ArgumentError, "cannot link directory %s to itself %s" % [path, dest]
+          end
+          begin
+            Dir.mkdir dest
+          rescue
+            raise unless File.directory?(dest)
+          end
+        else file?
+          File.link path(), dest
+        end
+      end
+
+      unless const_defined?(:DIRECTORY_TERM)
+        if File::ALT_SEPARATOR
+          DIRECTORY_TERM = "(?=[/#{Regexp.quote(File::ALT_SEPARATOR)}]|\\z)".freeze
+        else
+          DIRECTORY_TERM = "(?=/|\\z)".freeze
+        end
+        SYSCASE = File::FNM_SYSCASE.nonzero? ? "-i" : ""
+      end
+
+      unless method_defined?(:descendant_diretory?)
+        def descendant_diretory?(descendant, ascendant)
+          /\A(?#{SYSCASE}:#{Regexp.quote(ascendant)})#{DIRECTORY_TERM}/ =~ File.dirname(descendant)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/standard/facets/fileutils/outofdate.rb

@@ -0,0 +1,38 @@
+require 'fileutils'
+
+module FileUtils
+  module_function
+
+  # The opposite of #uptodate?
+  def outofdate?(path, *sources)
+    #return true unless File.exist?(path)
+    ! uptodate?(path, sources.flatten)
+  end
+
+  # Alias for #outofdate?
+  alias_method :out_of_date?, :outofdate?
+
+  # Alias for #uptodate?
+  alias_method :up_to_date?, :uptodate?
+
+  # # TODO: Does a path need updating, based on given +sources+?
+  # # This compares mtimes of give paths. Returns false
+  # # if the path needs to be updated.
+  # #
+  # # DEPRECATE: Is this in any way better than `! uptodate?` ?
+  # def out_of_date?(path, *sources)
+  #   return true unless File.exist?(path)
+  # 
+  #   sources = sources.collect{ |source| Dir.glob(source) }.flatten
+  #   mtimes  = sources.collect{ |file| File.mtime(file) }
+  # 
+  #   return true if mtimes.empty?  # TODO: This the way to go here?
+  # 
+  #   File.mtime(path) < mtimes.max
+  # end
+
+  # Make public (for all submodules too).
+  public :outofdate?
+  public :out_of_date?
+  public :up_to_date?
+end

data/lib/standard/facets/fileutils/safe_ln.rb

@@ -0,0 +1,27 @@
+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.
+  #
+  # CREDIT: Jim Weirich
+  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
+

data/lib/standard/facets/fileutils/slice.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+
+module FileUtils
+
+  module_function
+
+  # 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 Shashank Date, via Daniel Berger.
+
+  def slice(filename,from,to) #:yield:
+    IO.readlines(filename)[from-1..to-1]
+  end
+
+  # 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", 10)
+  #
+  def head(filename,lines) #: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):
+  #
+  #   # Returns last 3 lines of 'myfile'
+  #   FileUtils.tail("myfile",3)
+  #
+  # And no tail -f.
+  def tail(filename,lines) #:yield
+    IO.readlines(filename).reverse[0..lines-1].reverse
+  end
+
+end
+