mack-active_record 0.8.1 → 0.8.2

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

@@ -0,0 +1,45 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Integer #: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 months
+          ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+        end
+        alias :month :months
+
+        def years
+          ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+        end
+        alias :year :years
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'active_support/core_ext/integer/even_odd'
+require 'active_support/core_ext/integer/inflections'
+require 'active_support/core_ext/integer/time'
+
+class Integer #:nodoc:
+  include ActiveSupport::CoreExtensions::Integer::EvenOdd
+  include ActiveSupport::CoreExtensions::Integer::Inflections
+  include ActiveSupport::CoreExtensions::Integer::Time
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/kernel/agnostics.rb

@@ -0,0 +1,11 @@
+class Object
+  # Makes backticks behave (somewhat more) similarly on all platforms.
+  # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
+  # spawned shell prints a message to stderr and sets $?.  We emulate
+  # Unix on the former but not the latter.
+  def `(command) #:nodoc:
+    super
+  rescue Errno::ENOENT => e
+    STDERR.puts "#$0: #{e}"
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/kernel/daemonizing.rb

@@ -0,0 +1,7 @@
+module Kernel
+  # Turns the current script into a daemon process that detaches from the console.
+  # It can be shut down with a TERM signal.
+  def daemonize
+    Process.daemon
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/kernel/debugger.rb

@@ -0,0 +1,13 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call script/server --debugger to do load it).
+    def debugger
+      Rails.logger.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+    end
+  end
+
+  def breakpoint
+    Rails.logger.info "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    debugger
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/kernel/reporting.rb

@@ -0,0 +1,59 @@
+module Kernel
+  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  # Sets $VERBOSE to true for the duration of the block and back to its original value afterwards.
+  def enable_warnings
+    old_verbose, $VERBOSE = $VERBOSE, true
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  # For compatibility
+  def silence_stderr #:nodoc:
+    silence_stream(STDERR) { yield }
+  end
+
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+  # Blocks and ignores any exception passed as argument if raised within the block.
+  #
+  #   suppress(ZeroDivisionError) do
+  #     1/0
+  #     puts "This code is NOT reached"
+  #   end
+  #
+  #   puts "This code gets executed and nothing related to ZeroDivisionError was seen"
+  def suppress(*exception_classes)
+    begin yield
+    rescue Exception => e
+      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
+    end
+  end
+end

data/lib/gems/activesupport-2.2.2/lib/active_support/core_ext/kernel/requires.rb

@@ -0,0 +1,24 @@
+module Kernel
+  # Require a library with fallback to RubyGems.  Warnings during library
+  # loading are silenced to increase signal/noise for application warnings.
+  def require_library_or_gem(library_name)
+    silence_warnings do
+      begin
+        require library_name
+      rescue LoadError => cannot_require
+        # 1. Requiring the module is unsuccessful, maybe it's a gem and nobody required rubygems yet. Try.
+        begin
+          require 'rubygems'
+        rescue LoadError => rubygems_not_installed
+          raise cannot_require
+        end
+        # 2. Rubygems is installed and loaded. Try to load the library again
+        begin
+          require library_name
+        rescue LoadError => gem_not_installed
+          raise cannot_require
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/kernel/daemonizing'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/kernel/agnostics'
+require 'active_support/core_ext/kernel/requires'
+require 'active_support/core_ext/kernel/debugger'

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

@@ -0,0 +1,38 @@
+class MissingSourceFile < LoadError #:nodoc:
+  attr_reader :path
+  def initialize(message, path)
+    super(message)
+    @path = path
+  end
+
+  def is_missing?(path)
+    path.gsub(/\.rb$/, '') == self.path.gsub(/\.rb$/, '')
+  end
+
+  def self.from_message(message)
+    REGEXPS.each do |regexp, capture|
+      match = regexp.match(message)
+      return MissingSourceFile.new(message, match[capture]) unless match.nil?
+    end
+    nil
+  end
+
+  REGEXPS = [
+    [/^no such file to load -- (.+)$/i, 1],
+    [/^Missing \w+ (file\s*)?([^\s]+.rb)$/i, 2],
+    [/^Missing API definition file in (.+)$/i, 1]
+  ] unless defined?(REGEXPS)
+end
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module LoadErrorExtensions #:nodoc:
+      module LoadErrorClassMethods #:nodoc:
+        def new(*args)
+          (self == LoadError && MissingSourceFile.from_message(args.first)) || super
+        end
+      end
+      ::LoadError.extend(LoadErrorClassMethods)
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# Adds the 'around_level' method to Logger.
+
+class Logger
+  def self.define_around_helper(level)
+    module_eval <<-end_eval
+      def around_#{level}(before_message, after_message, &block)
+        self.#{level}(before_message)
+        return_value = block.call(self)
+        self.#{level}(after_message)
+        return return_value
+      end
+    end_eval
+  end
+  [:debug, :info, :error, :fatal].each {|level| define_around_helper(level) }
+end
+
+
+require 'logger'
+
+# 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
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      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
+
+    # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
+    # We can't test RUBY_VERSION because some distributions don't keep Ruby
+    # and its standard library in sync, leading to installations of Ruby 1.8.2
+    # with Logger from 1.8.3 and vice versa.
+    if method_defined?(:formatter=)
+      def format_message(severity, timestamp, progname, msg)
+        formatter.call(severity, timestamp, progname, msg)
+      end
+    else
+      def format_message(severity, timestamp, msg, progname)
+        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/gems/activesupport-2.2.2/lib/active_support/core_ext/module/aliasing.rb

@@ -0,0 +1,74 @@
+module ActiveSupport
+  module CoreExtensions
+    module Module
+      # Encapsulates the common pattern of:
+      #
+      #   alias_method :foo_without_feature, :foo
+      #   alias_method :foo, :foo_with_feature
+      #
+      # With this, you simply do:
+      #
+      #   alias_method_chain :foo, :feature
+      #
+      # And both aliases are set up for you.
+      #
+      # Query and bang methods (foo?, foo!) keep the same punctuation:
+      #
+      #   alias_method_chain :foo?, :feature
+      #
+      # is equivalent to
+      #
+      #   alias_method :foo_without_feature?, :foo?
+      #   alias_method :foo?, :foo_with_feature?
+      #
+      # so you can safely chain foo, foo?, and foo! with the same feature.
+      def alias_method_chain(target, feature)
+        # Strip out punctuation on predicates or bang methods since
+        # e.g. target?_without_feature is not a valid method name.
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        yield(aliased_target, punctuation) if block_given?
+
+        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        alias_method without_method, target
+        alias_method target, with_method
+
+        case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
+        end
+      end
+
+      # Allows you to make aliases for attributes, which includes
+      # getter, setter, and query methods.
+      #
+      # Example:
+      #
+      #   class Content < ActiveRecord::Base
+      #     # has a title attribute
+      #   end
+      #
+      #   class Email < Content
+      #     alias_attribute :subject, :title
+      #   end
+      #
+      #   e = Email.find(1)
+      #   e.title    # => "Superstars"
+      #   e.subject  # => "Superstars"
+      #   e.subject? # => true
+      #   e.subject = "Megastars"
+      #   e.title    # => "Megastars"
+      def alias_attribute(new_name, old_name)
+        module_eval <<-STR, __FILE__, __LINE__+1
+          def #{new_name}; self.#{old_name}; end
+          def #{new_name}?; self.#{old_name}?; end
+          def #{new_name}=(v); self.#{old_name} = v; end
+        STR
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+class Module
+  # Declare an attribute accessor with an initial default return value.
+  #
+  # To give attribute <tt>:age</tt> the initial value <tt>25</tt>:
+  #  
+  #   class Person
+  #     attr_accessor_with_default :age, 25
+  #   end
+  #
+  #   some_person.age
+  #   => 25
+  #   some_person.age = 26
+  #   some_person.age
+  #   => 26
+  #
+  # To give attribute <tt>:element_name</tt> a dynamic default value, evaluated
+  # in scope of self:
+  #
+  #   attr_accessor_with_default(:element_name) { name.underscore } 
+  #
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}=(value)
+        class << self; attr_reader :#{sym} end
+        @#{sym} = value
+      end
+    EVAL
+  end
+end

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

@@ -0,0 +1,32 @@
+class Module
+  # Declares an attribute reader backed by an internally-named instance variable.
+  def attr_internal_reader(*attrs)
+    attrs.each do |attr|
+      module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end"
+    end
+  end
+
+  # Declares an attribute writer backed by an internally-named instance variable.
+  def attr_internal_writer(*attrs)
+    attrs.each do |attr|
+      module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end"
+    end
+  end
+
+  # Declares an attribute reader and writer backed by an internally-named instance
+  # variable.
+  def attr_internal_accessor(*attrs)
+    attr_internal_reader(*attrs)
+    attr_internal_writer(*attrs)
+  end
+
+  alias_method :attr_internal, :attr_internal_accessor
+
+  private
+    mattr_accessor :attr_internal_naming_format
+    self.attr_internal_naming_format = '@_%s'
+
+    def attr_internal_ivar_name(attr)
+      attr_internal_naming_format % attr
+    end
+end

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

@@ -0,0 +1,58 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+#
+#  module AppConfiguration
+#    mattr_accessor :google_api_key
+#    self.google_api_key = "123456789"
+#
+#    mattr_accessor :paypal_url
+#    self.paypal_url = "www.sandbox.paypal.com"
+#  end
+#
+#  AppConfiguration.google_api_key = "overriding the api key!"
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+        
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

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

@@ -0,0 +1,95 @@
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{prefix}#{method}(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+class Module
+  # Returns the classes in the current ObjectSpace where this module has been
+  # mixed in according to Module#included_modules.
+  #
+  #   module M
+  #   end
+  #   
+  #   module N
+  #     include M
+  #   end
+  #   
+  #   class C
+  #     include M
+  #   end
+  #   
+  #   class D < C
+  #   end
+  #
+  #   p M.included_in_classes # => [C, D]
+  #
+  def included_in_classes
+    classes = []
+    ObjectSpace.each_object(Class) { |k| classes << k if k.included_modules.include?(self) }
+
+    classes.reverse.inject([]) do |unique_classes, klass| 
+      unique_classes << klass unless unique_classes.collect { |k| k.to_s }.include?(klass.to_s)
+      unique_classes
+    end
+  end
+end