rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/disabled_lines_formatter.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-module RuboCop
-  module Formatter
-    # A basic formatter that displays the lines disabled
-    # inline comments.
-    class DisabledLinesFormatter < BaseFormatter
-      include PathUtil
-      include Colorizable
-
-      attr_reader :cop_disabled_line_ranges
-
-      def started(_target_files)
-        @cop_disabled_line_ranges = {}
-      end
-
-      def file_started(file, options)
-        return unless options[:cop_disabled_line_ranges]
-
-        @cop_disabled_line_ranges[file] =
-          options[:cop_disabled_line_ranges]
-      end
-
-      def finished(_inspected_files)
-        cops_disabled_in_comments_summary
-      end
-
-      private
-
-      def cops_disabled_in_comments_summary
-        summary = "\nCops disabled line ranges:\n\n"
-
-        @cop_disabled_line_ranges.each do |file, disabled_cops|
-          disabled_cops.each do |cop, line_ranges|
-            line_ranges.each do |line_range|
-              file = cyan(smart_path(file))
-              summary << "#{file}:#{line_range}: #{cop}\n"
-            end
-          end
-        end
-
-        output.puts summary
-      end
-
-      def smart_path(path)
-        # Ideally, we calculate this relative to the project root.
-        base_dir = Dir.pwd
-
-        if path.start_with? base_dir
-          relative_path(path, base_dir)
-        else
-          path
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Formatter
-    # This formatter displays the report data in format that's
-    # easy to process in the Emacs text editor.
-    # The output is machine-parsable.
-    class EmacsStyleFormatter < BaseFormatter
-      def file_finished(file, offenses)
-        offenses.each do |o|
-          message = o.corrected? ? '[Corrected] ' : ''
-          message << o.message
-
-          output.printf("%s:%d:%d: %s: %s\n",
-                        file, o.line, o.real_column, o.severity.code,
-                        message)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/file_list_formatter.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Formatter
-    # This formatter displays just a list of the files with offenses in them,
-    # separated by newlines. The output is machine-parsable.
-    #
-    # Here's the format:
-    #
-    # /some/file
-    # /some/other/file
-    class FileListFormatter < BaseFormatter
-      def file_finished(file, offenses)
-        return if offenses.empty?
-        output.printf("%s\n", file)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/formatter_set.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Formatter
-    # This is a collection of formatters. A FormatterSet can hold multiple
-    # formatter instances and provides transparent formatter API methods
-    # which invoke same method of each formatters.
-    class FormatterSet < Array
-      BUILTIN_FORMATTERS_FOR_KEYS = {
-        'progress' => ProgressFormatter,
-        'simple'   => SimpleTextFormatter,
-        'clang'    => ClangStyleFormatter,
-        'fuubar'   => FuubarStyleFormatter,
-        'emacs'    => EmacsStyleFormatter,
-        'json'     => JSONFormatter,
-        'html'     => HTMLFormatter,
-        'files'    => FileListFormatter,
-        'offenses' => OffenseCountFormatter,
-        'disabled' => DisabledLinesFormatter
-      }
-
-      FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]
-
-      FORMATTER_APIS.each do |method_name|
-        define_method(method_name) do |*args|
-          each { |f| f.send(method_name, *args) }
-        end
-      end
-
-      def add_formatter(formatter_type, output_path = nil)
-        formatter_class = case formatter_type
-                          when Class
-                            formatter_type
-                          when /\A[A-Z]/
-                            custom_formatter_class(formatter_type)
-                          else
-                            builtin_formatter_class(formatter_type)
-                          end
-
-        output = output_path ? File.open(output_path, 'w') : $stdout
-
-        self << formatter_class.new(output)
-      end
-
-      def close_output_files
-        each do |formatter|
-          formatter.output.close if formatter.output.is_a?(File)
-        end
-      end
-
-      private
-
-      def builtin_formatter_class(specified_key)
-        matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          key.start_with?(specified_key)
-        end
-
-        if matching_keys.empty?
-          fail %(No formatter for "#{specified_key}")
-        elsif matching_keys.size > 1
-          fail %(Cannot determine formatter for "#{specified_key}")
-        end
-
-        BUILTIN_FORMATTERS_FOR_KEYS[matching_keys.first]
-      end
-
-      def custom_formatter_class(specified_class_name)
-        constant_names = specified_class_name.split('::')
-        constant_names.shift if constant_names.first.empty?
-        constant_names.reduce(Object) do |namespace, constant_name|
-          namespace.const_get(constant_name, false)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/fuubar_style_formatter.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-
-require 'ruby-progressbar'
-
-module RuboCop
-  module Formatter
-    # This formatter displays a progress bar and shows details of offenses as
-    # soon as they are detected.
-    # This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer.
-    # https://github.com/jeffkreeftmeijer/fuubar
-    class FuubarStyleFormatter < ClangStyleFormatter
-      RESET_SEQUENCE = "\e[0m"
-
-      def started(target_files)
-        super
-
-        @severest_offense = nil
-
-        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
-        )
-        with_color { @progressbar.start }
-      end
-
-      def file_finished(file, offenses)
-        count_stats(offenses)
-
-        unless offenses.empty?
-          @progressbar.clear
-          report_file(file, offenses)
-        end
-
-        with_color { @progressbar.increment }
-      end
-
-      def count_stats(offenses)
-        super
-
-        offenses = offenses.reject(&:corrected?)
-        return if offenses.empty?
-
-        offenses << @severest_offense if @severest_offense
-        @severest_offense = offenses.max_by(&:severity)
-      end
-
-      def with_color
-        if rainbow.enabled
-          output.write colorize('', progressbar_color).chomp(RESET_SEQUENCE)
-          yield
-          output.write RESET_SEQUENCE
-        else
-          yield
-        end
-      end
-
-      def progressbar_color
-        if @severest_offense
-          COLOR_FOR_SEVERITY[@severest_offense.severity.name]
-        else
-          :green
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/html_formatter.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'erb'
-require 'pathname'
-
-module RuboCop
-  module Formatter
-    # This formatter saves the output as a html file.
-    class HTMLFormatter < BaseFormatter
-      include PathUtil
-
-      attr_reader :output_hash
-
-      def initialize(output)
-        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
-        template = File.read(File
-          .expand_path('../../../../assets/output.html.erb', __FILE__))
-        erb = ERB.new(template)
-        html_content = erb.result(binding)
-        output.write html_content
-      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:     relative_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)
-        {
-          line:   offense.line,
-          column: offense.real_column,
-          length: offense.location.length,
-          source_line: offense.location.source_line,
-          highlight: highlight_line(offense.location)
-        }
-      end
-
-      def highlight_line(location)
-        column_length = if location.begin.line == location.end.line
-                          location.column_range.count
-                        else
-                          location.source_line.length - location.column
-                        end
-
-        ' ' * location.column + '^' * column_length
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/json_formatter.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-
-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)
-        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:     relative_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)
-        {
-          line:   offense.line,
-          column: offense.real_column,
-          length: offense.location.length
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/offense_count_formatter.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-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)
-      end
-
-      def file_finished(_file, offenses)
-        offenses.each { |o| @offense_counts[o.cop_name] += 1 }
-      end
-
-      def finished(_inspected_files)
-        report_summary(@offense_counts)
-      end
-
-      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
-
-      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.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/progress_formatter.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-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
-      def started(target_files)
-        super
-        @offenses_for_files = {}
-        file_phrase = target_files.count == 1 ? 'file' : 'files'
-        output.puts "Inspecting #{target_files.count} #{file_phrase}"
-      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.count,
-                       @total_offense_count,
-                       @total_correction_count)
-      end
-
-      def report_file_as_mark(offenses)
-        mark = if offenses.empty?
-                 green('.')
-               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.1.0/gems/rubocop-0.26.0/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,117 +0,0 @@
-# encoding: utf-8
-
-require 'rubocop/formatter/colorizable'
-
-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)
-        summary = pluralize(file_count, 'file')
-        summary << ' inspected, '
-
-        offenses_text = pluralize(offense_count, 'offense', no_for_zero: true)
-        offenses_text << ' detected'
-        summary << colorize(offenses_text, offense_count.zero? ? :green : :red)
-
-        if correction_count > 0
-          summary << ', '
-          correction_text = pluralize(correction_count, 'offense')
-          correction_text << ' corrected'
-          color = correction_count == offense_count ? :green : :cyan
-          summary << colorize(correction_text, color)
-        end
-
-        output.puts
-        output.puts summary
-      end
-
-      private
-
-      def count_stats(offenses)
-        @total_offense_count += offenses.count
-        @total_correction_count += offenses.select(&:corrected?).count
-      end
-
-      def smart_path(path)
-        # Ideally, we calculate this relative to the project root.
-        base_dir = Dir.pwd
-
-        if path.start_with? base_dir
-          relative_path(path, base_dir)
-        else
-          path
-        end
-      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(/`(.*?)`/, Rainbow('\1').yellow)
-      end
-
-      def message(offense)
-        message = offense.corrected? ? green('[Corrected] ') : ''
-        message << annotate_message(offense.message)
-      end
-
-      def pluralize(number, thing, options = {})
-        text = ''
-
-        if number == 0 && options[:no_for_zero]
-          text = 'no'
-        else
-          text << number.to_s
-        end
-
-        text << " #{thing}"
-        text << 's' unless number == 1
-
-        text
-      end
-    end
-  end
-end