rubbycop 0.49.0

data/lib/rubbycop/string_interpreter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # Take a string with embedded escapes, and convert the escapes as the Ruby
+  # interpreter would when reading a double-quoted string literal.
+  # For example, "\\n" will be converted to "\n".
+  class StringInterpreter
+    STRING_ESCAPES = {
+      '\a' => "\a", '\b' => "\b", '\e' => "\e", '\f' => "\f", '\n' => "\n",
+      '\r' => "\r", '\s' => ' ',  '\t' => "\t", '\v' => "\v", "\\\n" => ''
+    }.freeze
+    STRING_ESCAPE_REGEX = /\\(?:
+                            [abefnrstv\n]     |   # simple escapes (above)
+                            \d{1,3}           |   # octal byte escape
+                            x[0-9a-fA-F]{1,2} |   # hex byte escape
+                            u[0-9a-fA-F]{4}   |   # unicode char escape
+                            u\{[^}]*\}        |   # extended unicode escape
+                            .                     # any other escaped char
+                          )/x
+    class << self
+      def interpret(string)
+        # We currently don't handle \cx, \C-x, and \M-x
+        string.gsub(STRING_ESCAPE_REGEX) do |escape|
+          STRING_ESCAPES[escape] || interpret_string_escape(escape)
+        end
+      end
+
+      private
+
+      def interpret_string_escape(escape)
+        case escape[1]
+        when 'u'.freeze then interpret_unicode(escape)
+        when 'x'.freeze then interpret_hex(escape)
+        when /\d/       then interpret_octal(escape)
+        else
+          escape[1] # literal escaped char, like \\
+        end
+      end
+
+      def interpret_unicode(escape)
+        if escape[2] == '{'.freeze
+          escape[3..-1].split(/\s+/).map(&:hex).pack('U*'.freeze)
+        else
+          [escape[2..-1].hex].pack('U'.freeze)
+        end
+      end
+
+      def interpret_hex(escape)
+        [escape[2..-1].hex].pack('C'.freeze)
+      end
+
+      def interpret_octal(escape)
+        [escape[1..-1].to_i(8)].pack('C'.freeze)
+      end
+    end
+  end
+end

data/lib/rubbycop/string_util.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # This module provides approximate string matching methods.
+  module StringUtil
+    module_function
+
+    def similarity(string_a, string_b)
+      JaroWinkler.distance(string_a.to_s, string_b.to_s)
+    end
+
+    # This class computes Jaro distance, which is a measure of similarity
+    # between two strings.
+    class Jaro
+      attr_reader :shorter, :longer
+
+      def self.distance(*args)
+        new(*args).distance
+      end
+
+      def initialize(a, b)
+        if a.size < b.size
+          @shorter = a
+          @longer = b
+        else
+          @shorter = b
+          @longer = a
+        end
+      end
+
+      def distance
+        @distance ||= compute_distance
+      end
+
+      private
+
+      def compute_distance
+        common_chars_a, common_chars_b = find_common_characters
+        matched_count = common_chars_a.size
+
+        return 0.0 if matched_count.zero?
+
+        transposition_count =
+          count_transpositions(common_chars_a, common_chars_b)
+
+        compute_non_zero_distance(matched_count.to_f, transposition_count)
+      end
+
+      def find_common_characters
+        common_chars_of_shorter = Array.new(shorter.size)
+        common_chars_of_longer = Array.new(longer.size)
+
+        shorter.each_char.with_index do |shorter_char, shorter_index|
+          matching_index_range(shorter_index).each do |longer_index|
+            longer_char = longer.chars[longer_index]
+
+            next unless shorter_char == longer_char
+
+            common_chars_of_shorter[shorter_index] = shorter_char
+            common_chars_of_longer[longer_index] = longer_char
+
+            # Mark the matching character as already used
+            longer.chars[longer_index] = nil
+
+            break
+          end
+        end
+
+        [common_chars_of_shorter, common_chars_of_longer].map(&:compact)
+      end
+
+      def count_transpositions(common_chars_a, common_chars_b)
+        common_chars_a.size.times.count do |index|
+          common_chars_a[index] != common_chars_b[index]
+        end
+      end
+
+      def compute_non_zero_distance(matched_count, transposition_count)
+        sum = (matched_count / shorter.size.to_f) +
+              (matched_count / longer.size.to_f) +
+              ((matched_count - transposition_count / 2) / matched_count)
+
+        sum / 3.0
+      end
+
+      def matching_index_range(origin)
+        min = origin - matching_window
+        min = 0 if min < 0
+
+        max = origin + matching_window
+
+        min..max
+      end
+
+      def matching_window
+        @matching_window ||= (longer.size / 2).to_i - 1
+      end
+    end
+
+    # This class computes Jaro-Winkler distance, which adds prefix-matching
+    # bonus to Jaro distance.
+    class JaroWinkler < Jaro
+      # Add the prefix bonus only when the Jaro distance is above this value.
+      # In other words, if the Jaro distance is less than this value,
+      # JaroWinkler.distance returns the raw Jaro distance.
+      DEFAULT_BOOST_THRESHOLD = 0.7
+
+      # How much the prefix bonus is weighted.
+      # This should not exceed 0.25.
+      DEFAULT_SCALING_FACTOR = 0.1
+
+      # Cutoff the common prefix length to this value if it's longer than this.
+      MAX_COMMON_PREFIX_LENGTH = 4
+
+      attr_reader :boost_threshold, :scaling_factor
+
+      def initialize(a, b, boost_threshold = nil, scaling_factor = nil)
+        super(a, b)
+        @boost_threshold = boost_threshold || DEFAULT_BOOST_THRESHOLD
+        @scaling_factor = scaling_factor || DEFAULT_SCALING_FACTOR
+      end
+
+      private
+
+      def compute_distance
+        jaro_distance = super
+
+        if jaro_distance >= boost_threshold
+          bonus = limited_common_prefix_length.to_f * scaling_factor.to_f *
+                  (1.0 - jaro_distance)
+          jaro_distance + bonus
+        else
+          jaro_distance
+        end
+      end
+
+      def limited_common_prefix_length
+        length = common_prefix_length
+
+        if length > MAX_COMMON_PREFIX_LENGTH
+          MAX_COMMON_PREFIX_LENGTH
+        else
+          length
+        end
+      end
+
+      def common_prefix_length
+        shorter.size.times do |index|
+          return index unless shorter[index] == longer[index]
+        end
+
+        shorter.size
+      end
+    end
+  end
+end

