rubyjobbuilderdsl 0.0.2 → 0.0.3

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

@@ -1,116 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  # The CLI is a class responsible of handling all the command line interface
-  # logic.
-  class CLI
-    attr_reader :options, :config_store
-
-    def initialize
-      @options = {}
-      @config_store = ConfigStore.new
-    end
-
-    # Entry point for the application logic. Here we
-    # do the command line arguments processing and inspect
-    # the target files
-    # @return [Fixnum] UNIX exit code
-    def run(args = ARGV)
-      @options, paths = Options.new.parse(args)
-      act_on_options
-
-      runner = Runner.new(@options, @config_store)
-      trap_interrupt(runner)
-      all_passed = runner.run(paths)
-      display_error_summary(runner.errors)
-
-      all_passed && !runner.aborting? ? 0 : 1
-    rescue Cop::AmbiguousCopName => e
-      $stderr.puts "Ambiguous cop name #{e.message} needs namespace " \
-                   'qualifier.'
-      return 1
-    rescue => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
-      return 1
-    end
-
-    def trap_interrupt(runner)
-      Signal.trap('INT') do
-        exit!(1) if runner.aborting?
-        runner.abort
-        $stderr.puts
-        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
-      end
-    end
-
-    private
-
-    def act_on_options
-      handle_exiting_options
-
-      ConfigLoader.debug = @options[:debug]
-      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
-
-      @config_store.options_config = @options[:config] if @options[:config]
-
-      Rainbow.enabled = false unless @options[:color]
-    end
-
-    def handle_exiting_options
-      return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
-
-      puts RuboCop::Version.version(false) if @options[:version]
-      puts RuboCop::Version.version(true) if @options[:verbose_version]
-      print_available_cops if @options[:show_cops]
-      exit(0)
-    end
-
-    def print_available_cops
-      cops = Cop::Cop.all
-      show_all = @options[:show_cops].empty?
-
-      if show_all
-        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd}: "
-      end
-
-      cops.types.sort!.each { |type| print_cops_of_type(cops, type, show_all) }
-    end
-
-    def print_cops_of_type(cops, type, show_all)
-      cops_of_this_type = cops.with_type(type).sort_by!(&:cop_name)
-
-      if show_all
-        puts "# Type '#{type.to_s.capitalize}' (#{cops_of_this_type.size}):"
-      end
-
-      selected_cops = cops_of_this_type.select do |cop|
-        show_all || @options[:show_cops].include?(cop.cop_name)
-      end
-
-      selected_cops.each do |cop|
-        puts '# Supports --auto-correct' if cop.new.support_autocorrect?
-        puts "#{cop.cop_name}:"
-        cnf = @config_store.for(Dir.pwd.to_s).for_cop(cop)
-        puts cnf.to_yaml.lines.to_a[1..-1].map { |line| '  ' + line }
-        puts
-      end
-    end
-
-    def display_error_summary(errors)
-      return if errors.empty?
-
-      plural = errors.count > 1 ? 's' : ''
-      warn "\n#{errors.count} error#{plural} occurred:".color(:red)
-
-      errors.each { |error| warn error }
-
-      warn <<-END.strip_indent
-        Errors are usually caused by RuboCop bugs.
-        Please, report your problems to RuboCop's issue tracker.
-        Mention the following information in the issue report:
-        #{RuboCop::Version.version(true)}
-      END
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  # This class parses the special `rubocop:disable` comments in a source
-  # and provides a way to check if each cop is enabled at arbitrary line.
-  class CommentConfig
-    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      '\A# rubocop : ((?:dis|en)able)\b ((?:[\w/]+,? )+)'.gsub(' ', '\s*')
-    )
-
-    attr_reader :processed_source
-
-    def initialize(processed_source)
-      @processed_source = processed_source
-    end
-
-    def cop_enabled_at_line?(cop, line_number)
-      cop = cop.cop_name if cop.respond_to?(:cop_name)
-      disabled_line_ranges = cop_disabled_line_ranges[cop]
-      disabled_line_ranges.none? { |range| range.include?(line_number) }
-    end
-
-    def cop_disabled_line_ranges
-      @cop_disabled_line_ranges ||= analyze
-    end
-
-    private
-
-    def analyze
-      disabled_line_ranges = Hash.new { |hash, key| hash[key] = [] }
-      disablement_start_line_numbers = {}
-
-      each_mentioned_cop do |cop_name, disabled, line, single_line|
-        if single_line
-          next unless disabled
-          disabled_line_ranges[cop_name] << (line..line)
-        else
-          if disabled
-            disablement_start_line_numbers[cop_name] = line
-          else
-            start_line = disablement_start_line_numbers.delete(cop_name)
-            next unless start_line
-            disabled_line_ranges[cop_name] << (start_line..line)
-          end
-        end
-      end
-
-      disablement_start_line_numbers.each do |cop_name, start_line|
-        disabled_line_ranges[cop_name] << (start_line..Float::INFINITY)
-      end
-
-      disabled_line_ranges
-    end
-
-    def each_mentioned_cop
-      all_cop_names = nil # For performance improvement
-
-      return if processed_source.comments.nil?
-
-      processed_source.comments.each do |comment|
-        match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
-        next unless match
-
-        switch, cops_string = match.captures
-
-        if cops_string == 'all'
-          all_cop_names ||= Cop::Cop.all.map(&:cop_name)
-          cop_names = all_cop_names
-        else
-          cop_names = cops_string.split(/,\s*/)
-        end
-
-        disabled = (switch == 'disable')
-        comment_line_number = comment.loc.expression.line
-        single_line = !comment_only_line?(comment_line_number)
-
-        cop_names.each do |cop_name|
-          cop_name = Cop::Cop.qualified_cop_name(cop_name,
-                                                 processed_source.buffer.name)
-          yield cop_name, disabled, comment_line_number, single_line
-        end
-      end
-    end
-
-    def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none? do |non_comment_line_number|
-        non_comment_line_number == line_number
-      end
-    end
-
-    def non_comment_token_line_numbers
-      @non_comment_token_line_numbers ||= begin
-        non_comment_tokens = processed_source.tokens.reject do |token|
-          token.type == :tCOMMENT
-        end
-
-        non_comment_tokens.map { |token| token.pos.line }.uniq
-      end
-    end
-  end
-end

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

