reek 2.2.1 → 3.0.0

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

@@ -1,69 +0,0 @@
-require_relative 'location_formatter'
-
-module Reek
-  module CLI
-    module Report
-      #
-      # Formatter handling the formatting of the report at large.
-      # Formatting of the individual warnings is handled by the
-      # passed-in warning formatter.
-      #
-      module Formatter
-        def self.format_list(warnings, formatter = SimpleWarningFormatter.new)
-          warnings.map do |warning|
-            "  #{formatter.format warning}"
-          end.join("\n")
-        end
-
-        def self.header(examiner)
-          count = examiner.smells_count
-          result = Rainbow("#{examiner.description} -- ").cyan +
-                   Rainbow("#{count} warning").yellow
-          result += Rainbow('s').yellow unless count == 1
-          result
-        end
-      end
-
-      #
-      # Basic formatter that just shows a simple message for each warning,
-      # prepended with the result of the passed-in location formatter.
-      #
-      class SimpleWarningFormatter
-        def initialize(location_formatter = BlankLocationFormatter)
-          @location_formatter = location_formatter
-        end
-
-        def format(warning)
-          "#{@location_formatter.format(warning)}#{base_format(warning)}"
-        end
-
-        private
-
-        def base_format(warning)
-          "#{warning.context} #{warning.message} (#{warning.smell_type})"
-        end
-      end
-
-      #
-      # Formatter that adds a link to the wiki to the basic message from
-      # SimpleWarningFormatter.
-      #
-      class WikiLinkWarningFormatter < SimpleWarningFormatter
-        BASE_URL_FOR_HELP_LINK = 'https://github.com/troessner/reek/wiki/'
-
-        def format(warning)
-          "#{super} " \
-            "[#{explanatory_link(warning)}]"
-        end
-
-        def explanatory_link(warning)
-          "#{BASE_URL_FOR_HELP_LINK}#{class_name_to_param(warning.smell_type)}"
-        end
-
-        def class_name_to_param(name)
-          name.split(/(?=[A-Z])/).join('-')
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Reek
-  module CLI
-    module Report
-      module HeadingFormatter
-        #
-        # Base class for heading formatters.
-        # Is responsible for formatting the heading emitted for each examiner
-        #
-        class Base
-          attr_reader :report_formatter
-
-          def initialize(report_formatter)
-            @report_formatter = report_formatter
-          end
-
-          def header(examiner)
-            if show_header?(examiner)
-              report_formatter.header examiner
-            else
-              ''
-            end
-          end
-        end
-
-        #
-        # Lists out each examiner, even if it has no smell
-        #
-        class Verbose < Base
-          def show_header?(_examiner)
-            true
-          end
-        end
-
-        #
-        # Lists only smelly examiners
-        #
-        class Quiet < Base
-          def show_header?(examiner)
-            examiner.smelly?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Reek
-  module CLI
-    module Report
-      #
-      # Formats the location of a warning as an empty string.
-      #
-      module BlankLocationFormatter
-        def self.format(_warning)
-          ''
-        end
-      end
-
-      #
-      # Formats the location of a warning as an array of line numbers.
-      #
-      module DefaultLocationFormatter
-        def self.format(warning)
-          "#{warning.lines.inspect}:"
-        end
-      end
-
-      #
-      # Formats the location of a warning as a combination of source file name
-      # and line number. In this format, it is not possible to show more than
-      # one line number, so the first number is displayed.
-      #
-      module SingleLineLocationFormatter
-        def self.format(warning)
-          "#{warning.source}:#{warning.lines.first}: "
-        end
-      end
-    end
-  end
-end

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

