abiquo-etk 0.4.13

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

@@ -0,0 +1,14 @@
+require 'active_support/deprecation'
+
+class Object
+  # Get object's meta (ghost, eigenclass, singleton) class.
+  #
+  # Deprecated in favor of Object#singleton_class.
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  deprecate :metaclass => :singleton_class
+end

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

@@ -0,0 +1,90 @@
+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
+
+  # Yields <code>x</code> to the block, and then returns <code>x</code>.
+  # The primary purpose of this method is to "tap into" a method chain,
+  # in order to perform operations on intermediate results within the chain.
+  #
+  #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
+  #     tap    { |x| puts "array: #{x.inspect}" }.
+  #     select { |x| x%2 == 0 }.
+  #     tap    { |x| puts "evens: #{x.inspect}" }.
+  #     map    { |x| x*x }.
+  #     tap    { |x| puts "squares: #{x.inspect}" }
+  def tap
+    yield self
+    self
+  end unless Object.respond_to?(:tap)
+
+  # 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/vendor/activesupport-2.3.8/lib/active_support/core_ext/object/singleton_class.rb

@@ -0,0 +1,13 @@
+class Object
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class)
+
+  # class_eval on an object acts like singleton_class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'active_support/core_ext/object/blank'
+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/singleton_class'
+require 'active_support/core_ext/object/misc'

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

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/process/daemon.rb

@@ -0,0 +1,25 @@
+if RUBY_VERSION < "1.9"
+  module Process
+    def self.daemon(nochdir = nil, noclose = nil)
+      exit if fork                     # Parent exits, child continues.
+      Process.setsid                   # Become session leader.
+      exit if fork                     # Zap session leader. See [1].
+
+      unless nochdir
+        Dir.chdir "/"                  # Release old working directory.
+      end
+
+      File.umask 0000                  # Ensure sensible umask. Adjust as needed.
+
+      unless noclose
+        STDIN.reopen "/dev/null"       # Free file descriptors and
+        STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
+        STDERR.reopen '/dev/null', 'a'
+      end
+
+      trap("TERM") { exit }
+
+      return 0
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/process.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/process/daemon'

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/range/blockless_step.rb

@@ -0,0 +1,32 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Range #:nodoc:
+      # Return an array when step is called without a block.
+      module BlocklessStep
+        def self.included(base) #:nodoc:
+          base.alias_method_chain :step, :blockless
+        end
+
+        if RUBY_VERSION < '1.9'
+          def step_with_blockless(value = 1, &block)
+            if block_given?
+              step_without_blockless(value, &block)
+            else
+              returning [] do |array|
+                step_without_blockless(value) { |step| array << step }
+              end
+            end
+          end
+        else
+          def step_with_blockless(value = 1, &block)
+            if block_given?
+              step_without_blockless(value, &block)
+            else
+              step_without_blockless(value).to_a
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Range #:nodoc:
+      # Getting ranges in different convenient string representations and other objects
+      module Conversions
+        RANGE_FORMATS = {
+          :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
+        }
+
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method :to_default_s, :to_s
+            alias_method :to_s, :to_formatted_s
+          end
+        end
+        # Gives a human readable format of the range.
+        #
+        # ==== Example
+        # 
+        #   [1..100].to_formatted_s # => "1..100"
+        def to_formatted_s(format = :default)
+          RANGE_FORMATS[format] ? RANGE_FORMATS[format].call(first, last) : to_default_s
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/range/include_range.rb

@@ -0,0 +1,30 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Range #:nodoc:
+      # Check if a Range includes another Range.
+      module IncludeRange
+        def self.included(base) #:nodoc:
+          base.alias_method_chain :include?, :range
+        end
+
+        # Extends the default Range#include? to support range comparisons.
+        #  (1..5).include?(1..5) # => true
+        #  (1..5).include?(2..3) # => true
+        #  (1..5).include?(2..6) # => false
+        #
+        # The native Range#include? behavior is untouched.
+        #  ("a".."f").include?("c") # => true
+        #  (5..9).include?(11) # => false
+        def include_with_range?(value)
+          if value.is_a?(::Range)
+            operator = exclude_end? ? :< : :<=
+            end_value = value.exclude_end? ? last.succ : last
+            include?(value.first) && (value.last <=> end_value).send(operator, 0)
+          else
+            include_without_range?(value)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/range/overlaps.rb

@@ -0,0 +1,15 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Range #:nodoc:
+      # Check if Ranges overlap.
+      module Overlaps
+        # Compare two ranges and see if they overlap eachother
+        #  (1..5).overlaps?(4..6) # => true
+        #  (1..5).overlaps?(7..9) # => false
+        def overlaps?(other)
+          include?(other.first) || other.include?(first)
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/range.rb

