abiquo-etk 0.4.13

data/vendor/activesupport-2.3.8/lib/active_support/secure_random.rb

@@ -0,0 +1,199 @@
+begin
+  require 'securerandom'
+rescue LoadError
+end
+
+module ActiveSupport
+  if defined?(::SecureRandom)
+    # Use Ruby's SecureRandom library if available.
+    SecureRandom = ::SecureRandom # :nodoc:
+  else
+    # = Secure random number generator interface.
+    #
+    # This library is an interface for secure random number generator which is
+    # suitable for generating session key in HTTP cookies, etc.
+    #
+    # It supports following secure random number generators.
+    #
+    # * openssl
+    # * /dev/urandom
+    # * Win32
+    #
+    # *Note*: This module is based on the SecureRandom library from Ruby 1.9,
+    # revision 18786, August 23 2008. It's 100% interface-compatible with Ruby 1.9's
+    # SecureRandom library.
+    #
+    # == Example
+    #
+    #  # random hexadecimal string.
+    #  p SecureRandom.hex(10) #=> "52750b30ffbc7de3b362"
+    #  p SecureRandom.hex(10) #=> "92b15d6c8dc4beb5f559"
+    #  p SecureRandom.hex(11) #=> "6aca1b5c58e4863e6b81b8"
+    #  p SecureRandom.hex(12) #=> "94b2fff3e7fd9b9c391a2306"
+    #  p SecureRandom.hex(13) #=> "39b290146bea6ce975c37cfc23"
+    #  ...
+    #
+    #  # random base64 string.
+    #  p SecureRandom.base64(10) #=> "EcmTPZwWRAozdA=="
+    #  p SecureRandom.base64(10) #=> "9b0nsevdwNuM/w=="
+    #  p SecureRandom.base64(10) #=> "KO1nIU+p9DKxGg=="
+    #  p SecureRandom.base64(11) #=> "l7XEiFja+8EKEtY="
+    #  p SecureRandom.base64(12) #=> "7kJSM/MzBJI+75j8"
+    #  p SecureRandom.base64(13) #=> "vKLJ0tXBHqQOuIcSIg=="
+    #  ...
+    #
+    #  # random binary string.
+    #  p SecureRandom.random_bytes(10) #=> "\016\t{\370g\310pbr\301"
+    #  p SecureRandom.random_bytes(10) #=> "\323U\030TO\234\357\020\a\337"
+    #  ...
+    module SecureRandom
+      # SecureRandom.random_bytes generates a random binary string.
+      #
+      # The argument n specifies the length of the result string.
+      #
+      # If n is not specified, 16 is assumed.
+      # It may be larger in future.
+      #
+      # If secure random number generator is not available,
+      # NotImplementedError is raised.
+      def self.random_bytes(n=nil)
+        n ||= 16
+
+        unless defined? OpenSSL
+          begin
+            require 'openssl'
+          rescue LoadError
+          end
+        end
+
+        if defined? OpenSSL::Random
+          return OpenSSL::Random.random_bytes(n)
+        end
+
+        if !defined?(@has_urandom) || @has_urandom
+          flags = File::RDONLY
+          flags |= File::NONBLOCK if defined? File::NONBLOCK
+          flags |= File::NOCTTY if defined? File::NOCTTY
+          flags |= File::NOFOLLOW if defined? File::NOFOLLOW
+          begin
+            File.open("/dev/urandom", flags) {|f|
+              unless f.stat.chardev?
+                raise Errno::ENOENT
+              end
+              @has_urandom = true
+              ret = f.readpartial(n)
+              if ret.length != n
+                raise NotImplementedError, "Unexpected partial read from random device"
+              end
+              return ret
+            }
+          rescue Errno::ENOENT
+            @has_urandom = false
+          end
+        end
+
+        if !defined?(@has_win32)
+          begin
+            require 'Win32API'
+
+            crypt_acquire_context = Win32API.new("advapi32", "CryptAcquireContext", 'PPPII', 'L')
+            @crypt_gen_random = Win32API.new("advapi32", "CryptGenRandom", 'LIP', 'L')
+
+            hProvStr = " " * 4
+            prov_rsa_full = 1
+            crypt_verifycontext = 0xF0000000
+
+            if crypt_acquire_context.call(hProvStr, nil, nil, prov_rsa_full, crypt_verifycontext) == 0
+              raise SystemCallError, "CryptAcquireContext failed: #{lastWin32ErrorMessage}"
+            end
+            @hProv, = hProvStr.unpack('L')
+
+            @has_win32 = true
+          rescue LoadError
+            @has_win32 = false
+          end
+        end
+        if @has_win32
+          bytes = " " * n
+          if @crypt_gen_random.call(@hProv, bytes.size, bytes) == 0
+            raise SystemCallError, "CryptGenRandom failed: #{lastWin32ErrorMessage}"
+          end
+          return bytes
+        end
+
+        raise NotImplementedError, "No random device"
+      end
+
+      # SecureRandom.hex generates a random hex string.
+      #
+      # The argument n specifies the length of the random length.
+      # The length of the result string is twice of n.
+      #
+      # If n is not specified, 16 is assumed.
+      # It may be larger in future.
+      #
+      # If secure random number generator is not available,
+      # NotImplementedError is raised.
+      def self.hex(n=nil)
+        random_bytes(n).unpack("H*")[0]
+      end
+
+      # SecureRandom.base64 generates a random base64 string.
+      #
+      # The argument n specifies the length of the random length.
+      # The length of the result string is about 4/3 of n.
+      #
+      # If n is not specified, 16 is assumed.
+      # It may be larger in future.
+      #
+      # If secure random number generator is not available,
+      # NotImplementedError is raised.
+      def self.base64(n=nil)
+        [random_bytes(n)].pack("m*").delete("\n")
+      end
+
+      # SecureRandom.random_number generates a random number.
+      #
+      # If an positive integer is given as n,
+      # SecureRandom.random_number returns an integer:
+      # 0 <= SecureRandom.random_number(n) < n.
+      #
+      # If 0 is given or an argument is not given,
+      # SecureRandom.random_number returns an float:
+      # 0.0 <= SecureRandom.random_number() < 1.0.
+      def self.random_number(n=0)
+        if 0 < n
+          hex = n.to_s(16)
+          hex = '0' + hex if (hex.length & 1) == 1
+          bin = [hex].pack("H*")
+          mask = bin[0]
+          mask |= mask >> 1
+          mask |= mask >> 2
+          mask |= mask >> 4
+          begin
+            rnd = SecureRandom.random_bytes(bin.length)
+            rnd[0] = rnd[0] & mask
+          end until rnd < bin
+          rnd.unpack("H*")[0].hex
+        else
+          # assumption: Float::MANT_DIG <= 64
+          i64 = SecureRandom.random_bytes(8).unpack("Q")[0]
+          Math.ldexp(i64 >> (64-Float::MANT_DIG), -Float::MANT_DIG)
+        end
+      end
+
+      # Following code is based on David Garamond's GUID library for Ruby.
+      def self.lastWin32ErrorMessage # :nodoc:
+        get_last_error = Win32API.new("kernel32", "GetLastError", '', 'L')
+        format_message = Win32API.new("kernel32", "FormatMessageA", 'LPLLPLPPPPPPPP', 'L')
+        format_message_ignore_inserts = 0x00000200
+        format_message_from_system    = 0x00001000
+
+        code = get_last_error.call
+        msg = "\0" * 1024
+        len = format_message.call(format_message_ignore_inserts + format_message_from_system, 0, code, 0, msg, 1024, nil, nil, nil, nil, nil, nil, nil, nil)
+        msg[0, len].tr("\r", '').chomp
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/string_inquirer.rb

