reek 2.0.4 → 3.0.0

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

@@ -1,69 +0,0 @@
-require 'reek/cli/report/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,131 +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
-    end
-  end
-end

data/lib/reek/core/tree_walker.rb

@@ -1,180 +0,0 @@
-require 'reek/core/method_context'
-require 'reek/core/module_context'
-require 'reek/core/stop_context'
-require 'reek/core/singleton_method_context'
-
-module Reek
-  module Core
-    #
-    # Traverses a Sexp abstract syntax tree and fires events whenever
-    # it encounters specific node types.
-    #
-    # SMELL: This class is responsible for counting statements and for feeding
-    # each context to the smell repository.
-    class TreeWalker
-      def initialize(smell_repository = Core::SmellRepository.new)
-        @smell_repository = smell_repository
-        @element = StopContext.new
-      end
-
-      def process(exp)
-        context_processor = "process_#{exp.type}"
-        if context_processor_exists?(context_processor)
-          send(context_processor, exp)
-        else
-          process_default exp
-        end
-        @element
-      end
-
-      def process_default(exp)
-        exp.children.each do |child|
-          process(child) if child.is_a? AST::Node
-        end
-      end
-
-      def process_module(exp)
-        inside_new_context(ModuleContext, exp) do
-          process_default(exp)
-        end
-      end
-
-      alias_method :process_class, :process_module
-
-      def process_def(exp)
-        inside_new_context(MethodContext, exp) do
-          count_clause(exp.body)
-          process_default(exp)
-        end
-      end
-
-      def process_defs(exp)
-        inside_new_context(SingletonMethodContext, exp) do
-          count_clause(exp.body)
-          process_default(exp)
-        end
-      end
-
-      def process_args(_) end
-
-      #
-      # Recording of calls to methods and self
-      #
-
-      def process_send(exp)
-        @element.record_call_to(exp)
-        process_default(exp)
-      end
-
-      alias_method :process_attrasgn, :process_send
-      alias_method :process_op_asgn, :process_send
-
-      def process_ivar(exp)
-        @element.record_use_of_self
-        process_default(exp)
-      end
-
-      alias_method :process_ivasgn, :process_ivar
-
-      def process_self(_)
-        @element.record_use_of_self
-      end
-
-      alias_method :process_zsuper, :process_self
-
-      #
-      # Statement counting
-      #
-
-      def process_block(exp)
-        count_clause(exp.block)
-        process_default(exp)
-      end
-
-      def process_begin(exp)
-        count_statement_list(exp.children)
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      alias_method :process_kwbegin, :process_begin
-
-      def process_if(exp)
-        count_clause(exp[2])
-        count_clause(exp[3])
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      def process_while(exp)
-        count_clause(exp[2])
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      alias_method :process_until, :process_while
-
-      def process_for(exp)
-        count_clause(exp[3])
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      def process_rescue(exp)
-        count_clause(exp[1])
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      def process_resbody(exp)
-        count_statement_list(exp[2..-1].compact)
-        process_default(exp)
-      end
-
-      def process_case(exp)
-        count_clause(exp.else_body)
-        @element.count_statements(-1)
-        process_default(exp)
-      end
-
-      def process_when(exp)
-        count_clause(exp.body)
-        process_default(exp)
-      end
-
-      private
-
-      def context_processor_exists?(name)
-        respond_to?(name)
-      end
-
-      def count_clause(sexp)
-        @element.count_statements(1) if sexp
-      end
-
-      def count_statement_list(statement_list)
-        @element.count_statements statement_list.length
-      end
-
-      def inside_new_context(klass, exp)
-        scope = klass.new(@element, exp)
-        push(scope) do
-          yield
-          check_smells(exp.type)
-        end
-        scope
-      end
-
-      def check_smells(type)
-        @smell_repository.examine(@element, type)
-      end
-
-      def push(scope)
-        orig = @element
-        @element = scope
-        yield
-        @element = orig
-      end
-    end
-  end
-end

data/lib/reek/smell_warning.rb

