activesupport 1.0.0

data/lib/active_support/core_ext/string.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/string/inflections'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Inflections
+end

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

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../inflector'
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Makes it possible to do "posts".singularize that returns "post" and "MegaCoolClass".underscore that returns "mega_cool_class".
+      module Inflections
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        def camelize
+          Inflector.camelize(self)
+        end
+
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        def classify
+          Inflector.classify(self)
+        end
+        
+        def humanize
+          Inflector.humanize(self)
+        end
+
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/time.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/time/calculations'
+require File.dirname(__FILE__) + '/time/conversions'
+
+class Time#:nodoc:
+  include ActiveSupport::CoreExtensions::Time::Calculations
+  include ActiveSupport::CoreExtensions::Time::Conversions
+end

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

@@ -0,0 +1,133 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Time #:nodoc:
+      # Enables the use of time calculations within Time itself
+      module Calculations
+        # Seconds since midnight: Time.now.seconds_since_midnight
+        def seconds_since_midnight
+          self.hour.hours + self.min.minutes + self.sec + (self.usec/1.0e+6)
+        end
+            
+        # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+        # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and 
+        # minute is passed, then sec and usec is set to 0.
+        def change(options)
+          ::Time.send(
+            self.utc? ? :utc : :local, 
+            options[:year]  || self.year, 
+            options[:month] || self.month, 
+            options[:mday]  || self.mday, 
+            options[:hour]  || self.hour, 
+            options[:min]   || (options[:hour] ? 0 : self.min),
+            options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+            options[:usec]  || ((options[:hour] || options[:min] || options[:usec]) ? 0 : self.usec)
+          )
+        end
+
+        # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
+        # Do not use this method in combination with x.months, use months_ago instead!
+        def ago(seconds)
+          seconds.until(self)
+        end
+
+        # Returns a new Time representing the time a number of seconds since the instance time, this is basically a wrapper around 
+        #the Numeric extension. Do not use this method in combination with x.months, use months_since instead!
+        def since(seconds)
+          seconds.since(self)
+        end
+        alias :in :since
+
+        # Returns a new Time representing the time a number of specified months ago
+        def months_ago(months)
+          if months >= self.month 
+            change(:year => self.year - 1, :month => 12).months_ago(months - self.month)
+          else
+            change(:year => self.year, :month => self.month - months)
+          end
+        end
+
+        def months_since(months)
+          if months + self.month > 12
+            change(:year => self.year + 1, :month => 1).months_since(months - (self.month == 1 ? 12 : (self.month + 1)))
+          else
+            change(:year => self.year, :month => self.month + months)
+          end
+        end
+
+        # Returns a new Time representing the time a number of specified years ago
+        def years_ago(years)
+          change(:year => self.year - years)
+        end
+        
+        def years_since(years)
+          change(:year => self.year + years)
+        end
+
+        # Short-hand for months_ago(1)
+        def last_year
+          years_since(1)
+        end
+        
+        # Short-hand for months_since(1)
+        def next_year
+          years_since(1)
+        end
+
+
+        # Short-hand for months_ago(1)
+        def last_month
+          months_ago(1)
+        end
+
+        # Short-hand for months_since(1)
+        def next_month
+          months_since(1)
+        end
+        
+        # Returns a new Time representing the "start" of this week (Monday, 0:00)
+        def beginning_of_week
+          (self - self.wday.days).midnight + 1.day
+        end
+        alias :monday :beginning_of_week
+        alias :at_beginning_of_week :beginning_of_week
+        
+        # Returns a new Time representing the start of the given day in next week (default is Monday).
+        def next_week(day = :monday)
+          days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
+          since(1.week).beginning_of_week.since(days_into_week[day].day).change(:hour => 0)
+        end
+        
+        # Returns a new Time representing the start of the day (0:00)
+        def beginning_of_day
+          self - self.seconds_since_midnight
+        end
+        alias :midnight :beginning_of_day
+        alias :at_midnight :beginning_of_day
+        alias :at_beginning_of_day :beginning_of_day
+        
+        # Returns a new Time representing the start of the month (1st of the month, 0:00)
+        def beginning_of_month
+          #self - ((self.mday-1).days + self.seconds_since_midnight)
+          change(:mday => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+        end
+        alias :at_beginning_of_month :beginning_of_month
+        
+        # Returns  a new Time representing the start of the year (1st of january, 0:00)
+        def beginning_of_year
+          change(:month => 1,:mday => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+        end
+        alias :at_beginning_of_year :beginning_of_year
+        
+        # Convenience method which returns a new Time representing the time 1 day ago
+        def yesterday
+          self.ago(1.day)
+        end
+        
+        # Convenience method which returns a new Time representing the time 1 day since the instance time
+        def tomorrow
+          self.since(1.day)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'date'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Time #:nodoc:
+      # Getting times in different convenient string representations and other objects
+      module Conversions
+        def self.append_features(klass)
+          super
+          klass.send(:alias_method, :to_default_s, :to_s)
+          klass.send(:alias_method, :to_s, :to_formatted_s)
+        end
+        
+        def to_formatted_s(format = :default)
+          case format
+            when :default then to_default_s
+            when :db      then strftime("%Y-%m-%d %H:%M:%S")
+            when :short   then strftime("%e %b %H:%M").strip
+            when :long    then strftime("%B %e, %Y %H:%M").strip
+          end
+        end
+
+        def to_date
+          ::Date.new(year, month, day)
+        end
+
+        # To be able to keep Dates and Times interchangeable on conversions
+        def to_time
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_support/dependencies.rb

@@ -0,0 +1,212 @@
+require File.dirname(__FILE__) + '/module_attribute_accessors'
+
+module Dependencies
+  extend self
+
+  @@loaded = [ ]
+  mattr_accessor :loaded
+
+  @@mechanism = :load
+  mattr_accessor :mechanism
+  
+  def load?
+    mechanism == :load
+  end
+  
+  def depend_on(file_name, swallow_load_errors = false)
+    if !loaded.include?(file_name)
+      loaded << file_name
+
+      begin
+        require_or_load(file_name)
+      rescue LoadError
+        raise unless swallow_load_errors
+      rescue Object => e
+        raise ScriptError, "#{e.message}"
+      end
+    end
+  end
+
+  def associate_with(file_name)
+    depend_on(file_name, true)
+  end
+  
+  def clear
+    self.loaded = [ ]
+  end
+  
+  def require_or_load(file_name)
+    load? ? load("#{file_name}.rb") : require(file_name)
+  end
+  
+  def remove_subclasses_for(*classes)
+    classes.each { |klass| klass.remove_subclasses }
+  end
+  
+  # LoadingModules implement namespace-safe dynamic loading.
+  # They support automatic loading via const_missing, allowing contained items to be automatically
+  # loaded when required. No extra syntax is required, as expressions such as Controller::Admin::UserController
+  # load the relavent files automatically.
+  #
+  # Ruby-style modules are supported, as a folder named 'submodule' will load 'submodule.rb' when available.
+  class LoadingModule < Module
+    attr_reader :path
+    attr_reader :root
+    
+    def self.root(*load_paths)
+      RootLoadingModule.new(*load_paths)
+    end
+            
+    def initialize(root, path=[])
+      @path = path.clone.freeze
+      @root = root
+    end
+    
+    def load_paths() self.root.load_paths end
+    
+    # Load missing constants if possible.
+    def const_missing(name)
+      const_load!(name) ? const_get(name) : super(name)
+    end
+  
+    # Load the controller class or a parent module.
+    def const_load!(name, file_name = nil)
+      path = self.path + [file_name || name]
+
+      load_paths.each do |load_path|
+        fs_path = load_path.filesystem_path(path)
+        next unless fs_path
+
+        if File.directory?(fs_path)
+          self.const_set name, LoadingModule.new(self.root, self.path + [name])
+          break
+        elsif File.file?(fs_path)
+          self.root.load_file!(fs_path)
+          break
+        end
+      end
+
+      return self.const_defined?(name)
+    end
+    
+    # Is this name present or loadable?
+    # This method is used by Routes to find valid controllers.
+    def const_available?(name)
+      self.const_defined?(name) || load_paths.any? {|lp| lp.filesystem_path(path + [name])}
+    end
+  end
+  
+  class RootLoadingModule < LoadingModule
+    attr_reader :load_paths
+
+    def initialize(*paths)
+      @load_paths = paths.flatten.collect {|p| p.kind_of?(ConstantLoadPath) ? p : ConstantLoadPath.new(p)}
+    end
+
+    def root() self end
+
+    def path() [] end
+    
+    # Load the source file at the given file path
+    def load_file!(file_path)
+      begin root.module_eval(IO.read(file_path), file_path, 1)
+      rescue Object => exception
+        exception.blame_file! file_path
+        raise
+      end
+    end
+
+    # Erase all items in this module
+    def clear!
+      constants.each do |name|
+        Object.send(:remove_const, name) if Object.const_defined?(name) && self.path.empty?
+        self.send(:remove_const, name)
+      end
+    end
+  end
+  
+  # This object defines a path from which Constants can be loaded.
+  class ConstantLoadPath
+    # Create a new load path with the filesystem path
+    def initialize(root) @root = root end
+    
+    # Return nil if the path does not exist, or the path to a directory
+    # if the path leads to a module, or the path to a file if it leads to an object.
+    def filesystem_path(path, allow_module=true)
+      fs_path = [@root]
+      fs_path += path[0..-2].collect {|name| const_name_to_module_name name}
+
+      if allow_module
+        result = File.join(fs_path, const_name_to_module_name(path.last))
+        return result if File.directory? result # Return the module path if one exists
+      end
+
+      result = File.join(fs_path, const_name_to_file_name(path.last))
+
+      return File.file?(result) ? result : nil
+    end
+    
+    def const_name_to_file_name(name)
+      name.to_s.underscore + '.rb'
+    end
+
+    def const_name_to_module_name(name)
+      name.to_s.underscore
+    end
+  end
+end
+
+Object.send(:define_method, :require_or_load)     { |file_name| Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
+Object.send(:define_method, :require_dependency)  { |file_name| Dependencies.depend_on(file_name) } unless Object.respond_to?(:require_dependency)
+Object.send(:define_method, :require_association) { |file_name| Dependencies.associate_with(file_name) } unless Object.respond_to?(:require_association)
+
+class Object #:nodoc:
+  class << self
+    # Use const_missing to autoload associations so we don't have to
+    # require_association when using single-table inheritance.
+    def const_missing(class_id)
+      if Object.const_defined?(:Controllers) and Object::Controllers.const_available?(class_id)
+        return Object::Controllers.const_get(class_id)
+      end
+
+      begin
+        require_or_load(class_id.to_s.demodulize.underscore)
+        if Object.const_defined?(class_id) then return Object.const_get(class_id) else raise LoadError end
+      rescue LoadError
+        raise NameError, "uninitialized constant #{class_id}"
+      end
+    end
+  end
+
+  def load(file, *extras)
+    begin super(file, *extras)
+    rescue Object => exception
+      exception.blame_file! file
+      raise
+    end
+  end
+
+  def require(file, *extras)
+    begin super(file, *extras)
+    rescue Object => exception
+      exception.blame_file! file
+      raise
+    end
+  end
+end
+
+# Add file-blaming to exceptions
+class Exception
+  def blame_file!(file)
+    (@blamed_files ||= []).unshift file
+  end
+
+  def blamed_files
+    @blamed_files ||= []
+  end
+
+  def describe_blame
+    return nil if blamed_files.empty?
+    "This error occured while loading the following files:\n   #{blamed_files.join "\n   "}"
+  end
+end

data/lib/active_support/inflector.rb

@@ -0,0 +1,93 @@
+# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+# and class names to foreign keys.
+module Inflector 
+  extend self
+
+  def pluralize(word)
+    result = word.to_s.dup
+    plural_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def singularize(word)
+    result = word.to_s.dup
+    singular_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+  end
+
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_/, " ").capitalize
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+  
+  def classify(table_name)
+    camelize(singularize(table_name))
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    Inflector.underscore(Inflector.demodulize(class_name)) + 
+      (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
+  def constantize(camel_cased_word)
+    camel_cased_word.split("::").inject(Object) do |final_type, part| 
+      final_type = final_type.const_get(part)
+    end
+  end
+
+  private
+    def plural_rules #:doc:
+      [
+        [/(x|ch|ss|sh)$/, '\1es'],               # search, switch, fix, box, process, address
+        [/series$/, '\1series'],
+        [/([^aeiouy]|qu)ies$/, '\1y'],
+        [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
+        [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
+        [/sis$/, 'ses'],                      # basis, diagnosis
+        [/([ti])um$/, '\1a'],                 # datum, medium
+        [/person$/, 'people'],                # person, salesperson
+        [/man$/, 'men'],                      # man, woman, spokesman
+        [/child$/, 'children'],               # child
+        [/s$/, 's'],                          # no change (compatibility)
+        [/$/, 's']
+      ]
+    end
+
+    def singular_rules #:doc:
+      [
+        [/(x|ch|ss)es$/, '\1'],
+        [/movies$/, 'movie'],
+        [/series$/, 'series'],
+        [/([^aeiouy]|qu)ies$/, '\1y'],
+        [/([lr])ves$/, '\1f'],
+        [/([^f])ves$/, '\1fe'],
+        [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'],
+        [/([ti])a$/, '\1um'],
+        [/people$/, 'person'],
+        [/men$/, 'man'],
+        [/status$/, 'status'],
+        [/children$/, 'child'],
+        [/news$/, 'news'],
+        [/s$/, '']
+      ]
+    end
+end