activesupport 1.4.4 → 2.0.0

data/lib/active_support/clean_logger.rb

@@ -1,10 +1,23 @@
 require 'logger'
-require File.dirname(__FILE__) + '/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/attribute_accessors'
 
-class Logger #:nodoc:
+# Extensions to the built in Ruby logger.
+#
+# If you want to use the default log formatter as defined in the Ruby core, then you 
+# will need to set the formatter for the logger as in:
+#
+#   logger.formatter = Formatter.new
+#
+# You can then specify the datetime format, for example:
+#
+#   logger.datetime_format = "%Y-%m-%d"
+#
+# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
+class Logger
+  # Set to false to disable the silencer
   cattr_accessor :silencer
   self.silencer = true
-
+  
   # Silences the logger for the duration of the block.
   def silence(temporary_level = Logger::ERROR)
     if silencer
@@ -18,6 +31,73 @@ class Logger #:nodoc:
       yield self
     end
   end
+  
+  alias :old_datetime_format= :datetime_format=
+  # Logging date-time format (string passed to +strftime+). Ignored if the formatter
+  # does not respond to datetime_format=.
+  def datetime_format=(datetime_format)
+    formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
+  end
+  
+  alias :old_datetime_format :datetime_format
+  # Get the logging datetime format. Returns nil if the formatter does not support
+  # datetime formatting.
+  def datetime_format
+    formatter.datetime_format if formatter.respond_to?(:datetime_format)
+  end
+  
+  alias :old_formatter :formatter if method_defined?(:formatter)
+  # Get the current formatter. The default formatter is a SimpleFormatter which only
+  # displays the log message
+  def formatter
+    @formatter ||= SimpleFormatter.new
+  end
+
+  unless const_defined? :Formatter
+    class Formatter
+      Format = "%s, [%s#%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        Format % [severity[0..0], format_datetime(time), $$, severity, progname,
+        msg2str(msg)]
+      end
+
+      private
+        def format_datetime(time)
+          if @datetime_format.nil?
+            time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
+          else
+            time.strftime(@datetime_format)
+          end
+        end
+
+        def msg2str(msg)
+          case msg
+          when ::String
+            msg
+          when ::Exception
+            "#{ msg.message } (#{ msg.class })\n" <<
+            (msg.backtrace || []).join("\n")
+          else
+            msg.inspect
+          end
+        end
+    end
+  end
+  
+  # Simple formatter which only displays the message.
+  class SimpleFormatter < Logger::Formatter
+    # This method is invoked when a log event occurs
+    def call(severity, timestamp, progname, msg)
+      "#{String === msg ? msg : msg.inspect}\n"
+    end
+  end
 
   private
     alias old_format_message format_message
@@ -28,11 +108,20 @@ class Logger #:nodoc:
     # with Logger from 1.8.3 and vice versa.
     if method_defined?(:formatter=)
       def format_message(severity, timestamp, progname, msg)
-        "#{msg}\n"
+        formatter.call(severity, timestamp, progname, msg)
       end
     else
       def format_message(severity, timestamp, msg, progname)
-        "#{msg}\n"
+        formatter.call(severity, timestamp, progname, msg)
       end
+      
+      attr_writer :formatter
+      public :formatter=
+
+      alias old_format_datetime format_datetime
+      def format_datetime(datetime) datetime end
+
+      alias old_msg2str msg2str
+      def msg2str(msg) msg end
     end
 end

data/lib/active_support/core_ext.rb

@@ -1 +1,4 @@
-Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "active_support/core_ext/#{filename}"
+end

data/lib/active_support/core_ext/array.rb

@@ -1,7 +1,13 @@
-require File.dirname(__FILE__) + '/array/conversions'
-require File.dirname(__FILE__) + '/array/grouping'
+require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/grouping'
+require 'active_support/core_ext/array/random_access'
 
 class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::Access
   include ActiveSupport::CoreExtensions::Array::Conversions
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
   include ActiveSupport::CoreExtensions::Array::Grouping
+  include ActiveSupport::CoreExtensions::Array::RandomAccess
 end

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

