sidekiq-statsd 0.1.1 → 0.1.2

data/vendor/ruby/1.9.1/gems/rspec-core-2.13.1/lib/rspec/core/formatters/base_text_formatter.rb

@@ -1,292 +0,0 @@
-require 'rspec/core/formatters/base_formatter'
-require 'set'
-
-module RSpec
-  module Core
-    module Formatters
-
-      # Base for all of RSpec's built-in formatters. See RSpec::Core::Formatters::BaseFormatter
-      # to learn more about all of the methods called by the reporter.
-      #
-      # @see RSpec::Core::Formatters::BaseFormatter
-      # @see RSpec::Core::Reporter
-      class BaseTextFormatter < BaseFormatter
-        def message(message)
-          output.puts message
-        end
-
-        def dump_failures
-          return if failed_examples.empty?
-          output.puts
-          output.puts "Failures:"
-          failed_examples.each_with_index do |example, index|
-            output.puts
-            pending_fixed?(example) ? dump_pending_fixed(example, index) : dump_failure(example, index)
-            dump_backtrace(example)
-          end
-        end
-
-        # @api public
-        #
-        # Colorizes the output red for failure, yellow for
-        # pending, and green otherwise.
-        #
-        # @param [String] string
-        def colorise_summary(summary)
-          if failure_count > 0
-            color(summary, RSpec.configuration.failure_color)
-          elsif pending_count > 0
-            color(summary, RSpec.configuration.pending_color)
-          else
-            color(summary, RSpec.configuration.success_color)
-          end
-        end
-
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          super(duration, example_count, failure_count, pending_count)
-          dump_profile if profile_examples?
-          output.puts "\nFinished in #{format_duration(duration)}\n"
-          output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
-          dump_commands_to_rerun_failed_examples
-        end
-
-        # @api public
-        #
-        # Outputs commands which can be used to re-run failed examples.
-        #
-        def dump_commands_to_rerun_failed_examples
-          return if failed_examples.empty?
-          output.puts
-          output.puts("Failed examples:")
-          output.puts
-
-          failed_examples.each do |example|
-            output.puts(failure_color("rspec #{RSpec::Core::Metadata::relative_path(example.location)}") + " " + detail_color("# #{example.full_description}"))
-          end
-        end
-
-        # @api public
-        #
-        # Outputs the slowest examples in a report when using `--profile COUNT` (default 10).
-        #
-        def dump_profile
-          number_of_examples = RSpec.configuration.profile_examples
-          sorted_examples = examples.sort_by {|example|
-            example.execution_result[:run_time] }.reverse.first(number_of_examples)
-
-          total, slows = [examples, sorted_examples].map {|exs|
-            exs.inject(0.0) {|i, e| i + e.execution_result[:run_time] }}
-
-          time_taken = slows / total
-          percentage = '%.1f' % ((time_taken.nan? ? 0.0 : time_taken) * 100)
-
-          output.puts "\nTop #{sorted_examples.size} slowest examples (#{format_seconds(slows)} seconds, #{percentage}% of total time):\n"
-
-          sorted_examples.each do |example|
-            output.puts "  #{example.full_description}"
-            output.puts detail_color("    #{failure_color(format_seconds(example.execution_result[:run_time]))} #{failure_color("seconds")} #{format_caller(example.location)}")
-          end
-        end
-
-        # @api public
-        #
-        # Outputs summary with number of examples, failures and pending.
-        #
-        def summary_line(example_count, failure_count, pending_count)
-          summary = pluralize(example_count, "example")
-          summary << ", " << pluralize(failure_count, "failure")
-          summary << ", #{pending_count} pending" if pending_count > 0
-          summary
-        end
-
-        def dump_pending
-          unless pending_examples.empty?
-            output.puts
-            output.puts "Pending:"
-            pending_examples.each do |pending_example|
-              output.puts pending_color("  #{pending_example.full_description}")
-              output.puts detail_color("    # #{pending_example.execution_result[:pending_message]}")
-              output.puts detail_color("    # #{format_caller(pending_example.location)}")
-              if pending_example.execution_result[:exception] \
-                && RSpec.configuration.show_failures_in_pending_blocks?
-                dump_failure_info(pending_example)
-                dump_backtrace(pending_example)
-              end
-            end
-          end
-        end
-
-        def seed(number)
-          output.puts
-          output.puts "Randomized with seed #{number}"
-          output.puts
-        end
-
-        def close
-          output.close if IO === output && output != $stdout
-        end
-
-        VT100_COLORS = {
-          :black => 30,
-          :red => 31,
-          :green => 32,
-          :yellow => 33,
-          :blue => 34,
-          :magenta => 35,
-          :cyan => 36,
-          :white => 37
-        }
-
-        VT100_COLOR_CODES = VT100_COLORS.values.to_set
-
-        def color_code_for(code_or_symbol)
-          if VT100_COLOR_CODES.include?(code_or_symbol)
-            code_or_symbol
-          else
-            VT100_COLORS.fetch(code_or_symbol) do
-              color_code_for(:white)
-            end
-          end
-        end
-
-        def colorize(text, code_or_symbol)
-          "\e[#{color_code_for(code_or_symbol)}m#{text}\e[0m"
-        end
-
-      protected
-
-        def bold(text)
-          color_enabled? ? "\e[1m#{text}\e[0m" : text
-        end
-
-        def color(text, color_code)
-          color_enabled? ? colorize(text, color_code) : text
-        end
-
-        def failure_color(text)
-          color(text, RSpec.configuration.failure_color)
-        end
-
-        def success_color(text)
-          color(text, RSpec.configuration.success_color)
-        end
-
-        def pending_color(text)
-          color(text, RSpec.configuration.pending_color)
-        end
-
-        def fixed_color(text)
-          color(text, RSpec.configuration.fixed_color)
-        end
-
-        def detail_color(text)
-          color(text, RSpec.configuration.detail_color)
-        end
-
-        def default_color(text)
-          color(text, RSpec.configuration.default_color)
-        end
-
-        def red(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#red", "#failure_color", "3.0")
-          color(text, :red)
-        end
-
-        def green(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#green", "#success_color", "3.0")
-          color(text, :green)
-        end
-
-        def yellow(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#yellow", "#pending_color", "3.0")
-          color(text, :yellow)
-        end
-
-        def blue(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#blue", "#fixed_color", "3.0")
-          color(text, :blue)
-        end
-
-        def magenta(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#magenta", nil, "3.0")
-          color(text, :magenta)
-        end
-
-        def cyan(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#cyan", "#detail_color", "3.0")
-          color(text, :cyan)
-        end
-
-        def white(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#white", "#default_color", "3.0")
-          color(text, :white)
-        end
-
-        def short_padding
-          '  '
-        end
-
-        def long_padding
-          '     '
-        end
-
-      private
-
-        def format_caller(caller_info)
-          backtrace_line(caller_info.to_s.split(':in `block').first)
-        end
-
-        def dump_backtrace(example)
-          format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
-            output.puts detail_color("#{long_padding}# #{backtrace_info}")
-          end
-        end
-
-        def dump_pending_fixed(example, index)
-          output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
-          output.puts fixed_color("#{long_padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised.")
-        end
-
-        def pending_fixed?(example)
-          example.execution_result[:exception].pending_fixed?
-        end
-
-        def dump_failure(example, index)
-          output.puts "#{short_padding}#{index.next}) #{example.full_description}"
-          dump_failure_info(example)
-        end
-
-        def dump_failure_info(example)
-          exception = example.execution_result[:exception]
-          exception_class_name = exception_class_name_for(exception)
-          output.puts "#{long_padding}#{failure_color("Failure/Error:")} #{failure_color(read_failed_line(exception, example).strip)}"
-          output.puts "#{long_padding}#{failure_color(exception_class_name)}:" unless exception_class_name =~ /RSpec/
-          exception.message.to_s.split("\n").each { |line| output.puts "#{long_padding}  #{failure_color(line)}" } if exception.message
-
-          if shared_group = find_shared_group(example)
-            dump_shared_failure_info(shared_group)
-          end
-        end
-
-        def exception_class_name_for(exception)
-          name = exception.class.name.to_s
-          name ="(anonymous error class)" if name == ''
-          name
-        end
-
-        def dump_shared_failure_info(group)
-          output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
-            "#{backtrace_line(group.metadata[:example_group][:location])}"
-        end
-
-        def find_shared_group(example)
-          group_and_parent_groups(example).find {|group| group.metadata[:shared_group_name]}
-        end
-
-        def group_and_parent_groups(example)
-          example.example_group.parent_groups + [example.example_group]
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/rspec-core-2.13.1/lib/rspec/core/formatters/documentation_formatter.rb

@@ -1,67 +0,0 @@
-require 'rspec/core/formatters/base_text_formatter'
-
-module RSpec
-  module Core
-    module Formatters
-      class DocumentationFormatter < BaseTextFormatter
-        def initialize(output)
-          super(output)
-          @group_level = 0
-        end
-
-        def example_group_started(example_group)
-          super(example_group)
-
-          output.puts if @group_level == 0
-          output.puts "#{current_indentation}#{example_group.description.strip}"
-
-          @group_level += 1
-        end
-
-        def example_group_finished(example_group)
-          @group_level -= 1
-        end
-
-        def example_passed(example)
-          super(example)
-          output.puts passed_output(example)
-        end
-
-        def example_pending(example)
-          super(example)
-          output.puts pending_output(example, example.execution_result[:pending_message])
-        end
-
-        def example_failed(example)
-          super(example)
-          output.puts failure_output(example, example.execution_result[:exception])
-        end
-
-        def failure_output(example, exception)
-          failure_color("#{current_indentation}#{example.description.strip} (FAILED - #{next_failure_index})")
-        end
-
-        def next_failure_index
-          @next_failure_index ||= 0
-          @next_failure_index += 1
-        end
-
-        def passed_output(example)
-          success_color("#{current_indentation}#{example.description.strip}")
-        end
-
-        def pending_output(example, message)
-          pending_color("#{current_indentation}#{example.description.strip} (PENDING: #{message})")
-        end
-
-        def current_indentation
-          '  ' * @group_level
-        end
-
-        def example_group_chain
-          example_group.parent_groups.reverse
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/rspec-core-2.13.1/lib/rspec/core/formatters/helpers.rb

@@ -1,103 +0,0 @@
-module RSpec
-  module Core
-    module BacktraceFormatter
-      extend self
-
-      def format_backtrace(backtrace, options = {})
-        return "" unless backtrace
-        return backtrace if options[:full_backtrace] == true
-
-        if at_exit_index = backtrace.index(RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE)
-          backtrace = backtrace[0, at_exit_index]
-        end
-
-        cleansed = backtrace.map { |line| backtrace_line(line) }.compact
-        cleansed.empty? ? backtrace : cleansed
-      end
-
-    protected
-
-      def backtrace_line(line)
-        return nil if RSpec.configuration.cleaned_from_backtrace?(line)
-        RSpec::Core::Metadata::relative_path(line)
-      rescue SecurityError
-        nil
-      end
-    end
-
-    module Formatters
-      module Helpers
-        include BacktraceFormatter
-
-        SUB_SECOND_PRECISION = 5
-        DEFAULT_PRECISION = 2
-
-        # @api private
-        #
-        # Formats seconds into a human-readable string.
-        #
-        # @param [Float, Fixnum] duration in seconds
-        # @return [String] human-readable time
-        #
-        # @example
-        #    format_duration(1) #=>  "1 minute 1 second"
-        #    format_duration(135.14) #=> "2 minutes 15.14 seconds"
-        def format_duration(duration)
-          if duration > 60
-            minutes = duration.to_i / 60
-            seconds = duration - minutes * 60
-
-            "#{pluralize(minutes, 'minute')} #{pluralize(format_seconds(seconds), 'second')}"
-          else
-            pluralize(format_seconds(duration), 'second')
-          end
-        end
-
-        # @api private
-        #
-        # Formats seconds to have 5 digits of precision with trailing zeros removed if the number
-        # if less than 1 or with 2 digits of precision if the number is greater than zero.
-        #
-        # @param [Float] float
-        # @return [String] formatted float
-        #
-        # @example
-        #    format_seconds(0.000006) #=> "0.00001"
-        #    format_seconds(0.020000) #=> "0.02"
-        #    format_seconds(1.00000000001) #=> "1"
-        #
-        # The precision used is set in {Helpers::SUB_SECOND_PRECISION} and {Helpers::DEFAULT_PRECISION}.
-        #
-        # @see #strip_trailing_zeroes
-        def format_seconds(float)
-          precision ||= (float < 1) ? SUB_SECOND_PRECISION : DEFAULT_PRECISION
-          formatted = sprintf("%.#{precision}f", float)
-          strip_trailing_zeroes(formatted)
-        end
-
-        # @api private
-        #
-        # Remove trailing zeros from a string.
-        #
-        # @param [String] string string with trailing zeros
-        # @return [String] string with trailing zeros removed
-        def strip_trailing_zeroes(string)
-          stripped = string.sub(/[^1-9]+$/, '')
-          stripped.empty? ? "0" : stripped
-        end
-
-        # @api private
-        #
-        # Pluralize a word based on a count.
-        #
-        # @param [Fixnum] count number of objects
-        # @param [String] string word to be pluralized
-        # @return [String] pluralized word
-        def pluralize(count, string)
-          "#{count} #{string}#{'s' unless count.to_f == 1}"
-        end
-      end
-
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/rspec-core-2.13.1/lib/rspec/core/formatters/html_formatter.rb

@@ -1,154 +0,0 @@
-require 'rspec/core/formatters/base_text_formatter'
-require 'rspec/core/formatters/html_printer'
-
-module RSpec
-  module Core
-    module Formatters
-      class HtmlFormatter < BaseTextFormatter
-
-        def initialize(output)
-          super(output)
-          @example_group_number = 0
-          @example_number = 0
-          @header_red = nil
-          @printer = HtmlPrinter.new(output)
-        end
-
-        private
-        def method_missing(m, *a, &b)
-          # no-op
-        end
-
-        public
-        def message(message)
-        end
-
-        # The number of the currently running example_group
-        def example_group_number
-          @example_group_number
-        end
-
-        # The number of the currently running example (a global counter)
-        def example_number
-          @example_number
-        end
-
-        def start(example_count)
-          super(example_count)
-          @printer.print_html_start
-          @printer.flush
-        end
-
-        def example_group_started(example_group)
-          super(example_group)
-          @example_group_red = false
-          @example_group_number += 1
-
-          unless example_group_number == 1
-            @printer.print_example_group_end
-          end
-          @printer.print_example_group_start( example_group_number, example_group.description, example_group.parent_groups.size )
-          @printer.flush
-        end
-
-        def start_dump
-          @printer.print_example_group_end
-          @printer.flush
-        end
-
-        def example_started(example)
-          super(example)
-          @example_number += 1
-        end
-
-        def example_passed(example)
-          @printer.move_progress(percent_done)
-          @printer.print_example_passed( example.description, example.execution_result[:run_time] )
-          @printer.flush
-        end
-
-        def example_failed(example)
-          super(example)
-
-          unless @header_red
-            @header_red = true
-            @printer.make_header_red 
-          end
-
-          unless @example_group_red
-            @example_group_red = true
-            @printer.make_example_group_header_red(example_group_number)
-          end
-
-          @printer.move_progress(percent_done)
-
-          exception = example.metadata[:execution_result][:exception]
-          exception_details = if exception
-            { 
-              :message => exception.message, 
-              :backtrace => format_backtrace(exception.backtrace, example).join("\n")
-            }
-          else
-            false 
-          end
-          extra = extra_failure_content(exception)
-
-          @printer.print_example_failed( 
-            exception.pending_fixed?,
-            example.description,
-            example.execution_result[:run_time],
-            @failed_examples.size,
-            exception_details,
-            (extra == "") ? false : extra
-          )
-          @printer.flush
-        end
-
-        def example_pending(example)
-
-          @printer.make_header_yellow unless @header_red
-          @printer.make_example_group_header_yellow(example_group_number) unless @example_group_red
-          @printer.move_progress(percent_done)
-          @printer.print_example_pending( example.description, example.metadata[:execution_result][:pending_message] )
-          @printer.flush
-        end
-
-        # Override this method if you wish to output extra HTML for a failed spec. For example, you
-        # could output links to images or other files produced during the specs.
-        #
-        def extra_failure_content(exception)
-          require 'rspec/core/formatters/snippet_extractor'
-          backtrace = exception.backtrace.map {|line| backtrace_line(line)}
-          backtrace.compact!
-          @snippet_extractor ||= SnippetExtractor.new
-          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
-        end
-
-        def percent_done
-          result = 100.0
-          if @example_count > 0
-            result = ((example_number).to_f / @example_count.to_f * 1000).to_i / 10.0
-          end
-          result
-        end
-
-        def dump_failures
-        end
-
-        def dump_pending
-        end
-
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          @printer.print_summary(
-            dry_run?,
-            duration,
-            example_count,
-            failure_count,
-            pending_count
-          )
-          @printer.flush
-        end
-      end
-    end
-  end
-end