rubyjobbuilderdsl 0.0.0 → 0.0.1

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

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

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

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

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

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

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