@@ -0,0 +1,28 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      # Makes it easier to access parts of an array.
+      module Access
+        # Returns the remaining of the array from the +position+.
+        #
+        # Examples: 
+        #   %w( a b c d ).from(0)  # => %w( a b c d )
+        #   %w( a b c d ).from(2)  # => %w( c d )
+        #   %w( a b c d ).from(10) # => nil
+        def from(position)
+          self[position..-1]
+        end
+        
+        # Returns the beginning of the array up to the +position+.
+        #
+        # Examples: 
+        #   %w( a b c d ).to(0)  # => %w( a )
+        #   %w( a b c d ).to(2)  # => %w( a b c )
+        #   %w( a b c d ).to(10) # => %w( a b c d )
+        def to(position)
+          self[0..position]
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,26 @@
+require 'builder'
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Array #:nodoc:
       module Conversions
-        # Converts the array to comma-seperated sentence where the last element is joined by the connector word. Options:
-        # * <tt>:connector</tt>: The word used to join the last element in arrays with two or more elements (default: "and")
-        # * <tt>:skip_last_comma</tt>: Set to true to return "a, b and c" instead of "a, b, and c".
+        # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+        # * <tt>:connector</tt> - The word used to join the last element in arrays with two or more elements (default: "and")
+        # * <tt>:skip_last_comma</tt> - Set to true to return "a, b and c" instead of "a, b, and c".
         def to_sentence(options = {})
           options.assert_valid_keys(:connector, :skip_last_comma)
           options.reverse_merge! :connector => 'and', :skip_last_comma => false
-          
+          options[:connector] = "#{options[:connector]} " unless options[:connector].nil? || options[:connector].strip == ''
+
           case length
-          	when 0
-          		""
+            when 0
+              ""
             when 1
               self[0]
             when 2
-              "#{self[0]} #{options[:connector]} #{self[1]}"
+              "#{self[0]} #{options[:connector]}#{self[1]}"
             else
-              "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]} #{self[-1]}"
+              "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]}#{self[-1]}"
           end
         end
 
@@ -25,12 +28,14 @@ module ActiveSupport #:nodoc:
         def to_param
           join '/'
         end
-        
-        def self.included(klass) #:nodoc:
-          klass.send(:alias_method, :to_default_s, :to_s)
-          klass.send(:alias_method, :to_s, :to_formatted_s)
+
+        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
-        
+
         def to_formatted_s(format = :default)
           case format
             when :db
@@ -43,7 +48,7 @@ module ActiveSupport #:nodoc:
               to_default_s
           end
         end
-        
+
         def to_xml(options = {})
           raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
 
@@ -63,7 +68,15 @@ module ActiveSupport #:nodoc:
 
           opts = options.merge({ :root => children })
 
-          options[:builder].tag!(root) { each { |e| e.to_xml(opts.merge!({ :skip_instruct => true })) } }
+          xml = options[:builder]
+          if empty?
+            xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
+          else
+            xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
+              yield xml if block_given?
+              each { |e| e.to_xml(opts.merge!({ :skip_instruct => true })) }
+            }
+          end
         end
 
       end

data/lib/active_support/core_ext/array/extract_options.rb

@@ -0,0 +1,19 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module ExtractOptions
+        # Extract options from a set of arguments. Removes and returns the last element in the array if it's a hash, otherwise returns a blank hash.
+        #
+        #   def options(*args)
+        #     args.extract_options!
+        #   end
+        #
+        #   options(1, 2)           # => {}
+        #   options(1, 2, :a => :b) # => {:a=>:b}
+        def extract_options!
+          last.is_a?(::Hash) ? pop : {}
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/array/grouping.rb

@@ -1,3 +1,5 @@
+require 'enumerator'
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Array #:nodoc:
@@ -21,14 +23,23 @@ module ActiveSupport #:nodoc:
         #   ["1", "2"]
         #   ["3"]
         def in_groups_of(number, fill_with = nil, &block)
-          require 'enumerator'
-          collection = dup
-          collection << fill_with until collection.size.modulo(number).zero? unless fill_with == false
-          grouped_collection = [] unless block_given?
-          collection.each_slice(number) do |group|
-            block_given? ? yield(group) : grouped_collection << group
+          if fill_with == false
+            collection = self
+          else
+            # size % number gives how many extra we have;
+            # subtracting from number gives how many to add;
+            # modulo number ensures we don't add group of just fill.
+            padding = (number - size % number) % number
+            collection = dup.concat([fill_with] * padding)
+          end
+
+          if block_given?
+            collection.each_slice(number, &block)
+          else
+            returning [] do |groups|
+              collection.each_slice(number) { |group| groups << group }
+            end
           end
