facets 2.9.3 → 3.0.0

data/lib/standard/facets/pathname/op_fetch.rb

@@ -0,0 +1,13 @@
+class Pathname
+
+  # Alternate to Pathname#new.
+  #
+  #   Pathname['/usr/share']
+  #
+  # Returns [Pathname]
+
+  def self.[](path)
+    new(path)
+  end
+
+end

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

@@ -0,0 +1,13 @@
+require 'facets/fileutils/outofdate'
+
+class Pathname
+
+  # Is a path out of date relative a set of source files.
+  #
+  # Returns [Boolean]
+
+  def outofdate?(*sources)
+    ::FileUtils.outofdate?(to_s, sources.flatten)
+  end
+
+end

data/lib/standard/facets/pathname/readline.rb

@@ -0,0 +1,13 @@
+class Pathname
+  # Reads the first line of the file
+  #
+  # Captures the best practice from this post at stack overflow:
+  # https://stackoverflow.com/questions/1490138/reading-the-first-line-of-a-file-in-ruby
+  #
+  # Credit: Ryan Duryea
+  def readline(*args)
+    open { |f| f.readline(*args) }
+  end
+end
+
+

data/lib/standard/facets/pathname/root.rb

@@ -0,0 +1,10 @@
+class Pathname
+
+  # Root constant for building paths from root directory onward.
+  #
+  # Returns [Pathname]
+  def self.root
+    Pathname.new('/')
+  end
+
+end

data/lib/standard/facets/pathname/rootname.rb

@@ -0,0 +1,10 @@
+require 'facets/file/rootname'
+
+class Pathname
+
+  #
+  def rootname
+    self.class.new(File.rootname(to_s))
+  end
+
+end

data/lib/standard/facets/pathname/safe.rb

@@ -0,0 +1,15 @@
+require 'facets/filetest/safe'
+
+class Pathname
+
+  # Is a path reasonably safe?
+  #
+  # Do not mistake this for a perfect solution!
+  #
+  # Returns [Boolean]
+
+  def safe?
+    FileTest.safe?(to_s)
+  end
+
+end

data/lib/standard/facets/pathname/split_root.rb

@@ -0,0 +1,9 @@
+class Pathname
+
+  #
+  def split_root
+    head, tail = *::File.split_root(to_s)
+    [self.class.new(head), self.class.new(tail)]
+  end
+
+end

data/lib/standard/facets/pathname/to_path.rb

@@ -0,0 +1,28 @@
+# Unfortunately NilClass#to_path causes FileUtils to bomb when testing
+# for symlinks. See issue #77. It would be better if Ruby could be changed
+# so this would work. But until then we have no choice but to deprecate
+# this method.
+
+#class NilClass
+#  # Provide platform dependent null path.
+#  #
+#  # @standard
+#  #   require 'facets/pathname'
+#  #
+#  # @author Daniel Burger
+#  def to_path
+#    Pathname.null
+#  end
+#end
+
+class Array
+  # Convert array to Pathname instance.
+  #
+  # @standard
+  #   require 'facets/pathname'
+  #
+  def to_path
+    Pathname.new(join('/'))
+  end
+end
+

data/lib/standard/facets/pathname/to_str.rb

@@ -0,0 +1,8 @@
+class Pathname
+
+  # Alias #to_s to #to_str when #to_str is not defined.
+  #
+  # Returns [String]
+  alias_method(:to_str, :to_s) unless method_defined?(:to_str)
+
+end

data/lib/standard/facets/pathname/uptodate.rb

@@ -0,0 +1,11 @@
+class Pathname
+
+  # Is a path up to date relative to a set of source files?
+  #
+  # Returns [Boolean]
+
+  def uptodate?(*sources)
+    ::FileUtils.uptodate?(to_s, sources.flatten)
+  end
+
+end

data/lib/standard/facets/pathname/visit.rb

