primary_connect_proto 0.0.8 → 0.4.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/html_formatter.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'erb'
+require 'ostruct'
+require 'base64'
+require_relative 'text_util'
+
+module RuboCop
+  module Formatter
+    # This formatter saves the output as an html file.
+    class HTMLFormatter < BaseFormatter
+      ELLIPSES = '<span class="extra-code">...</span>'.freeze
+      TEMPLATE_PATH =
+        File.expand_path('../../../assets/output.html.erb', __dir__)
+
+      Color = Struct.new(:red, :green, :blue, :alpha) do
+        def to_s
+          "rgba(#{values.join(', ')})"
+        end
+
+        def fade_out(amount)
+          dup.tap do |color|
+            color.alpha -= amount
+          end
+        end
+      end
+
+      attr_reader :files, :summary
+
+      def initialize(output, options = {})
+        super
+        @files = []
+        @summary = OpenStruct.new(offense_count: 0)
+      end
+
+      def started(target_files)
+        summary.target_files = target_files
+      end
+
+      def file_finished(file, offenses)
+        files << OpenStruct.new(path: file, offenses: offenses)
+        summary.offense_count += offenses.count
+      end
+
+      def finished(inspected_files)
+        summary.inspected_files = inspected_files
+
+        render_html
+      end
+
+      def render_html
+        context = ERBContext.new(files, summary)
+
+        template = File.read(TEMPLATE_PATH, encoding: Encoding::UTF_8)
+
+        # The following condition is workaround for until Ruby 2.6 is released.
+        # https://github.com/ruby/ruby/commit/cc777d09f44fa909a336ba14f3aa802ffe16e010
+        erb = if RUBY_VERSION >= '2.6'
+                ERB.new(template, trim_mode: '-')
+              else
+                ERB.new(template, nil, '-')
+              end
+        html = erb.result(context.binding)
+
+        output.write html
+      end
+
+      # This class provides helper methods used in the ERB template.
+      class ERBContext
+        include PathUtil
+        include TextUtil
+
+        SEVERITY_COLORS = {
+          refactor: Color.new(0xED, 0x9C, 0x28, 1.0),
+          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
+          warning: Color.new(0x96, 0x28, 0xEF, 1.0),
+          error: Color.new(0xD2, 0x32, 0x2D, 1.0),
+          fatal: Color.new(0xD2, 0x32, 0x2D, 1.0)
+        }.freeze
+
+        LOGO_IMAGE_PATH =
+          File.expand_path('../../../assets/logo.png', __dir__)
+
+        attr_reader :files, :summary
+
+        def initialize(files, summary)
+          @files = files.sort_by(&:path)
+          @summary = summary
+        end
+
+        # Make Kernel#binding public.
+        def binding
+          super
+        end
+
+        def decorated_message(offense)
+          offense.message.gsub(/`(.+?)`/) do
+            "<code>#{Regexp.last_match(1)}</code>"
+          end
+        end
+
+        def highlighted_source_line(offense)
+          source_before_highlight(offense) +
+            hightlight_source_tag(offense) +
+            source_after_highlight(offense) +
+            possible_ellipses(offense.location)
+        end
+
+        def hightlight_source_tag(offense)
+          "<span class=\"highlight #{offense.severity}\">" \
+            "#{escape(offense.highlighted_area.source)}" \
+            '</span>'
+        end
+
+        def source_before_highlight(offense)
+          source_line = offense.location.source_line
+          escape(source_line[0...offense.highlighted_area.begin_pos])
+        end
+
+        def source_after_highlight(offense)
+          source_line = offense.location.source_line
+          escape(source_line[offense.highlighted_area.end_pos..-1])
+        end
+
+        def possible_ellipses(location)
+          location.first_line == location.last_line ? '' : " #{ELLIPSES}"
+        end
+
+        def escape(string)
+          CGI.escapeHTML(string)
+        end
+
+        def base64_encoded_logo_image
+          image = File.read(LOGO_IMAGE_PATH, binmode: true)
+          Base64.encode64(image)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/json_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+
+module RuboCop
+  module Formatter
+    # This formatter formats the report data in JSON format.
+    class JSONFormatter < BaseFormatter
+      include PathUtil
+
+      attr_reader :output_hash
+
+      def initialize(output, options = {})
+        super
+        @output_hash = {
+          metadata: metadata_hash,
+          files: [],
+          summary: { offense_count: 0 }
+        }
+      end
+
+      def started(target_files)
+        output_hash[:summary][:target_file_count] = target_files.count
+      end
+
+      def file_finished(file, offenses)
+        output_hash[:files] << hash_for_file(file, offenses)
+        output_hash[:summary][:offense_count] += offenses.count
+      end
+
+      def finished(inspected_files)
+        output_hash[:summary][:inspected_file_count] = inspected_files.count
+        output.write output_hash.to_json
+      end
+
+      def metadata_hash
+        {
+          rubocop_version: RuboCop::Version::STRING,
+          ruby_engine: RUBY_ENGINE,
+          ruby_version: RUBY_VERSION,
+          ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
+          ruby_platform: RUBY_PLATFORM
+        }
+      end
+
+      def hash_for_file(file, offenses)
+        {
+          path: smart_path(file),
+          offenses: offenses.map { |o| hash_for_offense(o) }
+        }
+      end
+
+      def hash_for_offense(offense)
+        {
+          severity: offense.severity.name,
+          message: offense.message,
+          cop_name: offense.cop_name,
+          corrected: offense.corrected?,
+          location: hash_for_location(offense)
+        }
+      end
+
+      # TODO: Consider better solution for Offense#real_column.
+      def hash_for_location(offense)
+        {
+          start_line: offense.line,
+          start_column: offense.real_column,
+          last_line: offense.last_line,
+          last_column: offense.last_column,
+          length: offense.location.length,
+          # `line` and `column` exist for compatibility.
+          # Use `start_line` and `start_column` instead.
+          line: offense.line,
+          column: offense.real_column
+        }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/offense_count_formatter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter displays the list of offended cops with a count of how
+    # many offenses of their kind were found. Ordered by desc offense count
+    #
+    # Here's the format:
+    #
+    # 26  LineLength
+    # 3   OneLineConditional
+    # --
+    # 29  Total
+    class OffenseCountFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      def started(target_files)
+        super
+        @offense_counts = Hash.new(0)
+
+        return unless output.tty?
+
+        file_phrase = target_files.count == 1 ? 'file' : 'files'
+
+        # 185/407 files |====== 45 ======>                    |  ETA: 00:00:04
+        # %c / %C       |       %w       >         %i         |       %e
+        bar_format = " %c/%C #{file_phrase} |%w>%i| %e "
+
+        @progressbar = ProgressBar.create(
+          output: output,
+          total: target_files.count,
+          format: bar_format,
+          autostart: false
+        )
+        @progressbar.start
+      end
+
+      def file_finished(_file, offenses)
+        offenses.each { |o| @offense_counts[o.cop_name] += 1 }
+        @progressbar.increment if instance_variable_defined?(:@progressbar)
+      end
+
+      def finished(_inspected_files)
+        report_summary(@offense_counts)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def report_summary(offense_counts)
+        per_cop_counts = ordered_offense_counts(offense_counts)
+        total_count = total_offense_count(offense_counts)
+
+        output.puts
+
+        per_cop_counts.each do |cop_name, count|
+          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}" \
+                      "#{cop_name}\n"
+        end
+        output.puts '--'
+        output.puts "#{total_count}  Total"
+
+        output.puts
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ordered_offense_counts(offense_counts)
+        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.inject(0, :+)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/progress_formatter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter display dots for files with no offenses and
+    # letters for files with problems in the them. In the end it
+    # appends the regular report data in the clang style format.
+    class ProgressFormatter < ClangStyleFormatter
+      include TextUtil
+
+      DOT = '.'.freeze
+
+      def initialize(output, options = {})
+        super
+        @dot = green(DOT)
+      end
+
+      def started(target_files)
+        super
+        @offenses_for_files = {}
+        output.puts "Inspecting #{pluralize(target_files.size, 'file')}"
+      end
+
+      def file_finished(file, offenses)
+        unless offenses.empty?
+          count_stats(offenses)
+          @offenses_for_files[file] = offenses
+        end
+
+        report_file_as_mark(offenses)
+      end
+
+      def finished(inspected_files)
+        output.puts
+
+        unless @offenses_for_files.empty?
+          output.puts
+          output.puts 'Offenses:'
+          output.puts
+
+          @offenses_for_files.each do |file, offenses|
+            report_file(file, offenses)
+          end
+        end
+
+        report_summary(inspected_files.size,
+                       @total_offense_count,
+                       @total_correction_count)
+      end
+
+      def report_file_as_mark(offenses)
+        mark = if offenses.empty?
+                 @dot
+               else
+                 highest_offense = offenses.max_by(&:severity)
+                 colored_severity_code(highest_offense)
+               end
+
+        output.write mark
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/quiet_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # If no offenses are found, no output is displayed.
+    # Otherwise, SimpleTextFormatter's output is displayed.
+    class QuietFormatter < SimpleTextFormatter
+      def report_summary(file_count, offense_count, correction_count)
+        super unless offense_count.zero?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/simple_text_formatter.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'colorizable'
+require_relative 'text_util'
+
+module RuboCop
+  module Formatter
+    # A basic formatter that displays only files with offenses.
+    # Offenses are displayed at compact form - just the
+    # location of the problem and the associated message.
+    class SimpleTextFormatter < BaseFormatter
+      include Colorizable
+      include PathUtil
+
+      COLOR_FOR_SEVERITY = {
+        refactor: :yellow,
+        convention: :yellow,
+        warning: :magenta,
+        error: :red,
+        fatal: :red
+      }.freeze
+
+      def started(_target_files)
+        @total_offense_count = 0
+        @total_correction_count = 0
+      end
+
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        count_stats(offenses)
+        report_file(file, offenses)
+      end
+
+      def finished(inspected_files)
+        report_summary(inspected_files.count,
+                       @total_offense_count,
+                       @total_correction_count)
+      end
+
+      def report_file(file, offenses)
+        output.puts yellow("== #{smart_path(file)} ==")
+
+        offenses.each do |o|
+          output.printf("%s:%3d:%3d: %s\n",
+                        colored_severity_code(o),
+                        o.line, o.real_column, message(o))
+        end
+      end
+
+      def report_summary(file_count, offense_count, correction_count)
+        report = Report.new(file_count,
+                            offense_count,
+                            correction_count,
+                            rainbow)
+
+        output.puts
+        output.puts report.summary
+      end
+
+      private
+
+      def count_stats(offenses)
+        @total_offense_count += offenses.count
+        @total_correction_count += offenses.count(&:corrected?)
+      end
+
+      def colored_severity_code(offense)
+        color = COLOR_FOR_SEVERITY[offense.severity.name]
+        colorize(offense.severity.code, color)
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/m, yellow('\1'))
+      end
+
+      def message(offense)
+        message = offense.corrected? ? green('[Corrected] ') : ''
+        "#{message}#{annotate_message(offense.message)}"
+      end
+
+      # A helper class for building the report summary text.
+      class Report
+        include Colorizable
+        include TextUtil
+
+        def initialize(file_count, offense_count, correction_count, rainbow)
+          @file_count = file_count
+          @offense_count = offense_count
+          @correction_count = correction_count
+          @rainbow = rainbow
+        end
+
+        def summary
+          if @correction_count > 0
+            "#{files} inspected, #{offenses} detected, #{corrections} corrected"
+          else
+            "#{files} inspected, #{offenses} detected"
+          end
+        end
+
+        private
+
+        attr_reader :rainbow
+
+        def files
+          pluralize(@file_count, 'file')
+        end
+
+        def offenses
+          text = pluralize(@offense_count, 'offense', no_for_zero: true)
+          color = @offense_count.zero? ? :green : :red
+
+          colorize(text, color)
+        end
+
+        def corrections
+          text = pluralize(@correction_count, 'offense')
+          color = @correction_count == @offense_count ? :green : :cyan
+
+          colorize(text, color)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/tap_formatter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data using the Test Anything Protocol.
+    # TAP allows for to communicate tests results in a language agnostics way.
+    class TapFormatter < ClangStyleFormatter
+      def started(target_files)
+        super
+        @progress_count = 1
+        output.puts "1..#{target_files.size}"
+      end
+
+      def file_finished(file, offenses)
+        if offenses.empty?
+          output.puts "ok #{@progress_count} - #{smart_path(file)}"
+        else
+          output.puts "not ok #{@progress_count} - #{smart_path(file)}"
+
+          count_stats(offenses)
+          report_file(file, offenses)
+        end
+
+        @progress_count += 1
+      end
+
+      private
+
+      def report_line(location)
+        source_line = location.source_line
+
+        if location.first_line == location.last_line
+          output.puts("# #{source_line}")
+        else
+          output.puts("# #{source_line} #{yellow(ELLIPSES)}")
+        end
+      end
+
+      def report_highlighted_area(highlighted_area)
+        output.puts("# #{' ' * highlighted_area.begin_pos}" \
+                    "#{'^' * highlighted_area.size}")
+      end
+
+      def report_offense(file, offense)
+        output.printf("# %s:%d:%d: %s: %s\n",
+                      cyan(smart_path(file)), offense.line, offense.real_column,
+                      colored_severity_code(offense), message(offense))
+
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          return unless valid_line?(offense)
+
+          report_line(offense.location)
+          report_highlighted_area(offense.highlighted_area)
+        rescue IndexError
+          # range is not on a valid line; perhaps the source file is empty
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/, '\1')
+      end
+
+      def message(offense)
+        message = offense.corrected? ? '[Corrected] ' : ''
+        "#{message}#{annotate_message(offense.message)}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/text_util.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # Common logic for UI texts.
+    module TextUtil
+      module_function
+
+      def pluralize(number, thing, options = {})
+        if number.zero? && options[:no_for_zero]
+          "no #{thing}s"
+        elsif number == 1
+          "1 #{thing}"
+        else
+          "#{number} #{thing}s"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Formatter
+    # This formatter displays the list of offensive files, sorted by number of
+    # offenses with the worst offenders first.
+    #
+    # Here's the format:
+    #
+    # 26  this/file/is/really/bad.rb
+    # 3   just/ok.rb
+    # --
+    # 29  Total
+    class WorstOffendersFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      def started(target_files)
+        super
+        @offense_counts = {}
+      end
+
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        @offense_counts[path] = offenses.size
+      end
+
+      def finished(_inspected_files)
+        report_summary(@offense_counts)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def report_summary(offense_counts)
+        per_file_counts = ordered_offense_counts(offense_counts)
+        total_count = total_offense_count(offense_counts)
+
+        output.puts
+
+        per_file_counts.each do |file_name, count|
+          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}" \
+                      "#{file_name}\n"
+        end
+        output.puts '--'
+        output.puts "#{total_count}  Total"
+
+        output.puts
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ordered_offense_counts(offense_counts)
+        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.inject(0, :+)
+      end
+    end
+  end
+end