teksymmetry-reek 1.1.3.1

data/History.txt

@@ -0,0 +1,131 @@
+== 1.1.4 (in git)
+
+=== Minor Changes
+* LongMethod now counts statements deeper into each method (#25)
+* LongMethod no longer counts control structures, only their contained stmts
+
+== 1.1.3 2009-05-19
+
+=== Minor Changes
+* No longer depends directly on the sexp_processor gem
+
+=== Fixes
+* LargeClass now relies only on the given source code (#26)
+
+== 1.1.2 2009-05-18
+
+=== Major Enhancements
+* Switched from ParseTree to ruby_parser for source code parsing
+* 'MyClass.should_not reek' now only possible if ParseTree gem installed
+
+== 1.1.1 2009-05-08
+
+=== Minor enhancements
+* LargeClass now also warns about any class with > 9 instance variables (#6)
+* Now depends on ruby2ruby, to display code better
+* Duplication notices more repeated method calls
+* Smells within blocks are now reported better
+
+== 1.1.0 2009-04-10
+
+=== Minor enhancements
+* Now possible to write 'MyClass.should_not reek' (#33)
+
+=== Fixes
+* Now counts attr assignments ([]= etc) in feature envy calculations
+* Doesn't attempt to find *.reek files when reading code from stdin
+
+== 1.0.1 2009-04-06
+
+=== Fixes
+* Dir[...].to_source now creates a Report that can be browsed (#36)
+
+== 1.0.0 2009-04-05
+
+=== Major enhancements
+* Use *.reek files in source tree to configure Reek's behaviour
+* Added -f option to configure report format
+* --sort_order replaced by -f, -c and -s
+* Matchers provided for rspec; eg. foo.should_not reek
+
+=== Minor enhancements
+* Smells in singleton methods are now analysed
+* Uncommunicative parameter names in blocks now reported
+* Modules and blocks now reflected in scope of smell reports
+
+=== Fixes
+* Corrected false reports of long arg lists to yield
+* A method can now be a UtilityFunction only when it includes a call
+
+== 0.3.1 2008-11-17
+
+=== Minor enhancements
+* Uncommunicative Name now checks instance variables more thoroughly
+* Uncommunicative Name now warns about names of the form 'x2'
+* Added check for duplicated calls within a method
+* Reduced scope of Feature Envy warnings to cover only overuse of lvars
+* Added rdoc comments explaining what each smell is about
+* Chained iterators are no longer mis-reported as nested
+
+== 0.3.0 2008-11-02
+
+=== Minor enhancements
+* New smell: first naive checks for Control Couple
+* reek now only checks sources passed on the command line
+* Code snippets can be supplied on the commandline
+* Added headings and warnings count when smells in multiple files
+* Added Reek::RakeTask to run reek from rakefiles
+
+=== Fixes
+* Fixed: Returns exit status 2 when smells are reported
+* Fixed: no longer claims an empty method is a Utility Function
+
+== 0.2.3 2008-09-22
+
+* Minor enhancements:
+  * Only reports Feature Envy when the method isn't a Utility Function
+  * General improvements to assessing Feature Envy
+* Tweaks:
+  * Fixed: coping with parameterless yield call
+  * Fixed: copes with :self as an expression
+  * Fixed: displaying the receiver of many more kinds of Feature Envy
+  * Fixed: Large Class calculation for Object
+
+== 0.2.2 2008-09-15
+
+* Tweaks:
+  * Fixed --version!
+
+== 0.2.1 2008-09-14
+
+* Tweaks:
+  * Now works from the source code, instead of requiring each named file
+  * Added integration tests that run reek on a couple of gems
+
+== 0.2.0 2008-09-10
+
+* Minor enhancements:
+  * Added --help, --version options
+  * Added --sort option to sort the report by smell or by code location
+
+== 0.1.1 2008-09-09
+
+* Some tweaks:
+  * Fixed report printing for Feature Envy when the receiver is a block
+  * Fixed: successive iterators reported as nested
+  * Fixed: Long Method now reports the total length of the method
+  * Fixed: each smell reported only once
+
+== 0.1.0 2008-09-09
+
+* 1 minor enhancement:
+  * Added a check for nested iterators within a method
+* Some tweaks:
+  * Begun adding some rdoc
+  * Split some of the specs into more meaningful chunks
+  * Updated the rakefile so that rcov is no longer the default
+
+== 0.0.1 2008-09-08
+
+* 1 major enhancement:
+  * Initial release

data/README.txt

@@ -0,0 +1,36 @@
+== Reek
+
+Code smell detection for Ruby.
+
+The documentation is at http://wiki.github.com/kevinrutherford/reek
+The code lives at http://github.com/kevinrutherford/reek/tree
+
+
+== How to use Uncommunicative name verifier extension ?
+
+ * Create your configuration reek file under your source base (RAILS_ROOT/app/app.reek)
+
+ * Add the following configurations -
+    UncommunicativeName:
+      verifierExtention:
+      - <path to your ruby script file>
+
+	example - 
+	UncommunicativeName:
+      verifierExtention:
+		  - config/smells/strict_uncommunicative_variable_name_verifier
+
+ * Remember ruby class name and file name must be similar,
+   Use "_" for separating different words. ie SimpleVerifier => simple_verifier.rb
+
+ * Write following class - 
+	class StrictUncommunicativeVariableNameVerifier 
+		def accepted?(p_context, p_variable_name)
+		  # do stuffs with variable name 
+		  # if it match your requirement 
+		  # return true, nil
+		  # otherwise
+		  # return false, "error message"
+		end
+	end
+	 

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rake'
+require 'rake/clean'
+
+$:.unshift File.dirname(__FILE__) + '/lib'
+
+PROJECT_NAME = 'reek'
+
+BUILD_DIR = 'build'; directory BUILD_DIR
+PKG_DIR = "#{BUILD_DIR}/pkg"; directory PKG_DIR
+RDOC_DIR = "#{BUILD_DIR}/rdoc"; directory RDOC_DIR
+
+GEM_MANIFEST = "Manifest.txt"
+VERSION_FILE = 'lib/reek.rb'
+
+CLOBBER.include("#{BUILD_DIR}/*")
+
+Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/reek

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+#
+# Reek examines Ruby source code for smells.
+# Visit http://reek.rubyforge.org/ for docs etc.
+#
+# Author: Kevin Rutherford
+#
+
+# Allow local access
+if ARGV.include?("-TX")
+  ARGV.delete("-TX")
+  require File.join('~/projects/tekSymmetry/reek', 'lib/reek')
+  require File.join('~/projects/tekSymmetry/reek', 'lib/reek/source')
+  require File.join('~/projects/tekSymmetry/reek', 'lib/reek/options')
+else
+  require 'reek'
+  require 'reek/source'
+  require 'reek/options'
+end
+
+exitstatus = 0
+source = Reek::Options.parse(ARGV)
+if source.smelly?
+  puts source.report
+  exitstatus = 2
+end
+exit(exitstatus)

data/config/defaults.reek

@@ -0,0 +1,51 @@
+--- 
+LargeClass: 
+  max_methods: 25
+  exclude: []
+
+  enabled: true
+  max_instance_variables: 9
+LongParameterList: 
+  max_params: 3
+  exclude: []
+
+  enabled: true
+FeatureEnvy: 
+  exclude: 
+  - initialize
+  enabled: true
+UncommunicativeName: 
+  accept: 
+  - Inline::C
+  exclude: []
+
+  enabled: true
+  reject: 
+  - !ruby/regexp /^.[0-9]*$/
+NestedIterators: 
+  exclude: []
+
+  enabled: true
+LongMethod: 
+  max_statements: 5
+  exclude: 
+  - initialize
+  enabled: true
+Duplication: 
+  exclude: []
+
+  enabled: true
+  max_calls: 1
+UtilityFunction: 
+  exclude: []
+
+  enabled: true
+ControlCouple: 
+  exclude: 
+  - initialize
+  enabled: true
+LongYieldList: 
+  max_params: 3
+  exclude: []
+
+  enabled: true

data/lib/reek/block_context.rb

@@ -0,0 +1,59 @@
+require 'set'
+require 'reek/code_context'
+
+module Reek
+
+  module ParameterSet
+    def names
+      return @names if @names
+      return (@names = []) if empty?
+      arg = slice(1)
+      case slice(0)
+      when :masgn
+        @names = arg[1..-1].map {|lasgn| Name.new(lasgn[1]) }
+      when :lasgn
+        @names = [Name.new(arg)]
+      end
+    end
+
+    def include?(name)
+      names.include?(name)
+    end
+  end
+
+  class BlockContext < CodeContext
+
+    def initialize(outer, exp)
+      super
+      @name = Name.new('block')
+      @parameters = exp[0] if exp
+      @parameters ||= []
+      @parameters.extend(ParameterSet)
+      @local_variables = Set.new
+    end
+
+    def inside_a_block?
+      true
+    end
+
+    def has_parameter(name)
+      @parameters.include?(name) or @outer.has_parameter(name)
+    end
+
+    def nested_block?
+      @outer.inside_a_block?
+    end
+    
+    def record_local_variable(sym)
+      @local_variables << Name.new(sym)
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}/"
+    end
+    
+    def variable_names
+      @parameters.names + @local_variables.to_a
+    end
+  end
+end

data/lib/reek/class_context.rb

@@ -0,0 +1,68 @@
+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)
+  end
+end
+
+module Reek
+  class ClassContext < CodeContext
+
+    def ClassContext.create(outer, exp)
+      res = Name.resolve(exp[1], outer)
+      ClassContext.new(res[0], res[1], exp[2])
+    end
+
+    def initialize(outer, name, superclass = nil)
+      super(outer, nil)
+      @name = name
+      @superclass = superclass
+      @parsed_methods = []
+      @instance_variables = Set.new
+    end
+
+    def myself
+      @myself ||= @outer.find_module(@name)
+    end
+
+    def find_module(modname)
+      return nil unless myself
+      @myself.const_or_nil(modname.to_s)
+    end
+
+    def is_overriding_method?(name)
+      return false unless myself
+      @myself.is_overriding_method?(name.to_s)
+    end
+    
+    def is_struct?
+      @superclass == [:const, :Struct]
+    end
+
+    def num_methods
+      @parsed_methods.length
+    end
+
+    def record_instance_variable(sym)
+      @instance_variables << Name.new(sym)
+    end
+
+    def record_method(name)
+      @parsed_methods << name.to_s
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}#"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+
+    def variable_names
+      @instance_variables
+    end
+  end
+end

data/lib/reek/code_context.rb

@@ -0,0 +1,54 @@
+class Module
+
+  def const_or_nil(sym)
+    const_defined?(sym) ? const_get(sym) : nil
+  end
+end
+
+module Reek
+  
+  #
+  # 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
+
+    def initialize(outer, exp)
+      @outer = outer
+      @exp = exp
+      @myself = nil
+    end
+
+    def matches?(strings)
+      me = @name.to_s
+      strings.any? do |str|
+        re = /#{str}/
+        re === me or re === self.to_s
+      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 outer_name
+      "#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+  end
+end

data/lib/reek/code_parser.rb

@@ -0,0 +1,221 @@
+require 'rubygems'
+require 'sexp'
+require 'reek/block_context'
+require 'reek/class_context'
+require 'reek/module_context'
+require 'reek/stop_context'
+require 'reek/if_context'
+require 'reek/method_context'
+require 'reek/singleton_method_context'
+require 'reek/yield_call_context'
+
+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
+      @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[0..-1].each { |sub| process(sub) if Array === sub }
+    end
+
+    def process_module(exp)
+      push(ModuleContext.create(@element, exp)) do
+        process_default(exp)
+        check_smells(:module)
+      end
+    end
+
+    def process_class(exp)
+      push(ClassContext.create(@element, exp)) do
+        process_default(exp) unless @element.is_struct?
+        check_smells(:class)
+      end
+    end
+
+    def process_defn(exp)
+      handle_context(MethodContext, :defn, exp)
+    end
+
+    def process_defs(exp)
+      handle_context(SingletonMethodContext, :defs, exp)
+    end
+
+    def process_args(exp)
+      exp[1..-1].each {|sym| @element.record_parameter(sym) }
+    end
+
+    def process_attrset(exp)
+      @element.record_depends_on_self if /^@/ === exp[1].to_s
+    end
+
+    def process_lit(exp)
+      val = exp[1]
+      @element.record_depends_on_self if val == :self
+    end
+
+    def process_iter(exp)
+      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))
+      process_default(exp)
+    end
+
+    def process_yield(exp)
+      handle_context(YieldCallContext, :yield, exp)
+    end
+
+    def process_call(exp)
+      @element.record_call_to(exp)
+      process_default(exp)
+    end
+
+    def process_cfunc(exp)
+      @element.record_depends_on_self
+    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])
+      handle_context(IfContext, :if, exp)
+      @element.count_statements(-1)
+    end
+
+    def process_while(exp)
+      count_clause(exp[2])
+      process_default(exp)
+      @element.count_statements(-1)
+    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_default(exp)
+      @element.count_statements(-1)
+    end
+
+    def process_rescue(exp)
+      count_clause(exp[1])
+      process_default(exp)
+      @element.count_statements(-1)
+    end
+
+    def process_resbody(exp)
+      count_clause(exp[2])
+      process_default(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_lasgn(exp)
+      @element.record_local_variable(exp[1])
+      process_default(exp)
+    end
+
+    def process_iasgn(exp)
+      @element.record_instance_variable(exp[1])
+      @element.record_depends_on_self
+      process_default(exp)
+    end
+
+    def process_self(exp)
+      @element.record_depends_on_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)
+      listeners = @smells[type]
+      listeners.each {|smell| smell.examine(@element, @report) } if listeners
+    end
+
+    def push(context)
+      orig = @element
+      @element = context
+      yield
+      @element = orig
+    end
+  end
+end

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