dmurphy_palindrome 0.1.0

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/old_activesupport_fix.rb

@@ -0,0 +1,24 @@
+require "active_support/testing/setup_and_teardown"
+
+module ActiveSupport
+  module Testing
+    module SetupAndTeardown
+      if defined?(ForMinitest)
+        ForMiniTest = ForMinitest
+      end
+      module ForMiniTest
+        remove_method :run
+
+        def before_setup
+          super
+          run_callbacks :setup
+        end
+
+        def after_teardown
+          run_callbacks :teardown
+          super
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/relative_position.rb

@@ -0,0 +1,26 @@
+module Minitest
+  module RelativePosition
+    TEST_PADDING = 2
+    TEST_SIZE = 63
+    MARK_SIZE = 5
+    INFO_PADDING = 8
+
+    private
+
+    def print_with_info_padding(line)
+      puts pad(line, INFO_PADDING)
+    end
+
+    def pad(str, size = INFO_PADDING)
+      ' ' * size + str
+    end
+
+    def pad_mark(str)
+      "%#{MARK_SIZE}s" % str
+    end
+
+    def pad_test(str)
+      pad("%-#{TEST_SIZE}s" % str, TEST_PADDING)
+    end
+  end
+end

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/reporters.rb

@@ -0,0 +1,89 @@
+require 'minitest'
+
+module Minitest
+  require "minitest/relative_position"
+  require "minitest/extensible_backtrace_filter"
+
+  module Reporters
+    require "minitest/reporters/version"
+
+    autoload :ANSI, "minitest/reporters/ansi"
+    autoload :BaseReporter, "minitest/reporters/base_reporter"
+    autoload :DefaultReporter, "minitest/reporters/default_reporter"
+    autoload :SpecReporter, "minitest/reporters/spec_reporter"
+    autoload :ProgressReporter, "minitest/reporters/progress_reporter"
+    autoload :RubyMateReporter, "minitest/reporters/ruby_mate_reporter"
+    autoload :RubyMineReporter, "minitest/reporters/rubymine_reporter"
+    autoload :JUnitReporter, "minitest/reporters/junit_reporter"
+    autoload :HtmlReporter, "minitest/reporters/html_reporter"
+    autoload :MeanTimeReporter, "minitest/reporters/mean_time_reporter"
+
+    class << self
+      attr_accessor :reporters
+    end
+
+    def self.use!(console_reporters = ProgressReporter.new, env = ENV, backtrace_filter = nil)
+      use_runner!(console_reporters, env)
+      if backtrace_filter.nil? && !defined?(::Rails)
+        backtrace_filter = ExtensibleBacktraceFilter.default_filter
+      end
+      Minitest.backtrace_filter = backtrace_filter unless backtrace_filter.nil?
+
+      unless defined?(@@loaded)
+        use_around_test_hooks!
+        use_old_activesupport_fix!
+        @@loaded = true
+      end
+    end
+
+    def self.use_runner!(console_reporters, env)
+      self.reporters = choose_reporters(console_reporters, env)
+    end
+
+    def self.use_around_test_hooks!
+      Minitest::Test.class_eval do
+        def run_with_hooks(*args)
+          if defined?(Minitest::Reporters) && (reporters = Minitest::Reporters.reporters)
+            reporters.each { |r| r.before_test(self) }
+            result = run_without_hooks(*args)
+            reporters.each { |r| r.after_test(self) }
+            result
+          else
+            run_without_hooks(*args)
+          end
+        end
+
+        alias_method :run_without_hooks, :run
+        alias_method :run, :run_with_hooks
+      end
+    end
+
+    def self.choose_reporters(console_reporters, env)
+      if env["TM_PID"]
+        [RubyMateReporter.new]
+      elsif env["RM_INFO"] || env["TEAMCITY_VERSION"]
+        [RubyMineReporter.new]
+      elsif !env["VIM"]
+        Array(console_reporters)
+      end
+    end
+
+    def self.clock_time
+      if minitest_version >= 561
+        Minitest.clock_time
+      else
+        Time.now
+      end
+    end
+
+    def self.minitest_version
+      Minitest::VERSION.gsub('.', '').to_i
+    end
+
+    def self.use_old_activesupport_fix!
+      if defined?(ActiveSupport::VERSION) && ActiveSupport::VERSION::MAJOR < 4
+        require "minitest/old_activesupport_fix"
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/reporters/ansi.rb

