improve_your_code 1.0.0

data/lib/improve_your_code/smell_detectors/uncommunicative_variable_name.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class UncommunicativeVariableName < BaseDetector
+      REJECT_KEY = 'reject'
+      DEFAULT_REJECT_SET = [
+        /^.$/, # single-character names
+        /[0-9]$/,  # any name ending with a number
+        /[A-Z]/    # camelCaseVariableNames
+      ].freeze
+      ACCEPT_KEY = 'accept'
+      DEFAULT_ACCEPT_SET = [/^_$/].freeze
+
+      def self.default_config
+        super.merge(
+          REJECT_KEY => DEFAULT_REJECT_SET,
+          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts
+        %i[module class def defs]
+      end
+
+      def sniff
+        variable_names.select do |name, _lines|
+          uncommunicative_variable_name?(name)
+        end.map do |name, lines|
+          smell_warning(
+            context: context,
+            lines: lines,
+            message: "has the variable name '#{name}'",
+            parameters: { name: name.to_s }
+          )
+        end
+      end
+
+      private
+
+      def reject_names
+        @reject_names ||= value(REJECT_KEY, context)
+      end
+
+      def accept_names
+        @accept_names ||= value(ACCEPT_KEY, context)
+      end
+
+      def uncommunicative_variable_name?(name)
+        sanitized_name = name.to_s.gsub(/^[@\*\&]*/, '')
+        !acceptable_name?(sanitized_name)
+      end
+
+      def acceptable_name?(name)
+        any_accept_names?(name) || any_reject_names?(name)
+      end
+
+      def any_accept_names?(name)
+        Array(accept_names).any? { |accept_pattern| name.match accept_pattern }
+      end
+
+      def any_reject_names?(name)
+        Array(reject_names).none? { |reject_pattern| name.match reject_pattern }
+      end
+
+      def variable_names
+        result = Hash.new { |hash, key| hash[key] = [] }
+
+        find_assignment_variable_names(result)
+        find_block_argument_variable_names(result)
+
+        result
+      end
+
+      def find_assignment_variable_names(accumulator)
+        assignment_nodes = expression.each_node(
+          :lvasgn, %i[class module defs def]
+        )
+
+        case expression.type
+        when :class, :module
+          assignment_nodes += expression.each_node(:ivasgn, %i[class module])
+        end
+
+        assignment_nodes.each do |asgn|
+          accumulator[asgn.children.first].push(asgn.line)
+        end
+      end
+
+      def find_block_argument_variable_names(accumulator)
+        arg_search_exp = case expression.type
+                         when :class, :module
+                           expression
+                         when :defs, :def
+                           expression.body
+                         end
+
+        return unless arg_search_exp
+
+        args_nodes = arg_search_exp
+          .each_node(:args, %i[class module defs def])
+
+        args_nodes.each do |args_node|
+          recursively_record_variable_names(accumulator, args_node)
+        end
+      end
+
+      def recursively_record_variable_names(accumulator, exp)
+        exp.children.each do |subexp|
+          case subexp.type
+          when :mlhs
+            recursively_record_variable_names(accumulator, subexp)
+          else
+            record_variable_name(exp, subexp.name, accumulator)
+          end
+        end
+      end
+
+      def record_variable_name(exp, symbol, accumulator)
+        varname = symbol.to_s.sub(/^\*/, '')
+        return if varname == ''
+        var = varname.to_sym
+        accumulator[var].push(exp.line)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/unused_parameters.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class UnusedParameters < BaseDetector
+      def sniff
+        return [] if context.uses_super_with_implicit_arguments?
+
+        context.unused_params.map do |param|
+          name = param.name.to_s
+
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: "has unused parameter '#{name}'",
+            parameters: { name: name }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/unused_private_method.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class UnusedPrivateMethod < BaseDetector
+      def self.default_config
+        super.merge(SmellConfiguration::ENABLED_KEY => false)
+      end
+
+      class Hit
+        attr_reader :name, :line
+
+        def initialize(context)
+          @name  = context.name
+          @line  = context.exp.line
+        end
+      end
+
+      def self.contexts
+        [:class]
+      end
+
+      def sniff
+        hits.map do |hit|
+          name = hit.name
+
+          smell_warning(
+            context: context,
+            lines: [hit.line],
+            message: "has the unused private instance method '#{name}'",
+            parameters: { name: name.to_s }
+          )
+        end
+      end
+
+      private
+
+      def hits
+        unused_private_methods.map do |defined_method|
+          Hit.new(defined_method) unless ignore_method?(defined_method)
+        end.compact
+      end
+
+      def unused_private_methods
+        defined_private_methods.reject do |defined_method|
+          called_method_names.include?(defined_method.name)
+        end
+      end
+
+      def defined_private_methods
+        context.defined_instance_methods(visibility: :private)
+      end
+
+      def called_method_names
+        context.instance_method_calls.map(&:name)
+      end
+
+      def ignore_method?(method)
+        ignore_contexts = value(EXCLUDE_KEY, context)
+        ignore_contexts.any? do |ignore_context|
+          full_name = "#{method.parent.full_name}##{method.name}"
+          full_name[ignore_context]
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_warning.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module ImproveYourCode
+  class SmellWarning
+    include Comparable
+    extend Forwardable
+
+    attr_reader :context, :lines, :message, :parameters, :smell_detector, :source
+    def_delegators :smell_detector, :smell_type
+
+    def initialize(smell_detector, context: '', lines:, message:,
+                   source:, parameters: {})
+      @smell_detector = smell_detector
+      @source         = source
+      @context        = context.to_s
+      @lines          = lines
+      @message        = message
+      @parameters     = parameters
+
+      freeze
+    end
+
+    def hash
+      identifying_values.hash
+    end
+
+    def <=>(other)
+      identifying_values <=> other.identifying_values
+    end
+
+    def eql?(other)
+      (self <=> other).zero?
+    end
+
+    def to_hash
+      stringified_params = Hash[parameters.map { |key, val| [key.to_s, val] }]
+      base_hash.merge(stringified_params)
+    end
+
+    alias yaml_hash to_hash
+
+    def base_message
+      "#{smell_type}: #{context} #{message}"
+    end
+
+    def smell_class
+      smell_detector.class
+    end
+
+    protected
+
+    def identifying_values
+      [smell_type, context, message, lines]
+    end
+
+    private
+
+    def base_hash
+      {
+        'context'        => context,
+        'lines'          => lines,
+        'message'        => message,
+        'smell_type'     => smell_type,
+        'source'         => source
+      }
+    end
+  end
+end

data/lib/improve_your_code/source/source_code.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../cli/silencer'
+ImproveYourCode::CLI::Silencer.silently do
+  require 'parser/ruby24'
+end
+require_relative '../tree_dresser'
+require_relative '../ast/node'
+require_relative '../ast/builder'
+
+ImproveYourCode::AST::Builder.emit_lambda = true
+
+module ImproveYourCode
+  module Source
+    class SourceCode
+      IO_IDENTIFIER     = 'STDIN'
+      STRING_IDENTIFIER = 'string'
+
+      attr_reader :origin
+
+      def initialize(code:, origin:, parser: default_parser)
+        @origin = origin
+        @diagnostics = []
+        @parser = parser
+        @code = code
+      end
+
+      def self.from(source)
+        case source
+        when File then new(code: source.read, origin: source.path)
+        when IO then new(code: source.readlines.join, origin: IO_IDENTIFIER)
+        when Pathname then new(code: source.read, origin: source.to_s)
+        when String then new(code: source, origin: STRING_IDENTIFIER)
+        end
+      end
+
+      def valid_syntax?
+        diagnostics.none? do |diagnostic|
+          %i[error fatal].include?(diagnostic.level)
+        end
+      end
+
+      def diagnostics
+        parse_if_needed
+
+        @diagnostics
+      end
+
+      def syntax_tree
+        parse_if_needed
+      end
+
+      private
+
+      def parse_if_needed
+        @syntax_tree ||= parse(@parser, @code)
+      end
+
+      attr_reader :source
+
+      def parse(parser, source)
+        buffer = Parser::Source::Buffer.new(origin, 1)
+        source.force_encoding(Encoding::UTF_8)
+        buffer.source = source
+        ast, comments = parser.parse_with_comments(buffer)
+
+        comment_map = Parser::Source::Comment.associate(ast, comments) if ast
+
+        TreeDresser.new.dress(ast, comment_map)
+      end
+
+      def default_parser
+        Parser::Ruby24.new(AST::Builder.new).tap do |parser|
+          diagnostics = parser.diagnostics
+          diagnostics.all_errors_are_fatal = false
+          diagnostics.ignore_warnings      = false
+          diagnostics.consumer = lambda do |diagnostic|
+            @diagnostics << diagnostic
+          end
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/source/source_locator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'find'
+require 'pathname'
+
+module ImproveYourCode
+  module Source
+    class SourceLocator
+      def initialize(paths)
+        @paths = paths.flat_map { |string| Pathname.new(string).entries }
+      end
+
+      def sources
+        paths.each_with_object([]) do |given_path, relevant_paths|
+          given_path.find do |path|
+            if path.directory?
+              ignore_path?(path) ? Find.prune : next
+            elsif ruby_file?(path)
+              relevant_paths << path
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :paths
+
+      def ignore_path?(path)
+        path.basename.to_s.start_with? '.'
+      end
+
+      def ruby_file?(path)
+        path.extname == '.rb'
+      end
+    end
+  end
+end

data/lib/improve_your_code/tree_dresser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'ast/ast_node_class_map'
+
+module ImproveYourCode
+  class TreeDresser
+    def initialize(klass_map: AST::ASTNodeClassMap.new)
+      @klass_map = klass_map
+    end
+
+    def dress(sexp, comment_map)
+      return sexp unless sexp.is_a? ::Parser::AST::Node
+
+      type = sexp.type
+      children = sexp.children.map { |child| dress(child, comment_map) }
+      comments = comment_map[sexp]
+
+      klass_map.klass_for(type).new(type, children, location: sexp.loc, comments: comments)
+    end
+
+    private
+
+    attr_reader :klass_map
+  end
+end
+
+
+['const',
+'class',
+'module',
+'args',
+'cbase',
+'sym',
+'send',
+'pair',
+'hash',
+'lvasgn',
+'lvar',
+'begin',
+'def',
+'str',
+'optarg',
+'arg',
+'return',
+'and',
+'if',
+'array',
+'casgn',
+'block',
+'int',
+'self',
+'true',
+'false',
+'dstr',
+'block_pass',
+'kwarg',
+'resbody',
+'rescue',
+'sclass',
+'nil',
+'ivasgn',
+'or_asgn',
+'regopt',
+'regexp',
+'csend',
+'kwbegin',
+'or',
+'kwoptarg',
+'splat',
+'float',
+'op_asgn',
+'kwsplat',
+'defs'
+]