@@ -0,0 +1,11 @@
+require 'active_support/core_ext/range/conversions'
+require 'active_support/core_ext/range/overlaps'
+require 'active_support/core_ext/range/include_range'
+require 'active_support/core_ext/range/blockless_step'
+
+class Range #:nodoc:
+  include ActiveSupport::CoreExtensions::Range::Conversions
+  include ActiveSupport::CoreExtensions::Range::Overlaps
+  include ActiveSupport::CoreExtensions::Range::IncludeRange
+  include ActiveSupport::CoreExtensions::Range::BlocklessStep
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/rexml.rb

@@ -0,0 +1,41 @@
+# Fixes the rexml vulnerability disclosed at:
+# http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
+# This fix is identical to rexml-expansion-fix version 1.0.1
+require 'rexml/rexml'
+
+# Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION
+unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
+  require 'rexml/document'
+
+  # REXML in 1.8.7 has the patch but didn't update Version from 3.1.7.2.
+  unless REXML::Document.respond_to?(:entity_expansion_limit=)
+    require 'rexml/entity'
+
+    module REXML
+      class Entity < Child
+        undef_method :unnormalized
+        def unnormalized
+          document.record_entity_expansion! if document
+          v = value()
+          return nil if v.nil?
+          @unnormalized = Text::unnormalize(v, parent)
+          @unnormalized
+        end
+      end
+      class Document < Element
+        @@entity_expansion_limit = 10_000
+        def self.entity_expansion_limit= val
+          @@entity_expansion_limit = val
+        end
+
+        def record_entity_expansion!
+          @number_of_expansions ||= 0
+          @number_of_expansions += 1
+          if @number_of_expansions > @@entity_expansion_limit
+            raise "Number of entity expansions exceeded, processing aborted."
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/string/access.rb

@@ -0,0 +1,106 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      unless '1.9'.respond_to?(:force_encoding)
+        # Makes it easier to access parts of a string, such as specific characters and substrings.
+        module Access
+          # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+          #
+          # Examples: 
+          #   "hello".at(0)  # => "h"
+          #   "hello".at(4)  # => "o"
+          #   "hello".at(10) # => nil
+          def at(position)
+            mb_chars[position, 1].to_s
+          end
+          
+          # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+          #
+          # Examples: 
+          #   "hello".from(0)  # => "hello"
+          #   "hello".from(2)  # => "llo"
+          #   "hello".from(10) # => nil
+          def from(position)
+            mb_chars[position..-1].to_s
+          end
+          
+          # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+          #
+          # Examples: 
+          #   "hello".to(0)  # => "h"
+          #   "hello".to(2)  # => "hel"
+          #   "hello".to(10) # => "hello"
+          def to(position)
+            mb_chars[0..position].to_s
+          end
+
+          # Returns the first character of the string or the first +limit+ characters.
+          #
+          # Examples: 
+          #   "hello".first     # => "h"
+          #   "hello".first(2)  # => "he"
+          #   "hello".first(10) # => "hello"
+          def first(limit = 1)
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              mb_chars[0...limit].to_s
+            end
+          end
+
+          # Returns the last character of the string or the last +limit+ characters.
+          #
+          # Examples: 
+          #   "hello".last     # => "o"
+          #   "hello".last(2)  # => "lo"
+          #   "hello".last(10) # => "hello"
+          def last(limit = 1)
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              mb_chars[(-limit)..-1].to_s
+            end
+          end
+        end
+      else
+        module Access #:nodoc:
+          def at(position)
+            self[position]
+          end
+
+          def from(position)
+            self[position..-1]
+          end
+
+          def to(position)
+            self[0..position]
+          end
+
+          def first(limit = 1)
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              to(limit - 1)
+            end
+          end
+
+          def last(limit = 1)
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              from(-limit)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/string/behavior.rb

@@ -0,0 +1,13 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      module Behavior
+        # Enable more predictable duck-typing on String-like classes. See
+        # Object#acts_like?.
+        def acts_like_string?
+          true
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/core_ext/string/bytesize.rb

@@ -0,0 +1,5 @@
+unless '1.9'.respond_to?(:bytesize)
+  class String
+    alias :bytesize :size
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'date'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Converting strings to other objects
+      module Conversions
+        # 'a'.ord == 'a'[0] for Ruby 1.9 forward compatibility.
+        def ord
+          self[0]
+        end if RUBY_VERSION < '1.9'
+
+        # Form can be either :utc (default) or :local.
+        def to_time(form = :utc)
+          ::Time.send("#{form}_time", *::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
+        end
+
+        def to_date
+          ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
+        end
+
+        def to_datetime
+          ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
+        end
+      end
+    end
+  end
+end