rubyjobbuilderdsl 0.0.0 → 0.0.1

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

@@ -0,0 +1,203 @@
+# 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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,91 @@
+# 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

@@ -0,0 +1,88 @@
+# 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

@@ -0,0 +1,156 @@
+# 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