reek 0.3.1 → 1.0.0

data/lib/reek/exceptions.reek

@@ -0,0 +1,13 @@
+--- 
+FeatureEnvy:
+  exclude:
+  - examine_context
+LargeClass:
+  exclude:
+  - CodeParser
+LongMethod:
+  exclude:
+  - Reek::SexpFormatter#self.format
+UtilityFunction:
+  exclude:
+  - Reek::Spec

data/lib/reek/if_context.rb

@@ -0,0 +1,25 @@
+require 'reek/code_context'
+
+module Reek
+  class IfContext < CodeContext
+    attr_reader :if_expr
+    
+    def initialize(outer, exp)
+      @outer = outer
+      @exp = exp
+      @if_expr = exp[1]
+    end
+    
+    def tests_a_parameter?
+      @if_expr[0] == :lvar and has_parameter(@if_expr[1])
+    end
+
+    def outer_name
+      @outer.outer_name
+    end
+
+    def to_s
+      @outer.to_s
+    end
+  end
+end

data/lib/reek/method_context.rb

@@ -0,0 +1,85 @@
+require 'reek/name'
+require 'reek/code_context'
+require 'reek/object_refs'
+
+module Reek
+  class MethodContext < CodeContext
+    attr_reader :parameters
+    attr_reader :calls
+    attr_reader :refs
+    attr_reader :num_statements
+
+    def initialize(outer, exp, record = true)
+      super(outer, exp)
+      @parameters = []
+      @local_variables = []
+      @name = Name.new(exp[1])
+      @num_statements = 0
+      @calls = Hash.new(0)
+      @depends_on_self = false
+      @refs = ObjectRefs.new
+      @outer.record_method(@name)    # TODO: should be children of outer?
+    end
+
+    def count_statements(num)
+      @num_statements += num
+    end
+
+    def depends_on_instance?
+      @depends_on_self || is_overriding_method?(@name)
+    end
+
+    def has_parameter(sym)
+      @parameters.include?(sym.to_s)
+    end
+    
+    def record_call_to(exp)
+      @calls[exp] += 1
+      receiver, meth = exp[1..2]
+      if receiver.nil?
+        record_depends_on_self
+      else
+        case receiver[0]
+        when :lvar
+          @refs.record_ref(receiver) unless meth == :new
+        when :ivar
+          record_depends_on_self
+          @refs.record_reference_to_self
+        end
+      end
+    end
+    
+    def record_depends_on_self
+      @depends_on_self = true
+    end
+
+    def record_local_variable(sym)
+      @local_variables << Name.new(sym)
+    end
+
+    def self.is_block_arg?(param)
+      Array === param and param[0] == :block
+    end
+
+    def record_parameter(param)
+      @parameters << Name.new(param) unless MethodContext.is_block_arg?(param)
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+
+    def envious_receivers
+      return [] if @refs.self_is_max?
+      @refs.max_keys
+    end
+
+    def variable_names
+      @parameters + @local_variables
+    end
+  end
+end

data/lib/reek/module_context.rb

@@ -0,0 +1,34 @@
+require 'reek/code_context'
+
+module Reek
+  class ModuleContext < CodeContext
+
+    def ModuleContext.create(outer, exp)
+      res = Name.resolve(exp[1], outer)
+      ModuleContext.new(res[0], res[1])
+    end
+
+    def initialize(outer, name)
+      super(outer, nil)
+      @name = name
+    end
+
+    def myself
+      @myself ||= @outer.find_module(@name)
+    end
+
+    def find_module(modname)
+      return nil unless myself
+      sym = modname.to_s
+      myself.const_defined?(sym) ? myself.const_get(sym) : nil
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}::"
+    end
+
+    def variable_names
+      []
+    end
+  end
+end

data/lib/reek/name.rb

