reek 1.2.6 → 1.2.8

data/features/yaml.feature

@@ -0,0 +1,85 @@
+@yaml
+Feature: Report smells using simple YAML layout
+  In order to parse reek's output simply and consistently, simply
+  output a list of smells in Yaml.
+
+  Scenario: output is empty when there are no smells
+    When I run reek --yaml spec/samples/three_clean_files
+    Then it succeeds
+    And stdout equals ""
+
+  @masking
+  Scenario: masked smells always appear
+    When I run reek --yaml spec/samples/masked/dirty.rb
+    Then the exit status indicates smells
+    And it reports:
+      """
+      --- 
+      - !ruby/object:Reek::SmellWarning 
+        location: 
+          lines: 
+          - 4
+          - 6
+          context: Dirty#a
+          source: spec/samples/masked/dirty.rb
+        smell: 
+          class: Duplication
+          occurrences: 2
+          subclass: DuplicateMethodCall
+          call: "@s.title"
+          message: calls @s.title twice
+        status: 
+          is_active: true
+      - !ruby/object:Reek::SmellWarning 
+        location: 
+          lines: 
+          - 5
+          - 7
+          context: Dirty#a
+          source: spec/samples/masked/dirty.rb
+        smell: 
+          class: Duplication
+          occurrences: 2
+          subclass: DuplicateMethodCall
+          call: puts(@s.title)
+          message: calls puts(@s.title) twice
+        status: 
+          is_active: true
+      - !ruby/object:Reek::SmellWarning 
+        location: 
+          lines: 
+          - 5
+          context: Dirty#a
+          source: spec/samples/masked/dirty.rb
+        smell: 
+          class: NestedIterators
+          depth: 2
+          subclass: NestedIterators
+          message: contains iterators nested 2 deep
+        status: 
+          is_active: true
+
+      """
+
+  @stdin
+  Scenario: return non-zero status when there are smells
+    When I pass "class Turn; end" to reek --yaml
+    Then the exit status indicates smells
+    And it reports:
+      """
+      --- 
+      - !ruby/object:Reek::SmellWarning 
+        location: 
+          lines: 
+          - 1
+          context: Turn
+          source: $stdin
+        smell: 
+          class: IrresponsibleModule
+          subclass: IrresponsibleModule
+          module_name: Turn
+          message: has no descriptive comment
+        status: 
+          is_active: true
+
+      """

data/lib/reek/cli/application.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'command_line')
+
+module Reek
+  module Cli
+
+    #
+    # Represents an instance of a Reek application.
+    # This is the entry point for all invocations of Reek from the
+    # command line.
+    #
+    class Application
+
+      STATUS_SUCCESS = 0
+      STATUS_ERROR   = 1
+      STATUS_SMELLS  = 2
+
+      def initialize(argv)
+        @options = Options.new(argv)
+        @status = STATUS_SUCCESS
+      end
+
+      def execute
+        begin
+          cmd = @options.parse
+          cmd.execute(self)
+        rescue Exception => error
+          $stderr.puts "Error: #{error}"
+          @status = STATUS_ERROR
+        end
+        return @status
+      end
+
+      def output(text)
+        print text
+      end
+
+      def report_success
+        @status = STATUS_SUCCESS
+      end
+
+      def report_smells
+        @status = STATUS_SMELLS
+      end
+    end
+  end
+end

data/lib/reek/cli/command_line.rb

