rubyjobbuilderdsl 0.0.2 → 0.0.3

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

@@ -1,203 +0,0 @@
-# encoding: utf-8
-
-require 'optparse'
-
-module RuboCop
-  # This module contains help texts for command line options.
-  module OptionsHelp
-    TEXT = {
-      only:              'Run only the given cop(s).',
-      require:           'Require Ruby file.',
-      config:            'Specify configuration file.',
-      auto_gen_config:  ['Generate a configuration file acting as a',
-                         'TODO list.'],
-      force_exclusion:  ['Force excluding files specified in the',
-                         'configuration `Exclude` even if they are',
-                         'explicitly passed as arguments.'],
-      format:           ['Choose an output formatter. This option',
-                         'can be specified multiple times to enable',
-                         'multiple formatters at the same time.',
-                         '  [p]rogress (default)',
-                         '  [s]imple',
-                         '  [c]lang',
-                         '  [d]isabled cops via inline comments',
-                         '  [fu]ubar',
-                         '  [e]macs',
-                         '  [j]son',
-                         '  [h]tml',
-                         '  [fi]les',
-                         '  [o]ffenses',
-                         '  custom formatter class name'],
-      out:              ['Write output to a file instead of STDOUT.',
-                         'This option applies to the previously',
-                         'specified --format, or the default format',
-                         'if no format is specified.'],
-      fail_level:        'Minimum severity for exit with error code.',
-      show_cops:        ['Shows the given cops, or all cops by',
-                         'default, and their configurations for the',
-                         'current directory.'],
-      fail_fast:        ['Inspect files in order of modification',
-                         'time and stop after the first file',
-                         'containing offenses.'],
-      debug:             'Display debug info.',
-      display_cop_names: 'Display cop names in offense messages.',
-      rails:             'Run extra Rails cops.',
-      lint:              'Run only lint cops.',
-      auto_correct:      'Auto-correct offenses.',
-      no_color:          'Disable color output.',
-      version:           'Display version.',
-      verbose_version:   'Display verbose version.'
-    }
-  end
-
-  # This class handles command line options.
-  class Options
-    DEFAULT_FORMATTER = 'progress'
-    EXITING_OPTIONS = [:version, :verbose_version, :show_cops]
-
-    def initialize
-      @options = {}
-    end
-
-    def parse(args)
-      ignore_dropped_options(args)
-      convert_deprecated_options(args)
-
-      OptionParser.new do |opts|
-        opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
-
-        option(opts, '--only [COP1,COP2,...]') do |list|
-          @options[:only] = list.split(',').map do |c|
-            Cop::Cop.qualified_cop_name(c, '--only option')
-          end
-        end
-
-        add_configuration_options(opts, args)
-        add_formatting_options(opts)
-
-        option(opts, '-r', '--require FILE') { |f| require f }
-
-        add_severity_option(opts)
-        add_flags_with_optional_args(opts)
-        add_boolean_flags(opts)
-      end.parse!(args)
-
-      if (incompat = @options.keys & EXITING_OPTIONS).size > 1
-        fail ArgumentError, "Incompatible cli options: #{incompat.inspect}"
-      end
-
-      [@options, args]
-    end
-
-    private
-
-    def add_configuration_options(opts, args)
-      option(opts, '-c', '--config FILE')
-
-      option(opts, '--auto-gen-config') do
-        validate_auto_gen_config_option(args)
-        @options[:formatters] = [[DEFAULT_FORMATTER],
-                                 [Formatter::DisabledConfigFormatter,
-                                  ConfigLoader::AUTO_GENERATED_FILE]]
-      end
-
-      option(opts, '--force-exclusion')
-    end
-
-    def add_formatting_options(opts)
-      option(opts, '-f', '--format FORMATTER') do |key|
-        @options[:formatters] ||= []
-        @options[:formatters] << [key]
-      end
-
-      option(opts, '-o', '--out FILE') do |path|
-        @options[:formatters] ||= [[DEFAULT_FORMATTER]]
-        @options[:formatters].last << path
-      end
-    end
-
-    def add_severity_option(opts)
-      option(opts, '--fail-level SEVERITY',
-             RuboCop::Cop::Severity::NAMES,
-             RuboCop::Cop::Severity::CODE_TABLE) do |severity|
-        @options[:fail_level] = severity
-      end
-    end
-
-    def add_flags_with_optional_args(opts)
-      option(opts, '--show-cops [COP1,COP2,...]') do |list|
-        @options[:show_cops] = list.nil? ? [] : list.split(',')
-      end
-    end
-
-    def add_boolean_flags(opts)
-      option(opts, '-F', '--fail-fast')
-      option(opts, '-d', '--debug')
-      option(opts, '-D', '--display-cop-names')
-      option(opts, '-R', '--rails')
-      option(opts, '-l', '--lint')
-      option(opts, '-a', '--auto-correct')
-
-      @options[:color] = true
-      option(opts, '-n', '--no-color') { @options[:color] = false }
-
-      option(opts, '-v', '--version')
-      option(opts, '-V', '--verbose-version')
-    end
-
-    # Sets a value in the @options hash, based on the given long option and its
-    # value, in addition to calling the block if a block is given.
-    def option(opts, *args)
-      long_opt_symbol = long_opt_symbol(args)
-      args += Array(OptionsHelp::TEXT[long_opt_symbol])
-      opts.on(*args) do |arg|
-        @options[long_opt_symbol] = arg
-        yield arg if block_given?
-      end
-    end
-
-    # Finds the option in `args` starting with -- and converts it to a symbol,
-    # e.g. [..., '--auto-correct', ...] to :auto_correct.
-    def long_opt_symbol(args)
-      long_opt = args.find { |arg| arg.start_with?('--') }
-      long_opt[2..-1].sub(/ .*/, '').gsub(/-/, '_').to_sym
-    end
-
-    def ignore_dropped_options(args)
-      # Currently we don't make -s/--silent option raise error
-      # since those are mostly used by external tools.
-      rejected = args.reject! { |a| %w(-s --silent).include?(a) }
-      return unless rejected
-
-      warn '-s/--silent options is dropped. ' \
-           '`emacs` and `files` formatters no longer display summary.'
-    end
-
-    def convert_deprecated_options(args)
-      args.map! do |arg|
-        case arg
-        when '-e', '--emacs'
-          deprecate("#{arg} option", '--format emacs', '1.0.0')
-          %w(--format emacs)
-        else
-          arg
-        end
-      end.flatten!
-    end
-
-    def deprecate(subject, alternative = nil, version = nil)
-      message =  "#{subject} is deprecated"
-      message << " and will be removed in RuboCop #{version}" if version
-      message << '.'
-      message << " Please use #{alternative} instead." if alternative
-      warn message
-    end
-
-    def validate_auto_gen_config_option(args)
-      return unless args.any?
-
-      warn '--auto-gen-config can not be combined with any other arguments.'
-      exit(1)
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  # Common methods and behaviors for dealing with paths.
-  module PathUtil
-    module_function
-
-    def relative_path(path, base_dir = Dir.pwd)
-      path_name = Pathname.new(File.expand_path(path))
-      path_name.relative_path_from(Pathname.new(base_dir)).to_s
-    end
-
-    # TODO: The old way of matching patterns is flawed, so a new one has been
-    # introduced. We keep supporting the old way for a while and issue
-    # deprecation warnings when a pattern is used that produced a match with
-    # the old way but doesn't match with the new.
-    def match_path?(pattern, path, config_path)
-      case pattern
-      when String
-        basename = File.basename(path)
-        old_match = basename == pattern || File.fnmatch?(pattern, path)
-        new_match = File.fnmatch?(pattern, path, File::FNM_PATHNAME)
-        if old_match && !new_match
-          instruction = if basename == pattern
-                          ". Change to '**/#{pattern}'."
-                        elsif pattern.end_with?('**')
-                          ". Change to '#{pattern}/*'."
-                        end
-          warn("Warning: Deprecated pattern style '#{pattern}' in " \
-               "#{config_path}#{instruction}")
-        end
-        old_match || new_match
-      when Regexp
-        path =~ pattern
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# encoding: utf-8
-
-require 'astrolabe/builder'
-
-module RuboCop
-  # ProcessedSource contains objects which are generated by Parser
-  # and other information such as disabled lines for cops.
-  # It also provides a convenient way to access source lines.
-  class ProcessedSource
-    STRING_SOURCE_NAME = '(string)'
-    attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                :parser_error, :raw_source
-
-    def self.from_file(path)
-      new(File.read(path), path)
-    end
-
-    def initialize(source, path = nil)
-      # In Ruby 2, source code encoding defaults to UTF-8. We follow the same
-      # principle regardless of which Ruby version we're running under.
-      # Encoding comments will override this setting.
-      source.force_encoding(Encoding::UTF_8)
-
-      @raw_source = source
-      @path = path
-      @diagnostics = []
-      parse(source)
-    end
-
-    def comment_config
-      @comment_config ||= CommentConfig.new(self)
-    end
-
-    def disabled_line_ranges
-      comment_config.cop_disabled_line_ranges
-    end
-
-    def lines
-      @lines ||= raw_source.lines.map(&:chomp)
-    end
-
-    def [](*args)
-      lines[*args]
-    end
-
-    def valid_syntax?
-      return false if @parser_error
-      @diagnostics.none? { |d| [:error, :fatal].include?(d.level) }
-    end
-
-    private
-
-    def parse(source)
-      buffer_name = @path || STRING_SOURCE_NAME
-      @buffer = Parser::Source::Buffer.new(buffer_name, 1)
-
-      begin
-        @buffer.source = source
-      rescue EncodingError => error
-        @parser_error = error
-        return
-      end
-
-      parser = create_parser
-
-      begin
-        @ast, @comments, tokens = parser.tokenize(@buffer)
-      rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
-        # All errors are in diagnostics. No need to handle exception.
-      end
-
-      @tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
-    end
-
-    def create_parser
-      builder = Astrolabe::Builder.new
-
-      Parser::CurrentRuby.new(builder).tap do |parser|
-        # On JRuby and Rubinius, there's a risk that we hang in tokenize() if we
-        # don't set the all errors as fatal flag. The problem is caused by a bug
-        # in Racc that is discussed in issue #93 of the whitequark/parser
-        # project on GitHub.
-        parser.diagnostics.all_errors_are_fatal = (RUBY_ENGINE != 'ruby')
-        parser.diagnostics.ignore_warnings = false
-        parser.diagnostics.consumer = lambda do |diagnostic|
-          @diagnostics << diagnostic
-        end
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-# encoding: utf-8
-
-require 'rake'
-require 'rake/tasklib'
-
-module RuboCop
-  # Provides a custom rake task.
-  #
-  # require 'rubocop/rake_task'
-  # RuboCop::RakeTask.new
-  class RakeTask < Rake::TaskLib
-    attr_accessor :name
-    attr_accessor :verbose
-    attr_accessor :fail_on_error
-    attr_accessor :patterns
-    attr_accessor :formatters
-    attr_accessor :requires
-    attr_accessor :options
-
-    def initialize(*args, &task_block)
-      setup_ivars(args)
-
-      desc 'Run RuboCop' unless ::Rake.application.last_comment
-
-      task(name, *args) do |_, task_args|
-        RakeFileUtils.send(:verbose, verbose) do
-          if task_block
-            task_block.call(*[self, task_args].slice(0, task_block.arity))
-          end
-          run_main_task(verbose)
-        end
-      end
-
-      setup_subtasks(name)
-    end
-
-    def run_main_task(verbose)
-      run_cli(verbose, full_options)
-    end
-
-    private
-
-    def run_cli(verbose, options)
-      # We lazy-load rubocop so that the task doesn't dramatically impact the
-      # load time of your Rakefile.
-      require 'rubocop'
-
-      cli = CLI.new
-      puts 'Running RuboCop...' if verbose
-      result = cli.run(options)
-      abort('RuboCop failed!') if fail_on_error unless result == 0
-    end
-
-    def full_options
-      [].tap do |result|
-        result.concat(formatters.map { |f| ['--format', f] }.flatten)
-        result.concat(requires.map { |r| ['--require', r] }.flatten)
-        result.concat(options)
-        result.concat(patterns)
-      end
-    end
-
-    def setup_ivars(args)
-      # More lazy-loading to keep load time down.
-      require 'rubocop/options'
-
-      @name = args.shift || :rubocop
-      @verbose = true
-      @fail_on_error = true
-      @patterns = []
-      @requires = []
-      @options = []
-      @formatters = [RuboCop::Options::DEFAULT_FORMATTER]
-    end
-
-    def setup_subtasks(name)
-      namespace name do
-
-        desc 'Auto-correct RuboCop offenses'
-
-        task :auto_correct do
-          options = full_options.unshift('--auto-correct')
-          run_cli(verbose, options)
-        end
-      end
-    end
-  end
-end

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

