mack-active_record 0.8.1 → 0.8.2

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/module/introspection.rb

@@ -0,0 +1,90 @@
+module ActiveSupport
+  module CoreExtensions
+    module Module
+      # Returns the name of the module containing this one.
+      #
+      #   p M::N.parent_name # => "M"
+      def parent_name
+        unless defined? @parent_name
+          @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+        end
+        @parent_name
+      end
+
+      # Returns the module which contains this one according to its name.
+      #
+      #   module M
+      #     module N
+      #     end
+      #   end
+      #   X = M::N
+      #
+      #   p M::N.parent # => M
+      #   p X.parent    # => M
+      #
+      # The parent of top-level and anonymous modules is Object.
+      #
+      #   p M.parent          # => Object
+      #   p Module.new.parent # => Object
+      #
+      def parent
+        parent_name ? parent_name.constantize : Object
+      end
+
+      # Returns all the parents of this module according to its name, ordered from
+      # nested outwards. The receiver is not contained within the result.
+      #
+      #   module M
+      #     module N
+      #     end
+      #   end
+      #   X = M::N
+      #
+      #   p M.parents    # => [Object]
+      #   p M::N.parents # => [M, Object]
+      #   p X.parents    # => [M, Object]
+      #
+      def parents
+        parents = []
+        if parent_name
+          parts = parent_name.split('::')
+          until parts.empty?
+            parents << (parts * '::').constantize
+            parts.pop
+          end
+        end
+        parents << Object unless parents.include? Object
+        parents
+      end
+
+      if RUBY_VERSION < '1.9'
+        # Returns the constants that have been defined locally by this object and
+        # not in an ancestor. This method is exact if running under Ruby 1.9. In
+        # previous versions it may miss some constants if their definition in some
+        # ancestor is identical to their definition in the receiver.
+        def local_constants
+          inherited = {}
+
+          ancestors.each do |anc|
+            next if anc == self
+            anc.constants.each { |const| inherited[const] = anc.const_get(const) }
+          end
+
+          constants.select do |const|
+            !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
+          end
+        end
+      else
+        def local_constants #:nodoc:
+          constants(false)
+        end
+      end
+
+      # Returns the names of the constants defined locally rather than the
+      # constants themselves. See <tt>local_constants</tt>.
+      def local_constant_names
+        local_constants.map { |c| c.to_s }
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/module/loading.rb

@@ -0,0 +1,23 @@
+class Module
+  # Returns String#underscore applied to the module name minus trailing classes.
+  #
+  #   ActiveRecord.as_load_path               # => "active_record"
+  #   ActiveRecord::Associations.as_load_path # => "active_record/associations"
+  #   ActiveRecord::Base.as_load_path         # => "active_record" (Base is a class)
+  #
+  # The Kernel module gives an empty string by definition.
+  #
+  #   Kernel.as_load_path # => ""
+  #   Math.as_load_path   # => "math"
+  def as_load_path
+    if self == Object || self == Kernel
+      ''
+    elsif is_a? Class
+      parent == self ? '' : parent.as_load_path
+    else
+      name.split('::').collect do |word|
+        word.underscore
+      end * '/'
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/module/model_naming.rb

@@ -0,0 +1,23 @@
+module ActiveSupport
+  class ModelName < String
+    attr_reader :singular, :plural, :cache_key, :partial_path
+
+    def initialize(name)
+      super
+      @singular = underscore.tr('/', '_').freeze
+      @plural = @singular.pluralize.freeze
+      @cache_key = tableize.freeze
+      @partial_path = "#{@cache_key}/#{demodulize.underscore}".freeze
+    end
+  end
+
+  module CoreExtensions
+    module Module
+      # Returns an ActiveSupport::ModelName object for module. It can be
+      # used to retrieve all kinds of naming-related information.
+      def model_name
+        @model_name ||= ModelName.new(name)
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/module/synchronization.rb

