reek 2.1.0 → 2.2.0

data/lib/reek/cli/reek_command.rb

@@ -1,5 +1,5 @@
 require_relative 'command'
-require_relative '../examiner'
+require_relative '../core/examiner'
 
 module Reek
   module CLI
@@ -10,7 +10,7 @@ module Reek
     class ReekCommand < Command
       def execute(app)
         @options.sources.each do |source|
-          reporter.add_examiner Examiner.new(source, smell_names)
+          reporter.add_examiner Core::Examiner.new(source, smell_names)
         end
         reporter.smells? ? app.report_smells : app.report_success
         reporter.show

data/lib/reek/cli/report/report.rb

@@ -126,6 +126,66 @@ module Reek
           print("Html file saved\n")
         end
       end
+
+      #
+      # Generates a list of smells in XML format
+      #
+      class XMLReport < Base
+        require 'rexml/document'
+
+        def initialize(options = {})
+          super options
+        end
+
+        def show
+          checkstyle = REXML::Element.new('checkstyle', document)
+
+          smells.group_by(&:source).each do |file, file_smells|
+            file_to_xml(file, file_smells, checkstyle)
+          end
+
+          print_xml(checkstyle.parent)
+        end
+
+        private
+
+        def document
+          REXML::Document.new.tap do |doc|
+            doc << REXML::XMLDecl.new
+          end
+        end
+
+        def file_to_xml(file, file_smells, parent)
+          REXML::Element.new('file', parent).tap do |element|
+            element.attributes['name'] = File.realpath(file)
+            smells_to_xml(file_smells, element)
+          end
+        end
+
+        def smells_to_xml(smells, parent)
+          smells.each do |smell|
+            smell_to_xml(smell, parent)
+          end
+        end
+
+        def smell_to_xml(smell, parent)
+          REXML::Element.new('error', parent).tap do |element|
+            attributes = [
+              ['line', smell.lines.first],
+              ['column', 0],
+              ['severity', 'warning'],
+              ['message', smell.message],
+              ['source', smell.smell_type]
+            ]
+            element.add_attributes(attributes)
+          end
+        end
+
+        def print_xml(document)
+          formatter = REXML::Formatters::Default.new
+          puts formatter.write(document, '')
+        end
+      end
     end
   end
 end

data/lib/reek/cli/silencer.rb

@@ -0,0 +1,13 @@
+module Reek
+  module CLI
+    # CLI silencer
+    module Silencer
+      def self.silently
+        old_verbose, $VERBOSE = $VERBOSE, nil
+        yield if block_given?
+      ensure
+        $VERBOSE = old_verbose
+      end
+    end
+  end
+end

data/lib/reek/{source → core}/ast_node.rb

@@ -1,7 +1,7 @@
 require 'parser'
 
 module Reek
-  module Source
+  module Core
     # Base class for AST nodes extended with utility methods. Contains some
     # methods to ease the transition from Sexp to AST::Node.
     class ASTNode < Parser::AST::Node

data/lib/reek/{source → core}/ast_node_class_map.rb

@@ -1,9 +1,9 @@
 require_relative 'ast_node'
-require_relative 'sexp_node'
-require_relative 'sexp_extensions'
+require_relative '../sexp/sexp_node'
+require_relative '../sexp/sexp_extensions'
 
 module Reek
-  module Source
+  module Core
     # Maps AST node types to sublasses of ASTNode extended with the relevant
     # utility modules.
     class ASTNodeClassMap
@@ -12,21 +12,20 @@ module Reek
       end
 
       def klass_for(type)
-        @klass_map[type] ||=
-          begin
-            klass = Class.new(ASTNode)
-            klass.send :include, extension_map[type] if extension_map[type]
-            klass.send :include, SexpNode
-          end
+        @klass_map[type] ||= Class.new(ASTNode).tap do |klass|
+          extension = extension_map[type]
+          klass.send :include, extension if extension
+          klass.send :include, Sexp::SexpNode
+        end
       end
 
       def extension_map
         @extension_map ||=
           begin
