backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/setup_and_teardown.rb

@@ -1,118 +0,0 @@
-require 'active_support/concern'
-require 'active_support/callbacks'
-
-module ActiveSupport
-  module Testing
-    module SetupAndTeardown
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks :setup, :teardown
-
-        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-          include ForMiniTest
-        else
-          include ForClassicTestUnit
-        end
-      end
-
-      module ClassMethods
-        def setup(*args, &block)
-          set_callback(:setup, :before, *args, &block)
-        end
-
-        def teardown(*args, &block)
-          set_callback(:teardown, :after, *args, &block)
-        end
-      end
-
-      module ForMiniTest
-        PASSTHROUGH_EXCEPTIONS = MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
-        def run(runner)
-          result = '.'
-          begin
-            run_callbacks :setup do
-              result = super
-            end
-          rescue *PASSTHROUGH_EXCEPTIONS => e
-            raise e
-          rescue Exception => e
-            result = runner.puke(self.class, method_name, e)
-          ensure
-            begin
-              run_callbacks :teardown
-            rescue *PASSTHROUGH_EXCEPTIONS => e
-              raise e
-            rescue Exception => e
-              result = runner.puke(self.class, method_name, e)
-            end
-          end
-          result
-        end
-      end
-
-      module ForClassicTestUnit
-        # For compatibility with Ruby < 1.8.6
-        PASSTHROUGH_EXCEPTIONS = Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS rescue [NoMemoryError, SignalException, Interrupt, SystemExit]
-
-        # This redefinition is unfortunate but test/unit shows us no alternative.
-        # Doubly unfortunate: hax to support Mocha's hax.
-        def run(result)
-          return if @method_name.to_s == "default_test"
-
-          mocha_counter = retrieve_mocha_counter(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-
-          begin
-            begin
-              run_callbacks :setup do
-                setup
-                __send__(@method_name)
-                mocha_verify(mocha_counter) if mocha_counter
-              end
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue Exception => e
-              raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
-              add_error(e)
-            ensure
-              begin
-                teardown
-                run_callbacks :teardown
-              rescue Test::Unit::AssertionFailedError => e
-                add_failure(e.message, e.backtrace)
-              rescue Exception => e
-                raise if PASSTHROUGH_EXCEPTIONS.include?(e.class)
-                add_error(e)
-              end
-            end
-          ensure
-            mocha_teardown if mocha_counter
-          end
-
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
-        end
-
-        protected
-
-        def retrieve_mocha_counter(result) #:nodoc:
-          if respond_to?(:mocha_verify) # using mocha
-            if defined?(Mocha::TestCaseAdapter::AssertionCounter)
-              Mocha::TestCaseAdapter::AssertionCounter.new(result)
-            elsif defined?(Mocha::Integration::TestUnit::AssertionCounter)
-              Mocha::Integration::TestUnit::AssertionCounter.new(result)
-            else
-              Mocha::MonkeyPatching::TestUnit::AssertionCounter.new(result)
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/time.rb

@@ -1,35 +0,0 @@
-require 'active_support'
-
-module ActiveSupport
-  autoload :Duration, 'active_support/duration'
-  autoload :TimeWithZone, 'active_support/time_with_zone'
-  autoload :TimeZone, 'active_support/values/time_zone'
-
-  on_load_all do
-    [Duration, TimeWithZone, TimeZone]
-  end
-end
-
-require 'date'
-require 'time'
-
-require 'active_support/core_ext/time/publicize_conversion_methods'
-require 'active_support/core_ext/time/marshal'
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/zones'
-
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/freeze'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date/conversions'
-require 'active_support/core_ext/date/zones'
-
-require 'active_support/core_ext/date_time/acts_like'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date_time/zones'
-
-require 'active_support/core_ext/integer/time'
-require 'active_support/core_ext/numeric/time'

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/time/autoload.rb

@@ -1,5 +0,0 @@
-module ActiveSupport
-  autoload :Duration, 'active_support/duration'
-  autoload :TimeWithZone, 'active_support/time_with_zone'
-  autoload :TimeZone, 'active_support/values/time_zone'
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/time_with_zone.rb

@@ -1,358 +0,0 @@
-require "active_support/values/time_zone"
-require 'active_support/core_ext/object/acts_like'
-require 'active_support/core_ext/object/inclusion'
-
-module ActiveSupport
-  # A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are
-  # limited to UTC and the system's <tt>ENV['TZ']</tt> zone.
-  #
-  # You shouldn't ever need to create a TimeWithZone instance directly via <tt>new</tt> . Instead use methods
-  # +local+, +parse+, +at+ and +now+ on TimeZone instances, and +in_time_zone+ on Time and DateTime instances.
-  # Examples:
-  #
-  #   Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
-  #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.parse('2007-02-10 15:30:45')          # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.at(1170361845)                        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #   Time.zone.now                                   # => Sun, 18 May 2008 13:07:55 EDT -04:00
-  #   Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45 EST -05:00
-  #
-  # See Time and TimeZone for further documentation of these methods.
-  #
-  # TimeWithZone instances implement the same API as Ruby Time instances, so that Time and TimeWithZone instances are interchangeable.
-  # Examples:
-  #
-  #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25 EDT -04:00
-  #   t.hour                                # => 13
-  #   t.dst?                                # => true
-  #   t.utc_offset                          # => -14400
-  #   t.zone                                # => "EDT"
-  #   t.to_s(:rfc822)                       # => "Sun, 18 May 2008 13:27:25 -0400"
-  #   t + 1.day                             # => Mon, 19 May 2008 13:27:25 EDT -04:00
-  #   t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00 EST -05:00
-  #   t > Time.utc(1999)                    # => true
-  #   t.is_a?(Time)                         # => true
-  #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
-  #
-  class TimeWithZone
-    def self.name
-      'Time' # Report class name as 'Time' to thwart type checking
-    end
-
-    include Comparable
-    attr_reader :time_zone
-
-    def initialize(utc_time, time_zone, local_time = nil, period = nil)
-      @utc, @time_zone, @time = utc_time, time_zone, local_time
-      @period = @utc ? period : get_period_and_ensure_valid_local_time
-    end
-
-    # Returns a Time or DateTime instance that represents the time in +time_zone+.
-    def time
-      @time ||= period.to_local(@utc)
-    end
-
-    # Returns a Time or DateTime instance that represents the time in UTC.
-    def utc
-      @utc ||= period.to_utc(@time)
-    end
-    alias_method :comparable_time, :utc
-    alias_method :getgm, :utc
-    alias_method :getutc, :utc
-    alias_method :gmtime, :utc
-
-    # Returns the underlying TZInfo::TimezonePeriod.
-    def period
-      @period ||= time_zone.period_for_utc(@utc)
-    end
-
-    # Returns the simultaneous time in <tt>Time.zone</tt>, or the specified zone.
-    def in_time_zone(new_zone = ::Time.zone)
-      return self if time_zone == new_zone
-      utc.in_time_zone(new_zone)
-    end
-
-    # Returns a <tt>Time.local()</tt> instance of the simultaneous time in your system's <tt>ENV['TZ']</tt> zone
-    def localtime
-      utc.respond_to?(:getlocal) ? utc.getlocal : utc.to_time.getlocal
-    end
-    alias_method :getlocal, :localtime
-
-    def dst?
-      period.dst?
-    end
-    alias_method :isdst, :dst?
-
-    def utc?
-      time_zone.name == 'UTC'
-    end
-    alias_method :gmt?, :utc?
-
-    def utc_offset
-      period.utc_total_offset
-    end
-    alias_method :gmt_offset, :utc_offset
-    alias_method :gmtoff, :utc_offset
-
-    def formatted_offset(colon = true, alternate_utc_string = nil)
-      utc? && alternate_utc_string || TimeZone.seconds_to_utc_offset(utc_offset, colon)
-    end
-
-    # Time uses +zone+ to display the time zone abbreviation, so we're duck-typing it.
-    def zone
-      period.zone_identifier.to_s
-    end
-
-    def inspect
-      "#{time.strftime('%a, %d %b %Y %H:%M:%S')} #{zone} #{formatted_offset}"
-    end
-
-    def xmlschema(fraction_digits = 0)
-      fraction = if fraction_digits > 0
-        (".%06i" % time.usec)[0, fraction_digits + 1]
-      end
-
-      "#{time.strftime("%Y-%m-%dT%H:%M:%S")}#{fraction}#{formatted_offset(true, 'Z')}"
-    end
-    alias_method :iso8601, :xmlschema
-
-    # Coerces time to a string for JSON encoding. The default format is ISO 8601. You can get
-    # %Y/%m/%d %H:%M:%S +offset style by setting <tt>ActiveSupport::JSON::Encoding.use_standard_json_time_format</tt>
-    # to false.
-    #
-    # ==== Examples
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
-    #   # => "2005-02-01T15:15:10Z"
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone.to_json
-    #   # => "2005/02/01 15:15:10 +0000"
-    #
-    def as_json(options = nil)
-      if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema
-      else
-        %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-      end
-    end
-
-    def encode_with(coder)
-      if coder.respond_to?(:represent_object)
-        coder.represent_object(nil, utc)
-      else
-        coder.represent_scalar(nil, utc.strftime("%Y-%m-%d %H:%M:%S.%9NZ"))
-      end
-    end
-
-    def to_yaml(options = {})
-      return super if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
-
-      utc.to_yaml(options)
-    end
-
-    def httpdate
-      utc.httpdate
-    end
-
-    def rfc2822
-      to_s(:rfc822)
-    end
-    alias_method :rfc822, :rfc2822
-
-    # <tt>:db</tt> format outputs time in UTC; all others output time in local.
-    # Uses TimeWithZone's +strftime+, so <tt>%Z</tt> and <tt>%z</tt> work correctly.
-    def to_s(format = :default)
-      if format == :db
-        utc.to_s(format)
-      elsif formatter = ::Time::DATE_FORMATS[format]
-        formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
-      else
-        "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby 1.9 Time#to_s format
-      end
-    end
-    alias_method :to_formatted_s, :to_s
-
-    # Replaces <tt>%Z</tt> and <tt>%z</tt> directives with +zone+ and +formatted_offset+, respectively, before passing to
-    # Time#strftime, so that zone information is correct
-    def strftime(format)
-      format = format.gsub('%Z', zone).
-                      gsub('%z',   formatted_offset(false)).
-                      gsub('%:z',  formatted_offset(true)).
-                      gsub('%::z', formatted_offset(true) + ":00")
-
-      time.strftime(format)
-    end
-
-    # Use the time in UTC for comparisons.
-    def <=>(other)
-      utc <=> other
-    end
-
-    def between?(min, max)
-      utc.between?(min, max)
-    end
-
-    def past?
-      utc.past?
-    end
-
-    def today?
-      time.today?
-    end
-
-    def future?
-      utc.future?
-    end
-
-    def eql?(other)
-      utc.eql?(other)
-    end
-
-    def hash
-      utc.hash
-    end
-
-    def +(other)
-      # If we're adding a Duration of variable length (i.e., years, months, days), move forward from #time,
-      # otherwise move forward from #utc, for accuracy when moving across DST boundaries
-      if duration_of_variable_length?(other)
-        method_missing(:+, other)
-      else
-        result = utc.acts_like?(:date) ? utc.since(other) : utc + other rescue utc.since(other)
-        result.in_time_zone(time_zone)
-      end
-    end
-
-    def -(other)
-      # If we're subtracting a Duration of variable length (i.e., years, months, days), move backwards from #time,
-      # otherwise move backwards #utc, for accuracy when moving across DST boundaries
-      if other.acts_like?(:time)
-        utc.to_f - other.to_f
-      elsif duration_of_variable_length?(other)
-        method_missing(:-, other)
-      else
-        result = utc.acts_like?(:date) ? utc.ago(other) : utc - other rescue utc.ago(other)
-        result.in_time_zone(time_zone)
-      end
-    end
-
-    def since(other)
-      # If we're adding a Duration of variable length (i.e., years, months, days), move forward from #time,
-      # otherwise move forward from #utc, for accuracy when moving across DST boundaries
-      if duration_of_variable_length?(other)
-        method_missing(:since, other)
-      else
-        utc.since(other).in_time_zone(time_zone)
-      end
-    end
-
-    def ago(other)
-      since(-other)
-    end
-
-    def advance(options)
-      # If we're advancing a value of variable length (i.e., years, weeks, months, days), advance from #time,
-      # otherwise advance from #utc, for accuracy when moving across DST boundaries
-      if options.values_at(:years, :weeks, :months, :days).any?
-        method_missing(:advance, options)
-      else
-        utc.advance(options).in_time_zone(time_zone)
-      end
-    end
-
-    %w(year mon month day mday wday yday hour min sec to_date).each do |method_name|
-      class_eval <<-EOV, __FILE__, __LINE__ + 1
-        def #{method_name}    # def month
-          time.#{method_name} #   time.month
-        end                   # end
-      EOV
-    end
-
-    def usec
-      time.respond_to?(:usec) ? time.usec : 0
-    end
-
-    def to_a
-      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
-    end
-
-    def to_f
-      utc.to_f
-    end
-
-    def to_i
-      utc.to_i
-    end
-    alias_method :tv_sec, :to_i
-
-    # A TimeWithZone acts like a Time, so just return +self+.
-    def to_time
-      utc
-    end
-
-    def to_datetime
-      utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
-    end
-
-    # So that +self+ <tt>acts_like?(:time)</tt>.
-    def acts_like_time?
-      true
-    end
-
-    # Say we're a Time to thwart type checking.
-    def is_a?(klass)
-      klass == ::Time || super
-    end
-    alias_method :kind_of?, :is_a?
-
-    def freeze
-      period; utc; time # preload instance variables before freezing
-      super
-    end
-
-    def marshal_dump
-      [utc, time_zone.name, time]
-    end
-
-    def marshal_load(variables)
-      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
-    end
-
-    # Ensure proxy class responds to all methods that underlying time instance responds to.
-    def respond_to?(sym, include_priv = false)
-      # consistently respond false to acts_like?(:date), regardless of whether #time is a Time or DateTime
-      return false if sym.to_s == 'acts_like_date?'
-      super || time.respond_to?(sym, include_priv)
-    end
-
-    # Send the missing method to +time+ instance, and wrap result in a new TimeWithZone with the existing +time_zone+.
-    def method_missing(sym, *args, &block)
-      result = time.__send__(sym, *args, &block)
-      result.acts_like?(:time) ? self.class.new(nil, time_zone, result) : result
-    end
-
-    private
-      def get_period_and_ensure_valid_local_time
-        # we don't want a Time.local instance enforcing its own DST rules as well,
-        # so transfer time values to a utc constructor if necessary
-        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
-        begin
-          @time_zone.period_for_local(@time)
-        rescue ::TZInfo::PeriodNotFound
-          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
-          @time += 1.hour
-          retry
-        end
-      end
-
-      def transfer_time_values_to_utc_constructor(time)
-        ::Time.utc_time(time.year, time.month, time.day, time.hour, time.min, time.sec, time.respond_to?(:usec) ? time.usec : 0)
-      end
-
-      def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.any? {|p| p[0].in?([:years, :months, :days]) }
-      end
-  end
-end