mack-active_record 0.8.2 → 0.8.3

data/lib/gems/activesupport-2.2.2/lib/active_support/multibyte/unicode_database.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-
-module ActiveSupport #:nodoc:
-  module Multibyte #:nodoc:
-    # Holds data about a codepoint in the Unicode database
-    class Codepoint
-      attr_accessor :code, :combining_class, :decomp_type, :decomp_mapping, :uppercase_mapping, :lowercase_mapping
-    end
-
-    # Holds static data from the Unicode database
-    class UnicodeDatabase
-      ATTRIBUTES = :codepoints, :composition_exclusion, :composition_map, :boundary, :cp1252
-
-      attr_writer(*ATTRIBUTES)
-
-      def initialize
-        @codepoints = Hash.new(Codepoint.new)
-        @composition_exclusion = []
-        @composition_map = {}
-        @boundary = {}
-        @cp1252 = {}
-      end
-
-      # Lazy load the Unicode database so it's only loaded when it's actually used
-      ATTRIBUTES.each do |attr_name|
-        class_eval(<<-EOS, __FILE__, __LINE__)
-          def #{attr_name}
-            load
-            @#{attr_name}
-          end
-        EOS
-      end
-
-      # Loads the Unicode database and returns all the internal objects of UnicodeDatabase.
-      def load
-        begin
-          @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, 'rb') { |f| Marshal.load f.read }
-        rescue Exception => e
-            raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
-        end
-
-        # Redefine the === method so we can write shorter rules for grapheme cluster breaks
-        @boundary.each do |k,_|
-          @boundary[k].instance_eval do
-            def ===(other)
-              detect { |i| i === other } ? true : false
-            end
-          end if @boundary[k].kind_of?(Array)
-        end
-
-        # define attr_reader methods for the instance variables
-        class << self
-          attr_reader(*ATTRIBUTES)
-        end
-      end
-
-      # Returns the directory in which the data files are stored
-      def self.dirname
-        File.dirname(__FILE__) + '/../values/'
-      end
-
-      # Returns the filename for the data file for this version
-      def self.filename
-        File.expand_path File.join(dirname, "unicode_tables.dat")
-      end
-    end
-
-    # UniCode Database
-    UCD = UnicodeDatabase.new
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/multibyte.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'active_support/multibyte/chars'
-require 'active_support/multibyte/exceptions'
-require 'active_support/multibyte/unicode_database'
-
-module ActiveSupport #:nodoc:
-  module Multibyte
-    # A list of all available normalization forms. See http://www.unicode.org/reports/tr15/tr15-29.html for more
-    # information about normalization.
-    NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
-
-    # The Unicode version that is supported by the implementation
-    UNICODE_VERSION = '5.1.0'
-
-    # The default normalization used for operations that require normalization. It can be set to any of the
-    # normalizations in NORMALIZATION_FORMS.
-    #
-    # Example:
-    #   ActiveSupport::Multibyte.default_normalization_form = :c
-    mattr_accessor :default_normalization_form
-    self.default_normalization_form = :kc
-
-    # The proxy class returned when calling mb_chars. You can use this accessor to configure your own proxy
-    # class so you can support other encodings. See the ActiveSupport::Multibyte::Chars implementation for
-    # an example how to do this.
-    #
-    # Example:
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    mattr_accessor :proxy_class
-    self.proxy_class = ActiveSupport::Multibyte::Chars
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/option_merger.rb

@@ -1,17 +0,0 @@
-module ActiveSupport
-  class OptionMerger #:nodoc:
-    instance_methods.each do |method|
-      undef_method(method) if method !~ /^(__|instance_eval|class|object_id)/
-    end
-
-    def initialize(context, options)
-      @context, @options = context, options
-    end
-
-    private
-      def method_missing(method, *arguments, &block)
-        arguments << (arguments.last.respond_to?(:to_hash) ? @options.deep_merge(arguments.pop) : @options.dup)
-        @context.__send__(method, *arguments, &block)
-      end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/ordered_hash.rb

