facets-glimmer 3.2.0

data/lib/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/lib/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/lib/standard/facets/timer.rb

@@ -0,0 +1,217 @@
+if RUBY_ENGINE == 'rubymotion'
+  def require(*args, &block)
+    # No Op (just a shim for RubyMotion)
+  end
+  def require_relative(*args, &block)
+    # No Op (just a shim for RubyMotion)
+  end
+end
+  
+require 'timeout'  # for Timeout::Error
+
+# = Timer
+#
+# Provides a strightforward means for controlling time critical execution.
+# Can be used as a "stop watch" timer or as a "time bomb" timer:
+#
+#   t = Timer.new(10) { raise Timeout::Error, "timeout!" }
+#   t.start
+#     :      # done within 10sec timeout
+#   t.stop
+#   t.start
+#     :
+#   if condition then
+#     t.reset       #--> restart timer
+#   end
+#
+# A class method is also provided for easily timing the exectuion of a block.
+#
+#   Timer.time do |timer|
+#    timer.total_time.round  #=> 0
+#
+#    sleep 1
+#    timer.total_time.round  #=> 1
+#
+#    timer.stop
+#    timer.total_time.round  #=> 1
+#
+#    sleep 1
+#    timer.total_time.round  #=> 1
+#
+#    timer.start
+#    timer.total_time.round  #=> 1
+#
+#    sleep 1
+#    timer.total_time.round  #=> 2
+#   end
+#
+# Thanks to Paul Brannan for TimeLimit and Minero Aoki for Timer.
+# These two libraries served as models for building this class.
+
+class Timer
+
+  #
+  def initialize(time_limit=nil, &block)
+    # standard timer
+    @start_time = nil
+    @end_time = nil
+    @total_time = 0
+    @runnning = nil
+    # for using time limit
+    @time_limit = time_limit
+    @on_timeout = block
+    @current_thread = nil
+    @timer_thread = nil
+  end
+
+  #
+  attr_accessor :time_limit
+
+  #
+  def start_time
+    @start_time
+  end
+
+  #
+  def end_time
+    @end_time
+  end
+
+  #
+  def on_timeout( &block )
+    if block then
+      @on_timeout = block
+      true
+    else
+      false
+    end
+  end
+
+  # Start the timer.
+  def start
+    @running = true
+    @start_time = Time.now
+
+    limit if @time_limit
+
+    self
+
+    ##if block_given? then
+    ##  begin
+    ##    yield( self )
+    ##  ensure
+    ##    stop
+    ##  end
+    ##else
+    ##  @time_limit
+    ##end
+  end
+
+  # Establish a time limit on execution.
+  def limit( time_limit=nil )
+    if @time_limit || time_limit
+      @current_thread = Thread.current
+      @timer_thread = Thread.fork {
+        sleep @time_limit
+        if @on_timeout then
+          @on_timeout.call @time_limit
+        else
+          @current_thread.raise Timeout::Error, "#{@time_limit} seconds past"
+        end
+      }
+    end
+  end
+
+  # Kill time limit thread, if any.
+  def defuse
+    if @timer_thread
+      #Thread.kill @timer_thread
+      @timer_thread.kill
+      @timer_thread = nil
+    end
+  end
+
+  # Stops timer and returns total time.
+  # If timer was not running returns false.
+  def stop
+    if @running
+      defuse
+      # record running time
+      @end_time = Time.now
+      @running = false
+      @total_time += (@end_time - @start_time)
+    else
+      nil
+    end
+  end
+
+  # Stops and resets the timer. If the timer was running
+  # returns the total time. If not returns 0.
+  def reset
+    if running?
+      r = stop
+    else
+      r = 0
+    end
+    @total_time = 0
+    return r
+  end
+
+  # Resets the time limit. Same as:
+  #
+  #   t.stop
+  #   t.start
+  #
+  def reset_limit
+    #stop
+    #start
+    defuse
+    limit
+  end
+
+  # Queries whether the timer is still running.
+  def running?
+    return @running
+  end
+
+  # Queries whether the timer is still not running.
+  def stopped?
+    return !@running
+  end
+
+  # Queries total recorded time of timer.
+  def total_time
+    if running? then
+      return @total_time + (Time.now - @start_time)
+    else
+      return @total_time
+    end
+  end
+
+  # Takes a block and returns the total time it took to execute.
+  def self.time
+    yield( timer = Timer.new.start )
+    return timer.total_time
+  end
+
+  # Timer::Dummy - Dummy Timer (i.e. no real time limit)
+  #--
+  # TODO: Timer::Dummy needs some work.
+  #++
+  class Dummy < self
+    def start
+      if block_given? then
+        yield
+      else
+        time_limit()
+      end
+    end
+
+    def stop
+      false
+    end
+  end #class Dummy
+
+end #class Timer
+
+# Copyright (c) 2004 Rubyworks

