genkaio 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/formatters/html_snippet_extractor.rb

@@ -0,0 +1,120 @@
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      #
+      # Extracts code snippets by looking at the backtrace of the passed error
+      # and applies synax highlighting and line numbers using html.
+      class HtmlSnippetExtractor
+        # @private
+        module NullConverter
+          def self.convert(code)
+            %Q(#{code}\n<span class="comment"># Install the coderay gem to get syntax highlighting</span>)
+          end
+        end
+
+        # @private
+        module CoderayConverter
+          def self.convert(code)
+            CodeRay.scan(code, :ruby).html(:line_numbers => false)
+          end
+        end
+
+        # rubocop:disable Style/ClassVars
+        # @private
+        @@converter = NullConverter
+
+        begin
+          require 'coderay'
+          RSpec::Support.require_rspec_core 'formatters/syntax_highlighter'
+          RSpec::Core::Formatters::SyntaxHighlighter.attempt_to_add_rspec_terms_to_coderay_keywords
+          @@converter = CoderayConverter
+          # rubocop:disable Lint/HandleExceptions
+        rescue LoadError
+          # it'll fall back to the NullConverter assigned above
+          # rubocop:enable Lint/HandleExceptions
+        end
+
+        # rubocop:enable Style/ClassVars
+
+        # @api private
+        #
+        # Extract lines of code corresponding to  a backtrace.
+        #
+        # @param backtrace [String] the backtrace from a test failure
+        # @return [String] highlighted code snippet indicating where the test
+        #   failure occured
+        #
+        # @see #post_process
+        def snippet(backtrace)
+          raw_code, line = snippet_for(backtrace[0])
+          highlighted = @@converter.convert(raw_code)
+          post_process(highlighted, line)
+        end
+        # rubocop:enable Style/ClassVars
+
+        # @api private
+        #
+        # Create a snippet from a line of code.
+        #
+        # @param error_line [String] file name with line number (i.e.
+        #   'foo_spec.rb:12')
+        # @return [String] lines around the target line within the file
+        #
+        # @see #lines_around
+        def snippet_for(error_line)
+          if error_line =~ /(.*):(\d+)/
+            file = Regexp.last_match[1]
+            line = Regexp.last_match[2].to_i
+            [lines_around(file, line), line]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1]
+          end
+        end
+
+        # @api private
+        #
+        # Extract lines of code centered around a particular line within a
+        # source file.
+        #
+        # @param file [String] filename
+        # @param line [Fixnum] line number
+        # @return [String] lines around the target line within the file (2 above
+        #   and 1 below).
+        def lines_around(file, line)
+          if File.file?(file)
+            lines = File.read(file).split("\n")
+            min = [0, line - 3].max
+            max = [line + 1, lines.length - 1].min
+            selected_lines = []
+            selected_lines.join("\n")
+            lines[min..max].join("\n")
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        rescue SecurityError
+          "# Couldn't get snippet for #{file}"
+        end
+
+        # @api private
+        #
+        # Adds line numbers to all lines and highlights the line where the
+        # failure occurred using html `span` tags.
+        #
+        # @param highlighted [String] syntax-highlighted snippet surrounding the
+        #   offending line of code
+        # @param offending_line [Fixnum] line where failure occured
+        # @return [String] completed snippet
+        def post_process(highlighted, offending_line)
+          new_lines = []
+          highlighted.split("\n").each_with_index do |line, i|
+            new_line = "<span class=\"linenum\">#{offending_line + i - 2}</span>#{line}"
+            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/formatters/json_formatter.rb