@@ -0,0 +1,38 @@
+class Pathname
+
+  # Recursively visit a directory located by its path, yielding each resource
+  # as its full matching pathname object. If called on a file, yield the file.
+  #
+  # call-seq:
+  #   visit => yield each file
+  #   visit(all: true) => yield visited directories as well
+  #   visit(hidden: true) => yield hidden files and directories as well
+  #
+  # Examples
+  #
+  #     # Locate any file but *.haml within app/**/*
+  #     Pathname.new("app").visit do |f|
+  #       next unless f.to_s =~ /\.haml$/
+  #       f
+  #     end 
+  #
+  # TODO: Use #map instead of #each?
+  # 
+  # CREDIT: Jean-Denis Vauguet
+
+  def visit(options = {:all => false, :hidden => false})
+    if self.directory?
+      children.each do |entry|
+        next if entry.basename.to_s[0] == "." && !options[:hidden]
+        yield(entry) unless entry.directory? && !options[:all]
+        ##entry.visit(:all => options[:all]) { |sub_entry| yield sub_entry } if entry.directory?
+        entry.visit(:all => options[:all], :hidden => options[:hidden]) do |sub_entry|
+          yield(sub_entry)
+        end if entry.directory?
+      end
+    else
+      yield self
+    end
+  end
+
+end

data/lib/standard/facets/pathname/work.rb

@@ -0,0 +1,10 @@
+class Pathname
+
+  # Work constant for building paths from root directory onward.
+  #
+  # Returns [Pathname]
+  def self.work
+    Pathname.new('.')
+  end
+
+end

data/lib/standard/facets/platform.rb

@@ -56,7 +56,7 @@ class Platform
 
   #
   def self.local
-    arch = Config::CONFIG['arch']
+    arch = RbConfig::CONFIG['arch']
     arch = "#{arch}_60" if arch =~ /mswin32$/
     @local ||= new(arch)
   end
@@ -141,7 +141,7 @@ class Platform
 
   #
   def inspect
-    "#s:0x%x @cpu=%p, @os=%p, @version=%p>" % [self.class, object_id, *to_a]
+    "#<%s:0x%x @cpu=%p, @os=%p, @version=%p>" % [self.class, object_id, *to_a]
   end
 
   #

data/lib/standard/facets/random.rb

@@ -51,6 +51,7 @@ class Random
     (Random.number(26) + (Random.number(2) == 0 ? 65 : 97) ).chr
   end
 
+  # Random extensions for Range class.
   #
   module RangeExtensions
     # Return a random element from the range.
@@ -96,6 +97,7 @@ class Random
     end
   end
 
+  # Random extensions fo Integer class.
   #
   module IntegerExtensions
     #
@@ -107,6 +109,7 @@ class Random
     end
   end
 
+  # Random extensions for Numeric class.
   #
   module NumericExtensions
     #
@@ -118,6 +121,7 @@ class Random
     end
   end
 
+  # Random extensions for Array class.
   #
   module ArrayExtensions
     # Return a random element from the array.
@@ -193,7 +197,7 @@ class Random
     #   [1, 2, 3, 4].rand_subset           #~> [1, 3, 4]
     #   [1, 2, 3, 4].rand_subset           #~> [2, 3]
     #
-    def rand_subset( number=nil, exclusive=true )
+    def rand_subset(number=nil, exclusive=true)
       number = Random.number(size) unless number
       number = number.to_int
       #return self.dup if (number >= size and exlusive)
@@ -202,6 +206,23 @@ class Random
       return values_at(*ri)
     end
 
+    # Generates random subarrays. Uses random numbers and bit-
+    # fiddling to assure performant uniform distributions even
+    # for large arrays.
+    #
+    #   a = *1..5
+    #   a.rand_subarrays(2) #=> [[3, 4, 5], []]
+    #   a.rand_subarrays(3) #=> [[1], [1, 4, 5], [2, 3]]
+    #
+    # CREDIT: Michael Kohl
+    def rand_subarrays(n=1)
+      raise ArgumentError, "negative argument" if n < 0
+      (1..n).map do
+        r = rand(2**self.size)
+        self.select.with_index { |_, i| r[i] == 1 }
+      end
+    end
+
     # Randomize the order of an array.
     #
     #   [1,2,3,4].shuffle  #~> [2,4,1,3]