data/lib/standard/facets/tuple.rb

@@ -0,0 +1,280 @@
+require 'facets/multiton'
+
+# = Tuple
+#
+# Tuple is essentially an Array, but Comaparable and Immutable.
+#
+# A tuple can be made using #new or #[] just as one builds an array,
+# or using the #to_t method on a string or array. With a string tuple
+# remembers the first non-alphanumeric character as the tuple divider.
+#
+# == Usage
+#
+#   t1 = Tuple[1,2,3]
+#   t2 = Tuple[2,3,4]
+#
+#   (t1 < t2)   #=> true
+#   (t1 > t2)   #=> false
+#
+#   t1 = '1.2.3'.to_t
+#   t2 = '1-2-3'.to_t
+#
+#   t1.to_s  #=> "1.2.3"
+#   t2.to_s  #=> "1.2.3"
+#
+#   (t1 == t2)  #=> true
+#
+# Keep in mind that Tuple[1,2,3] is not the same as Tuple['1','2','3'].
+#
+#--
+# TODO: The #hash method needs a touch-up.
+#
+# TODO: There are a few more methods yet to borrow from Array.
+# Consider how #+, #-, etc. ought to work.
+#++
+class Tuple
+
+  include ::Multiton
+  include ::Enumerable
+  include ::Comparable
+
+  def self.multiton_id(arg=0, default=0, &block)
+    if block_given?
+      values = []
+      arg.times { |i| values << block[i] }
+    elseif Integer === arg
+      values = [ default ] * arg
+    else
+      values = arg.to_ary
+    end
+    values
+  end
+
+  def initialize(arg=0, default=0, &blk)
+    if block_given?
+      @values = []
+      arg.times { |i| @values << blk[i] }
+    elseif Integer === arg
+      @values = [ default ] * arg
+    else
+      @values = arg.to_ary
+    end
+    @default = default
+    ##@divider = '.'
+  end
+
+  attr_accessor :default
+
+  ##def divider( set=nil )
+  ##  return @divider unless set
+  ##  @divider = set
+  ##  self
+  ##end
+
+protected
+
+  def values() @values end
+
+public
+
+  SEGMENT_SEPARATOR = '.'
+
+  def inspect() to_a.inspect end
+
+  def to_t()     self end
+  def to_tuple() self end
+
+  def to_a()   Array(@values) end
+  def to_ary() Array(@values) end
+
+  def to_s(divider=nil)
+    @values.join(divider || SEGMENT_SEPARATOR)
+  end
+
+  def size()   @values.size end
+  def length() @values.size end
+
+  def empty?()
+    return true if @values.empty?
+    return true if @values == [ @default ] * @values.size
+    false
+  end
+
+  def each( &block )
+    @values.each( &block )
+  end
+
+  def each_index( &block )
+    @values.each_index( &block )
+  end
+
+  def [](i)
+    @values.fetch(i,@default)
+  end
+
+  def []=(i,v)
+    @values[i] = v
+  end
+
+  def index()  @values.index end
+  def rindex() @values.rindex end
+
+  # Unlike Array, Tuple#<< cannot act in place
+  # becuase Tuple's are immutable.
+  def <<( obj )
+    self.class.instance( to_a << obj )
+  end
+
+  def pop() Tuple.instance( to_a.pop ) end
+
+  def push( obj ) Tuple.instance( to_a.push(obj) ) end
+
+  # Pulls a value off the beginning of a tuple.
+  # This method is otherwsie known as #shift.
+  def pull() Tuple.instance( to_a.shift ) end
+
+  # Stands for "Put On Top". This method is the opposite of #pull and is
+  # otherwise known as #unshift.
+  def pot( obj ) Tuple.instance( to_a.unshift(obj) ) end
+
+  alias_method :unshift, :pot
+  alias_method :shift, :pull
+
+  # Returns true if two tuple references are for the
+  # very same tuple.
+  def eql?( other )
+    return true if object_id == other.object_id
+    ##return true if values.eql? other.values
+  end
+
+  #
+  def <=>( other )
+    other = other.to_t
+    [size, other.size].max.times do |i|
+      c = self[i] <=> other[i]
+      return c if c != 0
+    end
+    0
+  end
+
+  # For pessimistic constraint (like '~>' in gems)
+  def =~( other )
+    other = other.to_t
+    upver = other.dup
+    upver[0] += 1
+    self >= other and self < upver
+  end
+
+  def first() @values.first end
+  def last()  @values.last end
+
+  # These are useful for using a Tuple as a version.
+  def major() @values.first end
+  def minor() @values.at(1) end
+  def teeny() @values.at(2) end
+
+  # Unique hash value.
+  def hash
+    # TODO: This needs to take into account the default
+    # and maybe the divider too.
+    to_a.hash
+  end
+
+  # class-level -----------------------------------------------
+
+  class << self
+
+    #
+    def []( *args )
+      instance( args )
+    end
+
+    # Translates a string in the form on a set of numerical and/or
+    # alphanumerical characters separated by non-word characters (eg \W+)
+    # into a Tuple. The values of the tuple will be converted to integers
+    # if they are purely numerical.
+    #
+    #   Tuple.cast_from_string('1.2.3a')  #=> [1,2,"3a"]
+    #
+    # It you would like to control the interpretation of each value
+    # as it is added to the tuple you can supply a block.
+    #
+    #   Tuple.cast_from_string('1.2.3a'){ |v| v.upcase }  #=> ["1","2","3A"]
+    #
+    # This method is called by String#to_t.
+    def cast_from_string( str, &yld )
+      args = str.to_s.split(/\W+/)
+      div = /\W+/.match( str.to_s )[0]
+      if block_given?
+        args = args.collect{ |a| yld[a] }
+      else
+        args = args.collect { |i| /^[0-9]+$/ =~ i ? i.to_i : i }
+      end
+      self.instance(args) #.divider( div )
+    end
+
+    #
+    def cast_from_array( arr )
+      self.instance( arr )
+    end
+
+    # Parses a constraint returning the operation as a lambda.
+    def constraint_to_lambda( constraint, &yld )
+      op, val = *parse_constraint( constraint, &yld )
+      lambda { |t| t.send(op, val) }
+    end
+
+    #
+    def parse_constraint( constraint, &yld )
+      constraint = constraint.strip
+      re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
+      if md = re.match( constraint )
+        if op = md[1]
+          op = '=~' if op == '~>'
+          op = '==' if op == '='
+          val = cast_from_string( md[2], &yld ) #instance( md[2] )
+        else
+          op = '=='
+          val = cast_from_string( constraint, &yld ) #instance( constraint )
+        end
+      else
+        raise ArgumentError, "invalid constraint"
+      end
+      return op, val
+    end
+
+  end
+
+end
+
+
+class ::String
+
+  # Translates a string in the form on a set of numerical and/or
+  # alphanumerical characters separated by non-word characters (eg \W+)
+  # into a Tuple. The values of the tuple will be converted to integers
+  # if they are purely numerical.
+  #
+  #   '1.2.3a'.to_t  #=> [1,2,"3a"]
+  #
+  # It you would like to control the interpretation of each value
+  # as it is added to the tuple you can supply a block.
+  #
+  #   '1.2.3a'.to_t { |v| v.upcase }  #=> ["1","2","3A"]
+  #
+  # This method calls Tuple.cast_from_string.
+  def to_t( &yld )
+    Tuple.cast_from_string( self, &yld )
+  end
+
+end
+
+
+class ::Array
+
+  # Convert an array into a tuple.
+  def to_t
+    Tuple.cast_from_array( self )
+  end
+
+end

data/lib/standard/facets/uri/cgi_escape.rb

@@ -0,0 +1,46 @@
+require 'uri'
+
+module URI
+
+  module_function
+
+  # TODO: How does `URI.cgi_escape` compare to `URI.escape`?
+
+  #
+  # CGI 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
+
+end
+

data/lib/standard/facets/uri/cgi_parse.rb

@@ -0,0 +1 @@
+require 'facets/uri/cgi_escape'

data/lib/standard/facets/uri/cgi_unescape.rb

@@ -0,0 +1 @@
+require 'facets/uri/cgi_escape'

data/lib/standard/facets/uri/decode.rb

@@ -0,0 +1,32 @@
+require 'uri'
+
+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
+
+end