@@ -0,0 +1,102 @@
+RSpec::Support.require_rspec_core "formatters/base_formatter"
+require 'json'
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class JsonFormatter < BaseFormatter
+        Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :seed, :close
+
+        attr_reader :output_hash
+
+        def initialize(output)
+          super
+          @output_hash = {
+            :version => RSpec::Core::Version::STRING
+          }
+        end
+
+        def message(notification)
+          (@output_hash[:messages] ||= []) << notification.message
+        end
+
+        def dump_summary(summary)
+          @output_hash[:summary] = {
+            :duration => summary.duration,
+            :example_count => summary.example_count,
+            :failure_count => summary.failure_count,
+            :pending_count => summary.pending_count,
+            :errors_outside_of_examples_count => summary.errors_outside_of_examples_count
+          }
+          @output_hash[:summary_line] = summary.totals_line
+        end
+
+        def stop(notification)
+          @output_hash[:examples] = notification.examples.map do |example|
+            format_example(example).tap do |hash|
+              e = example.exception
+              if e
+                hash[:exception] =  {
+                  :class => e.class.name,
+                  :message => e.message,
+                  :backtrace => e.backtrace,
+                }
+              end
+            end
+          end
+        end
+
+        def seed(notification)
+          return unless notification.seed_used?
+          @output_hash[:seed] = notification.seed
+        end
+
+        def close(_notification)
+          output.write @output_hash.to_json
+        end
+
+        def dump_profile(profile)
+          @output_hash[:profile] = {}
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+        # @api private
+        def dump_profile_slowest_examples(profile)
+          @output_hash[:profile] = {}
+          @output_hash[:profile][:examples] = profile.slowest_examples.map do |example|
+            format_example(example).tap do |hash|
+              hash[:run_time] = example.execution_result.run_time
+            end
+          end
+          @output_hash[:profile][:slowest] = profile.slow_duration
+          @output_hash[:profile][:total] = profile.duration
+        end
+
+        # @api private
+        def dump_profile_slowest_example_groups(profile)
+          @output_hash[:profile] ||= {}
+          @output_hash[:profile][:groups] = profile.slowest_groups.map do |loc, hash|
+            hash.update(:location => loc)
+          end
+        end
+
+      private
+
+        def format_example(example)
+          {
+            :id => example.id,
+            :description => example.description,
+            :full_description => example.full_description,
+            :status => example.execution_result.status.to_s,
+            :file_path => example.metadata[:file_path],
+            :line_number  => example.metadata[:line_number],
+            :run_time => example.execution_result.run_time,
+            :pending_message => example.execution_result.pending_message,
+          }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/formatters/profile_formatter.rb

@@ -0,0 +1,68 @@
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      # Formatter for providing profile output.
+      class ProfileFormatter
+        Formatters.register self, :dump_profile
+
+        def initialize(output)
+          @output = output
+        end
+
+        # @private
+        attr_reader :output
+
+        # @api public
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [ProfileNotification] containing duration,
+        #   slowest_examples and slowest_example_groups
+        def dump_profile(profile)
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+      private
+
+        def dump_profile_slowest_examples(profile)
+          @output.puts "\nTop #{profile.slowest_examples.size} slowest " \
+            "examples (#{Helpers.format_seconds(profile.slow_duration)} " \
+            "seconds, #{profile.percentage}% of total time):\n"
+
+          profile.slowest_examples.each do |example|
+            @output.puts "  #{example.full_description}"
+            @output.puts "    #{bold(Helpers.format_seconds(example.execution_result.run_time))} " \
+                         "#{bold("seconds")} #{format_caller(example.location)}"
+          end
+        end
+
+        def dump_profile_slowest_example_groups(profile)
+          return if profile.slowest_groups.empty?
+
+          @output.puts "\nTop #{profile.slowest_groups.size} slowest example groups:"
+          profile.slowest_groups.each do |loc, hash|
+            average = "#{bold(Helpers.format_seconds(hash[:average]))} #{bold("seconds")} average"
+            total   = "#{Helpers.format_seconds(hash[:total_time])} seconds"
+            count   = Helpers.pluralize(hash[:count], "example")
+            @output.puts "  #{hash[:description]}"
+            @output.puts "    #{average} (#{total} / #{count}) #{loc}"
+          end
+        end
+
+        def format_caller(caller_info)
+          RSpec.configuration.backtrace_formatter.backtrace_line(
+            caller_info.to_s.split(':in `block').first)
+        end
+
+        def bold(text)
+          ConsoleCodes.wrap(text, :bold)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/formatters/progress_formatter.rb