@@ -0,0 +1,42 @@
+module Reek
+  class Name
+    include Comparable
+
+    def self.resolve(exp, context)
+      return [context, new(exp)] unless Array === exp
+      name = exp[1]
+      case exp[0]
+      when :colon2
+        return [resolve(name, context)[0], new(exp[2])]
+      when :const
+        return [ModuleContext.create(context, exp), new(name)]
+      when :colon3
+        return [StopContext.new, new(name)]
+      else
+        return [context, new(name)]
+      end
+    end
+
+    def initialize(sym)
+      @name = sym.to_s
+    end
+
+    def hash  # :nodoc:
+      @name.hash
+    end
+
+    def <=>(other)  # :nodoc:
+      @name <=> other.to_s
+    end
+
+    alias eql? <=>
+
+    def effective_name
+      @name.gsub(/^@*/, '')
+    end
+
+    def to_s
+      @name
+    end
+  end
+end

data/lib/reek/object_refs.rb

@@ -1,12 +1,9 @@
-$:.unshift File.dirname(__FILE__)
-
 require 'rubygems'
-require 'sexp'
-require 'reek/printer'
+require 'sexp_processor'
 
 module Reek
 
-  class ObjectRefs
+  class ObjectRefs  # :nodoc:
     def initialize
       @refs = Hash.new(0)
       record_reference_to_self
@@ -41,7 +38,7 @@ module Reek
     # no way to turn off that report; which would therefore make the tests fail
     def max_keys
       max = max_refs
-      @refs.reject {|k,v| v != max}.keys
+      @refs.reject {|key,val| val != max}.keys
     end
 
     def self_is_max?

data/lib/reek/options.rb

@@ -1,18 +1,16 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/report'
-require 'reek/version'
 require 'optparse'
-
-include Reek
+require 'reek/source'
 
 module Reek
-
+    
   class Options
+
+    CTX_SORT = '%c %w (%s)'
+    SMELL_SORT = '[%s] %c %w'
+
     def self.default_options
       {
-        :sort_order => Report::SORT_ORDERS[:context],
-        :expressions => []
+        :format => CTX_SORT
       }
     end
     
@@ -24,49 +22,71 @@ module Reek
 
     def self.parse_args(args)
       result = default_options
-      parser = OptionParser.new do |opts|
-        opts.banner = <<EOB
-Usage: #{File.basename($0)} [options] SOURCES
+      parser = OptionParser.new { |opts| set_options(opts, result) }
+      parser.parse!(args)
+      result
+    end
+    
+    def self.set_options(opts, config)
+      opts.banner = <<EOB
+Usage: #{opts.program_name} [options] files...
 
-The SOURCES may be any combination of file paths and Ruby source code.
+If no files are given, Reek reads source code from standard input.
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
 EOB
+      
+      opts.separator "\nOptions:"
+      set_help_option(opts)
+      set_sort_option(config, opts)
+      set_version_option(opts)
+    end
 
-        opts.separator ""
-        opts.separator "Options:"
-
-        opts.on("-h", "--help", "Show this message") do
-          puts opts
-          exit(0)
+    def self.parse(args)
+      begin
+        @@opts = parse_args(args)
+        if ARGV.length > 0
+          return Source.from_pathlist(ARGV)
+        else
+          return Source.from_io($stdin, 'stdin')
         end
+      rescue OptionParser::ParseError, SystemCallError => err
+        fatal_error(err)
+      end
+    end
 
-        opts.on('-s', "--sort ORDER", Report::SORT_ORDERS.keys,
-          "Select sort order for report (#{Report::SORT_ORDERS.keys.join(', ')})") do |arg|
-          result[:sort_order] = Report::SORT_ORDERS[arg] unless arg.nil?
-        end
+  private
+    
+    def self.set_version_option(opts)
+      opts.on("-v", "--version", "Show version") do
+        puts "#{opts.program_name} #{Reek::VERSION}"
+        exit(0)
+      end
+    end
 
-        opts.on("-v", "--version", "Show version") do
-          puts "#{File.basename($0)} #{Reek::VERSION::STRING}"
-          exit(0)
-        end
+    def self.set_help_option(opts)
+      opts.on("-h", "--help", "Show this message") do
+        puts opts
+        exit(0)
       end
+    end
 
-      parser.parse!(args)
-      result
+    def self.set_sort_option(config, opts)
+      opts.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
+        config[:format] = arg unless arg.nil?
+      end
+      opts.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
+        config[:format] = CTX_SORT
+      end
+      opts.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
+        config[:format] = SMELL_SORT
+      end
     end
     