@@ -1,156 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  # This class handles the processing of files, which includes dealing with
-  # formatters and letting cops inspect the files.
-  class Runner
-    attr_reader :errors, :aborting
-    alias_method :aborting?, :aborting
-
-    def initialize(options, config_store)
-      @options = options
-      @config_store = config_store
-      @errors = []
-      @aborting = false
-    end
-
-    def run(paths)
-      target_files = find_target_files(paths)
-
-      inspected_files = []
-      all_passed = true
-
-      formatter_set.started(target_files)
-
-      target_files.each do |file|
-        break if aborting?
-        offenses = process_file(file)
-        all_passed = false if offenses.any? { |o| considered_failure?(o) }
-        inspected_files << file
-        break if @options[:fail_fast] && !all_passed
-      end
-
-      formatter_set.finished(inspected_files.freeze)
-      formatter_set.close_output_files
-
-      all_passed
-    end
-
-    def abort
-      @aborting = true
-    end
-
-    private
-
-    def find_target_files(paths)
-      target_finder = TargetFinder.new(@config_store, @options)
-      target_files = target_finder.find(paths)
-      target_files.each(&:freeze).freeze
-    end
-
-    def process_file(file)
-      puts "Scanning #{file}" if @options[:debug]
-
-      processed_source = ProcessedSource.from_file(file)
-
-      formatter_set.file_started(file, file_info(processed_source))
-
-      offenses = []
-
-      # When running with --auto-correct, we need to inspect the file (which
-      # includes writing a corrected version of it) until no more corrections
-      # are made. This is because automatic corrections can introduce new
-      # offenses. In the normal case the loop is only executed once.
-      loop do
-        # The offenses that couldn't be corrected will be found again so we
-        # only keep the corrected ones in order to avoid duplicate reporting.
-        offenses.select!(&:corrected?)
-
-        new_offenses, updated_source_file = inspect_file(processed_source)
-        offenses.concat(new_offenses).uniq!
-        break unless updated_source_file
-
-        # We have to reprocess the source to pickup the changes. Since the
-        # change could (theoretically) introduce parsing errors, we break the
-        # loop if we find any.
-        processed_source = ProcessedSource.from_file(file)
-      end
-
-      formatter_set.file_finished(file, offenses.sort.freeze)
-
-      offenses
-    end
-
-    def inspect_file(processed_source)
-      config = @config_store.for(processed_source.path)
-      team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
-      offenses = team.inspect_file(processed_source)
-      @errors.concat(team.errors)
-      [offenses, team.updated_source_file?]
-    end
-
-    def mobilized_cop_classes(config)
-      @mobilized_cop_classes ||= {}
-      @mobilized_cop_classes[config.object_id] ||= begin
-        cop_classes = Cop::Cop.all
-
-        if @options[:only]
-          validate_only_option
-
-          cop_classes.select! do |c|
-            @options[:only].include?(c.cop_name) || @options[:lint] && c.lint?
-          end
-        else
-          # filter out Rails cops unless requested
-          cop_classes.reject!(&:rails?) unless run_rails_cops?(config)
-
-          # filter out style cops when --lint is passed
-          cop_classes.select!(&:lint?) if @options[:lint]
-        end
-
-        cop_classes
-      end
-    end
-
-    def validate_only_option
-      @options[:only].each do |cop_to_run|
-        next unless Cop::Cop.all.none? { |c| c.cop_name == cop_to_run }
-        fail ArgumentError, "Unrecognized cop name: #{cop_to_run}."
-      end
-    end
-
-    def run_rails_cops?(config)
-      @options[:rails] || config['AllCops']['RunRailsCops']
-    end
-
-    def formatter_set
-      @formatter_set ||= begin
-        set = Formatter::FormatterSet.new
-        pairs = @options[:formatters] || [[Options::DEFAULT_FORMATTER]]
-        pairs.each do |formatter_key, output_path|
-          set.add_formatter(formatter_key, output_path)
-        end
-        set
-      rescue => error
-        warn error.message
-        $stderr.puts error.backtrace
-        exit(1)
-      end
-    end
-
-    def considered_failure?(offense)
-      offense.severity >= minimum_severity_to_fail
-    end
-
-    def minimum_severity_to_fail
-      @minimum_severity_to_fail ||= begin
-        name = @options[:fail_level] || :refactor
-        RuboCop::Cop::Severity.new(name)
-      end
-    end
-
-    def file_info(processed_source)
-      { cop_disabled_line_ranges: processed_source.disabled_line_ranges }
-    end
-  end
-end