rhodes 3.2.0.beta.4 → 3.2.0.beta.5

data/lib/extensions/net-http/net/protocol.rb

@@ -11,7 +11,7 @@
 # modify this program under the same terms as Ruby itself,
 # Ruby Distribute License or GNU General Public License.
 #
-# $Id: protocol.rb 12091 2007-03-19 02:27:08Z aamine $
+# $Id: protocol.rb 25189 2009-10-02 12:04:37Z akr $
 #++
 #
 # WARNING: This file is going to remove.
@@ -131,9 +131,25 @@ module Net # :nodoc:
     BUFSIZE = 1024 * 16
 
     def rbuf_fill
-      timeout(@read_timeout) {
-        @rbuf << @io.sysread(BUFSIZE)
-      }
+      
+      begin
+        @rbuf << @io.read_nonblock(BUFSIZE)
+      rescue IO::WaitReadable
+        if IO.select([@io], nil, nil, @read_timeout)
+          retry
+        else
+          raise Timeout::Error
+        end
+      rescue IO::WaitWritable
+        # OpenSSL::Buffering#read_nonblock may fail with IO::WaitWritable.
+        # http://www.openssl.org/support/faq.html#PROG10
+        if IO.select(nil, [@io], nil, @read_timeout)
+          retry
+        else
+          raise Timeout::Error
+        end
+      end
+      
     end
 
     def rbuf_consume(len)

data/lib/extensions/rexml/rexml/document.rb

@@ -67,26 +67,28 @@ module REXML
     # We override this, because XMLDecls and DocTypes must go at the start
     # of the document
     def add( child )
-      if child.kind_of? XMLDecl
-        @children.unshift child
+      if child.kind_of? ( XMLDecl )
+        if @children[0].kind_of?( XMLDecl )
+          @children[0] = child
+        else
+          @children.unshift child
+        end
         child.parent = self
       elsif child.kind_of? DocType
         # Find first Element or DocType node and insert the decl right 
         # before it.  If there is no such node, just insert the child at the
         # end.  If there is a child and it is an DocType, then replace it.
-        insert_before_index = 0
-        @children.find { |x| 
-          insert_before_index += 1
+        insert_before_index = @children.find_index { |x|
           x.kind_of?(Element) || x.kind_of?(DocType)
         }
-        if @children[ insert_before_index ] # Not null = not end of list
-          if @children[ insert_before_index ].kind_of DocType
+        if insert_before_index # Not null = not end of list
+          if @children[ insert_before_index ].kind_of? DocType
             @children[ insert_before_index ] = child
           else
-            @children[ index_before_index-1, 0 ] = child
+            @children[ insert_before_index-1, 0 ] = child
           end
         else  # Insert at end of list
-          @children[insert_before_index] = child
+          @children << child
         end
         child.parent = self
       else

data/lib/extensions/rexml/rexml/element.rb

@@ -492,7 +492,7 @@ module REXML
     def text=( text )
       if text.kind_of? String
         text = Text.new( text, whitespace(), nil, raw() )
-      elsif text and !text.kind_of? Text
+      elsif !text.nil? and !text.kind_of? Text
         text = Text.new( text.to_s, whitespace(), nil, raw() )
       end
       old_text = get_text

data/lib/extensions/rexml/rexml/entity.rb

@@ -25,7 +25,7 @@ module REXML
     # Create a new entity.  Simple entities can be constructed by passing a
     # name, value to the constructor; this creates a generic, plain entity
     # reference. For anything more complicated, you have to pass a Source to
-    # the constructor with the entity definiton, or use the accessor methods.
+    # the constructor with the entity definition, or use the accessor methods.
     # +WARNING+: There is no validation of entity state except when the entity
     # is read from a stream.  If you start poking around with the accessors,
     # you can easily create a non-conformant Entity.  The best thing to do is

data/lib/extensions/rexml/rexml/formatters/default.rb

@@ -63,7 +63,9 @@ module REXML
       def write_element( node, output )
         output << "<#{node.expanded_name}"
 
-        node.attributes.to_a.sort_by {|attr| attr.name}.each do |attr|
+        node.attributes.to_a.map { |a|
+          Hash === a ? a.values : a
+        }.flatten.sort_by {|attr| attr.name}.each do |attr|
           output << " "
           attr.write( output )
         end unless node.attributes.empty?

data/lib/extensions/rexml/rexml/formatters/pretty.rb

@@ -88,7 +88,7 @@ module REXML
         s = node.to_s()
         s.gsub!(/\s/,' ')
         s.squeeze!(" ")
-        s = wrap(s, 80-@level)
+        s = wrap(s, @width - @level)
         s = indent_text(s, @level, " ", true)
         output << (' '*@level + s)
       end

data/lib/extensions/rexml/rexml/light/node.rb

@@ -1,5 +1,4 @@
 require 'rexml/xmltokens'
-require 'rexml/light/node'
 
 # [ :element, parent, name, attributes, children* ]
   # a = Node.new
@@ -163,7 +162,7 @@ module REXML
       private
 
       def namesplit
-        return if defined? @name
+        return if @name.defined?
         at(2) =~ NAMESPLIT
         @prefix = '' || $1
         @name = $2

data/lib/extensions/rexml/rexml/parent.rb

@@ -34,6 +34,7 @@ module REXML
       found = false
       @children.delete_if {|c| c.equal?(object) and found = true }
       object.parent = nil if found
+      found ? object : nil
     end
     
     def each(&block)

data/lib/extensions/rexml/rexml/parsers/xpathparser.rb

@@ -17,6 +17,7 @@ module REXML
       end
 
       def parse path
+        path = path.dup
         path.gsub!(/([\(\[])\s+/, '\1') # Strip ignorable spaces
         path.gsub!( /\s+([\]\)])/, '\1' )
         parsed = []
@@ -551,7 +552,7 @@ module REXML
           end
         end
         #puts "BEFORE WITH '#{rest}'"
-        rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w_*]/
+        rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w*]/
         parsed.concat(n)
         return rest
       end

