abiquo-etk 0.4.13

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/module/delegation.rb

@@ -0,0 +1,135 @@
+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"
+  #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
+  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]}_"
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
+        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+        rescue NoMethodError                                # rescue NoMethodError
+          if #{to}.nil?                                     #   if client.nil?
+            #{on_nil}
+          else                                              #   else
+            raise                                           #     raise
+          end                                               #   end
+        end                                                 # end
+      EOS
+    end
+  end
+end

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

data/vendor/activesupport-2.3.8/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/vendor/activesupport-2.3.8/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/vendor/activesupport-2.3.8/lib/active_support/core_ext/module/model_naming.rb

@@ -0,0 +1,25 @@
+module ActiveSupport
+  class ModelName < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path
+    alias_method :cache_key, :collection
+
+    def initialize(name)
+      super
+      @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+      @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
+      @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
+      @collection = ActiveSupport::Inflector.tableize(self).freeze
+      @partial_path = "#{@collection}/#{@element}".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 ||= ::ActiveSupport::ModelName.new(name)
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/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__ + 1)
+        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
+          #{with}.synchronize do                                                    #   @@lock.synchronize do
+            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
+          end                                                                       #   end
+        end                                                                         # end
+      EOS
+
+      alias_method_chain method, :synchronization
+    end
+  end
+end

data/vendor/activesupport-2.3.8/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/vendor/activesupport-2.3.8/lib/active_support/core_ext/name_error.rb

@@ -0,0 +1,19 @@
+# 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
+    if /undefined local variable or method/ !~ message
+      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+    end
+  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.3.8/lib/active_support/core_ext/numeric/bytes.rb

@@ -0,0 +1,50 @@
+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
+        KILOBYTE = 1024
+        MEGABYTE = KILOBYTE * 1024
+        GIGABYTE = MEGABYTE * 1024
+        TERABYTE = GIGABYTE * 1024
+        PETABYTE = TERABYTE * 1024
+        EXABYTE  = PETABYTE * 1024
+
+        def bytes
+          self
+        end
+        alias :byte :bytes
+
+        def kilobytes
+          self * KILOBYTE
+        end
+        alias :kilobyte :kilobytes
+
+        def megabytes
+          self * MEGABYTE
+        end
+        alias :megabyte :megabytes
+
+        def gigabytes
+          self * GIGABYTE
+        end
+        alias :gigabyte :gigabytes
+
+        def terabytes
+          self * TERABYTE
+        end
+        alias :terabyte :terabytes
+
+        def petabytes
+          self * PETABYTE
+        end
+        alias :petabyte :petabytes
+
+        def exabytes
+          self * EXABYTE
+        end
+        alias :exabyte :exabytes
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/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 ? '-' : '+')
+          hours = seconds.abs / 3600
+          minutes = (seconds.abs % 3600) / 60
+          "%s%02d%s%02d" % [ sign, hours, colon ? ":" : "", minutes ]
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/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/vendor/activesupport-2.3.8/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/vendor/activesupport-2.3.8/lib/active_support/core_ext/object/blank.rb

@@ -0,0 +1,76 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies:
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # ...to:
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+  
+  # Returns object if it's #present? otherwise returns nil.
+  # object.presence is equivalent to object.present? ? object : nil.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/object/conversions.rb

@@ -0,0 +1,15 @@
+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)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
+  end
+end