-            assoc = SexpExtensions.constants.map do |const|
+            assoc = Sexp::SexpExtensions.constants.map do |const|
               [
                 const.to_s.sub(/Node$/, '').downcase.to_sym,
-                SexpExtensions.const_get(const)
+                Sexp::SexpExtensions.const_get(const)
               ]
             end
             Hash[assoc]

data/lib/reek/{source → core}/code_comment.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 
 module Reek
-  module Source
+  module Core
     #
     # A comment header from an abstract syntax tree; found directly above
     # module, class and method definitions.

data/lib/reek/core/code_context.rb

@@ -97,7 +97,7 @@ module Reek
 
       def config
         @config ||= if @exp
-                      Source::CodeComment.new(@exp.comments || '').config
+                      Core::CodeComment.new(@exp.comments || '').config
                     else
                       {}
                     end

data/lib/reek/core/examiner.rb

@@ -0,0 +1,85 @@
+# NOTE: tree_walker is required first to ensure unparser is required before
+# parser. This prevents a potentially incompatible version of parser from being
+# loaded first. This is only relevant when running bin/reek straight from a
+# checkout directory without using Bundler.
+#
+# See also https://github.com/troessner/reek/pull/468
+require_relative 'tree_walker'
+require_relative 'smell_repository'
+require_relative 'warning_collector'
+require_relative '../source/source_repository'
+
+module Reek
+  module Core
+    #
+    # Applies all available smell detectors to a source.
+    #
+    class Examiner
+      #
+      # A simple description of the source being analysed for smells.
+      # If the source is a single File, this will be the file's path.
+      #
+      attr_accessor :description
+
+      #
+      # Creates an Examiner which scans the given +source+ for code smells.
+      #
+      # @param source [Source::SourceCode, Array<String>, #to_reek_source]
+      #   If +source+ is a String it is assumed to be Ruby source code;
+      #   if it is a File, the file is opened and parsed for Ruby source code;
+      #   and if it is an Array, it is assumed to be a list of file paths,
+      #   each of which is opened and parsed for source code.
+      #
+      def initialize(source, smell_types_to_filter_by = [])
+        @sources      = Source::SourceRepository.parse(source)
+        @description  = @sources.description
+        @collector    = Core::WarningCollector.new
+        @smell_types  = eligible_smell_types(smell_types_to_filter_by)
+
+        run
+      end
+
+      #
+      # @return [Array<SmellWarning>] the smells found in the source
+      #
+      def smells
+        @smells ||= @collector.warnings
+      end
+
+      #
+      # @return [Integer] the number of smells found in the source
+      #
+      def smells_count
+        smells.length
+      end
+
+      #
+      # @return [Boolean] true if and only if there are code smells in the source.
+      #
+      def smelly?
+        !smells.empty?
+      end
+
+      private
+
+      def run
+        @sources.each do |source|
+          smell_repository = Core::SmellRepository.new(source.description, @smell_types)
+          syntax_tree = source.syntax_tree
+          Core::TreeWalker.new(smell_repository).process(syntax_tree) if syntax_tree
+          smell_repository.report_on(@collector)
+        end
+      end
+
+      def eligible_smell_types(smell_types_to_filter_by = [])
+        if smell_types_to_filter_by.any?
+          Core::SmellRepository.smell_types.select do |klass|
+            smell_types_to_filter_by.include? klass.smell_type
+          end
+        else
+          Core::SmellRepository.smell_types
+        end
+      end
+    end
+  end
+end

data/lib/reek/core/method_context.rb

@@ -25,7 +25,7 @@ module Reek
       attr_reader :num_statements
 
       def initialize(outer, exp)
-        super(outer, exp)
+        super
         @parameters = exp.parameters.dup
         @parameters.extend MethodParameters
         @num_statements = 0