@@ -1,160 +0,0 @@
-# encoding: utf-8
-
-require 'delegate'
-require 'pathname'
-
-module RuboCop
-  # This class represents the configuration of the RuboCop application
-  # and all its cops. A Config is associated with a YAML configuration
-  # file from which it was read. Several different Configs can be used
-  # during a run of the rubocop program, if files in several
-  # directories are inspected.
-  class Config < DelegateClass(Hash)
-    include PathUtil
-
-    class ValidationError < StandardError; end
-
-    COMMON_PARAMS = %w(Exclude Include Severity)
-
-    attr_reader :loaded_path
-
-    def initialize(hash = {}, loaded_path = nil)
-      @hash = hash
-      @loaded_path = loaded_path
-      super(@hash)
-    end
-
-    def make_excludes_absolute
-      return unless self['AllCops'] && self['AllCops']['Exclude']
-
-      self['AllCops']['Exclude'].map! do |exclude_elem|
-        if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
-          File.join(base_dir_for_path_parameters, exclude_elem)
-        else
-          exclude_elem
-        end
-      end
-    end
-
-    def add_excludes_from_higher_level(highest_config)
-      return unless highest_config['AllCops'] &&
-        highest_config['AllCops']['Exclude']
-
-      self['AllCops'] ||= {}
-      excludes = self['AllCops']['Exclude'] ||= []
-      highest_config['AllCops']['Exclude'].each do |path|
-        unless path.is_a?(Regexp) || path.start_with?('/')
-          path = File.join(File.dirname(highest_config.loaded_path), path)
-        end
-        excludes << path unless excludes.include?(path)
-      end
-    end
-
-    def deprecation_check
-      all_cops = self['AllCops']
-      return unless all_cops
-
-      %w(Exclude Include).each do |key|
-        plural = "#{key}s"
-        next unless all_cops[plural]
-
-        all_cops[key] = all_cops[plural] # Stay backwards compatible.
-        all_cops.delete(plural)
-        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
-      end
-    end
-
-    def for_cop(cop)
-      cop = cop.cop_name if cop.respond_to?(:cop_name)
-      @for_cop ||= {}
-      @for_cop[cop] ||= self[Cop::Cop.qualified_cop_name(cop, loaded_path)]
-    end
-
-    def cop_enabled?(cop)
-      for_cop(cop).nil? || for_cop(cop)['Enabled']
-    end
-
-    def warn_unless_valid
-      validate
-    rescue Config::ValidationError => e
-      warn "Warning: #{e.message}".color(:red)
-    end
-
-    def add_missing_namespaces
-      keys.each do |k|
-        q = Cop::Cop.qualified_cop_name(k, loaded_path)
-        next if q == k
-
-        self[q] = self[k]
-        delete(k)
-      end
-    end
-
-    # TODO: This should be a private method
-    def validate
-      # Don't validate RuboCop's own files. Avoids inifinite recursion.
-      return if @loaded_path.start_with?(File.join(ConfigLoader::RUBOCOP_HOME,
-                                                   'config'))
-
-      default_config = ConfigLoader.default_configuration
-
-      valid_cop_names, invalid_cop_names = @hash.keys.partition do |key|
-        default_config.key?(key)
-      end
-
-      invalid_cop_names.each do |name|
-        fail ValidationError,
-             "unrecognized cop #{name} found in #{loaded_path || self}"
-      end
-
-      valid_cop_names.each do |name|
-        @hash[name].each_key do |param|
-          next if COMMON_PARAMS.include?(param) ||
-            default_config[name].key?(param)
-
-          fail ValidationError,
-               "unrecognized parameter #{name}:#{param} found " \
-               "in #{loaded_path || self}"
-        end
-      end
-    end
-
-    def file_to_include?(file)
-      relative_file_path = path_relative_to_config(file)
-      patterns_to_include.any? do |pattern|
-        match_path?(pattern, relative_file_path, loaded_path)
-      end
-    end
-
-    def file_to_exclude?(file)
-      file = File.expand_path(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file, loaded_path)
-      end
-    end
-
-    def patterns_to_include
-      @hash['AllCops']['Include']
-    end
-
-    def patterns_to_exclude
-      @hash['AllCops']['Exclude']
-    end
-
-    def path_relative_to_config(path)
-      relative_path(path, base_dir_for_path_parameters)
-    end
-
-    # Paths specified in .rubocop.yml files are relative to the directory where
-    # that file is. Paths in other config files are relative to the current
-    # directory. This is so that paths in config/default.yml, for example, are
-    # not relative to RuboCop's config directory since that wouldn't work.
-    def base_dir_for_path_parameters
-      if File.basename(loaded_path) == ConfigLoader::DOTFILE
-        File.expand_path(File.dirname(loaded_path))
-      else
-        Dir.pwd
-      end
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require 'yaml'
-require 'pathname'
-
-module RuboCop
-  # This class represents the configuration of the RuboCop application
-  # and all its cops. A Config is associated with a YAML configuration
-  # file from which it was read. Several different Configs can be used
-  # during a run of the rubocop program, if files in several
-  # directories are inspected.
-  class ConfigLoader
-    DOTFILE = '.rubocop.yml'
-    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
-    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'
-
-    class << self
-      attr_accessor :debug, :auto_gen_config
-      attr_writer :root_level # The upwards search is stopped at this level.
-
-      alias_method :debug?, :debug
-      alias_method :auto_gen_config?, :auto_gen_config
-
-      def load_file(path)
-        path = File.absolute_path(path)
-
-        # Psych can give an error when reading an empty file, so we use syck in
-        # Ruby versions where it's available. Also, the problem with empty
-        # files does not appear in Ruby 2 or in JRuby 1.9 mode.
-        if RUBY_VERSION < '2.0.0' && RUBY_PLATFORM != 'java'
-          original_yamler = YAML::ENGINE.yamler
-          YAML::ENGINE.yamler = 'syck'
-        end
-        hash = YAML.load_file(path) || {}
-        # Restore yamler for applications using RuboCop as a library.
-        YAML::ENGINE.yamler = original_yamler if original_yamler
-
-        puts "configuration from #{path}" if debug?
-
-        resolve_inheritance(path, hash)
-
-        Array(hash.delete('require')).each { |r| require(r) }
-
-        hash.delete('inherit_from')
-        config = Config.new(hash, path)
-
-        config.deprecation_check do |deprecation_message|
-          warn("#{path} - #{deprecation_message}")
-        end
-
-        config.add_missing_namespaces
-        config.warn_unless_valid
-        config.make_excludes_absolute
-        config
-      end
-
-      # Return a recursive merge of two hashes. That is, a normal hash merge,
-      # with the addition that any value that is a hash, and occurs in both
-      # arguments, will also be merged. And so on.
-      def merge(base_hash, derived_hash)
-        result = base_hash.merge(derived_hash)
-        keys_appearing_in_both = base_hash.keys & derived_hash.keys
-        keys_appearing_in_both.each do |key|
-          next unless base_hash[key].is_a?(Hash)
-          result[key] = merge(base_hash[key], derived_hash[key])
-        end
-        result
-      end
-
-      def base_configs(path, inherit_from)
-        configs = Array(inherit_from).map do |f|
-          f = File.join(File.dirname(path), f) unless f.start_with?('/')
-
-          if auto_gen_config?
-            next if f.include?(AUTO_GENERATED_FILE)
-            old_auto_config_file_warning if f.include?('rubocop-todo.yml')
-          end
-
-          print 'Inheriting ' if debug?
-          load_file(f)
-        end
-
-        configs.compact
-      end
-
-      # Returns the path of .rubocop.yml searching upwards in the
-      # directory structure starting at the given directory where the
-      # inspected file is. If no .rubocop.yml is found there, the
-      # user's home directory is checked. If there's no .rubocop.yml
-      # there either, the path to the default file is returned.
-      def configuration_file_for(target_dir)
-        config_files_in_path(target_dir).first || DEFAULT_FILE
-      end
-
-      def configuration_from_file(config_file)
-        config = load_file(config_file)
-        return config if config_file == DEFAULT_FILE
-
-        found_files = config_files_in_path(config_file)
-        if found_files.any? && found_files.last != config_file
-          print 'AllCops/Exclude ' if debug?
-          config.add_excludes_from_higher_level(load_file(found_files.last))
-        end
-        merge_with_default(config, config_file)
-      end
-
-      def default_configuration
-        @default_configuration ||= begin
-                                     print 'Default ' if debug?
-                                     load_file(DEFAULT_FILE)
-                                   end
-      end
-
-      def merge_with_default(config, config_file)
-        Config.new(merge(default_configuration, config), config_file)
-      end
-
-      private
-
-      def resolve_inheritance(path, hash)
-        base_configs(path, hash['inherit_from']).reverse_each do |base_config|
-          base_config.each do |k, v|
-            hash[k] = hash.key?(k) ? merge(v, hash[k]) : v if v.is_a?(Hash)
-          end
-        end
-      end
-
-      def config_files_in_path(target)
-        possible_config_files = dirs_to_search(target).map do |dir|
-          File.join(dir, DOTFILE)
-        end
-        possible_config_files.select { |config_file| File.exist?(config_file) }
-      end
-
-      def dirs_to_search(target_dir)
-        dirs_to_search = []
-        Pathname.new(File.expand_path(target_dir)).ascend do |dir_pathname|
-          break if dir_pathname.to_s == @root_level
-          dirs_to_search << dir_pathname.to_s
-        end
-        dirs_to_search << Dir.home
-      end
-
-      def old_auto_config_file_warning
-        warn 'Attention: rubocop-todo.yml has been renamed to ' \
-             "#{AUTO_GENERATED_FILE}".color(:red)
-        exit(1)
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  # Handles caching of configurations and association of inspected
-  # ruby files to configurations.
-  class ConfigStore
-    def initialize
-      # @options_config stores a config that is specified in the command line.
-      # This takes precedence over configs located in any directories
-      @options_config = nil
-
-      # @path_cache maps directories to configuration paths. We search
-      # for .rubocop.yml only if we haven't already found it for the
-      # given directory.
-      @path_cache = {}
-
-      # @object_cache maps configuration file paths to
-      # configuration objects so we only need to load them once.
-      @object_cache = {}
-    end
-
-    def options_config=(options_config)
-      loaded_config = ConfigLoader.load_file(options_config)
-      @options_config = ConfigLoader.merge_with_default(loaded_config,
-                                                        options_config)
-    end
-
-    def for(file_or_dir)
-      return @options_config if @options_config
-
-      dir = if File.directory?(file_or_dir)
-              file_or_dir
-            else
-              File.dirname(file_or_dir)
-            end
-      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
-      path = @path_cache[dir]
-      @object_cache[path] ||= begin
-                                print "For #{dir}: " if ConfigLoader.debug?
-                                ConfigLoader.configuration_from_file(path)
-                              end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-# encoding: utf-8
-
-module RuboCop
-  module Cop
-    # Commissioner class is responsible for processing the AST and delegating
-    # work to the specified cops.
-    class Commissioner < Parser::AST::Processor
-      attr_reader :errors
-
-      def self.callback_methods
-        Parser::Meta::NODE_TYPES.map { |type| "on_#{type}" }
-      end
-
-      # Methods that are not defined in Parser::AST::Processor
-      # won't have a `super` to call. So we should not attempt
-      # to invoke `super` when defining them.
-      def self.call_super(callback)
-        if Parser::AST::Processor.method_defined?(callback)
-          'super'
-        else
-          ''
-        end
-      end
-
-      def initialize(cops, forces, options = {})
-        @cops = cops
-        @forces = forces
-        @options = options
-        reset_errors
-      end
-
-      callback_methods.each do |callback|
-        class_eval <<-EOS
-          def #{callback}(node)
-            @cops.each do |cop|
-              next unless cop.respond_to?(:#{callback})
-              with_cop_error_handling(cop) do
-                cop.send(:#{callback}, node)
-              end
-            end
-
-            #{call_super(callback)}
-          end
-        EOS
-      end
-
-      def investigate(processed_source)
-        reset_errors
-        prepare(processed_source)
-        invoke_custom_processing(@cops, processed_source)
-        invoke_custom_processing(@forces, processed_source)
-        process(processed_source.ast) if processed_source.ast
-        @cops.each_with_object([]) do |cop, offenses|
-          filename = processed_source.buffer.name
-          # ignore files that are of no interest to the cop in question
-          offenses.concat(cop.offenses) if cop.relevant_file?(filename)
-        end
-      end
-
-      private
-
-      def reset_errors
-        @errors = Hash.new { |hash, k| hash[k] = [] }
-      end
-
-      # TODO: Bad design.
-      def prepare(processed_source)
-        @cops.each { |cop| cop.processed_source = processed_source }
-      end
-
-      # There are cops/forces that require their own custom processing.
-      # If they define the #investigate method, all input parameters passed
-      # to the commissioner will be passed to the cop too in order to do
-      # its own processing.
-      def invoke_custom_processing(cops_or_forces, processed_source)
-        cops_or_forces.each do |cop|
-          next unless cop.respond_to?(:investigate)
-
-          if cop.respond_to?(:relevant_file?)
-            # ignore files that are of no interest to the cop in question
-            filename = processed_source.buffer.name
-            next unless cop.relevant_file?(filename)
-          end
-
-          with_cop_error_handling(cop) do
-            cop.investigate(processed_source)
-          end
-        end
-      end
-
-      def with_cop_error_handling(cop)
-        yield
-      rescue => e
-        if @options[:raise_error]
-          raise e
-        else
-          @errors[cop] << e
-        end
-      end
-    end
-  end
-end