@@ -0,0 +1,21 @@
+module ActiveSupport
+  # Wrapping a string in this class gives you a prettier way to test
+  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
+  # in a StringInquirer object so instead of calling this:
+  #
+  #   Rails.env == "production"
+  #
+  # you can call this:
+  #
+  #   Rails.env.production?
+  #
+  class StringInquirer < String
+    def method_missing(method_name, *arguments)
+      if method_name.to_s[-1,1] == "?"
+        self == method_name.to_s[0..-2]
+      else
+        super
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/test_case.rb

@@ -0,0 +1,40 @@
+require 'test/unit/testcase'
+require 'active_support/testing/setup_and_teardown'
+require 'active_support/testing/assertions'
+require 'active_support/testing/deprecation'
+require 'active_support/testing/declarative'
+
+begin
+  gem 'mocha', ">= 0.9.7"
+  require 'mocha'
+rescue LoadError
+  # Fake Mocha::ExpectationError so we can rescue it in #run. Bleh.
+  Object.const_set :Mocha, Module.new
+  Mocha.const_set :ExpectationError, Class.new(StandardError)
+end
+
+module ActiveSupport
+  class TestCase < ::Test::Unit::TestCase
+    if defined? MiniTest
+      Assertion = MiniTest::Assertion
+      alias_method :method_name, :name if method_defined? :name
+      alias_method :method_name, :__name__ if method_defined? :__name__
+    else
+      # TODO: Figure out how to get the Rails::BacktraceFilter into minitest/unit
+      if defined?(Rails) && ENV['BACKTRACE'].nil?
+        require 'rails/backtrace_cleaner'
+        Test::Unit::Util::BacktraceFilter.module_eval { include Rails::BacktraceFilterForTestUnit }
+      end
+
+      Assertion = Test::Unit::AssertionFailedError
+
+      require 'active_support/testing/default'
+      include ActiveSupport::Testing::Default
+    end
+
+    include ActiveSupport::Testing::SetupAndTeardown
+    include ActiveSupport::Testing::Assertions
+    include ActiveSupport::Testing::Deprecation
+    extend ActiveSupport::Testing::Declarative
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/testing/assertions.rb

