reek 1.1.3 → 1.2.0

data/lib/reek/block_context.rb

@@ -11,7 +11,7 @@ module Reek
       case slice(0)
       when :masgn
         @names = arg[1..-1].map {|lasgn| Name.new(lasgn[1]) }
-      when :lasgn
+      when :lasgn, :iasgn
         @names = [Name.new(arg)]
       end
     end

data/lib/reek/class_context.rb

@@ -2,8 +2,11 @@ require 'set'
 require 'reek/code_context'
 
 class Class
-  def is_overriding_method?(sym)
-    instance_methods(false).include?(sym) and superclass.instance_methods(true).include?(sym)
+  def is_overriding_method?(name)
+    sym = name.to_sym
+    mine = instance_methods(false)
+    dads = superclass.instance_methods(true)
+    (mine.include?(sym) and dads.include?(sym)) or (mine.include?(name) and dads.include?(name))
   end
 end
 
@@ -15,12 +18,22 @@ module Reek
       ClassContext.new(res[0], res[1], exp[2])
     end
 
+    def ClassContext.from_s(src)
+      source = src.to_reek_source
+      sniffer = Sniffer.new(source)
+      CodeParser.new(sniffer).process_class(source.syntax_tree)
+    end
+
+    attr_reader :conditionals, :parsed_methods
+
+    # SMELL: inconsistent with other contexts (not linked to the sexp)
     def initialize(outer, name, superclass = nil)
       super(outer, nil)
       @name = name
       @superclass = superclass
       @parsed_methods = []
       @instance_variables = Set.new
+      @conditionals = []
     end
 
     def myself
@@ -28,9 +41,8 @@ module Reek
     end
 
     def find_module(modname)
-      sym = modname.to_s
       return nil unless myself
-      @myself.const_defined?(sym) ? @myself.const_get(sym) : nil
+      @myself.const_or_nil(modname.to_s)
     end
 
     def is_overriding_method?(name)
@@ -50,8 +62,8 @@ module Reek
       @instance_variables << Name.new(sym)
     end
 
-    def record_method(name)
-      @parsed_methods << name.to_s
+    def record_method(meth)
+      @parsed_methods << meth
     end
 
     def outer_name
@@ -65,5 +77,13 @@ module Reek
     def variable_names
       @instance_variables
     end
+
+    def record_conditional(exp)
+      @conditionals << exp
+    end
+
+    def parameterized_methods(min_clump_size)
+      parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
+    end
   end
 end

data/lib/reek/code_context.rb

@@ -1,3 +1,10 @@
+class Module
+
+  def const_or_nil(sym)
+    const_defined?(sym) ? const_get(sym) : nil
+  end
+end
+
 module Reek
   
   #
@@ -16,6 +23,7 @@ module Reek
       @myself = nil
     end
 
+    # SMELL: Temporary Field -- @name isn't always initialized
     def matches?(strings)
       me = @name.to_s
       strings.any? do |str|

data/lib/reek/code_parser.rb

@@ -9,15 +9,33 @@ require 'reek/method_context'
 require 'reek/singleton_method_context'
 require 'reek/yield_call_context'
 
+#
+# Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
+# syntax tree more easily.
+#
+class Sexp
+  def children
+    find_all { |item| Sexp === item }
+  end
+
+  def is_language_node?
+    first.class == Symbol
+  end
+
+  def has_type?(type)
+    is_language_node? and first == type
+  end
+end
+
 module Reek
 
   class CodeParser
 
-    # Creates a new Ruby code checker. Any smells discovered
-    # will be stored in +report+.
-    def initialize(report, smells, ctx = StopContext.new)
-      @report = report
-      @smells = smells
+    #
+    # Creates a new Ruby code checker.
+    #
+    def initialize(sniffer, ctx = StopContext.new)
+      @sniffer = sniffer
       @element = ctx
     end
 
@@ -25,6 +43,7 @@ module Reek
       meth = "process_#{exp[0]}"
       meth = :process_default unless self.respond_to?(meth)
       self.send(meth, exp)
+      @element
     end
 
     def process_default(exp)
@@ -39,10 +58,12 @@ module Reek
     end
 
     def process_class(exp)
-      push(ClassContext.create(@element, exp)) do
+      scope = ClassContext.create(@element, exp)
+      push(scope) do
         process_default(exp) unless @element.is_struct?
         check_smells(:class)
       end
+      scope
     end
 
     def process_defn(exp)
@@ -53,14 +74,16 @@ module Reek
       handle_context(SingletonMethodContext, :defs, exp)
     end
 
-    def process_args(exp)
-      exp[1..-1].each {|sym| @element.record_parameter(sym) }
-    end
+    def process_args(exp) end
 
     def process_attrset(exp)
       @element.record_depends_on_self if /^@/ === exp[1].to_s
     end
 
+    def process_zsuper(exp)
+      @element.record_use_of_self
+    end
+
     def process_lit(exp)
       val = exp[1]
       @element.record_depends_on_self if val == :self
@@ -70,11 +93,6 @@ module Reek
       process(exp[1])
       handle_context(BlockContext, :iter, exp[2..-1])
     end
-    
-    def process_dasgn_curr(exp)
-      @element.record_parameter(exp[1])
-      process_default(exp)
-    end
 
     def process_block(exp)
       @element.count_statements(CodeParser.count_statements(exp))
@@ -90,19 +108,10 @@ module Reek
       process_default(exp)
     end
 
