facets 2.9.1 → 2.9.2

data/src/standard/facets/rbconfig.rb

@@ -0,0 +1,78 @@
+# An extended rendition of the Ruby's standard RbConfig module.
+module RbConfig
+
+  #
+  def self.inspect
+    CONFIG.inspect
+  end
+
+  # Methodized lookup of config.
+  def self.method_missing(s,*a,&b)
+    s = s.to_s
+    if CONFIG.key?(s)
+      CONFIG[s]
+    elsif CONFIG.key?(s.upcase)
+      CONFIG[s.upcase]
+    else
+      super(s,*a,&b)
+    end
+  end
+
+  # TODO: parse configure_args into methods too?
+
+  # In case rubygems has already defined it.
+  unless method_defined?(:datadir)
+    # Return the path to the data directory associated with the
+    # given library/package name. Normally this is just
+    #
+    #   "#{Config::CONFIG['datadir']}/#{name}"
+    #
+    # but may be modified by tools like RubyGems to handle
+    # versioned data directories.
+    def self.datadir(package_name)
+      File.join(CONFIG['datadir'], package_name)
+    end
+  end
+
+  #
+  def self.host_os
+    CONFIG['host_os']
+  end
+
+  def linux?
+    host_os =~ /linux|cygwin/
+  end
+
+  def mac?
+    host_os =~ /mac|darwin/
+  end
+
+  def bsd?
+    host_os =~ /bsd/
+  end
+
+  def windows?
+    host_os =~ /mswin|mingw/
+  end
+
+  def solaris?
+    host_os =~ /solaris|sunos/
+  end
+
+  # TODO: who knows what symbian returns?
+  def symbian?
+    host_os =~ /symbian/
+  end
+
+  #
+  def posix?
+    linux? or mac? or bsd? or solaris? or begin 
+      fork do end
+      true
+    rescue NotImplementedError, NoMethodError
+      false
+    end
+  end
+
+end
+

data/src/standard/facets/set.rb

@@ -0,0 +1,32 @@
+require 'set'
+
+class Set
+
+  #
+  def power_set
+    if empty?
+      Set[ self ]
+    else
+      any_value = [to_a.first]
+      subsubs = (self - any_value).power_set
+      subsubs + subsubs.map{ |subset| subset + any_value }
+    end
+  end
+end
+
+class Array
+
+  #
+  def power_set
+    if empty?
+      [self]
+    else
+      subset  = dup
+      value   = [ subset.pop ]
+      subsubs = subset.power_set
+      subsubs.concat( subsubs.map{ |subset| subset + value } )
+    end
+  end
+
+end
+

data/src/standard/facets/shellwords.rb

