swivel 0.0.146 → 0.0.149

data/vendor/activesupport-2.0.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/vendor/activesupport-2.0.2-/lib/active_support/core_ext/logger.rb

@@ -0,0 +1,16 @@
+# 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

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module.rb

@@ -0,0 +1,8 @@
+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'

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/aliasing.rb

@@ -0,0 +1,70 @@
+class 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

data/vendor/activesupport-2.0.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/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/attr_internal.rb

@@ -0,0 +1,31 @@
+class Module
+  # Declare 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
+
+  # Declare 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
+
+  # Declare attributes backed by 'internal' instance variables names.
+  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/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -0,0 +1,48 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Module # :nodoc:
+  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/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/delegation.rb

@@ -0,0 +1,62 @@
+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 :to option (also a symbol
+  # or string).  At least one method and the :to 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 the variable as a symbol:
+  #   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
+  #
+  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
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{method}(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/inclusion.rb

@@ -0,0 +1,11 @@
+class Module
+  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

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/introspection.rb

@@ -0,0 +1,35 @@
+class Module
+  # Return the module which contains this one; if this is a root module, such as
+  # +::MyModule+, then Object is returned.
+  def parent
+    parent_name = name.split('::')[0..-2] * '::'
+    parent_name.empty? ? Object : parent_name.constantize
+  end
+  
+  # Return all the parents of this module, ordered from nested outwards. The
+  # receiver is not contained within the result.
+  def parents
+    parents = []
+    parts = name.split('::')[0..-2]
+    until parts.empty?
+      parents << (parts * '::').constantize
+      parts.pop
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
+  
+  # Return the constants that have been defined locally by this object and not
+  # in an ancestor. This method may miss some constants if their definition in
+  # the 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
+end

data/vendor/activesupport-2.0.2-/lib/active_support/core_ext/module/loading.rb

@@ -0,0 +1,13 @@
+class Module
+  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/vendor/activesupport-2.0.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/vendor/activesupport-2.0.2-/lib/active_support/core_ext/numeric.rb

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

data/vendor/activesupport-2.0.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