@@ -1,87 +0,0 @@
-require 'forwardable'
-
-module Reek
-  #
-  # Reports a warning that a smell has been found.
-  #
-  class SmellWarning
-    include Comparable
-    extend Forwardable
-    attr_accessor :smell_detector, :context, :lines, :message, :parameters
-    def_delegators :smell_detector, :smell_category, :smell_type, :source
-
-    def initialize(smell_detector, options = {})
-      self.smell_detector = smell_detector
-      self.context        = options.fetch(:context, '').to_s
-      self.lines          = options.fetch(:lines)
-      self.message        = options.fetch(:message)
-      self.parameters     = options.fetch(:parameters, {})
-    end
-
-    def smell_classes
-      [smell_detector.smell_category, smell_detector.smell_type]
-    end
-
-    def hash
-      sort_key.hash
-    end
-
-    def <=>(other)
-      sort_key <=> other.sort_key
-    end
-
-    def eql?(other)
-      (self <=> other) == 0
-    end
-
-    def matches?(klass, other_parameters = {})
-      smell_classes.include?(klass.to_s) && common_parameters_equal?(other_parameters)
-    end
-
-    def report_on(listener)
-      listener.found_smell(self)
-    end
-
-    def yaml_hash(warning_formatter = nil)
-      result = {
-        'smell_category' => smell_detector.smell_category,
-        'smell_type'     => smell_detector.smell_type,
-        'source'         => smell_detector.source,
-        'context'        => context,
-        'lines'          => lines,
-        'message'        => message
-      }
-      if warning_formatter.respond_to?(:explanatory_link)
-        result.merge!('wiki_link' => warning_formatter.explanatory_link(smell_detector))
-      end
-      parameters.each do |key, value|
-        result[key.to_s] = value
-      end
-      result
-    end
-
-    protected
-
-    def sort_key
-      [context, message, smell_category]
-    end
-
-    def common_parameters_equal?(other_parameters)
-      other_parameters.keys.each do |key|
-        unless parameters.key?(key)
-          raise ArgumentError, "The parameter #{key} you want to check for doesn't exist"
-        end
-      end
-
-      # Why not check for strict parameter equality instead of just the common ones?
-      #
-      # In `self`, `parameters` might look like this:  {:name=>"@other.thing", :count=>2}
-      # Coming from specs, 'other_parameters' might look like this, e.g.:
-      # {:name=>"@other.thing"}
-      # So in this spec we are just specifying the "name" parameter but not the "count".
-      # In order to allow for this kind of leniency we just test for common parameter equality,
-      # not for a strict one.
-      parameters.values_at(*other_parameters.keys) == other_parameters.values
-    end
-  end
-end

data/lib/reek/source/ast_node.rb

@@ -1,38 +0,0 @@
-require 'parser'
-
-module Reek
-  module Source
-    # 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/source/code_comment.rb

@@ -1,37 +0,0 @@
-require 'yaml'
-
-module Reek
-  module Source
-    #
-    # 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/source/core_extras.rb

@@ -1,46 +0,0 @@
-require 'reek/source/source_code'
-
-#
-# Extensions to +File+ needed by Reek.
-#
-class File
-  #
-  # Creates a new +Source+ that assumes this File contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  # @return [Reek::Source::SourceFile]
-  #
-  def to_reek_source
-    Reek::Source::SourceFile.new(path)
-  end
-end
-
-#
-# Extensions to +IO+ needed by Reek.
-#
-class IO
-  #
-  # Creates a new +Source+ that assumes this IO stream contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  # @return [Reek::Source::SourceCode]
-  #
-  def to_reek_source(description = 'io')
-    Reek::Source::SourceCode.new(readlines.join, description)
-  end
-end
-
-#
-# Extensions to +String+ needed by Reek.
-#
-class String
-  #
-  # Creates a new +Source+ that assumes this string contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  # @return [Reek::Source::SourceCode]
-  #
-  def to_reek_source
-    Reek::Source::SourceCode.new(self, 'string')
-  end
-end

data/lib/reek/source/reference_collector.rb

@@ -1,27 +0,0 @@
-
-module Reek
-  module Source
-    #
-    # 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
-        result = 0
-        [:self, :zsuper, :ivar, :ivasgn].each do |node_type|
-          @ast.look_for(node_type, STOP_NODES) { result += 1 }
-        end
-        @ast.look_for(:send, STOP_NODES) do |call|
-          result += 1 unless call.receiver
-        end
-        result
-      end
-    end
-  end
-end