-    def process_fcall(exp)
-      @element.record_use_of_self
-      process_default(exp)
-    end
-
     def process_cfunc(exp)
       @element.record_depends_on_self
     end
 
-    def process_vcall(exp)
-      @element.record_use_of_self
-    end
-
     def process_attrasgn(exp)
       process_call(exp)
     end
@@ -112,7 +121,46 @@ module Reek
     end
 
     def process_if(exp)
+      @element.record_conditional(exp[1])
+      count_clause(exp[2])
+      count_clause(exp[3])
       handle_context(IfContext, :if, exp)
+      @element.count_statements(-1)
+    end
+
+    def process_while(exp)
+      process_until(exp)
+    end
+
+    def process_until(exp)
+      count_clause(exp[2])
+      process_default(exp)
+      @element.count_statements(-1)
+    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)
+      @element.record_conditional(exp[1])
+      process_default(exp)
+      @element.count_statements(-1)
+    end
+
+    def process_when(exp)
+      count_clause(exp[2])
+      process_default(exp)
     end
 
     def process_ivar(exp)
@@ -131,36 +179,35 @@ module Reek
     end
 
     def process_self(exp)
-      @element.record_depends_on_self
+      @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 is_expr?(stmts[0], :args)
       ignore += 1 if stmts[1] == s(:nil)
       stmts.length - ignore
     end
 
   private
 
-    def self.is_expr?(exp, type)
-      Array === exp and exp[0] == type
-    end
-
-    def self.is_global_variable?(exp)
-      is_expr?(exp, :gvar)
-    end
-
     def handle_context(klass, type, exp)
-      push(klass.new(@element, exp)) do
+      scope = klass.new(@element, exp)
+      push(scope) do
         process_default(exp)
         check_smells(type)
       end
+      scope
     end
 
     def check_smells(type)
-      @smells[type].each {|smell| smell.examine(@element, @report) }
+      @sniffer.examine(@element, type)
     end
 
     def push(context)
@@ -169,9 +216,5 @@ module Reek
       yield
       @element = orig
     end
-    
-    def pop(exp)
-      @element = @element.outer
-    end
   end
 end

data/lib/reek/command_line.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+require 'reek'
+
+module Reek
+    
+  # SMELL: Greedy Module
+  # This creates the command-line parser AND invokes it. And for the
+  # -v and -h options it also executes them. And it holds the config
+  # options for the rest of the application.
+  class Options
+
+    CTX_SORT = '%m%c %w (%s)'
+    SMELL_SORT = '%m[%s] %c %w'
+
+    def self.default_options
+      {
+        :format => CTX_SORT,
+        :show_all => false,
+        :quiet => false
+      }
+    end
+
+    # SMELL: Global Variable
+    @@opts = default_options
+
+    def self.[](key)
+      @@opts[key]
+    end
+
+    def initialize(argv)
+      @argv = argv
+      @parser = OptionParser.new
+      set_options
+    end
+
+    def parse
+      @parser.parse!(@argv)
+      @argv
+    end
+
+    def set_options
+      @parser.banner = <<EOB
+Usage: #{@parser.program_name} [options] [files]
+
+Examples:
+
+#{@parser.program_name} lib/*.rb
+#{@parser.program_name} -q -a lib
+cat my_class.rb | #{@parser.program_name}
+
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
+
+EOB
+
+      @parser.separator "Common options:"
+
+      @parser.on("-h", "--help", "Show this message") do
+        puts @parser
+        exit(0)
+      end
+      @parser.on("-v", "--version", "Show version") do
+        puts "#{@parser.program_name} #{Reek::VERSION}"
+        exit(0)
+      end
+
+      @parser.separator "\nReport formatting:"
+
+      @parser.on("-a", "--[no-]show-all", "Show all smells, including those masked by config settings") do |opt|
+        @@opts[:show_all] = opt
+      end
+      @parser.on("-q", "--quiet", "Suppress headings for smell-free source files") do
+        @@opts[:quiet] = true
+      end
+      @parser.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
+        @@opts[:format] = arg unless arg.nil?
+      end
+      @parser.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
+        @@opts[:format] = CTX_SORT
+      end
+      @parser.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
+        @@opts[:format] = SMELL_SORT
+      end
+    end
+  end
+end

data/lib/reek/configuration.rb

@@ -0,0 +1,51 @@
+module Reek
+
+  #
+  # Represents a single set of configuration options for a smell detector
+  #
+  class SmellConfiguration
+
+    # The name of the config field that specifies whether a smell is
+    # enabled. Set to +true+ or +false+.
+    ENABLED_KEY = 'enabled'
+
+    # The name of the config field that sets scope-specific overrides
+    # for other values in the current smell detector's configuration.
+    OVERRIDES_KEY = 'overrides'
+
+    attr_reader :hash
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # SMELL: Getter
+    def enabled?
+      @hash[ENABLED_KEY]
+    end
+
+    def overrides_for(context)
+      Overrides.new(@hash.fetch(OVERRIDES_KEY, {})).for_context(context)
+    end
+
+    # Retrieves the value, if any, for the given +key+.
+    #
+    # Returns +fall_back+ if this config has no value for the key.
+    #
+    def value(key, context, fall_back)
+      overrides_for(context).each { |conf| return conf[key] if conf.has_key?(key) }
+      return @hash.fetch(key, fall_back)
+    end
+  end
+
+  class Overrides
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def for_context(context)
+      contexts = @hash.keys.select {|ckey| context.matches?([ckey])}
+      contexts.map { |exc| @hash[exc] }
+    end
+  end
+end