@@ -0,0 +1,108 @@
+require 'optparse'
+require File.join(File.dirname(File.expand_path(__FILE__)), 'report')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'reek_command')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'help_command')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'version_command')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'yaml_command')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
+
+module Reek
+  module Cli
+
+    #
+    # Parses the command line
+    #
+    class Options
+
+      def initialize(argv)
+        @argv = argv
+        @parser = OptionParser.new
+        @report_class = VerboseReport
+        @command_class = ReekCommand
+        @config_files = []
+        set_options
+      end
+
+      def banner
+        progname = @parser.program_name
+        # SMELL:
+        # The following banner isn't really correct. Help, Version and Reek
+        # are really sub-commands (in the git/svn sense) and so the usage
+        # banner should show three different command-lines. The other
+        # options are all flags for the Reek sub-command.
+        #
+        # reek -h|--help           Display a help message
+        #
+        # reek -v|--version        Output the tool's version number
+        #
+        # reek [options] files     List the smells in the given files
+        #      -c|--config file    Specify file(s) with config options
+        #      -q|-[no-]quiet      Only list files that have smells
+        #      files               Names of files or dirs to be checked
+        #
+        return <<EOB
+Usage: #{progname} [options] [files]
+
+Examples:
+
+#{progname} lib/*.rb
+#{progname} -q lib
+cat my_class.rb | #{progname}
+
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
+
+EOB
+      end
+
+      def set_options
+        @parser.banner = banner
+        @parser.separator "Common options:"
+        @parser.on("-h", "--help", "Show this message") do
+          @command_class = HelpCommand
+        end
+        @parser.on("-v", "--version", "Show version") do
+          @command_class = VersionCommand
+        end
+
+        @parser.separator "\nConfiguration:"
+        @parser.on("-c", "--config FILE", "Read configuration options from FILE") do |file|
+          @config_files << file
+        end
+
+        @parser.separator "\nReport formatting:"
+        @parser.on("-q", "--[no-]quiet", "Suppress headings for smell-free source files") do |opt|
+          @report_class = opt ? QuietReport : VerboseReport
+        end
+        @parser.on("-y", "--yaml", "Report smells in YAML format") do
+          @command_class = YamlCommand
+          # SMELL: the args passed to the command should be tested, because it may
+          # turn out that they are passed too soon, ie. before the files have been
+          # separated out from the options
+        end
+      end
+
+      def parse
+        @parser.parse!(@argv)
+        if @command_class == HelpCommand
+          HelpCommand.new(@parser)
+        elsif @command_class == VersionCommand
+          VersionCommand.new(@parser.program_name)
+        elsif @command_class == YamlCommand
+          sources = get_sources
+          YamlCommand.create(sources, @config_files)
+        else
+          sources = get_sources
+          ReekCommand.create(sources, @report_class, @config_files)
+        end
+      end
+
+      def get_sources
+        if @argv.empty?
+          return [$stdin.to_reek_source('$stdin')]
+        else
+          return Source::SourceLocator.new(@argv).all_sources
+        end
+      end
+    end
+  end
+end

data/lib/reek/cli/help_command.rb

@@ -0,0 +1,18 @@
+
+module Reek
+  module Cli
+
+    #
+    # A command to display usage information for this application.
+    #
+    class HelpCommand
+      def initialize(parser)
+        @parser = parser
+      end
+      def execute(view)
+        view.output(@parser.to_s)
+        view.report_success
+      end
+    end
+  end
+end

data/lib/reek/cli/reek_command.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'examiner')
+
+module Reek
+  module Cli
+
+    #
+    # A command to collect smells from a set of sources and write them out in
+    # text report format.
+    #
+    class ReekCommand
+      def self.create(sources, report_class, config_files = [])
+        new(report_class, sources, config_files)
+      end
+
+      def initialize(report_class, sources, config_files = [])
+        @sources = sources
+        @report_class = report_class
+        @config_files = config_files
+      end
+
+      def execute(view)
+        had_smells = false
+        @sources.each do |source|
+          examiner = Examiner.new(source, @config_files)
+          rpt = @report_class.new(examiner)
+          had_smells ||= examiner.smelly?
+          view.output(rpt.report)
+        end
+        if had_smells
+          view.report_smells
+        else
+          view.report_success
+        end
+      end
+    end
+  end
+end

data/lib/reek/cli/report.rb

