cocRb 0.1.0 → 0.1.2

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cli/command/init_dotfile.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  class CLI
-    module Command
-      # Generate a .rubocop.yml file in the current directory.
-      # @api private
-      class InitDotfile < Base
-        DOTFILE = ConfigLoader::DOTFILE
-
-        self.command_name = :init
-
-        def run
-          path = File.expand_path(DOTFILE)
-
-          if File.exist?(DOTFILE)
-            warn Rainbow("#{DOTFILE} already exists at #{path}").red
-
-            STATUS_ERROR
-          else
-            description = <<~DESC
-              # The behavior of RuboCop can be controlled via the .rubocop.yml
-              # configuration file. It makes it possible to enable/disable
-              # certain cops (checks) and to alter their behavior if they accept
-              # any parameters. The file can be placed either in your home
-              # directory or in some project directory.
-              #
-              # RuboCop will start looking for the configuration file in the directory
-              # where the inspected file is and continue its way up to the root directory.
-              #
-              # See https://docs.rubocop.org/rubocop/configuration
-            DESC
-
-            File.open(DOTFILE, 'w') { |f| f.write(description) }
-
-            puts "Writing new #{DOTFILE} to #{path}"
-
-            STATUS_SUCCESS
-          end
-        end
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cli/command/show_cops.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  class CLI
-    module Command
-      # Shows the given cops, or all cops by default, and their configurations
-      # for the current directory.
-      # @api private
-      class ShowCops < Base
-        self.command_name = :show_cops
-
-        def initialize(env)
-          super
-
-          # Load the configs so the require()s are done for custom cops
-          @config = @config_store.for(Dir.pwd)
-        end
-
-        def run
-          print_available_cops
-        end
-
-        private
-
-        def print_available_cops
-          registry = Cop::Registry.global
-          show_all = @options[:show_cops].empty?
-
-          puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: " if show_all
-
-          registry.departments.sort!.each do |department|
-            print_cops_of_department(registry, department, show_all)
-          end
-        end
-
-        def print_cops_of_department(registry, department, show_all)
-          selected_cops = if show_all
-                            cops_of_department(registry, department)
-                          else
-                            selected_cops_of_department(registry, department)
-                          end
-
-          puts "# Department '#{department}' (#{selected_cops.length}):" if show_all
-
-          print_cop_details(selected_cops)
-        end
-
-        def print_cop_details(cops)
-          cops.each do |cop|
-            puts '# Supports --auto-correct' if cop.support_autocorrect?
-            puts "#{cop.cop_name}:"
-            puts config_lines(cop)
-            puts
-          end
-        end
-
-        def selected_cops_of_department(cops, department)
-          cops_of_department(cops, department).select do |cop|
-            @options[:show_cops].include?(cop.cop_name)
-          end
-        end
-
-        def cops_of_department(cops, department)
-          cops.with_department(department).sort!
-        end
-
-        def config_lines(cop)
-          cnf = @config.for_cop(cop)
-          cnf.to_yaml.lines.to_a.drop(1).map { |line| "  #{line}" }
-        end
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cli/command/suggest_extensions.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  class CLI
-    module Command
-      # Suggest RuboCop extensions to install based on Gemfile dependencies.
-      # Only primary dependencies are evaluated, so if a dependency depends on a
-      # gem with an extension, it is not suggested. However, if an extension is
-      # a transitive dependency, it will not be suggested.
-      # @api private
-      class SuggestExtensions < Base
-        # Combination of short and long formatter names.
-        INCLUDED_FORMATTERS = %w[p progress fu fuubar pa pacman].freeze
-
-        self.command_name = :suggest_extensions
-
-        def run
-          return if skip? || extensions.none?
-
-          puts
-          puts 'Tip: Based on detected gems, the following '\
-            'RuboCop extension libraries might be helpful:'
-
-          extensions.sort.each do |extension|
-            puts "  * #{extension} (https://github.com/rubocop/#{extension})"
-          end
-
-          puts
-          puts 'You can opt out of this message by adding the following to your config '\
-            '(see https://docs.rubocop.org/rubocop/extensions.html#extension-suggestions '\
-            'for more options):'
-          puts '  AllCops:'
-          puts '    SuggestExtensions: false'
-
-          puts if @options[:display_time]
-        end
-
-        private
-
-        def skip?
-          # Disable outputting the notification:
-          # 1. On CI
-          # 2. When given RuboCop options that it doesn't make sense for
-          # 3. For all formatters except specified in `INCLUDED_FORMATTERS'`
-          ENV['CI'] ||
-            @options[:only] || @options[:debug] || @options[:list_target_files] ||
-            @options[:out] || @options[:stdin] ||
-            !INCLUDED_FORMATTERS.include?(current_formatter)
-        end
-
-        def current_formatter
-          @options[:format] || @config_store.for_pwd.for_all_cops['DefaultFormatter'] || 'p'
-        end
-
-        def extensions
-          return [] unless lockfile.dependencies.any?
-
-          extensions = @config_store.for_pwd.for_all_cops['SuggestExtensions'] || {}
-          extensions.select { |_, v| (Array(v) & dependent_gems).any? }.keys - installed_gems
-        end
-
-        def lockfile
-          @lockfile ||= Lockfile.new
-        end
-
-        def dependent_gems
-          lockfile.dependencies.map(&:name)
-        end
-
-        def installed_gems
-          lockfile.gems.map(&:name)
-        end
-
-        def puts(*args)
-          output = (@options[:stderr] ? $stderr : $stdout)
-          output.puts(*args)
-        end
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cli/command/version.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  class CLI
-    module Command
-      # Display version.
-      # @api private
-      class Version < Base
-        self.command_name = :version
-
-        def run
-          puts RuboCop::Version.version(debug: false) if @options[:version]
-          puts RuboCop::Version.version(debug: true, env: env) if @options[:verbose_version]
-        end
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cli/environment.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  class CLI
-    # Execution environment for a CLI command.
-    # @api private
-    class Environment
-      attr_reader :options, :config_store, :paths
-
-      def initialize(options, config_store, paths)
-        @options = options
-        @config_store = config_store
-        @paths = paths
-      end
-
-      # Run a command in this environment.
-      def run(name)
-        Command.run(self, name)
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/comment_config.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-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
-    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
-
-    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]
-      return true unless disabled_line_ranges
-
-      disabled_line_ranges.none? { |range| range.include?(line_number) }
-    end
-
-    def cop_disabled_line_ranges
-      @cop_disabled_line_ranges ||= analyze
-    end
-
-    def extra_enabled_comments
-      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: Hash.new(0))
-    end
-
-    def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none?(line_number)
-    end
-
-    private
-
-    def extra_enabled_comments_with_names(extras:, names:)
-      each_directive do |directive|
-        next unless comment_only_line?(directive.line_number)
-
-        if directive.enabled_all?
-          handle_enable_all(directive, names, extras)
-        else
-          handle_switch(directive, names, extras)
-        end
-      end
-
-      extras
-    end
-
-    def analyze # rubocop:todo Metrics/AbcSize
-      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
-
-      each_directive do |directive|
-        directive.cop_names.each do |cop_name|
-          cop_name = qualified_cop_name(cop_name)
-          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
-        end
-      end
-
-      analyses.each_with_object({}) do |element, hash|
-        cop_name, analysis = *element
-        hash[cop_name] = cop_line_ranges(analysis)
-      end
-    end
-
-    def analyze_cop(analysis, directive)
-      # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
-      if !comment_only_line?(directive.line_number) || directive.single_line?
-        analyze_single_line(analysis, directive)
-      elsif directive.disabled?
-        analyze_disabled(analysis, directive)
-      else
-        analyze_rest(analysis, directive)
-      end
-    end
-
-    def analyze_single_line(analysis, directive)
-      return analysis unless directive.disabled?
-
-      line = directive.line_number
-      start_line = analysis.start_line_number
-
-      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
-    end
-
-    def analyze_disabled(analysis, directive)
-      line = directive.line_number
-      start_line = analysis.start_line_number
-
-      # Cop already disabled on this line, so we end the current disabled
-      # range before we start a new range.
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, line)
-    end
-
-    def analyze_rest(analysis, directive)
-      line = directive.line_number
-      start_line = analysis.start_line_number
-
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, nil)
-    end
-
-    def cop_line_ranges(analysis)
-      return analysis.line_ranges unless analysis.start_line_number
-
-      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
-    end
-
-    def each_directive
-      processed_source.comments.each do |comment|
-        directive = DirectiveComment.new(comment)
-        yield directive if directive.cop_names
-      end
-    end
-
-    def qualified_cop_name(cop_name)
-      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
-    end
-
-    def non_comment_token_line_numbers
-      @non_comment_token_line_numbers ||= begin
-        non_comment_tokens = processed_source.tokens.reject(&:comment?)
-        non_comment_tokens.map(&:line).uniq
-      end
-    end
-
-    def handle_enable_all(directive, names, extras)
-      enabled_cops = 0
-      names.each do |name, counter|
-        next unless counter.positive?
-
-        names[name] -= 1
-        enabled_cops += 1
-      end
-
-      extras[directive.comment] << 'all' if enabled_cops.zero?
-    end
-
-    # Collect cops that have been disabled or enabled by name in a directive comment
-    # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
-    def handle_switch(directive, names, extras)
-      directive.cop_names.each do |name|
-        if directive.disabled?
-          names[name] += 1
-        elsif (names[name]).positive?
-          names[name] -= 1
-        else
-          extras[directive.comment] << name
-        end
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/config.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-
-# FIXME: Moving Rails department code to RuboCop Rails will remove
-# the following rubocop:disable comment.
-# rubocop:disable Metrics/ClassLength
-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
-    include PathUtil
-    include FileFinder
-    extend Forwardable
-
-    CopConfig = Struct.new(:name, :metadata)
-
-    DEFAULT_RAILS_VERSION = 5.0
-    attr_reader :loaded_path
-
-    def initialize(hash = {}, loaded_path = nil)
-      @loaded_path = loaded_path
-      @for_cop = Hash.new do |h, cop|
-        qualified_cop_name = Cop::Registry.qualified_cop_name(cop, loaded_path)
-        cop_options = self[qualified_cop_name] || {}
-        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
-        h[cop] = cop_options
-      end
-      @hash = hash
-      @validator = ConfigValidator.new(self)
-    end
-
-    def self.create(hash, path, check: true)
-      config = new(hash, path)
-      config.check if check
-
-      config
-    end
-
-    def loaded_features
-      @loaded_features ||= ConfigLoader.loaded_features
-    end
-
-    def check
-      deprecation_check { |deprecation_message| warn("#{loaded_path} - #{deprecation_message}") }
-      @validator.validate
-      make_excludes_absolute
-      self
-    end
-
-    def_delegators :@hash, :[], :[]=, :delete, :dig, :each, :key?, :keys, :each_key,
-                   :fetch, :map, :merge, :replace, :to_h, :to_hash, :transform_values
-    def_delegators :@validator, :validate, :target_ruby_version
-
-    def to_s
-      @to_s ||= @hash.to_s
-    end
-
-    def signature
-      @signature ||= Digest::SHA1.hexdigest(to_s)
-    end
-
-    # True if this is a config file that is shipped with RuboCop
-    def internal?
-      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME, 'config'))
-      File.expand_path(loaded_path).start_with?(base_config_path)
-    end
-
-    def make_excludes_absolute
-      each_key do |key|
-        @validator.validate_section_presence(key)
-        next unless self[key]['Exclude']
-
-        self[key]['Exclude'].map! do |exclude_elem|
-          if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
-            File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
-          else
-            exclude_elem
-          end
-        end
-      end
-    end
-
-    def add_excludes_from_higher_level(highest_config)
-      return unless highest_config.for_all_cops['Exclude']
-
-      excludes = for_all_cops['Exclude'] ||= []
-      highest_config.for_all_cops['Exclude'].each do |path|
-        unless path.is_a?(Regexp) || absolute?(path)
-          path = File.join(File.dirname(highest_config.loaded_path), path)
-        end
-        excludes << path unless excludes.include?(path)
-      end
-    end
-
-    def deprecation_check
-      %w[Exclude Include].each do |key|
-        plural = "#{key}s"
-        next unless for_all_cops[plural]
-
-        for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
-        for_all_cops.delete(plural)
-        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
-      end
-    end
-
-    # @return [Config] for the given cop / cop name.
-    # Note: the 'Enabled' attribute is calculated according to the department's
-    # and 'AllCops' configuration; other attributes are not inherited.
-    def for_cop(cop)
-      @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
-    end
-
-    # @return [Config] for the given cop merged with that of its department (if any)
-    # Note: the 'Enabled' attribute is same as that returned by `for_cop`
-    def for_badge(badge)
-      cop_config = for_cop(badge.to_s)
-      fetch(badge.department.to_s) { return cop_config }.merge(cop_config)
-    end
-
-    # @return [Config] for the given department name.
-    # Note: the 'Enabled' attribute will be present only if specified
-    # at the department's level
-    def for_department(department_name)
-      @for_department ||= Hash.new { |h, dept| h[dept] = self[dept] || {} }
-      @for_department[department_name.to_s]
-    end
-
-    def for_all_cops
-      @for_all_cops ||= self['AllCops'] || {}
-    end
-
-    def disabled_new_cops?
-      for_all_cops['NewCops'] == 'disable'
-    end
-
-    def enabled_new_cops?
-      for_all_cops['NewCops'] == 'enable'
-    end
-
-    def file_to_include?(file)
-      relative_file_path = path_relative_to_config(file)
-
-      # Optimization to quickly decide if the given file is hidden (on the top
-      # level) and cannot be matched by any pattern.
-      is_hidden = relative_file_path.start_with?('.') && !relative_file_path.start_with?('..')
-      return false if is_hidden && !possibly_include_hidden?
-
-      absolute_file_path = File.expand_path(file)
-
-      patterns_to_include.any? do |pattern|
-        if block_given?
-          yield pattern, relative_file_path, absolute_file_path
-        else
-          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
-        end
-      end
-    end
-
-    def allowed_camel_case_file?(file)
-      # Gemspecs are allowed to have dashes because that fits with bundler best
-      # practices in the case when the gem is nested under a namespace (e.g.,
-      # `bundler-console` conveys `Bundler::Console`).
-      return true if File.extname(file) == '.gemspec'
-
-      file_to_include?(file) do |pattern, relative_path, absolute_path|
-        /[A-Z]/.match?(pattern.to_s) &&
-          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
-      end
-    end
-
-    # Returns true if there's a chance that an Include pattern matches hidden
-    # files, false if that's definitely not possible.
-    def possibly_include_hidden?
-      return @possibly_include_hidden if defined?(@possibly_include_hidden)
-
-      @possibly_include_hidden = patterns_to_include.any? do |s|
-        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
-      end
-    end
-
-    def file_to_exclude?(file)
-      file = File.expand_path(file)
-      patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
-    end
-
-    def patterns_to_include
-      for_all_cops['Include'] || []
-    end
-
-    def patterns_to_exclude
-      for_all_cops['Exclude'] || []
-    end
-
-    def path_relative_to_config(path)
-      relative_path(path, base_dir_for_path_parameters)
-    end
-
-    # Paths specified in configuration files starting with .rubocop 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
-      @base_dir_for_path_parameters ||=
-        if File.basename(loaded_path).start_with?('.rubocop') &&
-           loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
-          File.expand_path(File.dirname(loaded_path))
-        else
-          Dir.pwd
-        end
-    end
-
-    def target_rails_version
-      @target_rails_version ||=
-        if for_all_cops['TargetRailsVersion']
-          for_all_cops['TargetRailsVersion'].to_f
-        elsif target_rails_version_from_bundler_lock_file
-          target_rails_version_from_bundler_lock_file
-        else
-          DEFAULT_RAILS_VERSION
-        end
-    end
-
-    def smart_loaded_path
-      PathUtil.smart_path(@loaded_path)
-    end
-
-    def bundler_lock_file_path
-      return nil unless loaded_path
-
-      base_path = base_dir_for_path_parameters
-      ['gems.locked', 'Gemfile.lock'].each do |file_name|
-        path = find_file_upwards(file_name, base_path)
-        return path if path
-      end
-      nil
-    end
-
-    def pending_cops
-      keys.each_with_object([]) do |qualified_cop_name, pending_cops|
-        department = department_of(qualified_cop_name)
-        next if department && department['Enabled'] == false
-
-        cop_metadata = self[qualified_cop_name]
-        next unless cop_metadata['Enabled'] == 'pending'
-
-        pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
-      end
-    end
-
-    private
-
-    def target_rails_version_from_bundler_lock_file
-      @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
-    end
-
-    def read_rails_version_from_bundler_lock_file
-      lock_file_path = bundler_lock_file_path
-      return nil unless lock_file_path
-
-      File.foreach(lock_file_path) do |line|
-        # If rails is in Gemfile.lock or gems.lock, there should be a line like:
-        #         rails (X.X.X)
-        result = line.match(/^\s+rails\s+\((\d+\.\d+)/)
-        return result.captures.first.to_f if result
-      end
-    end
-
-    def enable_cop?(qualified_cop_name, cop_options)
-      # If the cop is explicitly enabled, the other checks can be skipped.
-      return true if cop_options['Enabled'] == true
-
-      department = department_of(qualified_cop_name)
-      cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
-      return true if cop_enabled == 'override_department'
-      return false if department && department['Enabled'] == false
-
-      cop_enabled
-    end
-
-    def department_of(qualified_cop_name)
-      *cop_department, _ = qualified_cop_name.split('/')
-      return nil if cop_department.empty?
-
-      self[cop_department.join('/')]
-    end
-  end
-end
-# rubocop:enable Metrics/ClassLength