backbone-deep-rails 0.0.2 → 0.0.3

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

@@ -1,40 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Declarative
-
-      def self.extended(klass)
-        klass.class_eval do
-
-          unless method_defined?(:describe)
-            def self.describe(text)
-              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-                def self.name
-                  "#{text}"
-                end
-              RUBY_EVAL
-            end
-          end
-
-        end
-      end
-
-      unless defined?(Spec)
-        # 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
-end

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

@@ -1,55 +0,0 @@
-require 'active_support/deprecation'
-
-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'
-rescue LoadError
-  # Using miniunit, ignore.
-else
-  module Test
-    module Unit
-      class Error #:nodoc:
-        # Silence warnings when reporting test errors.
-        def message_with_silenced_deprecation
-          ::ActiveSupport::Deprecation.silence { message_without_silenced_deprecation }
-        end
-        alias_method :message_without_silenced_deprecation, :message
-        alias_method :message, :message_with_silenced_deprecation
-      end
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-require 'rbconfig'
-module ActiveSupport
-  module Testing
-    class RemoteError < StandardError
-
-      attr_reader :message, :backtrace
-
-      def initialize(exception)
-        @message = "caught #{exception.class.name}: #{exception.message}"
-        @backtrace = exception.backtrace
-      end
-    end
-
-    class ProxyTestResult
-      def initialize
-        @calls = []
-      end
-
-      def add_error(e)
-        e = Test::Unit::Error.new(e.test_name, RemoteError.new(e.exception))
-        @calls << [:add_error, e]
-      end
-
-      def __replay__(result)
-        @calls.each do |name, args|
-          result.send(name, *args)
-        end
-      end
-
-      def method_missing(name, *args)
-        @calls << [name, args]
-      end
-    end
-
-    module Isolation
-      def self.forking_env?
-        !ENV["NO_FORK"] && ((RbConfig::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
-      end
-
-      def self.included(base)
-        if defined?(::MiniTest) && base < ::MiniTest::Unit::TestCase
-          base.send :include, MiniTest
-        elsif defined?(Test::Unit)
-          base.send :include, TestUnit
-        end
-      end
-
-      def _run_class_setup      # class setup method should only happen in parent
-        unless defined?(@@ran_class_setup) || ENV['ISOLATION_TEST']
-          self.class.setup if self.class.respond_to?(:setup)
-          @@ran_class_setup = true
-        end
-      end
-
-      module TestUnit
-        def run(result)
-          _run_class_setup
-
-          yield(Test::Unit::TestCase::STARTED, name)
-
-          @_result = result
-
-          serialized = run_in_isolation do |proxy|
-            begin
-              super(proxy) { }
-            rescue Exception => e
-              proxy.add_error(Test::Unit::Error.new(name, e))
-            end
-          end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(@_result)
-
-          yield(Test::Unit::TestCase::FINISHED, name)
-          retval
-        end
-      end
-
-      module MiniTest
-        def run(runner)
-          _run_class_setup
-
-          serialized = run_in_isolation do |isolated_runner|
-            super(isolated_runner)
-          end
-
-          retval, proxy = Marshal.load(serialized)
-          proxy.__replay__(runner)
-          retval
-        end
-      end
-
-      module Forking
-        def run_in_isolation(&blk)
-          read, write = IO.pipe
-
-          pid = fork do
-            read.close
-            proxy = ProxyTestResult.new
-            retval = yield proxy
-            write.puts [Marshal.dump([retval, proxy])].pack("m")
-            exit!
-          end
-
-          write.close
-          result = read.read
-          Process.wait2(pid)
-          return result.unpack("m")[0]
-        end
-      end
-
-      module Subprocess
-        ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
-
-        # Crazy H4X to get this working in windows / jruby with
-        # no forking.
-        def run_in_isolation(&blk)
-          require "tempfile"
-
-          if ENV["ISOLATION_TEST"]
-            proxy = ProxyTestResult.new
-            retval = yield proxy
-            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
-              file.puts [Marshal.dump([retval, proxy])].pack("m")
-            end
-            exit!
-          else
-            Tempfile.open("isolation") do |tmpfile|
-              ENV["ISOLATION_TEST"]   = @method_name
-              ENV["ISOLATION_OUTPUT"] = tmpfile.path
-
-              load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
-
-              ENV.delete("ISOLATION_TEST")
-              ENV.delete("ISOLATION_OUTPUT")
-
-              return tmpfile.read.unpack("m")[0]
-            end
-          end
-        end
-      end
-
-      include forking_env? ? Forking : Subprocess
-    end
-  end
-end
-
-# Only in subprocess for windows / jruby.
-if ENV['ISOLATION_TEST']
-  require "test/unit/collector/objectspace"
-  class Test::Unit::Collector::ObjectSpace
-    def include?(test)
-      super && test.method_name == ENV['ISOLATION_TEST']
-    end
-  end
-end

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

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

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

@@ -1,52 +0,0 @@
-# Some code from jeremymcanally's "pending"
-# https://github.com/jeremymcanally/pending/tree/master
-
-module ActiveSupport
-  module Testing
-    module Pending
-
-      unless defined?(Spec)
-
-        @@pending_cases = []
-        @@at_exit = false
-
-        def pending(description = "", &block)
-          if defined?(::MiniTest)
-            skip(description.blank? ? nil : description)
-          else
-            if description.is_a?(Symbol)
-              is_pending = $tags[description]
-              return block.call unless is_pending
-            end
-
-            if block_given?
-              failed = false
-
-              begin
-                block.call
-              rescue Exception
-                failed = true
-              end
-
-              flunk("<#{description}> did not fail.") unless failed
-            end
-
-            caller[0] =~ (/(.*):(.*):in `(.*)'/)
-            @@pending_cases << "#{$3} at #{$1}, line #{$2}"
-            print "P"
-
-            @@at_exit ||= begin
-              at_exit do
-                puts "\nPending Cases:"
-                @@pending_cases.each do |test_case|
-                  puts test_case
-                end
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,317 +0,0 @@
-require 'fileutils'
-require 'rails/version'
-require 'active_support/concern'
-require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/string/inflections'
-require 'action_view/helpers/number_helper'
-
-module ActiveSupport
-  module Testing
-    module Performance
-      extend ActiveSupport::Concern
-
-      included do
-        superclass_delegating_accessor :profile_options
-        self.profile_options = {}
-
-        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-          include ForMiniTest
-        else
-          include ForClassicTestUnit
-        end
-      end
-
-      # each implementation should define metrics and freeze the defaults
-      DEFAULTS =
-        if ARGV.include?('--benchmark') # HAX for rake test
-          { :runs => 4,
-            :output => 'tmp/performance',
-            :benchmark => true }
-        else
-          { :runs => 1,
-            :output => 'tmp/performance',
-            :benchmark => false }
-        end
-
-      def full_profile_options
-        DEFAULTS.merge(profile_options)
-      end
-
-      def full_test_name
-        "#{self.class.name}##{method_name}"
-      end
-
-      module ForMiniTest
-        def run(runner)
-          @runner = runner
-
-          run_warmup
-          if full_profile_options && metrics = full_profile_options[:metrics]
-            metrics.each do |metric_name|
-              if klass = Metrics[metric_name.to_sym]
-                run_profile(klass.new)
-              end
-            end
-          end
-
-          return
-        end
-
-        def run_test(metric, mode)
-          result = '.'
-          begin
-            run_callbacks :setup
-            setup
-            metric.send(mode) { __send__ method_name }
-          rescue Exception => e
-            result = @runner.puke(self.class, method_name, e)
-          ensure
-            begin
-              teardown
-              run_callbacks :teardown, :enumerator => :reverse_each
-            rescue Exception => e
-              result = @runner.puke(self.class, method_name, e)
-            end
-          end
-          result
-        end
-      end
-
-      module ForClassicTestUnit
-        def run(result)
-          return if method_name =~ /^default_test$/
-
-          yield(self.class::STARTED, name)
-          @_result = result
-
-          run_warmup
-          if full_profile_options && metrics = full_profile_options[:metrics]
-            metrics.each do |metric_name|
-              if klass = Metrics[metric_name.to_sym]
-                run_profile(klass.new)
-                result.add_run
-              else
-                puts '%20s: unsupported' % metric_name
-              end
-            end
-          end
-
-          yield(self.class::FINISHED, name)
-        end
-
-        def run_test(metric, mode)
-          run_callbacks :setup
-          setup
-          metric.send(mode) { __send__ @method_name }
-        rescue ::Test::Unit::AssertionFailedError => e
-        add_failure(e.message, e.backtrace)
-        rescue StandardError, ScriptError => e
-          add_error(e)
-        ensure
-          begin
-            teardown
-            run_callbacks :teardown, :enumerator => :reverse_each
-          rescue ::Test::Unit::AssertionFailedError => e
-            add_failure(e.message, e.backtrace)
-          rescue StandardError, ScriptError => e
-            add_error(e)
-          end
-        end
-      end
-
-      protected
-        # overridden by each implementation
-        def run_gc; end
-
-        def run_warmup
-          run_gc
-
-          time = Metrics::Time.new
-          run_test(time, :benchmark)
-          puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
-
-          run_gc
-        end
-
-        def run_profile(metric)
-          klass = full_profile_options[:benchmark] ? Benchmarker : Profiler
-          performer = klass.new(self, metric)
-
-          performer.run
-          puts performer.report
-          performer.record
-        end
-
-      class Performer
-        delegate :run_test, :full_profile_options, :full_test_name, :to => :@harness
-
-        def initialize(harness, metric)
-          @harness, @metric, @supported = harness, metric, false
-        end
-
-        def report
-          if @supported
-            rate = @total / full_profile_options[:runs]
-            '%20s: %s' % [@metric.name, @metric.format(rate)]
-          else
-            '%20s: unsupported' % @metric.name
-          end
-        end
-
-        protected
-          def output_filename
-            "#{full_profile_options[:output]}/#{full_test_name}_#{@metric.name}"
-          end
-      end
-
-      # overridden by each implementation
-      class Profiler < Performer
-        def time_with_block
-          before = Time.now
-          yield
-          Time.now - before
-        end
-
-        def run;    end
-        def record; end
-      end
-
-      class Benchmarker < Performer     
-        def initialize(*args)
-          super
-          @supported = @metric.respond_to?('measure')
-        end
-
-        def run
-          return unless @supported
-
-          full_profile_options[:runs].to_i.times { run_test(@metric, :benchmark) }
-          @total = @metric.total
-        end
-
-        def record
-          avg = @metric.total / full_profile_options[:runs].to_i
-          now = Time.now.utc.xmlschema
-          with_output_file do |file|
-            file.puts "#{avg},#{now},#{environment}"
-          end
-        end
-
-        def environment
-          unless defined? @env
-            app = "#{$1}.#{$2}" if File.directory?('.git') && `git branch -v` =~ /^\* (\S+)\s+(\S+)/
-
-            rails = Rails::VERSION::STRING
-            if File.directory?('vendor/rails/.git')
-              Dir.chdir('vendor/rails') do
-                rails += ".#{$1}.#{$2}" if `git branch -v` =~ /^\* (\S+)\s+(\S+)/
-              end
-            end
-
-            ruby = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-            ruby += "-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
-
-            @env = [app, rails, ruby, RUBY_PLATFORM] * ','
-          end
-
-          @env
-        end
-
-        protected
-          HEADER = 'measurement,created_at,app,rails,ruby,platform'
-
-          def with_output_file
-            fname = output_filename
-
-            if new = !File.exist?(fname)
-              FileUtils.mkdir_p(File.dirname(fname))
-            end
-
-            File.open(fname, 'ab') do |file|
-              file.puts(HEADER) if new
-              yield file
-            end
-          end
-
-          def output_filename
-            "#{super}.csv"
-          end
-      end
-
-      module Metrics
-        def self.[](name)
-          const_get(name.to_s.camelize)
-        rescue NameError
-          nil
-        end
-
-        class Base
-          include ActionView::Helpers::NumberHelper
-
-          attr_reader :total
-
-          def initialize
-            @total = 0
-          end
-
-          def name
-            @name ||= self.class.name.demodulize.underscore
-          end
-
-          def benchmark            
-            with_gc_stats do
-              before = measure
-              yield
-              @total += (measure - before)
-            end
-          end
-
-          # overridden by each implementation
-          def profile; end
-
-          protected
-            # overridden by each implementation
-            def with_gc_stats; end
-        end
-
-        class Time < Base
-          def measure
-            ::Time.now.to_f
-          end
-
-          def format(measurement)
-            if measurement < 1
-              '%d ms' % (measurement * 1000)
-            else
-              '%.2f sec' % measurement
-            end
-          end
-        end
-
-        class Amount < Base
-          def format(measurement)
-            number_with_delimiter(measurement.floor)
-          end
-        end
-
-        class DigitalInformationUnit < Base
-          def format(measurement)
-            number_to_human_size(measurement, :precision => 2)
-          end
-        end
-
-        # each implementation provides its own metrics like ProcessTime, Memory or GcRuns
-      end
-    end
-  end
-end
-
-RUBY_ENGINE = 'ruby' unless defined?(RUBY_ENGINE) # mri 1.8
-case RUBY_ENGINE
-  when 'ruby'   then require 'active_support/testing/performance/ruby'
-  when 'rbx'    then require 'active_support/testing/performance/rubinius'
-  when 'jruby'  then require 'active_support/testing/performance/jruby'
-  else
-    $stderr.puts 'Your ruby interpreter is not supported for benchmarking.'
-    exit
-end