-          grouped_collection unless block_given?
         end
 
         # Divide the array into one or more subarrays based on a delimiting +value+
@@ -40,12 +51,14 @@ module ActiveSupport #:nodoc:
         #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
         def split(value = nil, &block)
           block ||= Proc.new { |e| e == value }
+
           inject([[]]) do |results, element|
             if block.call(element)
               results << []
             else
               results.last << element
             end
+
             results
           end
         end

data/lib/active_support/core_ext/array/random_access.rb

@@ -0,0 +1,12 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module RandomAccess
+        # Return a random element from the array.
+        def rand
+          self[Kernel.rand(length)]
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/bigdecimal.rb

@@ -1,3 +1,2 @@
 require 'bigdecimal'
-
-require File.dirname(__FILE__) + '/bigdecimal/formatting.rb'
+require 'active_support/core_ext/bigdecimal/conversions'

data/lib/active_support/core_ext/bigdecimal/{formatting.rb → conversions.rb}

@@ -1,7 +1,6 @@
 class BigDecimal #:nodoc:
-  
   alias :_original_to_s :to_s
   def to_s(format="F")
     _original_to_s(format)
   end
-end
+end

data/lib/active_support/core_ext/blank.rb

@@ -7,13 +7,7 @@ class Object
   # to
   #   if !address.blank?
   def blank?
-    if respond_to?(:empty?) && respond_to?(:strip)
-      empty? or strip.empty?
-    elsif respond_to?(:empty?)
-      empty?
-    else
-      !self
-    end
+    respond_to?(:empty?) ? empty? : !self
   end
 end
 
@@ -45,7 +39,7 @@ end
 
 class String #:nodoc:
   def blank?
-    empty? || strip.empty?
+    self !~ /\S/
   end
 end
 

data/lib/active_support/core_ext/cgi.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/cgi/escape_skipping_slashes'
+require 'active_support/core_ext/cgi/escape_skipping_slashes'
 
 class CGI #:nodoc:
-  extend(ActiveSupport::CoreExtensions::CGI::EscapeSkippingSlashes)
+  extend ActiveSupport::CoreExtensions::CGI::EscapeSkippingSlashes
 end

data/lib/active_support/core_ext/class.rb

@@ -1,3 +1,4 @@
-require File.dirname(__FILE__) + '/class/attribute_accessors'
-require File.dirname(__FILE__) + '/class/inheritable_attributes'
-require File.dirname(__FILE__) + '/class/removal'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/class/removal'
+require 'active_support/core_ext/class/delegating_attributes'

data/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -21,7 +21,7 @@ class Class # :nodoc:
   end
 
   def cattr_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    options = syms.extract_options!
     syms.flatten.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__)
         unless defined? @@#{sym}

data/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -0,0 +1,40 @@
+# These class attributes behave something like the class
+# inheritable accessors.  But instead of copying the hash over at
+# the time the subclass is first defined,  the accessors simply
+# delegate to their superclass unless they have been given a 
+# specific value.  This stops the strange situation where values 
+# set after class definition don't get applied to subclasses.
+class Class
+  def superclass_delegating_reader(*names)
+    class_name_to_stop_searching_on = self.superclass.name.blank? ? "Object" : self.superclass.name
+    names.each do |name|
+      class_eval <<-EOS
+      def self.#{name}
+        if defined?(@#{name})
+          @#{name}
+        elsif superclass < #{class_name_to_stop_searching_on} && superclass.respond_to?(:#{name})
+          superclass.#{name}
+        end
+      end
+      def #{name}
+        self.class.#{name}
+      end
+      EOS
+    end
+  end
+
+  def superclass_delegating_writer(*names)
+    names.each do |name|
+      class_eval <<-EOS
+        def self.#{name}=(value)
+          @#{name} = value
+        end
+      EOS
+    end
+  end
+
+  def superclass_delegating_accessor(*names)
+    superclass_delegating_reader(*names)
+    superclass_delegating_writer(*names)
+  end
+end