data/lib/extensions/rexml/rexml/quickpath.rb

@@ -141,6 +141,7 @@ module REXML
       return matches.uniq
     end
 
+    OPERAND_ = '((?=(?:(?!and|or).)*[^\s<>=])[^\s<>=]+)'
     # A predicate filters a node-set with respect to an axis to produce a
     # new node-set. For each node in the node-set to be filtered, the 
     # PredicateExpr is evaluated with that node as the context node, with 
@@ -170,7 +171,9 @@ module REXML
       rest = path[ind+1..-1]
 
       # have to change 'a [=<>] b [=<>] c' into 'a [=<>] b and b [=<>] c'
-      predicate.gsub!( /([^\s(and)(or)<>=]+)\s*([<>=])\s*([^\s(and)(or)<>=]+)\s*([<>=])\s*([^\s(and)(or)<>=]+)/u,
+      #
+      predicate.gsub!(
+        /#{OPERAND_}\s*([<>=])\s*#{OPERAND_}\s*([<>=])\s*#{OPERAND_}/u,
         '\1 \2 \3 and \3 \4 \5' )
       # Let's do some Ruby trickery to avoid some work:
       predicate.gsub!( /&/u, "&&" )

data/lib/extensions/rexml/rexml/rexml.rb

@@ -24,7 +24,7 @@ module REXML
   COPYRIGHT = "Copyright © 2001-2008 Sean Russell <ser@germane-software.com>"
   DATE = "2008/019"
   VERSION = "3.1.7.3"
-  REVISION = "$Revision: 15141 $".gsub(/\$Revision:|\$/,'').strip
+  REVISION = %w$Revision: 26193 $[1] || ''
 
   Copyright = COPYRIGHT
   Version = VERSION

data/lib/extensions/rexml/rexml/source.rb

@@ -162,6 +162,15 @@ module REXML
         @line_break = ">"
       end
       super( @source.eof? ? str : str+@source.readline( @line_break ) )
+
+      if !@to_utf and
+          @buffer.respond_to?(:force_encoding) and
+          @source.respond_to?(:external_encoding) and
+          @source.external_encoding != ::Encoding::UTF_8
+        @force_utf8 = true
+      else
+        @force_utf8 = false
+      end
     end
 
     def scan(pattern, cons=false)
@@ -174,11 +183,7 @@ module REXML
       if rv.size == 0
         until @buffer =~ pattern or @source.nil?
           begin
-            # READLINE OPT
-            #str = @source.read(@block_size)
-            str = @source.readline(@line_break)
-            str = decode(str) if @to_utf and str
-            @buffer << str
+            @buffer << readline
           rescue Iconv::IllegalSequence
             raise
           rescue
@@ -193,12 +198,7 @@ module REXML
 
     def read
       begin
-        str = @source.readline(@line_break)
-        str = decode(str) if @to_utf and str 
-        @buffer << str
-        if not @to_utf and @buffer.respond_to? :force_encoding
-          @buffer.force_encoding Encoding::UTF_8
-        end
+        @buffer << readline
       rescue Exception, NameError
         @source = nil
       end
@@ -213,9 +213,7 @@ module REXML
       @buffer = $' if cons and rv
       while !rv and @source
         begin
-          str = @source.readline(@line_break)
-          str = decode(str) if @to_utf and str
-          @buffer << str
+          @buffer << readline
           rv = pattern.match(@buffer)
           @buffer = $' if cons and rv
         rescue
@@ -254,5 +252,18 @@ module REXML
       end
       [pos, lineno, line]
     end
+
+    private
+    def readline
+      str = @source.readline(@line_break)
+      return nil if str.nil?
+
+      if @to_utf
+        decode(str)
+      else
+        str.force_encoding(::Encoding::UTF_8) if @force_utf8
+        str
+      end
+    end
   end
 end

data/lib/extensions/rexml/rexml/text.rb

@@ -36,7 +36,8 @@ module REXML
           when Range
             [item.first, '-'.ord, item.last].pack('UUU').force_encoding('utf-8')
           end
-        }.join + ']*$')
+        }.join +
+      ']*$')
     else
       VALID_XML_CHARS = /^(
            [\x09\x0A\x0D\x20-\x7E]            # ASCII
@@ -87,17 +88,16 @@ module REXML
     #   Text.new( "sean russell", false, nil, true, ["s"] ) #-> "sean russell"
     # In the last example, the +entity_filter+ argument is ignored.
     #
-    # +pattern+ INTERNAL USE ONLY
-    def initialize(arg, respect_whitespace=false, parent=nil, raw=nil, 
+    # +illegal+ INTERNAL USE ONLY
+    def initialize(arg, respect_whitespace=false, parent=nil, raw=nil,
       entity_filter=nil, illegal=NEEDS_A_SECOND_CHECK )
 
       @raw = false
+      @parent = nil
 
       if parent
         super( parent )
-        @raw = parent.raw 
-      else
-        @parent = nil
+        @raw = parent.raw
       end
 
       @raw = raw unless raw.nil?
@@ -105,20 +105,18 @@ module REXML
       @normalized = @unnormalized = nil
 
       if arg.kind_of? String
-        @string = arg.clone
+        @string = arg.dup
         @string.squeeze!(" \n\t") unless respect_whitespace
-      else  
-          if arg.kind_of? Text
-            @string = arg.to_s
-            @raw = arg.raw
-          else
-            raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
-          end
+      elsif arg.kind_of? Text
+        @string = arg.to_s
+        @raw = arg.raw
+      elsif
+        raise "Illegal argument of type #{arg.type} for Text constructor (#{arg})"
       end
-      
+
       @string.gsub!( /\r\n?/, "\n" )
 
-      Text.check(@string, NEEDS_A_SECOND_CHECK, doctype) if @raw and @parent
+      Text.check(@string, illegal, doctype) if @raw
     end
 
     def parent= parent
@@ -161,10 +159,11 @@ module REXML
             else
               raise "Illegal character '#{$1}' in raw string \"#{string}\""
             end
-          elsif $3 and !SUBSTITUTES.include?($1)
-            if !doctype or !doctype.entities.has_key?($3)
-              raise "Undeclared entity '#{$1}' in raw string \"#{string}\""
-            end
+          # FIXME: below can't work but this needs API change.
+          # elsif @parent and $3 and !SUBSTITUTES.include?($1)
+          #   if !doctype or !doctype.entities.has_key?($3)
+          #     raise "Undeclared entity '#{$1}' in raw string \"#{string}\""
+          #   end
           end
         end
       end
@@ -276,7 +275,7 @@ module REXML
     def indent_text(string, level=1, style="\t", indentfirstline=true)
       return string if level < 0
       new_string = ''
-      string.each { |line|
+      string.each_line { |line|
         indent_string = style * level
         new_line = (indent_string + line).sub(/[\s]+$/,'')
         new_string << new_line

data/lib/extensions/rexml/rexml/xmldecl.rb

@@ -76,10 +76,10 @@ module REXML
 
     def encoding=( enc )
       if enc.nil?
-        @@old_enc = "UTF-8"
+        self.old_enc = "UTF-8"
         @writeencoding = false
       else
-        @@old_enc = enc
+        self.old_enc = enc
         @writeencoding = true
       end
       self.dowrite

data/lib/extensions/rexml/rexml/xmltokens.rb

@@ -2,10 +2,10 @@ module REXML
   # Defines a number of tokens used for parsing XML.  Not for general
   # consumption.
   module XMLTokens
-    NCNAME_STR= '[\w:][\-\w\d.]*'
+    NCNAME_STR= '[\w:][\-\w.]*'
     NAME_STR= "(?:#{NCNAME_STR}:)?#{NCNAME_STR}"
 
-    NAMECHAR = '[\-\w\d\.:]'
+    NAMECHAR = '[\-\w\.:]'
     NAME = "([\\w:]#{NAMECHAR}*)"
     NMTOKEN = "(?:#{NAMECHAR})+"
     NMTOKENS = "#{NMTOKEN}(\\s+#{NMTOKEN})*"

data/lib/extensions/rexml/rexml/xpath_parser.rb

@@ -438,7 +438,8 @@ module REXML
         when :and
           left = expr( path_stack.shift, nodeset.dup, context )
           #puts "LEFT => #{left.inspect} (#{left.class.name})"
-          if left == false || left.nil? || !left.inject(false) {|a,b| a | b}
+          return [] unless left
+          if left.respond_to?(:inject) and !left.inject(false) {|a,b| a | b}
             return []
           end
           right = expr( path_stack.shift, nodeset.dup, context )

data/lib/extensions/set/set.rb

@@ -9,7 +9,7 @@
 # All rights reserved.  You can redistribute and/or modify it under the same
 # terms as Ruby.
 #
-#   $Id: set.rb 18571 2008-08-13 08:03:30Z knu $
+#   $Id: set.rb 28095 2010-05-30 13:15:17Z marcandre $
 #
 # == Overview 
 # 
@@ -20,7 +20,7 @@
 #
 # The method +to_set+ is added to Enumerable for convenience.
 #
-# See the Set class for an example of usage.
+# See the Set and SortedSet documentation for examples of usage.
 
 
 #
@@ -70,12 +70,23 @@ class Set
     enum.nil? and return
 
     if block
-      enum.each { |o| add(block[o]) }
+      do_with_enum(enum) { |o| add(block[o]) }
     else
       merge(enum)
     end
   end
 
+  def do_with_enum(enum, &block)
+    if enum.respond_to?(:each_entry)
+      enum.each_entry(&block)
+    elsif enum.respond_to?(:each)
+      enum.each(&block)
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+  private :do_with_enum
+
   # Copy internal hash.
   def initialize_copy(orig)
     @hash = orig.instance_eval{@hash}.dup
@@ -123,7 +134,7 @@ class Set
       @hash.replace(enum.instance_eval { @hash })
     else
       clear
-      enum.each { |o| add(o) }
+      merge(enum)
     end
 
     self
@@ -255,6 +266,14 @@ class Set
     self
   end
 
+  # Deletes every element of the set for which block evaluates to
+  # false, and returns self.
+  def keep_if
+    block_given? or return enum_for(__method__)
+    to_a.each { |o| @hash.delete(o) unless yield(o) }
+    self
+  end
+
   # Replaces the elements with ones returned by collect().
   def collect!
     block_given? or return enum_for(__method__)
@@ -273,13 +292,22 @@ class Set
     size == n ? nil : self
   end
 
+  # Equivalent to Set#keep_if, but returns nil if no changes were
+  # made.
+  def select!
+    block_given? or return enum_for(__method__)
+    n = size
+    keep_if { |o| yield(o) }
+    size == n ? nil : self
+  end
+
   # Merges the elements of the given enumerable object to the set and
   # returns self.
   def merge(enum)
-    if enum.is_a?(Set)
-      @hash.update(enum.instance_eval { @hash })
+    if enum.instance_of?(self.class)
+      @hash.update(enum.instance_variable_get(:@hash))
     else
-      enum.each { |o| add(o) }
+      do_with_enum(enum) { |o| add(o) }
     end
 
     self
@@ -288,7 +316,7 @@ class Set
   # Deletes every element that appears in the given enumerable object
   # and returns self.
   def subtract(enum)
-    enum.each { |o| delete(o) }
+    do_with_enum(enum) { |o| delete(o) }
     self
   end
 
@@ -311,7 +339,7 @@ class Set
   # given enumerable object.
   def &(enum)
     n = self.class.new
-    enum.each { |o| n.add(o) if include?(o) }
+    do_with_enum(enum) { |o| n.add(o) if include?(o) }
     n
   end
   alias intersection &	##
@@ -327,13 +355,16 @@ class Set
 
   # Returns true if two sets are equal.  The equality of each couple
   # of elements is defined according to Object#eql?.
-  def ==(set)
-    equal?(set) and return true
-
-    set.is_a?(Set) && size == set.size or return false
-
-    hash = @hash.dup
-    set.all? { |o| hash.include?(o) }
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
   end
 
   def hash	# :nodoc:
@@ -451,7 +482,35 @@ class Set
   end
 end
 
-# SortedSet implements a set which elements are sorted in order.  See Set.
+# 
+# SortedSet implements a Set that guarantees that it's element are
+# yielded in sorted order (according to the return values of their
+# #<=> methods) when iterating over them.
+# 
+# All elements that are added to a SortedSet must respond to the <=>
+# method for comparison.
+# 
+# Also, all elements must be <em>mutually comparable</em>: <tt>el1 <=>
+# el2</tt> must not return <tt>nil</tt> for any elements <tt>el1</tt>
+# and <tt>el2</tt>, else an ArgumentError will be raised when
+# iterating over the SortedSet.
+#
+# == Example
+# 
+#   require "set"
+#   
+#   set = SortedSet.new([2, 1, 5, 6, 4, 5, 3, 3, 3])
+#   ary = []
+#   
+#   set.each do |obj|
+#     ary << obj
+#   end
+#   
+#   p ary # => [1, 2, 3, 4, 5, 6]
+#   
+#   set2 = SortedSet.new([1, 2, "3"])
+#   set2.each { |obj| } # => raises ArgumentError: comparison of Fixnum with String failed
+#   
 class SortedSet < Set
   @@setup = false
 
@@ -476,6 +535,12 @@ class SortedSet < Set
 	    @hash = RBTree.new
 	    super
 	  end
+	  
+	  def add(o)
+	    o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
+	    super
+	  end
+	  alias << add
 	}
       rescue LoadError
 	module_eval %{
@@ -495,9 +560,9 @@ class SortedSet < Set
 	  end
 
 	  def add(o)
+	    o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
 	    @keys = nil
-	    @hash[o] = true
-	    self
+	    super
 	  end
 	  alias << add
 
@@ -515,6 +580,14 @@ class SortedSet < Set
 	    self
 	  end
 
+	  def keep_if
+	    block_given? or return enum_for(__method__)
+	    n = @hash.size
+	    super
+	    @keys = nil if @hash.size != n
+	    self
+	  end
+
 	  def merge(enum)
 	    @keys = nil
 	    super
@@ -600,15 +673,17 @@ end
 # 	end
 # 
 # 	def replace(enum)
+# 	  enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
 # 	  clear
-# 	  enum.each { |o| add(o) }
-# 
+# 	  enum.each_entry { |o| add(o) }
+#
 # 	  self
 # 	end
 # 
 # 	def merge(enum)
-# 	  enum.each { |o| add(o) }
-# 
+# 	  enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
+# 	  enum.each_entry { |o| add(o) }
+#
 # 	  self
 # 	end
 #       }
@@ -674,10 +749,10 @@ class TC_Set < Test::Unit::TestCase
       Set.new([1,2])
       Set.new('a'..'c')
     }
-    assert_raises(NoMethodError) {
+    assert_raises(ArgumentError) {
       Set.new(false)
     }
-    assert_raises(NoMethodError) {
+    assert_raises(ArgumentError) {
       Set.new(1)
     }
     assert_raises(ArgumentError) {