activesupport 2.3.18 → 3.0.0.beta

data/lib/active_support/core_ext/range.rb

@@ -1,11 +1,4 @@
+require 'active_support/core_ext/range/blockless_step'
 require 'active_support/core_ext/range/conversions'
-require 'active_support/core_ext/range/overlaps'
 require 'active_support/core_ext/range/include_range'
-require 'active_support/core_ext/range/blockless_step'
-
-class Range #:nodoc:
-  include ActiveSupport::CoreExtensions::Range::Conversions
-  include ActiveSupport::CoreExtensions::Range::Overlaps
-  include ActiveSupport::CoreExtensions::Range::IncludeRange
-  include ActiveSupport::CoreExtensions::Range::BlocklessStep
-end
+require 'active_support/core_ext/range/overlaps'

data/lib/active_support/core_ext/range/blockless_step.rb

@@ -1,32 +1,29 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Range #:nodoc:
-      # Return an array when step is called without a block.
-      module BlocklessStep
-        def self.included(base) #:nodoc:
-          base.alias_method_chain :step, :blockless
-        end
+require 'active_support/core_ext/module/aliasing'
 
-        if RUBY_VERSION < '1.9'
-          def step_with_blockless(value = 1, &block)
-            if block_given?
-              step_without_blockless(value, &block)
-            else
-              [].tap do |array|
-                step_without_blockless(value) { |step| array << step }
-              end
-            end
-          end
-        else
-          def step_with_blockless(value = 1, &block)
-            if block_given?
-              step_without_blockless(value, &block)
-            else
-              step_without_blockless(value).to_a
-            end
-          end
-        end
+class Range
+  begin
+    (1..2).step
+  # Range#step doesn't return an Enumerator
+  rescue LocalJumpError
+    # Return an array when step is called without a block.
+    def step_with_blockless(*args, &block)
+      if block_given?
+        step_without_blockless(*args, &block)
+      else
+        array = []
+        step_without_blockless(*args) { |step| array << step }
+        array
+      end
+    end
+  else
+    def step_with_blockless(*args, &block) #:nodoc:
+      if block_given?
+        step_without_blockless(*args, &block)
+      else
+        step_without_blockless(*args).to_a
       end
     end
   end
+
+  alias_method_chain :step, :blockless
 end

data/lib/active_support/core_ext/range/conversions.rb

@@ -1,27 +1,21 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Range #:nodoc:
-      # Getting ranges in different convenient string representations and other objects
-      module Conversions
-        RANGE_FORMATS = {
-          :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
-        }
+class Range
+  RANGE_FORMATS = {
+    :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
+  }
 
-        def self.included(base) #:nodoc:
-          base.class_eval do
-            alias_method :to_default_s, :to_s
-            alias_method :to_s, :to_formatted_s
-          end
-        end
-        # Gives a human readable format of the range.
-        #
-        # ==== Example
-        # 
-        #   [1..100].to_formatted_s # => "1..100"
-        def to_formatted_s(format = :default)
-          RANGE_FORMATS[format] ? RANGE_FORMATS[format].call(first, last) : to_default_s
-        end
-      end
+  # Gives a human readable format of the range.
+  #
+  # ==== Example
+  # 
+  #   [1..100].to_formatted_s # => "1..100"
+  def to_formatted_s(format = :default)
+    if formatter = RANGE_FORMATS[format]
+      formatter.call(first, last)
+    else
+      to_default_s
     end
   end
+
+  alias_method :to_default_s, :to_s
+  alias_method :to_s, :to_formatted_s
 end

data/lib/active_support/core_ext/range/include_range.rb