@@ -0,0 +1,31 @@
+module Minitest
+  module Reporters
+    module ANSI
+      module Code
+
+        def self.color?
+          return false if ENV['MINITEST_REPORTERS_MONO']
+          color_terminal = ENV['TERM'].to_s.downcase.include?("color")
+          $stdout.tty? || color_terminal
+        end
+
+        if color?
+          require 'ansi/code'
+
+          include ::ANSI::Code
+          extend ::ANSI::Code
+        else
+          def black(s = nil)
+            block_given? ? yield : s
+          end
+
+          %w[ red green yellow blue magenta cyan white ].each do |color|
+            alias_method color, :black
+          end
+
+          extend self
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/reporters/base_reporter.rb

@@ -0,0 +1,117 @@
+module Minitest
+  module Reporters
+    class BaseReporter < Minitest::StatisticsReporter
+      attr_accessor :tests
+
+      def initialize(options={})
+        super($stdout, options)
+        self.tests = []
+      end
+
+      def add_defaults(defaults)
+        self.options = defaults.merge(options)
+      end
+
+      # called by our own before hooks
+      def before_test(test)
+        last_test = tests.last
+
+        # Minitest broke API between 5.10 and 5.11 this gets around Result object
+        if last_test.respond_to? :klass
+          suite_changed = last_test.klass != test.class.name
+        else
+          suite_changed = last_test.class != test.class
+        end
+
+        if suite_changed
+          after_suite(last_test.class) if last_test
+          before_suite(test.class)
+        end
+      end
+
+      def record(test)
+        super
+        tests << test
+      end
+
+      # called by our own after hooks
+      def after_test(test)
+      end
+
+      def report
+        super
+        after_suite(tests.last.class)
+      end
+
+      protected
+
+      def after_suite(test)
+      end
+
+      def before_suite(test)
+      end
+
+      def result(test)
+        if test.error?
+          :error
+        elsif test.skipped?
+          :skip
+        elsif test.failure
+          :fail
+        else
+          :pass
+        end
+      end
+
+      def test_class(result)
+        if result.respond_to? :klass
+          result.klass
+        else
+          result.class
+        end
+      end
+
+      def print_colored_status(test)
+        if test.passed?
+          print(green { pad_mark( result(test).to_s.upcase ) })
+        elsif test.skipped?
+          print(yellow { pad_mark( result(test).to_s.upcase ) })
+        else
+          print(red { pad_mark( result(test).to_s.upcase ) })
+        end
+      end
+
+      def total_time
+        super || Minitest::Reporters.clock_time - start_time
+      end
+
+      def total_count
+        options[:total_count]
+      end
+
+      def filter_backtrace(backtrace)
+        Minitest.filter_backtrace(backtrace)
+      end
+
+      def puts(*args)
+        io.puts(*args)
+      end
+
+      def print(*args)
+        io.print(*args)
+      end
+
+      def print_info(e, name=true)
+        print "#{e.exception.class.to_s}: " if name
+        e.message.each_line { |line| print_with_info_padding(line) }
+
+        # When e is a Minitest::UnexpectedError, the filtered backtrace is already part of the message printed out
+        # by the previous line. In that case, and that case only, skip the backtrace output.
+        unless e.is_a?(MiniTest::UnexpectedError)
+          trace = filter_backtrace(e.backtrace)
+          trace.each { |line| print_with_info_padding(line) }
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.3.0/gems/dmurphy_palindrome-0.1.0/vendor/cache/ruby/2.3.0/gems/minitest-reporters-1.2.0/lib/minitest/reporters/default_reporter.rb

