reek 1.2.6 → 1.2.7

data/lib/reek.rb

@@ -1,5 +1,9 @@
-$:.unshift File.dirname(__FILE__)
-
-module Reek # :doc:
-  VERSION = '1.2.6'
+#
+# Reek's core functionality
+#
+module Reek
+  VERSION = '1.2.7'
 end
+
+require File.join(File.dirname(File.expand_path(__FILE__)), 'reek', 'examiner')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'reek', 'smell_warning')

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,106 @@
+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
+        @show_all = false
+        @command_class = ReekCommand
+        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
+        #      -a|--[no-]show-all  Report masked smells
+        #      -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 -a 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 "\nReport formatting:"
+        @parser.on("-a", "--[no-]show-all", "Show all smells, including those masked by config settings") do |opt|
+          @show_all = opt
+        end
+        @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)
+        else
+          sources = get_sources
+          ReekCommand.create(sources, @report_class, @show_all)
+        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, show_all)
+        examiners = sources.map {|src| Examiner.new(src) }
+        new(examiners, report_class, show_all)
+      end
+
+      def initialize(examiners, report_class, show_all)
+        @examiners = examiners
+        @report_class = report_class
+        @show_all = show_all    #SMELL: boolean parameter
+      end
+
+      def execute(view)
+        had_smells = false
+        @examiners.each do |examiner|
+          rpt = @report_class.new(examiner, @show_all)
+          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,91 @@
+module Reek
+  module Cli
+
+    #
+    # A section of a text report; has a heading that identifies the source
+    # and summarises the smell counts, and a body listing details of all
+    # smells found.
+    #
+    class ReportSection
+
+      SMELL_FORMAT = '%m%c %w (%s)'
+
+      def initialize(examiner, display_masked_warnings)
+        @examiner = examiner
+        @display_masked_warnings = display_masked_warnings  # SMELL: Control Couple
+      end
+
+      # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+      # this report, with a heading.
+      def verbose_report
+        result = header
+        result += ":\n#{smell_list}" if should_report
+        result += "\n"
+        result
+      end
+
+      def quiet_report
+        return '' unless should_report
+        # SMELL: duplicate knowledge of the header layout
+        "#{header}:\n#{smell_list}\n"
+      end
+
+      def header
+        "#{@examiner.description} -- #{visible_header}#{masked_header}"
+      end
+
+      # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+      # this report.
+      def smell_list
+        if @display_masked_warnings
+          result = @examiner.all_smells.map {|smell| "  #{smell.report(SMELL_FORMAT)}"}
+        else
+          result = @examiner.all_active_smells.map {|smell| "  #{smell.report(SMELL_FORMAT)}"}
+        end
+        result.join("\n")
+      end
+
+    private
+
+      def should_report
+        @examiner.num_active_smells > 0 or (@display_masked_warnings and @examiner.num_masked_smells > 0)
+      end
+
+      def visible_header
+        num_smells = @examiner.all_active_smells.length
+        result = "#{num_smells} warning"
+        result += 's' unless num_smells == 1
+        result
+      end
+
+      def masked_header
+        num_masked_warnings = @examiner.num_masked_smells
+        num_masked_warnings == 0 ? '' : " (+#{num_masked_warnings} masked)"
+      end
+    end
+
+    #
+    # A report that lists every source, including those that have no smells.
+    #
+    class VerboseReport
+      def initialize(examiner, display_masked_warnings)
+        @reporter = ReportSection.new(examiner, display_masked_warnings)
+      end
+      def report
+        @reporter.verbose_report
+      end
+    end
+
+    #
+    # A report that lists a section for each source that has smells.
+    #
+    class QuietReport
+      def initialize(examiner, display_masked_warnings)
+        @reporter = ReportSection.new(examiner, display_masked_warnings)
+      end
+      def report
+        @reporter.quiet_report
+      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)
+        examiners = sources.map {|src| Examiner.new(src) }
+        new(examiners)
+      end
+
+      def initialize(examiners)
+        @examiners = examiners
+      end
+
+      def execute(view)
+        smells = []
+        @examiners.each {|examiner| smells += examiner.all_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/block_context.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_context')
+
+module Reek
+  module Core
+
+    #
+    # A context wrapper for any block found in a syntax tree.
+    #
+    class BlockContext < CodeContext
+
+      def initialize(outer, exp)
+        super
+        @name = 'block'
+        @scope_connector = '/'
+      end
+    end
+  end
+end

data/lib/reek/core/class_context.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'module_context')
+
+module Reek
+  module Core
+
+    #
+    # A context wrapper for any class found in a syntax tree.
+    #
+    class ClassContext < ModuleContext
+
+      attr_reader :parsed_methods
+
+      def initialize(outer, name, exp)
+        super
+        @superclass = exp[2]
+      end
+
+      def is_struct?
+        @superclass == [:const, :Struct]
+      end
+    end
+  end
+end

data/lib/reek/core/code_context.rb

@@ -0,0 +1,72 @@
+
+#
+# Extensions to +Module+ needed by Reek.
+#
+class Module
+  def const_or_nil(sym)
+    const_defined?(sym) ? const_get(sym) : nil
+  end
+end
+
+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 :name, :exp
+
+      def initialize(outer, exp)
+        @outer = outer
+        @exp = exp
+        @scope_connector = ''
+      end
+
+      def local_nodes(type, &blk)
+        each_node(type, [:class, :module], &blk)
+      end
+
+      def each_node(type, ignoring, &blk)
+        if block_given?
+          @exp.look_for(type, ignoring, &blk)
+        else
+          result = []
+          @exp.look_for(type, ignoring) {|exp| result << exp}
+          result
+        end
+      end
+
+      # SMELL: Temporary Field -- @name isn't always initialized
+      def matches?(strings)
+        me = @name.to_s
+        strings.any? do |str|
+          re = /#{str}/
+          re === me or re === self.full_name
+        end
+      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 : ''
+        prefix = outer == '' ? '' : "#{outer}#{@scope_connector}"
+        "#{prefix}#{@name}"
+      end
+    end
+  end
+end