@@ -0,0 +1,58 @@
+module Reek
+  module Cli
+
+    module ReportFormatter
+      def header(desc, count)
+        result = "#{desc} -- #{count} warning"
+        result += 's' unless count == 1
+        result
+      end
+
+      def format_list(warnings)
+        warnings.map do |warning|
+          "  #{warning.context} #{warning.message} (#{warning.smell_class})"
+        end.join("\n")
+      end
+
+      module_function :format_list
+    end
+
+    #
+    # A report that lists every source, including those that have no smells.
+    #
+    class VerboseReport
+
+      include ReportFormatter
+
+      def initialize(examiner)
+        @examiner = examiner
+      end
+
+      def report
+        warnings = @examiner.smells
+        warning_count = warnings.length
+        result = header(@examiner.description, warning_count)
+        result += ":\n#{format_list(warnings)}" if warning_count > 0
+        result + "\n"
+      end
+    end
+
+    #
+    # A report that lists a section for each source that has smells.
+    #
+    class QuietReport
+
+      include ReportFormatter
+
+      def initialize(examiner)
+        @warnings = examiner.smells
+        @smell_count = @warnings.length
+        @desc = examiner.description
+      end
+
+      def report
+        @smell_count > 0 ? "#{header(@desc, @smell_count)}:\n#{format_list(@warnings)}\n" : ''
+      end
+    end
+  end
+end

data/lib/reek/cli/version_command.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'reek')
+
+module Reek
+  module Cli
+
+    #
+    # A command to report the application's current version number.
+    #
+    class VersionCommand
+      def initialize(progname)
+        @progname = progname
+      end
+      def execute(view)
+        view.output("#{@progname} #{Reek::VERSION}\n")
+        view.report_success
+      end
+    end
+  end
+end

data/lib/reek/cli/yaml_command.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'examiner')
+
+module Reek
+  module Cli
+
+    #
+    # A command to collect smells from a set of sources and write them out in
+    # YAML format.
+    #
+    class YamlCommand
+      def self.create(sources, config_files)
+        examiners = sources.map {|src| Examiner.new(src, config_files) }
+        new(examiners)
+      end
+
+      def initialize(examiners)
+        @examiners = examiners
+      end
+
+      def execute(view)
+        smells = []
+        @examiners.each {|examiner| smells += examiner.smells}
+        if smells.empty?
+          view.report_success
+        else
+          view.output(smells.to_yaml)
+          view.report_smells
+        end
+      end
+    end
+  end
+end

data/lib/reek/core/code_context.rb

