mack-active_record 0.8.1 → 0.8.2

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

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,33 @@
+# 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,58 @@
+# 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -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/lib/gems/activesupport-2.2.2/lib/active_support/test_case.rb

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -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