@@ -0,0 +1,39 @@
+class Module
+  # Synchronize access around a method, delegating synchronization to a
+  # particular mutex. A mutex (either a Mutex, or any object that responds to 
+  # #synchronize and yields to a block) must be provided as a final :with option.
+  # The :with option should be a symbol or string, and can represent a method, 
+  # constant, or instance or class variable.
+  # Example:
+  #   class SharedCache
+  #     @@lock = Mutex.new
+  #     def expire
+  #       ...
+  #     end
+  #     synchronize :expire, :with => :@@lock
+  #   end
+  def synchronize(*methods)
+    options = methods.extract_options!
+    unless options.is_a?(Hash) && with = options[:with]
+      raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)."
+    end
+
+    methods.each do |method|
+      aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+
+      if method_defined?("#{aliased_method}_without_synchronization#{punctuation}")
+        raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
+      end
+
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)
+          #{with}.synchronize do
+            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)
+          end
+        end
+      EOS
+
+      alias_method_chain method, :synchronization
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/module.rb

@@ -0,0 +1,23 @@
+require 'active_support/core_ext/module/inclusion'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/attr_accessor_with_default'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/introspection'
+require 'active_support/core_ext/module/loading'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/model_naming'
+require 'active_support/core_ext/module/synchronization'
+
+module ActiveSupport
+  module CoreExtensions
+    # Various extensions for the Ruby core Module class.
+    module Module
+      # Nothing here. Only defined for API documentation purposes.
+    end
+  end
+end
+
+class Module
+  include ActiveSupport::CoreExtensions::Module
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/name_error.rb

@@ -0,0 +1,17 @@
+# Add a +missing_name+ method to NameError instances.
+class NameError #:nodoc:  
+  # Add a method to obtain the missing name from a NameError.
+  def missing_name
+    $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+  end
+  
+  # Was this exception raised because the given name was missing?
+  def missing_name?(name)
+    if name.is_a? Symbol
+      last_name = (missing_name || '').split('::').last
+      last_name == name.to_s
+    else
+      missing_name == name.to_s
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/numeric/bytes.rb

@@ -0,0 +1,44 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+      module Bytes
+        def bytes
+          self
+        end
+        alias :byte :bytes
+
+        def kilobytes
+          self * 1024
+        end
+        alias :kilobyte :kilobytes
+
+        def megabytes
+          self * 1024.kilobytes
+        end
+        alias :megabyte :megabytes
+
+        def gigabytes
+          self * 1024.megabytes 
+        end
+        alias :gigabyte :gigabytes
+
+        def terabytes
+          self * 1024.gigabytes
+        end
+        alias :terabyte :terabytes
+        
+        def petabytes
+          self * 1024.terabytes
+        end
+        alias :petabyte :petabytes
+        
+        def exabytes
+          self * 1024.petabytes
+        end
+        alias :exabyte :exabytes
+        
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/numeric/conversions.rb

@@ -0,0 +1,19 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      module Conversions
+        # Assumes self represents an offset from UTC in seconds (as returned from Time#utc_offset)
+        # and turns this into an +HH:MM formatted string. Example:
+        #
+        #   -21_600.to_utc_offset_s   # => "-06:00"
+        def to_utc_offset_s(colon=true)
+          seconds = self
+          sign = (seconds < 0 ? -1 : 1)
+          hours = seconds.abs / 3600
+          minutes = (seconds.abs % 3600) / 60
+          "%+03d%s%02d" % [ hours * sign, colon ? ":" : "", minutes ]
+        end
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/numeric/time.rb

