activesupport 3.0.0.beta4 → 3.0.pre

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

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/multibyte'
-
 class String
   # Returns the string, first removing all whitespace on both ends of
   # the string, and then changing remaining consecutive whitespace
@@ -19,31 +17,4 @@ class String
     gsub!(/\s+/, ' ')
     self
   end
-
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
-  #
-  #   "Once upon a time in a world far far away".truncate(27)
-  #   # => "Once upon a time in a wo..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>:length</tt>:
-  #
-  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
-  #   # => "Once upon a time in a..."
-  #
-  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
-  #
-  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
-  #   # => "And they f... (continued)"
-  def truncate(length, options = {})
-    text = self.dup
-    options[:omission] ||= "..."
-
-    length_with_room_for_omission = length - options[:omission].mb_chars.length
-    chars = text.mb_chars
-    stop = options[:separator] ?
-      (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
-
-    (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
-  end
 end

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

@@ -2,7 +2,7 @@
 # For instance, you can figure out the name of a database from the name of a class.
 #
 #   "ScaleScore".tableize # => "scale_scores"
-#
+
 class String
   # Returns the plural form of the word in the string.
   #
@@ -146,4 +146,15 @@ class String
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end
+
+  # +constantize+ tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize # => Module
+  #   "Class".constantize  # => Class
+  def constantize
+    ActiveSupport::Inflector.constantize(self)
+  end
 end

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

@@ -1,2 +1,92 @@
-require 'active_support/i18n'
-require 'i18n/core_ext/string/interpolate'
+=begin
+  heavily based on Masao Mutoh's gettext String interpolation extension
+  http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
+  Copyright (C) 2005-2009 Masao Mutoh
+  You may redistribute it and/or modify it under the same license terms as Ruby.
+=end
+
+if RUBY_VERSION < '1.9'
+  require 'active_support/core_ext/string/bytesize'
+
+  # KeyError is raised by String#% when the string contains a named placeholder
+  # that is not contained in the given arguments hash. Ruby 1.9 includes and
+  # raises this exception natively. We define it to mimic Ruby 1.9's behaviour
+  # in Ruby 1.8.x
+
+  class KeyError < IndexError
+    def initialize(message = nil)
+      super(message || "key not found")
+    end
+  end unless defined?(KeyError)
+
+  # Extension for String class. This feature is included in Ruby 1.9 or later but not occur TypeError.
+  #
+  # String#% method which accept "named argument". The translator can know
+  # the meaning of the msgids using "named argument" instead of %s/%d style.
+
+  class String
+    alias :interpolate_without_ruby_19_syntax :% # :nodoc:
+
+    INTERPOLATION_PATTERN = Regexp.union(
+      /%%/,
+      /%\{(\w+)\}/,                               # matches placeholders like "%{foo}"
+      /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
+    )
+
+    # % uses self (i.e. the String) as a format specification and returns the
+    # result of applying it to the given arguments. In other words it interpolates
+    # the given arguments to the string according to the formats the string
+    # defines.
+    #
+    # There are three ways to use it:
+    #
+    # * Using a single argument or Array of arguments.
+    #
+    #   This is the default behaviour of the String class. See Kernel#sprintf for
+    #   more details about the format string.
+    #
+    #   Example:
+    #
+    #     "%d %s" % [1, "message"]
+    #     # => "1 message"
+    #
+    # * Using a Hash as an argument and unformatted, named placeholders.
+    #
+    #   When you pass a Hash as an argument and specify placeholders with %{foo}
+    #   it will interpret the hash values as named arguments.
+    #
+    #   Example:
+    #
+    #     "%{firstname}, %{lastname}" % {:firstname => "Masao", :lastname => "Mutoh"}
+    #     # => "Masao Mutoh"
+    #
+    # * Using a Hash as an argument and formatted, named placeholders.
+    #
+    #   When you pass a Hash as an argument and specify placeholders with %<foo>d
+    #   it will interpret the hash values as named arguments and format the value
+    #   according to the formatting instruction appended to the closing >.
+    #
+    #   Example:
+    #
+    #     "%<integer>d, %<float>.1f" % { :integer => 10, :float => 43.4 }
+    #     # => "10, 43.3"
+    def %(args)
+      if args.kind_of?(Hash)
+        dup.gsub(INTERPOLATION_PATTERN) do |match|
+          if match == '%%'
+            '%'
+          else
+            key = ($1 || $2).to_sym
+            raise KeyError unless args.has_key?(key)
+            $3 ? sprintf("%#{$3}", args[key]) : args[key]
+          end
+        end
+      elsif self =~ INTERPOLATION_PATTERN
+        raise ArgumentError.new('one hash required')
+      else
+        result = gsub(/%([{<])/, '%%\1')
+        result.send :'interpolate_without_ruby_19_syntax', args
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+unless '1.9'.respond_to?(:each_char)
+  class String
+    # Yields a single-character string for each character in the string.
+    # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
+    def each_char
+      require 'strscan' unless defined? ::StringScanner
+      scanner, char = ::StringScanner.new(self), /./mu
+      while c = scanner.scan(char)
+        yield c
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
 require 'active_support/multibyte'
 
 class String
-  if '1.9'.respond_to?(:force_encoding)
+  unless '1.9'.respond_to?(:force_encoding)
     # == Multibyte proxy
     #
     # +mb_chars+ is a multibyte safe proxy for string methods.
@@ -37,13 +37,30 @@ class String
     # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
     # information about how to change the default Multibyte behaviour see ActiveSupport::Multibyte.
     def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.consumes?(self)
+      if ActiveSupport::Multibyte.proxy_class.wants?(self)
         ActiveSupport::Multibyte.proxy_class.new(self)
       else
         self
       end
     end
+    
+    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
+    # them), returns false otherwise.
+    def is_utf8?
+      ActiveSupport::Multibyte::Chars.consumes?(self)
+    end
 
+    unless '1.8.7 and later'.respond_to?(:chars)
+      def chars
+        ActiveSupport::Deprecation.warn('String#chars has been deprecated in favor of String#mb_chars.', caller)
+        mb_chars
+      end
+    end
+  else
+    def mb_chars #:nodoc
+      self
+    end
+    
     def is_utf8? #:nodoc
       case encoding
       when Encoding::UTF_8
@@ -54,19 +71,5 @@ class String
         false
       end
     end
-  else
-    def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.wants?(self)
-        ActiveSupport::Multibyte.proxy_class.new(self)
-      else
-        self
-      end
-    end
-
-    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
-    # them), returns false otherwise.
-    def is_utf8?
-      ActiveSupport::Multibyte::Chars.consumes?(self)
-    end
   end
 end

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

@@ -1,109 +1,43 @@
-require 'erb'
-require 'active_support/core_ext/kernel/singleton_class'
-
-class ERB
-  module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
-    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
-
-    # A utility method for escaping HTML tag characters.
-    # This method is also aliased as <tt>h</tt>.
-    #
-    # In your ERb templates, use this method to escape any unsafe content. For example:
-    #   <%=h @person.name %>
-    #
-    # ==== Example:
-    #   puts html_escape("is a > 0 & a < 10?")
-    #   # => is a &gt; 0 &amp; a &lt; 10?
-    def html_escape(s)
-      s = s.to_s
-      if s.html_safe?
-        s
-      else
-        s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.html_safe
-      end
-    end
-
-    remove_method(:h)
-    alias h html_escape
-
-    module_function :h
-
-    singleton_class.send(:remove_method, :html_escape)
-    module_function :html_escape
-
-    # A utility method for escaping HTML entities in JSON strings.
-    # This method is also aliased as <tt>j</tt>.
-    #
-    # In your ERb templates, use this method to escape any HTML entities:
-    #   <%=j @person.to_json %>
-    #
-    # ==== Example:
-    #   puts json_escape("is a > 0 & a < 10?")
-    #   # => is a \u003E 0 \u0026 a \u003C 10?
-    def json_escape(s)
-      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
-    end
-
-    alias j json_escape
-    module_function :j
-    module_function :json_escape
-  end
-end
-
-class Object
+class String
   def html_safe?
-    false
+    defined?(@_rails_html_safe) && @_rails_html_safe
   end
-end
 
-class Fixnum
-  def html_safe?
-    true
+  def html_safe!
+    @_rails_html_safe = true
+    self
   end
-end
-
-module ActiveSupport #:nodoc:
-  class SafeBuffer < String
-    alias safe_concat concat
-
-    def concat(value)
-      if value.html_safe?
-        super(value)
-      else
-        super(ERB::Util.h(value))
-      end
-    end
-    alias << concat
-
-    def +(other)
-      dup.concat(other)
-    end
-
-    def html_safe?
-      true
-    end
-
-    def html_safe
-      self
-    end
-
-    def to_s
-      self
-    end
-
-    def to_yaml(*args)
-      to_str.to_yaml(*args)
+  
+  def html_safe
+    dup.html_safe!
+  end
+  
+  alias original_plus +
+  def +(other)
+    result = original_plus(other)
+    if html_safe? && also_html_safe?(other)
+      result.html_safe!
+    else
+      result
     end
   end
-end
-
-class String
-  def html_safe!
-    raise "You can't call html_safe! on a String"
+  
+  alias original_concat <<
+  def <<(other)
+    result = original_concat(other)
+    unless html_safe? && also_html_safe?(other)
+      @_rails_html_safe = false
+    end
+    result
   end
-
-  def html_safe
-    ActiveSupport::SafeBuffer.new(self)
+  
+  def concat(other)
+    self << other
   end
-end
+  
+  private
+    def also_html_safe?(other)
+      other.respond_to?(:html_safe?) && other.html_safe?
+    end
+  
+end

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

@@ -1,4 +1,18 @@
 class String
+  unless '1.8.7 and up'.respond_to?(:start_with?)
+    # Does the string start with the specified +prefix+?
+    def start_with?(prefix)
+      prefix = prefix.to_s
+      self[0, prefix.length] == prefix
+    end
+
+    # Does the string end with the specified +suffix+?
+    def end_with?(suffix)
+      suffix = suffix.to_s
+      self[-suffix.length, suffix.length] == suffix
+    end
+  end
+
   alias_method :starts_with?, :start_with?
   alias_method :ends_with?, :end_with?
 end

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

@@ -1,5 +1,5 @@
 begin
-  # See http://fast-xs.rubyforge.org/ by Eric Wong.
+  # See http://bogomips.org/fast_xs/ by Eric Wong.
   # Also included with hpricot.
   require 'fast_xs'
 rescue LoadError

data/lib/active_support/core_ext/symbol.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/symbol/to_proc'

data/lib/active_support/core_ext/symbol/to_proc.rb

@@ -0,0 +1,14 @@
+class Symbol
+  # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+  #
+  #   # The same as people.collect { |p| p.name }
+  #   people.collect(&:name)
+  #
+  #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+  #   people.select(&:manager?).collect(&:salary)
+  #
+  # This is a builtin method in Ruby 1.8.7 and later.
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end unless :to_proc.respond_to?(:to_proc)
+end

data/lib/active_support/core_ext/time.rb

@@ -0,0 +1,10 @@
+require 'date'
+require 'time'
+
+require 'active_support/core_ext/time/publicize_conversion_methods'
+require 'active_support/core_ext/time/marshal_with_utc_flag'
+
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/time/zones'

data/lib/active_support/core_ext/time/calculations.rb

@@ -1,7 +1,5 @@
 require 'active_support/duration'
-require 'active_support/core_ext/date/acts_like'
 require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
 
 class Time
   COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@ -24,11 +22,10 @@ class Time
     # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
     # otherwise returns a DateTime
     def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
-      time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
-      # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
-      time.year == year ? time : ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
+      ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
     rescue
-      ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
+      offset = utc_or_local.to_sym == :local ? ::DateTime.local_offset : 0
+      ::DateTime.civil(year, month, day, hour, min, sec, offset)
     end
 
     # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
@@ -133,7 +130,7 @@ class Time
   end
 
   # Short-hand for years_ago(1)
-  def prev_year
+  def last_year
     years_ago(1)
   end
 
@@ -142,8 +139,9 @@ class Time
     years_since(1)
   end
 
+
   # Short-hand for months_ago(1)
-  def prev_month
+  def last_month
     months_ago(1)
   end
 
@@ -260,7 +258,7 @@ class Time
   # are coerced into values that Time#- will recognize
   def minus_with_coercion(other)
     other = other.comparable_time if other.respond_to?(:comparable_time)
-    other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
+    minus_without_coercion(other)
   end
   alias_method :minus_without_coercion, :-
   alias_method :-, :minus_with_coercion