@@ -1,191 +0,0 @@
-require 'rainbow'
-require 'json'
-
-module Reek
-  module CLI
-    module Report
-      #
-      # A report that contains the smells and smell counts following source code analysis.
-      #
-      class Base
-        DEFAULT_FORMAT = :text
-        NO_WARNINGS_COLOR = :green
-        WARNINGS_COLOR = :red
-
-        def initialize(options = {})
-          @examiners           = []
-          @total_smell_count   = 0
-          @options             = options
-          @warning_formatter   = options.fetch :warning_formatter, SimpleWarningFormatter.new
-          @report_formatter    = options.fetch :report_formatter, Formatter
-          @sort_by_issue_count = options.fetch :sort_by_issue_count, false
-        end
-
-        def add_examiner(examiner)
-          @total_smell_count += examiner.smells_count
-          @examiners << examiner
-          self
-        end
-
-        def smells?
-          @total_smell_count > 0
-        end
-
-        def smells
-          @examiners.map(&:smells).flatten
-        end
-      end
-
-      #
-      # Generates a sorted, text summary of smells in examiners
-      #
-      class TextReport < Base
-        def show
-          sort_examiners if smells?
-          display_summary
-          display_total_smell_count
-        end
-
-        def smells
-          @examiners.each_with_object([]) do |examiner, result|
-            result << summarize_single_examiner(examiner)
-          end
-        end
-
-        private
-
-        def display_summary
-          smells.reject(&:empty?).each { |smell| puts smell }
-        end
-
-        def display_total_smell_count
-          return unless @examiners.size > 1
-          print total_smell_count_message
-        end
-
-        def summarize_single_examiner(examiner)
-          result = heading_formatter.header(examiner)
-          if examiner.smelly?
-            formatted_list = @report_formatter.format_list(examiner.smells,
-                                                           @warning_formatter)
-            result += ":\n#{formatted_list}"
-          end
-          result
-        end
-
-        def sort_examiners
-          @examiners.sort_by!(&:smells_count).reverse! if @sort_by_issue_count
-        end
-
-        def total_smell_count_message
-          colour = smells? ? WARNINGS_COLOR : NO_WARNINGS_COLOR
-          s = @total_smell_count == 1 ? '' : 's'
-          Rainbow("#{@total_smell_count} total warning#{s}\n").color(colour)
-        end
-
-        def heading_formatter
-          @heading_formatter ||=
-            @options.fetch(:heading_formatter, HeadingFormatter::Quiet).new(@report_formatter)
-        end
-      end
-
-      #
-      # Displays a list of smells in YAML format
-      # YAML with empty array for 0 smells
-      class YAMLReport < Base
-        def show
-          print smells.map(&:yaml_hash).to_yaml
-        end
-      end
-
-      #
-      # Displays a list of smells in JSON format
-      # JSON with empty array for 0 smells
-      class JSONReport < Base
-        def show
-          print ::JSON.generate(
-            smells.map do |smell|
-              smell.yaml_hash(@warning_formatter)
-            end
-          )
-        end
-      end
-
-      #
-      # Saves the report as a HTML file
-      #
-      class HTMLReport < Base
-        require 'erb'
-
-        def show
-          path = File.expand_path('../../../../../assets/html_output.html.erb',
-                                  __FILE__)
-          File.open('reek.html', 'w+') do |file|
-            file.puts ERB.new(File.read(path)).result(binding)
-          end
-          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/core/ast_node.rb

@@ -1,38 +0,0 @@
-require 'parser'
-
-module Reek
-  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
-      def initialize(type, children = [], options = {})
-        @comments = options.fetch(:comments, [])
-        super
-      end
-
-      def comments
-        @comments.map(&:text).join("\n")
-      end
-
-      # @deprecated
-      def [](index)
-        elements[index]
-      end
-
-      def line
-        loc.line
-      end
-
-      # @deprecated
-      def first
-        type
-      end
-
-      private
-
-      def elements
-        [type, *children]
-      end
-    end
-  end
-end

data/lib/reek/core/code_comment.rb

@@ -1,37 +0,0 @@
-require 'yaml'
-
-module Reek
-  module Core
-    #
-    # A comment header from an abstract syntax tree; found directly above
-    # module, class and method definitions.
-    #
-    class CodeComment
-      CONFIG_REGEX = /:reek:(\w+)(:\s*\{.*?\})?/
-
-      def initialize(text)
-        @text = text.gsub(CONFIG_REGEX) do
-          add_to_config($1, $2)
-          ''
-        end.gsub(/#/, '').gsub(/\n/, '').strip
-      end
-
-      def config
-        @config ||= Hash.new { |hash, key| hash[key] = {} }
-      end
-
-      def descriptive?
-        @text.split(/\s+/).length >= 2
-      end
-
-      protected
-
-      def add_to_config(smell, options)
-        options ||= ': { enabled: false }'
-        config.merge! YAML.load(smell.gsub(/(?:^|_)(.)/) { $1.upcase } + options)
-        # TODO: extend this to all configs -------------------^
-        # TODO: extend to allow configuration of whole smell class, not just subclass
-      end
-    end
-  end
-end

data/lib/reek/core/examiner.rb

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