@@ -0,0 +1,81 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+      #
+      # These methods use Time#advance for precise date calculations when using from_now, ago, etc. 
+      # as well as adding or subtracting their results from a Time object. For example:
+      #
+      #   # equivalent to Time.now.advance(:months => 1)
+      #   1.month.from_now
+      #
+      #   # equivalent to Time.now.advance(:years => 2)
+      #   2.years.from_now
+      #
+      #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+      #   (4.months + 5.years).from_now
+      # 
+      # While these methods provide precise calculation when used as in the examples above, care
+      # should be taken to note that this is not true if the result of `months', `years', etc is
+      # converted before use:
+      #
+      #   # equivalent to 30.days.to_i.from_now
+      #   1.month.to_i.from_now
+      #
+      #   # equivalent to 365.25.days.to_f.from_now
+      #   1.year.to_f.from_now
+      #
+      # In such cases, Ruby's core 
+      # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
+      # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+      # date and time arithmetic
+      module Time
+        def seconds
+          ActiveSupport::Duration.new(self, [[:seconds, self]])
+        end
+        alias :second :seconds
+
+        def minutes
+          ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+        end
+        alias :minute :minutes  
+        
+        def hours
+          ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+        end
+        alias :hour :hours
+        
+        def days
+          ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+        end
+        alias :day :days
+
+        def weeks
+          ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+        end
+        alias :week :weeks
+        
+        def fortnights
+          ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+        end
+        alias :fortnight :fortnights
+        
+        # Reads best without arguments:  10.minutes.ago
+        def ago(time = ::Time.now)
+          time - self
+        end
+
+        # Reads best with argument:  10.minutes.until(time)
+        alias :until :ago
+
+        # Reads best with argument:  10.minutes.since(time)
+        def since(time = ::Time.now)
+          time + self
+        end
+
+        # Reads best without arguments:  10.minutes.from_now
+        alias :from_now :since
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/numeric.rb

@@ -0,0 +1,9 @@
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/numeric/bytes'
+require 'active_support/core_ext/numeric/conversions'
+
+class Numeric #:nodoc:
+  include ActiveSupport::CoreExtensions::Numeric::Time 
+  include ActiveSupport::CoreExtensions::Numeric::Bytes
+  include ActiveSupport::CoreExtensions::Numeric::Conversions 
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object/conversions.rb

@@ -0,0 +1,14 @@
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+  # param name.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  def to_query(key)
+    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object/extending.rb