data/lib/rubbycop/target_finder.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RubbyCop
+  RUBY_EXTENSIONS = %w[.rb
+                       .builder
+                       .fcgi
+                       .gemspec
+                       .god
+                       .jbuilder
+                       .mspec
+                       .opal
+                       .pluginspec
+                       .podspec
+                       .rabl
+                       .rake
+                       .rbuild
+                       .rbw
+                       .rbx
+                       .ru
+                       .ruby
+                       .spec
+                       .thor
+                       .watchr].freeze
+
+  RUBY_INTERPRETERS = %w[ruby
+                         macruby
+                         rake
+                         jruby
+                         rbx].freeze
+
+  RUBY_FILENAMES = %w[.irbrc
+                      .pryrc
+                      Appraisals
+                      Berksfile
+                      Brewfile
+                      Buildfile
+                      Capfile
+                      Cheffile
+                      Dangerfile
+                      Deliverfile
+                      Fastfile
+                      Gemfile
+                      Guardfile
+                      Jarfile
+                      Mavenfile
+                      Podfile
+                      Puppetfile
+                      Rakefile
+                      Snapfile
+                      Thorfile
+                      Vagabondfile
+                      Vagrantfile
+                      buildfile].freeze
+
+  # This class finds target files to inspect by scanning the directory tree
+  # and picking ruby files.
+  class TargetFinder
+    def initialize(config_store, options = {})
+      @config_store = config_store
+      @options = options
+    end
+
+    def force_exclusion?
+      @options[:force_exclusion]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
+
+    # Generate a list of target files by expanding globbing patterns
+    # (if any). If args is empty, recursively find all Ruby source
+    # files under the current directory
+    # @return [Array] array of file paths
+    def find(args)
+      return target_files_in_dir if args.empty?
+
+      files = []
+
+      args.uniq.each do |arg|
+        files += if File.directory?(arg)
+                   target_files_in_dir(arg.chomp(File::SEPARATOR))
+                 else
+                   process_explicit_path(arg)
+                 end
+      end
+
+      files.map { |f| File.expand_path(f) }.uniq
+    end
+
+    # Finds all Ruby source files under the current or other supplied
+    # directory. A Ruby source file is defined as a file with the `.rb`
+    # extension or a file with no extension that has a ruby shebang line
+    # as its first line.
+    # It is possible to specify includes and excludes using the config file,
+    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # @param base_dir Root directory under which to search for
+    #   ruby source files
+    # @return [Array] Array of filenames
+    def target_files_in_dir(base_dir = Dir.pwd)
+      # Support Windows: Backslashes from command-line -> forward slashes
+      if File::ALT_SEPARATOR
+        base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
+      end
+      all_files = find_files(base_dir, File::FNM_DOTMATCH)
+      hidden_files = Set.new(all_files - find_files(base_dir, 0))
+      base_dir_config = @config_store.for(base_dir)
+
+      target_files = all_files.select do |file|
+        to_inspect?(file, hidden_files, base_dir_config)
+      end
+
+      # Most recently modified file first.
+      target_files.sort_by! { |path| -File.mtime(path).to_i } if fail_fast?
+
+      target_files
+    end
+
+    def to_inspect?(file, hidden_files, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_files.include?(file) && ruby_file?(file)
+      base_dir_config.file_to_include?(file)
+    end
+
+    # Search for files recursively starting at the given base directory using
+    # the given flags that determine how the match is made. Excluded files will
+    # be removed later by the caller, but as an optimization find_files removes
+    # the top level directories that are excluded in configuration in the
+    # normal way (dir/**/*).
+    def find_files(base_dir, flags)
+      wanted_toplevel_dirs = toplevel_dirs(base_dir, flags) -
+                             excluded_dirs(base_dir)
+      wanted_toplevel_dirs.map! { |dir| dir << '/**/*' }
+
+      pattern = if wanted_toplevel_dirs.empty?
+                  # We need this special case to avoid creating the pattern
+                  # /**/* which searches the entire file system.
+                  ["#{base_dir}/**/*"]
+                else
+                  # Search the non-excluded top directories, but also add files
+                  # on the top level, which would otherwise not be found.
+                  wanted_toplevel_dirs.unshift("#{base_dir}/*")
+                end
+      Dir.glob(pattern, flags).select { |path| FileTest.file?(path) }
+    end
+
+    def toplevel_dirs(base_dir, flags)
+      Dir.glob(File.join(base_dir, '*'), flags).select do |dir|
+        File.directory?(dir) && !dir.end_with?('/.', '/..')
+      end
+    end
+
+    def excluded_dirs(base_dir)
+      all_cops_config = @config_store.for(base_dir).for_all_cops
+      dir_tree_excludes = all_cops_config['Exclude'].select do |pattern|
+        pattern.is_a?(String) && pattern.end_with?('/**/*')
+      end
+      dir_tree_excludes.map { |pattern| pattern.sub(%r{/\*\*/\*$}, '') }
+    end
+
+    def ruby_extension?(file)
+      RUBY_EXTENSIONS.include?(File.extname(file))
+    end
+
+    def ruby_filename?(file)
+      RUBY_FILENAMES.include?(File.basename(file))
+    end
+
+    def ruby_executable?(file)
+      return false unless File.extname(file).empty? && File.exist?(file)
+      first_line = File.open(file, &:readline)
+      !(first_line =~ /#!.*(#{RUBY_INTERPRETERS.join('|')})/).nil?
+    rescue EOFError, ArgumentError => e
+      warn "Unprocessable file #{file}: #{e.class}, #{e.message}" if debug?
+      false
+    end
+
+    def ruby_file?(file)
+      ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
+    end
+
+    def process_explicit_path(path)
+      files = path.include?('*') ? Dir[path] : [path]
+
+      files.select! { |file| ruby_file?(file) }
+
+      return files unless force_exclusion?
+
+      files.reject do |file|
+        config = @config_store.for(file)
+        config.file_to_exclude?(file)
+      end
+    end
+  end
+end

data/lib/rubbycop/token.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # A basic wrapper around Parser's tokens.
+  class Token
+    attr_reader :pos, :type, :text
+
+    def self.from_parser_token(parser_token)
+      type, details = parser_token
+      text, range = details
+      new(range, type, text)
+    end
+
+    def initialize(pos, type, text)
+      @pos = pos
+      @type = type
+      # Parser token "text" may be an Integer
+      @text = text.to_s
+    end
+
+    def to_s
+      "[[#{@pos.line}, #{@pos.column}], #{@type}, #{@text.inspect}]"
+    end
+  end
+end

data/lib/rubbycop/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # This module holds the RubbyCop version information.
+  module Version
+    STRING = '0.49.0'.freeze
+
+    MSG = '%s (using Parser %s, running on %s %s %s)'.freeze
+
+    def self.version(debug = false)
+      if debug
+        format(MSG, STRING, Parser::VERSION,
+               RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM)
+      else
+        STRING
+      end
+    end
+  end
+end