@@ -1,58 +0,0 @@
-# OrderedHash is namespaced to prevent conflicts with other implementations
-module ActiveSupport
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    OrderedHash = ::Hash
-  else
-    class OrderedHash < Array #:nodoc:
-      def []=(key, value)
-        if pair = assoc(key)
-          pair.pop
-          pair << value
-        else
-          self << [key, value]
-        end
-        value
-      end
-
-      def [](key)
-        pair = assoc(key)
-        pair ? pair.last : nil
-      end
-
-      def delete(key)
-        pair = assoc(key)
-        pair ? array_index = index(pair) : nil
-        array_index ? delete_at(array_index).last : nil
-      end
-
-      def keys
-        collect { |key, value| key }
-      end
-
-      def values
-        collect { |key, value| value }
-      end
-
-      def to_hash
-        returning({}) do |hash|
-          each { |array| hash[array[0]] = array[1] }
-        end
-      end
-
-      def has_key?(k)
-        !assoc(k).nil?
-      end
-
-      alias_method :key?, :has_key?
-      alias_method :include?, :has_key?
-      alias_method :member?, :has_key?
-
-      def has_value?(v)
-        any? { |key, value| value == v }
-      end
-
-      alias_method :value?, :has_value?
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/ordered_options.rb

@@ -1,19 +0,0 @@
-module ActiveSupport #:nodoc:
-  class OrderedOptions < OrderedHash #:nodoc:
-    def []=(key, value)
-      super(key.to_sym, value)
-    end
-
-    def [](key)
-      super(key.to_sym)
-    end
-
-    def method_missing(name, *args)
-      if name.to_s =~ /(.*)=$/
-        self[$1.to_sym] = args.first
-      else
-        self[name]
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/rescuable.rb

@@ -1,108 +0,0 @@
-module ActiveSupport
-  # Rescuable module adds support for easier exception handling.
-  module Rescuable
-    def self.included(base) # :nodoc:
-      base.class_inheritable_accessor :rescue_handlers
-      base.rescue_handlers = []
-
-      base.extend(ClassMethods)
-    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
-          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 = Array(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/gems/activesupport-2.2.2/lib/active_support/secure_random.rb

@@ -1,197 +0,0 @@
-begin
-  require 'openssl'
-rescue LoadError
-end
-
-begin
-  require 'securerandom'
-rescue LoadError
-end
-
-module ActiveSupport
-  if defined?(::SecureRandom)
-    # Use Ruby 1.9's SecureRandom library whenever possible.
-    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
-
-        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/gems/activesupport-2.2.2/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/gems/activesupport-2.2.2/lib/active_support/test_case.rb

@@ -1,24 +0,0 @@
-require 'test/unit/testcase'
-require 'active_support/testing/default'
-require 'active_support/testing/core_ext/test'
-
-
-module ActiveSupport
-  class TestCase < Test::Unit::TestCase
-    # test "verify something" do
-    #   ...
-    # end
-    def self.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

data/lib/gems/activesupport-2.2.2/lib/active_support/testing/core_ext/test/unit/assertions.rb

@@ -1,72 +0,0 @@
-require 'test/unit/assertions'
-module Test
-  module Unit
-    #--
-    # FIXME: no Proc#binding in Ruby 2, must change this API
-    #++
-    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(expressions, difference = 1, message = nil, &block)
-        expression_evaluations = Array(expressions).map do |expression|
-          [expression, lambda do
-            eval(expression, block.__send__(:binding))
-          end]
-        end
-
-        original_values = expression_evaluations.inject([]) { |memo, expression| memo << expression[1].call }
-        yield
-        expression_evaluations.each_with_index do |expression, i|
-          full_message = ""
-          full_message << "#{message}.\n" if message
-          full_message << "<#{expression[0]}> was the expression that failed"
-          assert_equal original_values[i] + difference, expression[1].call, full_message
-        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(expressions, message = nil, &block)
-        assert_difference expressions, 0, message, &block
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/testing/core_ext/test.rb

@@ -1,6 +0,0 @@
-require 'active_support/testing/core_ext/test/unit/assertions'
-require 'active_support/testing/setup_and_teardown'
-
-class Test::Unit::TestCase #:nodoc:
-  include ActiveSupport::Testing::SetupAndTeardown
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/testing/default.rb

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