@@ -0,0 +1,29 @@
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class ProgressFormatter < BaseTextFormatter
+        Formatters.register self, :example_passed, :example_pending, :example_failed, :start_dump
+
+        def example_passed(_notification)
+          output.print ConsoleCodes.wrap('.', :success)
+        end
+
+        def example_pending(_notification)
+          output.print ConsoleCodes.wrap('*', :pending)
+        end
+
+        def example_failed(_notification)
+          output.print ConsoleCodes.wrap('F', :failure)
+        end
+
+        def start_dump(_notification)
+          output.puts
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/formatters/protocol.rb

@@ -0,0 +1,182 @@
+module RSpec
+  module Core
+    module Formatters
+      # This class isn't loaded at runtime but serves to document all of the
+      # notifications implemented as part of the standard interface. The
+      # reporter will issue these during a normal test suite run, but a
+      # formatter will only receive those notifications it has registered
+      # itself to receive. To register a formatter call:
+      #
+      # `::RSpec::Core::Formatters.register class, :list, :of, :notifications`
+      #
+      # e.g.
+      #
+      # `::RSpec::Core::Formatters.register self, :start, :example_started`
+      #
+      # @see RSpec::Core::Formatters::BaseFormatter
+      # @see RSpec::Core::Formatters::BaseTextFormatter
+      # @see RSpec::Core::Reporter
+      class Protocol
+        # @method initialize(output)
+        # @api public
+        #
+        # @param output [IO] the formatter output
+
+        # @method start(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked before any examples are run, right after
+        # they have all been collected. This can be useful for special
+        # formatters that need to provide progress on feedback (graphical ones).
+        #
+        # This will only be invoked once, and the next one to be invoked
+        # is {#example_group_started}.
+        #
+        # @param notification [Notifications::StartNotification]
+
+        # @method example_group_started(notification)
+        # @api public
+        # @group Group Notifications
+        #
+        # This method is invoked at the beginning of the execution of each
+        # example group.
+        #
+        # The next method to be invoked after this is {#example_passed},
+        # {#example_pending}, or {#example_group_finished}.
+        #
+        # @param notification [Notifications::GroupNotification] containing example_group
+        #   subclass of {ExampleGroup}
+
+        # @method example_group_finished(notification)
+        # @api public
+        # @group Group Notifications
+        #
+        # Invoked at the end of the execution of each example group.
+        #
+        # @param notification [Notifications::GroupNotification] containing example_group
+        #   subclass of {ExampleGroup}
+
+        # @method example_started(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the beginning of the execution of each example.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_finished(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the end of the execution of each example.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_passed(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example passes.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_pending(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example is pending.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method example_failed(notification)
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked when an example fails.
+        #
+        # @param notification [Notifications::ExampleNotification] containing example subclass
+        #   of {Example}
+
+        # @method message(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Used by the reporter to send messages to the output stream.
+        #
+        # @param notification [Notifications::MessageNotification] containing message
+
+        # @method stop(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked after all examples have executed, before dumping post-run
+        # reports.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method start_dump(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after all of the examples have executed. The
+        # next method to be invoked after this one is {#dump_failures}
+        # (BaseTextFormatter then calls {#dump_failures} once for each failed
+        # example).
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method dump_failures(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Dumps detailed information about each example failure.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method dump_summary(summary)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping of examples and failures.
+        # Each parameter is assigned to a corresponding attribute.
+        #
+        # @param summary [Notifications::SummaryNotification] containing duration,
+        #   example_count, failure_count and pending_count
+
+        # @method dump_profile(profile)
+        # @api public
+        # @group Suite Notifications
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [Notifications::ProfileNotification] containing duration,
+        #   slowest_examples and slowest_example_groups
+
+        # @method dump_pending(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Outputs a report of pending examples. This gets invoked
+        # after the summary if option is set to do so.
+        #
+        # @param notification [Notifications::NullNotification]
+
+        # @method close(notification)
+        # @api public
+        # @group Suite Notifications
+        #
+        # Invoked at the end of a suite run. Allows the formatter to do any
+        # tidying up, but be aware that formatter output streams may be used
+        # elsewhere so don't actually close them.
+        #
+        # @param notification [Notifications::NullNotification]
+      end
+    end
+  end
+end