@@ -0,0 +1,112 @@
+require 'shellwords'
+
+module Shellwords
+
+  module_function
+
+  # Escape special characters used in most unix shells
+  # to use it, eg. with system().
+  #
+  # This differs from Ruby's #escape in that it does not
+  # escape shell variables, e.g. $0.
+  def alt_escape(cmdline)
+    cmdline.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+  end
+
+  unless method_defined?(:escape)
+    def escape(cmdline)
+      cmdline.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+    end
+  end
+
+  # Escape special character used in DOS-based shells.
+  #
+  # TODO: How to integrate with rest of system?
+  # 1. Use platform condition?
+  # 2. Use separate dos_xxx methods?
+  # 3. Put in separate PowerShellwords module?
+  #
+  # CREDIT: Lavir the Whiolet
+  def dos_escape(cmdline)
+    '"' + cmdline.gsub(/\\(?=\\*\")/, "\\\\\\").gsub(/\"/, "\\\"").gsub(/\\$/, "\\\\\\").gsub("%", "%%") + '"'
+  end
+
+  # The coolest little arguments parser in all of Rubyland.
+  #
+  # CREDIT: Michel Martens
+  def run(argv, opts)
+    argv = (String === argv ? shellwords(argv) : argv.to_a.dup)
+    args = []
+    while argv.any?
+      item = argv.shift
+      flag = opts[item]
+      if flag
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+    args
+  end
+
+end
+
+class Array
+
+  # Convert an array into command line parameters.
+  # The array is accepted in the format of Ruby
+  # method arguments --ie. [arg1, arg2, ..., hash]
+  #
+  def shellwords
+    opts, args = *flatten.partition{ |e| Hash === e }
+    opts = opts.inject({}){ |m,h| m.update(h); m }
+    opts.shellwords + args
+  end
+
+  #
+  def shelljoin
+    Shellwords.shelljoin(shellwords)
+  end
+
+end
+
+class Hash
+
+  #
+  def shellwords
+    argv = []
+    each do |f,v|
+      m = f.to_s.size == 1 ? '-' : '--'
+      case v
+      when false, nil
+      when Array
+        v.each do |e|
+          argv << %[#{m}#{f}="#{e}"]
+        end
+      when true
+        argv << %[#{m}#{f}]
+      else
+        argv << %[#{m}#{f}="#{v}"]
+      end
+    end
+    argv
+  end
+
+  #
+  def shelljoin
+    shellwords.shelljoin
+  end
+
+end
+

data/src/standard/facets/strscan.rb

@@ -0,0 +1,16 @@
+require 'strscan'
+
+class StringScanner
+
+  # scans string until +pattern+ is encountered. If +pattern+ will not be
+  # encountered then it returns _nil_ but if +scan_anyway+ is _true_ then
+  # it scans until the end of the string.
+  def scan_before(pattern, scan_anyway = false)
+    if not check_until(pattern) and not scan_anyway then return nil; end
+    result = ""
+    result << getch until check(pattern) or eos?
+    return result
+  end
+
+end
+

data/src/standard/facets/thread.rb

@@ -0,0 +1,98 @@
+# = Thread Related Extensions
+#
+# This a small colleciton of thread-related extensions.
+
+require 'thread'
+
+require 'facets/binding/eval'
+require 'facets/kernel/__method__'
+
+# This is the non-threaded form of #threaded_map_send.
+require 'facets/enumerable/map_send'
+
+module Kernel
+
+  $MEMO_MUTEX = Mutex.new
+
+  $MEMO ||= {}
+
+  # Thead-safe instance-level memoization.
+  # 
+  #   class MemoExample
+  #     attr_accessor :a
+  #     def m
+  #       safe_memo{ @a }
+  #     end
+  #   end
+  #
+  #   ex = MemoExample.new
+  #
+  #   ex.a = 10
+  #   ex.m  #=> 10
+  #
+  #   ex.a = 20
+  #   ex.m  #=> 10
+  #
+  def safe_memo(*args, &block)
+    if args.empty?
+      args = block.binding.eval('[self, __method__]')
+    end
+    $MEMO_MUTEX.synchronize do
+      if $MEMO.key?(args)
+        $MEMO[args]
+      else
+        $MEMO[args] = block.call
+      end
+    end
+  end
+
+end
+
+
+module Enumerable
+
+  # Like Enumerable#map but each iteration is processed via
+  # a separate thread.
+  #
+  # CREDIT: Sean O'Halpin
+
+  def threaded_map #:yield:
+    map{ |e| Thread.new(e){ |t| yield(t) } }.map{ |t| t.value }
+  end
+
+  # Like Enumerable#map_send but each iteration is processed via
+  # a separate thread.
+  #
+  # CREDIT: Sean O'Halpin
+
+  def threaded_map_send(meth, *args, &block)
+    map{ |e| Thread.new(e){ |t| t.send(meth, *args, &block) } }.map{ |t| t.value }
+  end
+
+end
+
+
+module Kernel
+  private
+
+  # CREDIT: Zucker
+  def sandbox(rescueblock_or_default=nil) #:yield:
+    Thread.start do
+      $SAFE = 4
+      yield
+    end.value
+  rescue SecurityError => e
+    if !rescueblock_or_default.nil?
+      if rescueblock_or_default.is_a? Proc
+        rescueblock_or_default.call e
+      else
+        rescueblock_or_default
+      end
+    else
+      raise e
+    end
+  end
+
+end
+
+# Copyright (c) 2006 Sean O'Halpin, Thomas Sawyer

data/src/standard/facets/uri.rb

@@ -0,0 +1,211 @@
+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
+
+  # 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 Kernel
+    #
+    def uri(s, w=%r{[^a-zA-Z_0-9./-]})
+      URI.escape(s, w)
+    end
+
+    #
+    def unuri(s)
+      URI.unescape(s)
+    end
+  end
+
+  module Hash
+    #
+    def to_uri
+      URI.hash_to_query(self)
+    end
+  end
+
+end
+
+class Object #:nodoc:
+  include URI::Kernel
+end
+
+class Hash #:nodoc:
+  include URI::Hash
+end
+