csd 0.1.5 → 0.1.6

data/lib/active_support/rescuable.rb

@@ -1,114 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/proc'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
-
-module ActiveSupport
-  # Rescuable module adds support for easier exception handling.
-  module Rescuable
-    extend Concern
-
-    included do
-      class_attribute :rescue_handlers
-      self.rescue_handlers = []
-    end
-
-    module ClassMethods
-      # Rescue exceptions raised in controller actions.
-      #
-      # <tt>rescue_from</tt> receives a series of exception classes or class
-      # names, and a trailing <tt>:with</tt> option with the name of a method
-      # or a Proc object to be called to handle them. Alternatively a block can
-      # be given.
-      #
-      # Handlers that take one argument will be called with the exception, so
-      # that the exception can be inspected when dealing with it.
-      #
-      # Handlers are inherited. They are searched from right to left, from
-      # bottom to top, and up the hierarchy. The handler of the first class for
-      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if
-      # any.
-      #
-      #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, :with => :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, :with => :show_errors
-      #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render :xml => exception, :status => 500
-      #     end
-      #
-      #     protected
-      #       def deny_access
-      #         ...
-      #       end
-      #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
-      #       end
-      #   end
-      def rescue_from(*klasses, &block)
-        options = klasses.extract_options!
-
-        unless options.has_key?(:with)
-          if block_given?
-            options[:with] = block
-          else
-            raise ArgumentError, "Need a handler. Supply an options hash that has a :with key as the last argument."
-          end
-        end
-
-        klasses.each do |klass|
-          key = if klass.is_a?(Class) && klass <= Exception
-            klass.name
-          elsif klass.is_a?(String)
-            klass
-          else
-            raise ArgumentError, "#{klass} is neither an Exception nor a String"
-          end
-
-          # put the new handler at the end because the list is read in reverse
-          self.rescue_handlers += [[key, options[:with]]]
-        end
-      end
-    end
-
-    # Tries to rescue the exception by looking up and calling a registered handler.
-    def rescue_with_handler(exception)
-      if handler = handler_for_rescue(exception)
-        handler.arity != 0 ? handler.call(exception) : handler.call
-        true # don't rely on the return value of the handler
-      end
-    end
-
-    def handler_for_rescue(exception)
-      # We go from right to left because pairs are pushed onto rescue_handlers
-      # as rescue_from declarations are found.
-      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
-        # The purpose of allowing strings in rescue_from is to support the
-        # declaration of handler associations for exception classes whose
-        # definition is yet unknown.
-        #
-        # Since this loop needs the constants it would be inconsistent to
-        # assume they should exist at this point. An early raised exception
-        # could trigger some other handler and the array could include
-        # precisely a string whose corresponding constant has not yet been
-        # seen. This is why we are tolerant to unknown constants.
-        #
-        # Note that this tolerance only matters if the exception was given as
-        # a string, otherwise a NameError will be raised by the interpreter
-        # itself when rescue_from CONSTANT is executed.
-        klass = self.class.const_get(klass_name) rescue nil
-        klass ||= klass_name.constantize rescue nil
-        exception.is_a?(klass) if klass
-      end
-
-      case rescuer
-      when Symbol
-        method(rescuer)
-      when Proc
-        rescuer.bind(self)
-      end
-    end
-  end
-end

data/lib/active_support/ruby/shim.rb

@@ -1,22 +0,0 @@
-# Backported Ruby builtins so you can code with the latest & greatest
-# but still run on any Ruby 1.8.x.
-#
-# Date        next_year, next_month
-# DateTime    to_date, to_datetime, xmlschema
-# Enumerable  group_by, each_with_object, none?
-# Process     Process.daemon
-# REXML       security fix
-# String      ord
-# Time        to_date, to_time, to_datetime
-require 'active_support'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/process/daemon'
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/encoding'
-require 'active_support/core_ext/rexml'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/file/path'
-require 'active_support/core_ext/module/method_names'

data/lib/active_support/secure_random.rb

@@ -1,199 +0,0 @@
-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/lib/active_support/string_inquirer.rb

@@ -1,21 +0,0 @@
-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/lib/active_support/test_case.rb

@@ -1,42 +0,0 @@
-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'
-require 'active_support/testing/pending'
-require 'active_support/testing/isolation'
-require 'active_support/core_ext/kernel/reporting'
-
-begin
-  silence_warnings { 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
-      Assertion = Test::Unit::AssertionFailedError
-
-      require 'active_support/testing/default'
-      include ActiveSupport::Testing::Default
-    end
-
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
-    end
-
-    include ActiveSupport::Testing::SetupAndTeardown
-    include ActiveSupport::Testing::Assertions
-    include ActiveSupport::Testing::Deprecation
-    include ActiveSupport::Testing::Pending
-    extend ActiveSupport::Testing::Declarative
-  end
-end

data/lib/active_support/testing/assertions.rb

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