@@ -234,6 +255,7 @@ class Random
 
   end
 
+  # Random extensions for Hash class.
   #
   module HashExtensions
     # Returns a random key.
@@ -330,6 +352,7 @@ class Random
 
   end
 
+  # Random extensions for String class.
   #
   module StringExtensions
 
@@ -351,7 +374,7 @@ class Random
       # TODO: This is not very efficient. Better way?
       #++
       def random(max_length = 8, char_re = /[\w\d]/)
-        raise ArgumentError.new('char_re must be a regular expression!') unless char_re.is_a?(Regexp)
+        raise ArgumentError.new('second argument must be a regular expression') unless char_re.is_a?(Regexp)
         string = ""
         while string.length < max_length
             ch = Random.number(255).chr
@@ -359,6 +382,13 @@ class Random
         end
         return string
       end
+
+      # Generate a random binary string of +n_bytes+ size.
+      #
+      # CREDIT: Guido De Rosa
+      def random_binary(n_bytes)
+        ( Array.new(n_bytes){ rand(0x100) } ).pack('c*') 
+      end
     end
 
     # Return a random separation of the string.

data/lib/standard/facets/shellwords.rb

@@ -15,7 +15,7 @@ module Shellwords
 
   unless method_defined?(:escape)
     def escape(cmdline)