@@ -0,0 +1,80 @@
+class Object
+  def remove_subclasses_of(*superclasses) #:nodoc:
+    Class.remove_class(*subclasses_of(*superclasses))
+  end
+
+  begin
+    ObjectSpace.each_object(Class.new) {}
+
+    # Exclude this class unless it's a subclass of our supers and is defined.
+    # We check defined? in case we find a removed class that has yet to be
+    # garbage collected. This also fails for anonymous classes -- please
+    # submit a patch if you have a workaround.
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(class << sup; self; end) do |k|
+          if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+      end
+
+      subclasses
+    end
+  rescue RuntimeError
+    # JRuby and any implementations which cannot handle the objectspace traversal
+    # above fall back to this implementation
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(Class) do |k|
+          if superclasses.any? { |superclass| k < superclass } &&
+            (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+        subclasses.uniq!
+      end
+      subclasses
+    end
+  end
+
+  def extended_by #:nodoc:
+    ancestors = class << self; ancestors end
+    ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+  end
+
+  def extend_with_included_modules_from(object) #:nodoc:
+    object.extended_by.each { |mod| extend mod }
+  end
+
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object/instance_variables.rb

@@ -0,0 +1,74 @@
+class Object
+  # Available in 1.8.6 and later.
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+
+  # Returns a hash that maps instance variable names without "@" to their
+  # corresponding values. Keys are strings both in Ruby 1.8 and 1.9.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #   
+  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+  # Returns an array of instance variable names including "@". They are strings
+  # both in Ruby 1.8 and 1.9.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #   
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  if RUBY_VERSION >= '1.9'
+    def instance_variable_names
+      instance_variables.map { |var| var.to_s }
+    end
+  else
+    alias_method :instance_variable_names, :instance_variables
+  end
+
+  # Copies the instance variables of +object+ into +self+.
+  #
+  # Instance variable names in the +exclude+ array are ignored. If +object+
+  # responds to <tt>protected_instance_variables</tt> the ones returned are
+  # also ignored. For example, Rails controllers implement that method.
+  #
+  # In both cases strings and symbols are understood, and they have to include
+  # the at sign.
+  #
+  #   class C
+  #     def initialize(x, y, z)
+  #       @x, @y, @z = x, y, z
+  #     end
+  #   
+  #     def protected_instance_variables
+  #       %w(@z)
+  #     end
+  #   end
+  #   
+  #   a = C.new(0, 1, 2)
+  #   b = C.new(3, 4, 5)
+  #   
+  #   a.copy_instance_variables_from(b, [:@y])
+  #   # a is now: @x = 3, @y = 1, @z = 2
+  def copy_instance_variables_from(object, exclude = []) #:nodoc:
+    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
+
+    vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
+    vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object/metaclass.rb

@@ -0,0 +1,13 @@
+class Object
+  # Get object's meta (ghost, eigenclass, singleton) class
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  # If class_eval is called on an object, add those methods to its metaclass
+  def class_eval(*args, &block)
+    metaclass.class_eval(*args, &block)
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object/misc.rb

@@ -0,0 +1,74 @@
+class Object
+  # Returns +value+ after yielding +value+ to the block. This simplifies the
+  # process of constructing an object, performing work on the object, and then
+  # returning the object from a method. It is a Ruby-ized realization of the K
+  # combinator, courtesy of Mikael Brockman.
+  #
+  # ==== Examples
+  #
+  #  # Without returning
+  #  def foo
+  #    values = []
+  #    values << "bar"
+  #    values << "baz"
+  #    return values
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #
+  #  # returning with a local variable
+  #  def foo
+  #    returning values = [] do
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #  
+  #  # returning with a block argument
+  #  def foo
+  #    returning [] do |values|
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #  
+  #  foo # => ['bar', 'baz']
+  def returning(value)
+    yield(value)
+    value
+  end
+
+  # An elegant way to factor duplication out of options passed to a series of
+  # method calls. Each method called in the block, with the block variable as
+  # the receiver, will have its options merged with the default +options+ hash
+  # provided. Each method called on the block variable must take an options
+  # hash as its final argument.
+  # 
+  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
+  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
+  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
+  #     post.has_many :all_comments
+  #   end
+  #
+  # Can also be used with an explicit receiver:
+  #
+  #   map.with_options :controller => "people" do |people|
+  #     people.connect "/people",     :action => "index"
+  #     people.connect "/people/:id", :action => "show"
+  #   end
+  #
+  def with_options(options)
+    yield ActiveSupport::OptionMerger.new(self, options)
+  end
+  
+  # A duck-type assistant method. For example, Active Support extends Date
+  # to define an acts_like_date? method, and extends Time to define
+  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
+  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
+  # we want to act like Time simply need to define an acts_like_time? method.
+  def acts_like?(duck)
+    respond_to? "acts_like_#{duck}?"
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/object.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/object/extending'
+require 'active_support/core_ext/object/instance_variables'
+require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/misc'

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/pathname/clean_within.rb

@@ -0,0 +1,14 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Pathname #:nodoc:
+      module CleanWithin
+        # Clean the paths contained in the provided string.
+        def clean_within(string)
+          string.gsub(%r{[\w. ]+(/[\w. ]+)+(\.rb)?(\b|$)}) do |path|
+            new(path).cleanpath
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/pathname.rb

@@ -0,0 +1,7 @@
+require 'pathname'
+require 'active_support/core_ext/pathname/clean_within'
+
+class Pathname#:nodoc:
+  extend ActiveSupport::CoreExtensions::Pathname::CleanWithin
+end
+

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/proc.rb

@@ -0,0 +1,12 @@
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end