@@ -1,30 +1,21 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Range #:nodoc:
-      # Check if a Range includes another Range.
-      module IncludeRange
-        def self.included(base) #:nodoc:
-          base.alias_method_chain :include?, :range
-        end
-
-        # Extends the default Range#include? to support range comparisons.
-        #  (1..5).include?(1..5) # => true
-        #  (1..5).include?(2..3) # => true
-        #  (1..5).include?(2..6) # => false
-        #
-        # The native Range#include? behavior is untouched.
-        #  ("a".."f").include?("c") # => true
-        #  (5..9).include?(11) # => false
-        def include_with_range?(value)
-          if value.is_a?(::Range)
-            operator = exclude_end? ? :< : :<=
-            end_value = value.exclude_end? ? last.succ : last
-            include?(value.first) && (value.last <=> end_value).send(operator, 0)
-          else
-            include_without_range?(value)
-          end
-        end
-      end
+class Range
+  # Extends the default Range#include? to support range comparisons.
+  #  (1..5).include?(1..5) # => true
+  #  (1..5).include?(2..3) # => true
+  #  (1..5).include?(2..6) # => false
+  #
+  # The native Range#include? behavior is untouched.
+  #  ("a".."f").include?("c") # => true
+  #  (5..9).include?(11) # => false
+  def include_with_range?(value)
+    if value.is_a?(::Range)
+      operator = exclude_end? ? :< : :<=
+      end_value = value.exclude_end? ? last.succ : last
+      include_without_range?(value.first) && (value.last <=> end_value).send(operator, 0)
+    else
+      include_without_range?(value)
     end
   end
+
+  alias_method_chain :include?, :range
 end

data/lib/active_support/core_ext/range/overlaps.rb

@@ -1,15 +1,8 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Range #:nodoc:
-      # Check if Ranges overlap.
-      module Overlaps
-        # Compare two ranges and see if they overlap eachother
-        #  (1..5).overlaps?(4..6) # => true
-        #  (1..5).overlaps?(7..9) # => false
-        def overlaps?(other)
-          include?(other.first) || other.include?(first)
-        end
-      end
-    end
+class Range
+  # Compare two ranges and see if they overlap eachother
+  #  (1..5).overlaps?(4..6) # => true
+  #  (1..5).overlaps?(7..9) # => false
+  def overlaps?(other)
+    include?(other.first) || other.include?(first)
   end
 end

data/lib/active_support/core_ext/regexp.rb

@@ -0,0 +1,5 @@
+class Regexp #:nodoc:
+  def multiline?
+    options & MULTILINE == MULTILINE
+  end
+end

data/lib/active_support/core_ext/rexml.rb

@@ -1,18 +1,23 @@
+require 'active_support/core_ext/kernel/reporting'
+
 # Fixes the rexml vulnerability disclosed at:
 # http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
-# This fix is identical to rexml-expansion-fix version 1.0.1
+# This fix is identical to rexml-expansion-fix version 1.0.1.
+#
+# We still need to distribute this fix because albeit the REXML
+# in recent 1.8.7s is patched, it wasn't in early patchlevels.
 require 'rexml/rexml'
 
 # Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION
 unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
-  require 'rexml/document'
+  silence_warnings { require 'rexml/document' }
 
-  # REXML in 1.8.7 has the patch but didn't update Version from 3.1.7.2.
+  # REXML in 1.8.7 has the patch but early patchlevels didn't update Version from 3.1.7.2.
   unless REXML::Document.respond_to?(:entity_expansion_limit=)
-    require 'rexml/entity'
+    silence_warnings { require 'rexml/entity' }
 
-    module REXML
-      class Entity < Child
+    module REXML #:nodoc:
+      class Entity < Child #:nodoc:
         undef_method :unnormalized
         def unnormalized
           document.record_entity_expansion! if document
@@ -22,7 +27,7 @@ unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
           @unnormalized
         end
       end
-      class Document < Element
+      class Document < Element #:nodoc:
         @@entity_expansion_limit = 10_000
         def self.entity_expansion_limit= val
           @@entity_expansion_limit = val

data/lib/active_support/core_ext/string.rb

@@ -1,24 +1,11 @@
-# encoding: utf-8
-
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/string/bytesize'
 require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/access'
-require 'active_support/core_ext/string/starts_ends_with'
-require 'active_support/core_ext/string/iterators'
+require 'active_support/core_ext/string/filters'
 require 'active_support/core_ext/string/multibyte'
+require 'active_support/core_ext/string/starts_ends_with'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/access'
 require 'active_support/core_ext/string/xchar'
-require 'active_support/core_ext/string/filters'
 require 'active_support/core_ext/string/behavior'
+require 'active_support/core_ext/string/interpolation'
 require 'active_support/core_ext/string/output_safety'
-
-class String #:nodoc:
-  include ActiveSupport::CoreExtensions::String::Access
-  include ActiveSupport::CoreExtensions::String::Conversions
-  include ActiveSupport::CoreExtensions::String::Filters
-  include ActiveSupport::CoreExtensions::String::Inflections
-  include ActiveSupport::CoreExtensions::String::StartsEndsWith
-  include ActiveSupport::CoreExtensions::String::Iterators
-  include ActiveSupport::CoreExtensions::String::Behavior
-  include ActiveSupport::CoreExtensions::String::Multibyte
-end
+require 'active_support/core_ext/string/exclude'