-    def self.fatal_error(e) # :nodoc:
-      puts "Error: #{e}"
+    def self.fatal_error(err) # :nodoc:
+      puts "Error: #{err}"
       puts "Use '-h' for help."
       exit(1)
     end
-
-    def self.parse(args)
-      begin
-        @@opts = parse_args(args)
-        ARGV
-      rescue OptionParser::ParseError => e
-        fatal_error(e)
-      end
-    end
+    
   end
 end

data/lib/reek/rake_task.rb

@@ -19,37 +19,31 @@ module Reek
   #
   #   rake reek
   #
-  # If rake is invoked with a "SPEC=filename" command line option,
-  # then the list of spec files will be overridden to include only the
-  # filename specified on the command line.  This provides an easy way
-  # to run just one spec.
-  #
-  # If rake is invoked with a "REEK_SORT=order" command line option,
-  # then the given sort order will override the value of the +sort+
-  # attribute.
-  #
   # Examples:
   #
-  #   rake reek                                      # run specs normally
-  #   rake reek SPEC=just_one_file.rb                # run just one spec file.
-  #   rake reek REEK_SORT=smell                      # sort warnings by smell
+  #   rake reek                                # checks lib/**/*.rb
+  #   rake reek REEK_SRC=just_one_file.rb      # checks a single source file
+  #   rake reek REEK_OPTS=-s                   # sorts the report by smell
   #
   class RakeTask < ::Rake::TaskLib
 
-    # Name of reek task. (default is :reek)
+    # Name of reek task.
+    # Defaults to :reek.
     attr_accessor :name
 
     # Array of directories to be added to $LOAD_PATH before running reek.
     # Defaults to ['<the absolute path to reek's lib directory>']
     attr_accessor :libs
 
-    # Glob pattern to match source files. (default is 'lib/**/*.rb')
+    # Glob pattern to match source files.
     # Setting the REEK_SRC environment variable overrides this.
+    # Defaults to 'lib/**/*.rb'.
     attr_accessor :source_files
 
-    # Set the sort order for reported smells (see 'reek --help' for possible values).
-    # Setting the REEK_SORT environment variable overrides this.
-    attr_accessor :sort
+    # String containing commandline options to be passed to Reek.
+    # Setting the REEK_OPTS environment variable overrides this value.
+    # Defaults to ''.
+    attr_accessor :reek_opts
 
     # Array of commandline options to pass to ruby. Defaults to [].
     attr_accessor :ruby_opts
@@ -65,9 +59,10 @@ module Reek
     # Defines a new task, using the name +name+.
     def initialize(name = :reek)
       @name = name
-      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../lib')]
       @source_files = nil
       @ruby_opts = []
+      @reek_opts = ''
       @fail_on_error = true
       @sort = nil
 
@@ -79,7 +74,7 @@ module Reek
 private
     
     def define # :nodoc:
-      desc "Check for code smells" unless ::Rake.application.last_comment
+      desc 'Check for code smells' unless ::Rake.application.last_comment
       task(name) { run_task }
       self
     end
@@ -88,9 +83,9 @@ private
       return if source_file_list.empty?
       cmd = cmd_words.join(' ')
       puts cmd if @verbose
-      raise("Smells found!") if !system(cmd) and fail_on_error
+      raise('Smells found!') if !system(cmd) and fail_on_error
     end
-    
+
     def self.reek_script
       File.expand_path(File.dirname(__FILE__) + '/../../bin/reek')
     end
@@ -113,17 +108,13 @@ private
     end
     
     def sort_option
-      env_sort = ENV['REEK_SORT']
-      return "--sort #{env_sort}" if env_sort
-      return "--sort #{@sort}" if @sort
-      ''
+      ENV['REEK_OPTS'] || @reek_opts
     end
 
     def source_file_list # :nodoc:
-      env_src = ENV['REEK_SRC']
-      return env_src if env_src
-      return FileList[@source_files] if @source_files
-      []
+      files = ENV['REEK_SRC'] || @source_files
+      return [] unless files
+      return FileList[files]
     end
 
   end