@@ -0,0 +1,64 @@
+
+module Reek
+  module Core
+
+    #
+    # Superclass for all types of source code context. Each instance represents
+    # a code element of some kind, and each provides behaviour relevant to that
+    # code element. CodeContexts form a tree in the same way the code does,
+    # with each context holding a reference to a unique outer context.
+    #
+    class CodeContext
+
+      attr_reader :exp, :config
+
+      def initialize(outer, exp)
+        @outer = outer
+        @exp = exp
+        @config = local_config
+      end
+
+      def name
+        @exp.name
+      end
+
+      def local_nodes(type, &blk)
+        each_node(type, [:class, :module], &blk)
+      end
+
+      def each_node(type, ignoring, &blk)
+        @exp.each_node(type, ignoring, &blk)
+      end
+
+      def matches?(candidates)
+        my_fq_name = full_name
+        candidates.any? {|str| /#{str}/ === my_fq_name }
+      end
+
+      #
+      # Bounces messages up the context tree to the first enclosing context
+      # that knows how to deal with the request.
+      #
+      def method_missing(method, *args)
+        @outer.send(method, *args)
+      end
+
+      def num_methods
+        0
+      end
+
+      def full_name
+        outer = @outer ? @outer.full_name : ''
+        exp.full_name(outer)
+      end
+
+      def local_config
+        return Hash.new if @exp.nil?
+        config = Source::CodeComment.new(@exp.comments || '').config
+        return config unless @outer
+        @outer.config.deep_copy.adopt!(config)
+        # no tests for this -----^
+      end
+    end
+  end
+end

data/lib/reek/core/code_parser.rb

@@ -0,0 +1,166 @@
+require 'sexp'
+require File.join(File.dirname(File.expand_path(__FILE__)), 'method_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'module_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'stop_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'singleton_method_context')
+
+module Reek
+  module Core
+
+    #
+    # Traverses a Sexp abstract syntax tree and fires events whenever
+    # it encounters specific node types.
+    #
+    class CodeParser
+      def initialize(sniffer, ctx = StopContext.new)
+        @sniffer = sniffer
+        @element = ctx
+      end
+
+      def process(exp)
+        meth = "process_#{exp[0]}"
+        meth = :process_default unless self.respond_to?(meth)
+        self.send(meth, exp)
+        @element
+      end
+
+      def process_default(exp)
+        exp.each { |sub| process(sub) if Array === sub }
+      end
+
+      def process_module(exp)
+        name = Source::SexpFormatter.format(exp[1])
+        scope = ModuleContext.new(@element, name, exp)
+        push(scope) do
+          process_default(exp) unless exp.superclass == [:const, :Struct]
+          check_smells(exp[0])
+        end
+        scope
+      end
+
+      def process_class(exp)
+        process_module(exp)
+      end
+
+      def process_defn(exp)
+        handle_context(MethodContext, exp[0], exp)
+      end
+
+      def process_defs(exp)
+        handle_context(SingletonMethodContext, exp[0], exp)
+      end
+
+      def process_args(exp) end
+
+      def process_zsuper(exp)
+        @element.record_use_of_self
+      end
+
+      def process_block(exp)
+        @element.count_statements(CodeParser.count_statements(exp))
+        process_default(exp)
+      end
+
+      def process_call(exp)
+        @element.record_call_to(exp)
+        process_default(exp)
+      end
+
+      def process_attrasgn(exp)
+        process_call(exp)
+      end
+
+      def process_op_asgn1(exp)
+        process_call(exp)
+      end
+
+      def process_if(exp)
+        count_clause(exp[2])
+        count_clause(exp[3])
+        process_default(exp)
+        @element.count_statements(-1)
+      end
+
+      def process_while(exp)
+        process_until(exp)
+      end
+
+      def process_until(exp)
+        count_clause(exp[2])
+        process_case(exp)
+      end
+
+      def process_for(exp)
+        count_clause(exp[3])
+        process_case(exp)
+      end
+
+      def process_rescue(exp)
+        count_clause(exp[1])
+        process_case(exp)
+      end
+
+      def process_resbody(exp)
+        process_when(exp)
+      end
+
+      def process_case(exp)
+        process_default(exp)
+        @element.count_statements(-1)
+      end
+
+      def process_when(exp)
+        count_clause(exp[2])
+        process_default(exp)
+      end
+
+      def process_ivar(exp)
+        process_iasgn(exp)
+      end
+
+      def process_iasgn(exp)
+        @element.record_use_of_self
+        process_default(exp)
+      end
+
+      def process_self(exp)
+        @element.record_use_of_self
+      end
+
+      def count_clause(sexp)
+        if sexp and !sexp.has_type?(:block)
+          @element.count_statements(1)
+        end
+      end
+
+      def self.count_statements(exp)
+        stmts = exp[1..-1]
+        ignore = 0
+        ignore += 1 if stmts[1] == s(:nil)
+        stmts.length - ignore
+      end
+
+    private
+
+      def handle_context(klass, type, exp)
+        scope = klass.new(@element, exp)
+        push(scope) do
+          process_default(exp)
+          check_smells(type)
+        end
+        scope
+      end
+
+      def check_smells(type)
+        @sniffer.examine(@element, type)
+      end
+
+      def push(context)
+        orig = @element
+        @element = context
+        yield
+        @element = orig
+      end
+    end
+  end
+end