data/lib/reek/core/module_context.rb

@@ -1,5 +1,5 @@
 require_relative 'code_context'
-require_relative '../source/sexp_formatter'
+require_relative '../sexp/sexp_formatter'
 
 module Reek
   module Core
@@ -9,7 +9,7 @@ module Reek
     class ModuleContext < CodeContext
       def initialize(outer, exp)
         super(outer, exp)
-        @name = Source::SexpFormatter.format(exp.children.first)
+        @name = Sexp::SexpFormatter.format(exp.children.first)
       end
 
       def node_instance_methods

data/lib/reek/core/reference_collector.rb

@@ -0,0 +1,31 @@
+module Reek
+  module Core
+    #
+    # Locates references to the current object within a portion
+    # of an abstract syntax tree.
+    #
+    class ReferenceCollector
+      STOP_NODES = [:class, :module, :def, :defs]
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def num_refs_to_self
+        (explicit_self_calls + implicit_self_calls).size
+      end
+
+      private
+
+      def explicit_self_calls
+        [:self, :zsuper, :ivar, :ivasgn].flat_map do |node_type|
+          @ast.each_node(node_type, STOP_NODES)
+        end
+      end
+
+      def implicit_self_calls
+        @ast.each_node(:send, STOP_NODES).reject(&:receiver)
+      end
+    end
+  end
+end

data/lib/reek/core/singleton_method_context.rb

@@ -6,10 +6,6 @@ module Reek
     # A context wrapper for any singleton method definition found in a syntax tree.
     #
     class SingletonMethodContext < MethodContext
-      def initialize(outer, exp)
-        super(outer, exp)
-      end
-
       def envious_receivers
         []
       end

data/lib/reek/core/smell_repository.rb

@@ -11,7 +11,7 @@ module Reek
       attr_reader :detectors
 
       def self.smell_types
-        Reek::Smells::SmellDetector.descendants
+        Reek::Smells::SmellDetector.descendants.sort_by(&:name)
       end
 
       def initialize(source_description = nil, smell_types = self.class.smell_types)
@@ -24,7 +24,9 @@ module Reek
       end
 
       def configure(klass, config)
-        @detectors[klass].configure_with(config) if @detectors[klass]
+        detector = @detectors[klass]
+        raise ArgumentError, "Unknown smell type #{klass} found in configuration" unless detector
+        detector.configure_with(config)
       end
 
       def report_on(listener)

data/lib/reek/{source → core}/tree_dresser.rb

@@ -1,7 +1,7 @@
 require_relative 'ast_node_class_map'
 
 module Reek
-  module Source
+  module Core
     #
     # Adorns an abstract syntax tree with mix-in modules to make accessing
     # the tree more understandable and less implementation-dependent.

data/lib/reek/{source → sexp}/sexp_extensions.rb

@@ -1,8 +1,8 @@
 require_relative 'sexp_node'
-require_relative 'reference_collector'
+require_relative '../core/reference_collector'
 
 module Reek
-  module Source
+  module Sexp
     #
     # Extension modules providing utility methods to ASTNode objects, depending
     # on their type.
@@ -242,7 +242,7 @@ module Reek
         end
 
         def depends_on_instance?
-          ReferenceCollector.new(self).num_refs_to_self > 0
+          Core::ReferenceCollector.new(self).num_refs_to_self > 0
         end
       end
 
@@ -259,7 +259,7 @@ module Reek
         include MethodNodeBase
         def full_name(outer)
           prefix = outer == '' ? '' : "#{outer}#"
-          "#{prefix}#{SexpNode.format(receiver)}.#{name}"
+          "#{prefix}#{SexpFormatter.format(receiver)}.#{name}"
         end
 
         def depends_on_instance?
@@ -314,7 +314,7 @@ module Reek
         end
 
         def text_name
-          SexpNode.format(name)
+          SexpFormatter.format(name)
         end
       end
 

data/lib/reek/sexp/sexp_formatter.rb