data/lib/active_support/core_ext/string/access.rb

@@ -1,105 +1,98 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module String #:nodoc:
-      unless '1.9'.respond_to?(:force_encoding)
-        # Makes it easier to access parts of a string, such as specific characters and substrings.
-        module Access
-          # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
-          #
-          # Examples: 
-          #   "hello".at(0)  # => "h"
-          #   "hello".at(4)  # => "o"
-          #   "hello".at(10) # => nil
-          def at(position)
-            mb_chars[position, 1].to_s
-          end
-          
-          # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
-          #
-          # Examples: 
-          #   "hello".from(0)  # => "hello"
-          #   "hello".from(2)  # => "llo"
-          #   "hello".from(10) # => nil
-          def from(position)
-            mb_chars[position..-1].to_s
-          end
-          
-          # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
-          #
-          # Examples: 
-          #   "hello".to(0)  # => "h"
-          #   "hello".to(2)  # => "hel"
-          #   "hello".to(10) # => "hello"
-          def to(position)
-            mb_chars[0..position].to_s
-          end
+require "active_support/multibyte"
 
-          # Returns the first character of the string or the first +limit+ characters.
-          #
-          # Examples: 
-          #   "hello".first     # => "h"
-          #   "hello".first(2)  # => "he"
-          #   "hello".first(10) # => "hello"
-          def first(limit = 1)
-            if limit == 0
-              ''
-            elsif limit >= size
-              self
-            else
-              mb_chars[0...limit].to_s
-            end
-          end
+class String
+  unless '1.9'.respond_to?(:force_encoding)
+    # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples: 
+    #   "hello".at(0)  # => "h"
+    #   "hello".at(4)  # => "o"
+    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
+    def at(position)
+      mb_chars[position, 1].to_s
+    end
+    
+    # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples: 
+    #   "hello".from(0)  # => "hello"
+    #   "hello".from(2)  # => "llo"
+    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
+    def from(position)
+      mb_chars[position..-1].to_s
+    end
+    
+    # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples: 
+    #   "hello".to(0)  # => "h"
+    #   "hello".to(2)  # => "hel"
+    #   "hello".to(10) # => "hello"
+    def to(position)
+      mb_chars[0..position].to_s
+    end
+
+    # Returns the first character of the string or the first +limit+ characters.
+    #
+    # Examples: 
+    #   "hello".first     # => "h"
+    #   "hello".first(2)  # => "he"
+    #   "hello".first(10) # => "hello"
+    def first(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        mb_chars[0...limit].to_s
+      end
+    end
 
-          # Returns the last character of the string or the last +limit+ characters.
-          #
-          # Examples: 
-          #   "hello".last     # => "o"
-          #   "hello".last(2)  # => "lo"
-          #   "hello".last(10) # => "hello"
-          def last(limit = 1)
-            if limit == 0
-              ''
-            elsif limit >= size
-              self
-            else
-              mb_chars[(-limit)..-1].to_s
-            end
-          end
-        end
+    # Returns the last character of the string or the last +limit+ characters.
+    #
+    # Examples: 
+    #   "hello".last     # => "o"
+    #   "hello".last(2)  # => "lo"
+    #   "hello".last(10) # => "hello"
+    def last(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
       else
-        module Access #:nodoc:
-          def at(position)
-            self[position]
-          end
+        mb_chars[(-limit)..-1].to_s
+      end
+    end
+  else
+    def at(position)
+      self[position]
+    end
 
-          def from(position)
-            self[position..-1]
-          end
+    def from(position)
+      self[position..-1]
+    end
 
-          def to(position)
-            self[0..position]
-          end
+    def to(position)
+      self[0..position]
+    end
 
-          def first(limit = 1)
-            if limit == 0
-              ''
-            elsif limit >= size
-              self
-            else
-              to(limit - 1)
-            end
-          end
+    def first(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        to(limit - 1)
+      end
+    end
 
-          def last(limit = 1)
-            if limit == 0
-              ''
-            elsif limit >= size
-              self
-            else
-              from(-limit)
-            end
-          end
-        end
+    def last(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        from(-limit)
       end
     end
   end