@@ -0,0 +1,79 @@
+module ActiveSupport
+  module Testing
+    module Assertions
+      # Test numeric difference between the return value of an expression as a result of what is evaluated
+      # in the yielded block.
+      #
+      #   assert_difference 'Article.count' do
+      #     post :create, :article => {...}
+      #   end
+      #
+      # An arbitrary expression is passed in and evaluated.
+      #
+      #   assert_difference 'assigns(:article).comments(:reload).size' do
+      #     post :create, :comment => {...}
+      #   end
+      #
+      # An arbitrary positive or negative difference can be specified. The default is +1.
+      #
+      #   assert_difference 'Article.count', -1 do
+      #     post :delete, :id => ...
+      #   end
+      #
+      # An array of expressions can also be passed in and evaluated.
+      #
+      #   assert_difference [ 'Article.count', 'Post.count' ], +2 do
+      #     post :create, :article => {...}
+      #   end
+      #
+      # A error message can be specified.
+      #
+      #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
+      #     post :delete, :id => ...
+      #   end
+      def assert_difference(expression, difference = 1, message = nil, &block)
+        b = block.send(:binding)
+        exps = Array.wrap(expression)
+        before = exps.map { |e| eval(e, b) }
+
+        yield
+
+        exps.each_with_index do |e, i|
+          error = "#{e.inspect} didn't change by #{difference}"
+          error = "#{message}.\n#{error}" if message
+          assert_equal(before[i] + difference, eval(e, b), error)
+        end
+      end
+
+      # Assertion that the numeric result of evaluating an expression is not changed before and after
+      # invoking the passed in block.
+      #
+      #   assert_no_difference 'Article.count' do
+      #     post :create, :article => invalid_attributes
+      #   end
+      #
+      # A error message can be specified.
+      #
+      #   assert_no_difference 'Article.count', "An Article should not be destroyed" do
+      #     post :create, :article => invalid_attributes
+      #   end
+      def assert_no_difference(expression, message = nil, &block)
+        assert_difference expression, 0, message, &block
+      end
+      
+      # Test if an expression is blank. Passes if object.blank? is true.
+      #
+      #   assert_blank [] # => true
+      def assert_blank(object)
+        assert object.blank?, "#{object.inspect} is not blank"
+      end
+      
+      # Test if an expression is not blank. Passes if object.present? is true.
+      #
+      #   assert_present {:data => 'x' } # => true
+      def assert_present(object)
+        assert object.present?, "#{object.inspect} is blank"
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/testing/declarative.rb

@@ -0,0 +1,21 @@
+module ActiveSupport
+  module Testing
+    module Declarative
+      # test "verify something" do
+      #   ...
+      # end
+      def test(name, &block)
+        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        defined = instance_method(test_name) rescue false
+        raise "#{test_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/testing/default.rb

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Testing
+    module Default #:nodoc:
+      # Placeholder so test/unit ignores test cases without any tests.
+      def default_test
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/testing/deprecation.rb

@@ -0,0 +1,57 @@
+require "active_support/core_ext/module"
+
+module ActiveSupport
+  module Testing
+    module Deprecation #:nodoc:
+      def assert_deprecated(match = nil, &block)
+        result, warnings = collect_deprecations(&block)
+        assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
+        if match
+          match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
+          assert warnings.any? { |w| w =~ match }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
+        end
+        result
+      end
+
+      def assert_not_deprecated(&block)
+        result, deprecations = collect_deprecations(&block)
+        assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
+        result
+      end
+
+      private
+        def collect_deprecations
+          old_behavior = ActiveSupport::Deprecation.behavior
+          deprecations = []
+          ActiveSupport::Deprecation.behavior = Proc.new do |message, callstack|
+            deprecations << message
+          end
+          result = yield
+          [result, deprecations]
+        ensure
+          ActiveSupport::Deprecation.behavior = old_behavior
+        end
+    end
+  end
+end
+
+begin
+  require 'test/unit/error'
+
+  module Test
+    module Unit
+      class Error # :nodoc:
+        # Silence warnings when reporting test errors.
+        def message_with_silenced_deprecation
+          ActiveSupport::Deprecation.silence do
+            message_without_silenced_deprecation
+          end
+        end
+
+        alias_method_chain :message, :silenced_deprecation
+      end
+    end
+  end
+rescue LoadError
+  # Using miniunit, ignore.
+end