@@ -0,0 +1,29 @@
+require_relative '../cli/silencer'
+Reek::CLI::Silencer.silently do
+  require 'unparser'
+end
+
+module Reek
+  module Sexp
+    #
+    # Formats snippets of syntax tree back into Ruby source code.
+    #
+    # :reek:DuplicateMethodCall { max_calls: 2 } is ok for lines.first
+    class SexpFormatter
+      # Formats the given sexp.
+      #
+      # sexp - S-expression of type AST::Node or something that is at least to_s-able.
+      #
+      # Returns a formatted string representation.
+      def self.format(sexp)
+        return sexp.to_s unless sexp.is_a? AST::Node
+        lines = Unparser.unparse(sexp).split "\n"
+        case lines.length
+        when 1 then lines.first
+        when 2 then lines.join('; ')
+        else [lines.first, lines.last].join(' ... ')
+        end
+      end
+    end
+  end
+end

data/lib/reek/sexp/sexp_node.rb

@@ -0,0 +1,91 @@
+module Reek
+  module Sexp
+    #
+    # Extensions to +Sexp+ to allow +TreeWalker+ to navigate the abstract
+    # syntax tree more easily.
+    #
+    module SexpNode
+      #
+      # Carries out a depth-first traversal of this syntax tree, yielding
+      # every Sexp of type `target_type`. The traversal ignores any node
+      # whose type is listed in the Array `ignoring`.
+      # Takes a block as well.
+      #
+      # target_type - the type to look for, e.g. :send, :block
+      # ignoring - types to ignore, e.g. [:casgn, :class, :module]
+      # blk - block to execute for every hit
+      #
+      # Examples:
+      #   context.each_node(:send, [:mlhs]) do |call_node| .... end
+      #   context.each_node(:lvar).any? { |it| it.var_name == 'something' }
+      #
+      # Returns an array with all matching nodes.
+      def each_node(target_type, ignoring = [], &blk)
+        if block_given?
+          look_for_type(target_type, ignoring, &blk)
+        else
+          result = []
+          look_for_type(target_type, ignoring) { |exp| result << exp }
+          result
+        end
+      end
+
+      #
+      # Carries out a depth-first traversal of this syntax tree, yielding
+      # every Sexp of type `target_type`. The traversal ignores any node
+      # whose type is listed in the Array `ignoring`, including the top node.
+      # Takes a block as well.
+      #
+      # target_types - the types to look for, e.g. [:send, :block]
+      # ignoring - types to ignore, e.g. [:casgn, :class, :module]
+      # blk - block to execute for every hit
+      #
+      # Examples:
+      #   exp.find_nodes([:block]).flat_map do |elem| ... end
+      #
+      # Returns an array with all matching nodes.
+      def find_nodes(target_types, ignoring = [])
+        result = []
+        look_for_types(target_types, ignoring) { |exp| result << exp }
+        result
+      end
+
+      def contains_nested_node?(target_type)
+        look_for_type(target_type) { |_elem| return true }
+        false
+      end
+
+      def format_to_ruby
+        SexpFormatter.format(self)
+      end
+
+      protected
+
+      # See ".each_node" for documentation.
+      def look_for_type(target_type, ignoring = [], &blk)
+        each_sexp do |elem|
+          elem.look_for_type(target_type, ignoring, &blk) unless ignoring.include?(elem.type)
+        end
+        blk.call(self) if type == target_type
+      end
+
+      # See ".find_nodes" for documentation.
+      def look_for_types(target_types, ignoring = [], &blk)
+        return if ignoring.include?(type)
+        if target_types.include? type
+          blk.call(self)
+        else
+          each_sexp do |elem|
+            elem.look_for_types(target_types, ignoring, &blk)
+          end
+        end
+      end
+
+      private
+
+      def each_sexp
+        children.each { |elem| yield elem if elem.is_a? AST::Node }
+      end
+    end
+  end
+end