-      cmdline.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+      cmdline.gsub(/([\\\t\| &`<>)('"])\$/) { |s| '\\' << s }
     end
   end
 
@@ -34,7 +34,7 @@ module Shellwords
   # The coolest little arguments parser in all of Rubyland.
   #
   # CREDIT: Michel Martens
-  def run(argv, opts)
+  def parse(argv, opts)
     argv = (String === argv ? shellwords(argv) : argv.to_a.dup)
     args = []
     while argv.any?
@@ -60,6 +60,9 @@ module Shellwords
     args
   end
 
+  # Original name for Shellwords#parse.
+  alias_method :run, :parse
+
 end
 
 class Array

data/lib/standard/facets/thread.rb

@@ -4,8 +4,8 @@
 
 require 'thread'
 
-require 'facets/binding/eval'
-require 'facets/kernel/__method__'
+#require 'facets/binding/eval'
+#require 'facets/kernel/__method__'
 
 # This is the non-threaded form of #threaded_map_send.
 require 'facets/enumerable/map_send'

data/lib/standard/facets/uri.rb

@@ -1,184 +1,13 @@
 require 'uri'
-#require 'cgi'
-require 'facets/kernel/blank'
 
-module URI
-
-  module_function
-
-  # Decode the uri components.
-  #
-  def decode(uri)
-    ## gmosx: hmm is this needed?
-    ## guard against invalid filenames for example pictures with
-    ## spaces uploaded by users
-    escaped_uri = uri.gsub(/ /, "+")
-
-    if md = URI::REGEXP::REL_URI.match(escaped_uri)
-      path = "#{md[5]}#{md[6]}"
-      type = File.extname(path)
-      query_string = md[7]
-
-      ## real_path = "#{$root_dir}/#{path}"
-
-      parameters = URI.query_to_hash(query_string)
-      path.gsub!(/\+/, " ")
-
-      return [path, type, parameters, query_string]
-    end
-
-    ## this is usefull for uncovering bugs!
-    raise ArgumentError.new("the parameter '#{uri}' is not a valid uri")
-  end
-
-  # Extend the basic query string parser provided by the cgi module.
-  # converts single valued params (the most common case) to
-  # objects instead of arrays
-  #
-  # Returns hash of parameters, contains arrays for multivalued parameters
-  # (multiselect, checkboxes , etc).
-  #
-  # If no query string is provided (nil or "") returns an empty hash.
-  def query_to_hash(query_string)
-    return {} unless query_string
-
-    query_parameters = cgi_parse(query_string)
-
-    query_parameters.each { |key, val|
-      ## replace the array with an object
-      query_parameters[key] = val[0] if 1 == val.length
-    }
-
-    ## set default value to nil! cgi sets this to []
-    query_parameters.default = nil
-
-    return query_parameters
-  end
-
-  alias_method :query_string_to_hash, :query_to_hash
-
-  #
-  KEY_VALUE_SEPARATOR = ";"  # "&"
-
-  # Given a hash with parameter/value pairs construct a
-  # standard query string.
-  #
-  #   URI.hash_to_query(:a => 1, :b => 2)
-  #   #=> "a=1;b=2"
-  #
-  def hash_to_query(parameters)
-    return '' unless parameters
-    pairs = []
-    parameters.each do |param, value|
-      pairs << "#{param}=#{cgi_escape(value.to_s)}"
-    end
-    return pairs.join(KEY_VALUE_SEPARATOR)
-  end
-
-  alias_method :hash_to_query_string, :hash_to_query
-
-  # CGI escape
-  #
-  # TODO: How does this compare to URI.escape?
-  def cgi_escape(string)
-    string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
-      '%' + $1.unpack('H2' * $1.size).join('%').upcase
-    end.tr(' ', '+')
-  end
-
-  #
-  def cgi_unescape(string)
-    string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
-      [$1.delete('%')].pack('H*')
-    end
-  end
-
-  #
-  def cgi_parse(query)
-    params = Hash.new([].freeze)
-
-    query.split(/[&;]/n).each do |pairs|
-      key, value = pairs.split('=',2).collect{|v| cgi_unescape(v) }
-      if params.has_key?(key)
-        params[key].push(value)
-      else
-        params[key] = [value]
-      end
-    end
-
-    params
-  end
-
-  # This method returns the query string of a uri
-  #
-  # Input:
-  # the uri
-  #
-  # Output:
-  # the query string.
-  # returns nil if no query string
-  def get_query_string(uri)
-    return nil unless uri
-    # gmosx: INVESTIGATE ruby's URI seems to differently handle
-    # abs and rel uris.
-    if md = URI::REGEXP::ABS_URI.match(uri)
-      return md[8]
-    elsif md = URI::REGEXP::REL_URI.match(uri)
-      return md[7]
-    end
-    return nil
-  end
+require 'facets/uri/cgi_escape.rb'
+require 'facets/uri/cgi_unescape.rb'
+require 'facets/uri/cgi_parse.rb'
+require 'facets/uri/decode.rb'
+require 'facets/uri/parameters.rb'
+require 'facets/uri/query.rb'
 
-  # Removes the query string from a +uri+.
-  #
-  # Returns the chomped uri.
-  def chomp_query_string(uri)
-    return nil unless uri
-    query_string = self.get_query_string(uri)
-    return uri.dup.chomp("?#{query_string}")
-  end
-
-  # Get a uri and a hash of parameters. Inject the hash values
-  # as parameters in the query sting path. Returns the full uri.
-  #
-  # uri       - the uri to filter (String)
-  # parameter - hash of parameters to update
-  #
-  # Returns the full updated query string.
-  #
-  # TODO: optimize
-  def update_query_string(uri, parameters)
-    query_string = self.get_query_string(uri)
-    rest = uri.dup.gsub(/\?#{query_string}/, "")
-
-    hash = self.query_string_to_hash(query_string)
-    hash.update(parameters)
-    query_string = self.hash_to_query_string(hash)
-
-    unless query_string.blank?
-      return "#{rest}?#{query_string}"
-    else
-      return rest
-    end
-  end
-
-  # Gets the request uri, injects extra parameters in the query string
-  # and returns a new uri. The request object is not modified.
-  # There is always a qs string so an extra test is skipped.
-  #
-  # TODO: find a better name?
-  def update_request_uri(request, parameters)
-    hash = request.parameters.dup()
-    hash.update(parameters)
-
-    ## use this in hash_to_querystring.
-    query_string = hash.collect { |k, v|
-      "#{k}=#{v}"
-    }.join(";")
-
-    ## return "#{request.translated_uri}?#{query_string}"
-    return "#{request.path}?#{query_string}"
-  end
+module URI
 
   module Kernel
     #