@@ -0,0 +1,228 @@
+module Minitest
+  module Reporters
+    # A reporter identical to the standard Minitest reporter except with more
+    # colors.
+    #
+    # Based upon Ryan Davis of Seattle.rb's Minitest (MIT License).
+    #
+    # @see https://github.com/seattlerb/minitest Minitest
+
+    class DefaultReporter < BaseReporter
+      include ANSI::Code
+      include RelativePosition
+
+      def initialize(options = {})
+        super
+        @detailed_skip = options.fetch(:detailed_skip, true)
+        @slow_count = options.fetch(:slow_count, 0)
+        @slow_suite_count = options.fetch(:slow_suite_count, 0)
+        @suite_times = []
+        @suite_start_times = {}
+        @fast_fail = options.fetch(:fast_fail, false)
+        @options = options
+      end
+
+      def start
+        super
+        on_start
+      end
+
+      def on_start
+        puts
+        puts("# Running tests with run options %s:" % options[:args])
+        puts
+      end
+
+      def before_test(test)
+        super
+        print "\n#{test.class}##{test.name} " if options[:verbose]
+      end
+
+      def before_suite(suite)
+        @suite_start_times[suite] = Minitest::Reporters.clock_time
+        super
+      end
+
+      def after_suite(suite)
+        super
+        duration = suite_duration(suite)
+        @suite_times << [suite.name, duration]
+      end
+
+      def record(test)
+        super
+
+        on_record(test)
+      end
+
+      def on_record(test)
+        print "#{"%.2f" % test.time} = " if options[:verbose]
+
+        # Print the pass/skip/fail mark
+        print(if test.passed?
+          record_pass(test)
+        elsif test.skipped?
+          record_skip(test)
+        elsif test.failure
+          record_failure(test)
+        end)
+
+        # Print fast_fail information
+        if @fast_fail && (test.skipped? || test.failure)
+          print_failure(test)
+        end
+      end
+
+      def record_pass(record)
+        green(record.result_code)
+      end
+
+      def record_skip(record)
+        yellow(record.result_code)
+      end
+
+      def record_failure(record)
+        red(record.result_code)
+      end
+
+      def report
+        super
+        on_report
+      end
+
+      def on_report
+        status_line = "Finished tests in %.6fs, %.4f tests/s, %.4f assertions/s." %
+          [total_time, count / total_time, assertions / total_time]
+
+        puts
+        puts
+        puts colored_for(suite_result, status_line)
+        puts
+
+        unless @fast_fail
+          tests.reject(&:passed?).each do |test|
+            print_failure(test)
+          end
+        end
+
+        if @slow_count > 0
+          slow_tests = tests.sort_by(&:time).reverse.take(@slow_count)
+
+          puts
+          puts "Slowest tests:"
+          puts
+
+          slow_tests.each do |test|
+            puts "%.6fs %s" % [test.time, "#{test.name}##{test_class(test)}"]
+          end
+        end
+
+        if @slow_suite_count > 0
+          slow_suites = @suite_times.sort_by { |x| x[1] }.reverse.take(@slow_suite_count)
+
+          puts
+          puts "Slowest test classes:"
+          puts
+
+          slow_suites.each do |slow_suite|
+            puts "%.6fs %s" % [slow_suite[1], test_class(slow_suite[0])]
+          end
+        end
+
+        puts
+        print colored_for(suite_result, result_line)
+        puts
+      end
+
+      alias to_s report
+
+      def print_failure(test)
+        message = message_for(test)
+        unless message.nil? || message.strip == ''
+          puts
+          puts colored_for(result(test), message)
+        end
+      end
+
+      private
+
+      def color?
+        return @color if defined?(@color)
+        @color = @options.fetch(:color) do
+          io.tty? && (
+            ENV["TERM"] =~ /^screen|color/ ||
+            ENV["EMACS"] == "t"
+          )
+        end
+      end
+
+      def green(string)
+        color? ? ANSI::Code.green(string) : string
+      end
+
+      def yellow(string)
+        color? ? ANSI::Code.yellow(string) : string
+      end
+
+      def red(string)
+        color? ? ANSI::Code.red(string) : string
+      end
+
+      def colored_for(result, string)
+        case result
+        when :fail, :error; red(string)
+        when :skip; yellow(string)
+        else green(string)
+        end
+      end
+
+      def suite_result
+        case
+        when failures > 0; :fail
+        when errors > 0; :error
+        when skips > 0; :skip
+        else :pass
+        end
+      end
+
+      def location(exception)
+        last_before_assertion = ''
+
+        exception.backtrace.reverse_each do |s|
+          break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
+          last_before_assertion = s
+        end
+
+        last_before_assertion.sub(/:in .*$/, '')
+      end
+
+      def message_for(test)
+        e = test.failure
+
+        if test.skipped?
+          if @detailed_skip
+            "Skipped:\n#{test_class(test)}##{test.name} [#{location(e)}]:\n#{e.message}"
+          end
+        elsif test.error?
+          "Error:\n#{test_class(test)}##{test.name}:\n#{e.message}"
+        else
+          "Failure:\n#{test_class(test)}##{test.name} [#{test.failure.location}]\n#{e.class}: #{e.message}"
+        end
+      end
+
+      def result_line
+        '%d tests, %d assertions, %d failures, %d errors, %d skips' %
+          [count, assertions, failures, errors, skips]
+      end
+
+      def suite_duration(suite)
+        start_time = @suite_start_times.delete(suite)
+        if start_time.nil?
+          0
+        else
+          Minitest::Reporters.clock_time - start_time
+        end
+      end
+    end
+  end
+end