facets 2.9.2 → 2.9.3

data/src/standard/facets/rbconfig.rb

@@ -1,78 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,98 +0,0 @@
-# = 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

@@ -1,211 +0,0 @@
-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
-