excellent 1.5.4

data/History.txt

@@ -0,0 +1,69 @@
+= 1.5.4
+
+* fixed handling of parser errors
+
+= 1.5.3
+
+* added missing dependency to facets gem
+
+= 1.5.2
+
+* added GlobalVariableCheck
+* added Rails::CustomInitializeMethodCheck
+* added Rails::ParamsHashInViewCheck
+* added Rails::SessionHashInViewCheck
+
+= 1.5.1
+
+* removed duplication checks (they are just too coarse for dynamic languages like Ruby and especially Rails apps where you would call e.g. params all over the place)
+* added Rails::ValidationsCheck to the default checks
+
+= 1.5.0
+
+* new check Rails::ValidationsCheck that reports ActiveRecord models that do not validate anything
+* added DuplicationCheck to default checks
+* split DuplicationCheck up into MethodDuplicationCheck and BlockDuplicationCheck
+
+= 1.4.1
+
+* added Rake Task (see Rakefile for example)
+
+= 1.4.0
+
+* Excellent not parses *.erb files
+* added new check InstanceVarInPartialCheck
+
+= 1.3.1
+
+* FIX (forgot files in gemspec on 1.3.0)
+
+= 1.3.0
+
+* added formatters (currently text and HTML formatting is supported, see README)
+
+= 1.2.2
+
+* fixed specs
+
+= 1.2.1
+
+* renamed Error to Warning
+* added documentation
+
+= 1.2.0
+
+* cleanup
+* added 2 Rails specific checks, AttrAccessibleCheck and AttrProtectedCheck
+
+= 1.1.0
+
+* completely restructured, made everything running in the flow of the SexpProcessor
+* added most tests from reek (except for UtilityFunction and FeatureEnvy)
+
+= 1.0.1
+
+* fixed some errors
+
+= 1.0.0
+
+* this is basically just a custom version of roodi, converted to ruby_parser to be 1.9 safe

data/README.rdoc

@@ -0,0 +1,72 @@
+= Excellent
+
+Excellent *finds the nasty lines in your code*. It implements a comprehensive set of checks for possibly buggy parts of your app that would *otherwise make it into your repo and eventually to the production server*.
+
+See the API documentation at http://docs.github.com/simplabs/excellent and the WIKI at http://wiki.github.com/simplabs/excellent.
+Join the Google Group and discuss about the future and possibilities of Excellent: http://groups.google.com/group/excellent-gem.
+
+Excellent also has a CI server set up at http://ci.simplabs.com/excellent.
+
+== Installation
+
+Simply install with Ruby Gems:
+
+  gem sources -a http://gems.github.com
+  sudo gem install simplabs-excellent
+
+== Example
+
+Assume you have the following class definition,
+
+  class ShoppingBasket < ActiveRecord::Base
+
+    def initialize(items = [])
+      self.items = items
+    end
+
+  end
+
+then Excellent will report the problems in this piece of code:
+
+  $ excellent shopping_basket.rb 
+
+    Excellent result:
+
+    test.rb
+      * Line   1: ShoppingBasket does not validate any attributes.
+      * Line   1: ShoppingBasket defines initialize method.
+      * Line   1: ShoppingBasket does not specify attr_accessible.
+
+    Found 3 warnings.
+
+To analyse all the models in your Rails application, just do
+
+  excellent app/models
+
+in your <tt>RAILS_ROOT</tt>. You can also invoke analysation through the Simplabs::Excellent::Runner class. Excellent can also produce HTML output. To
+get a formatted HTML report, just specify <tt>html:<filename></tt>:
+
+  excellent html:out.html app/models
+
+You can also use Excellent in a Rake task:
+
+  require 'simplabs/excellent/rake'
+
+  Simplabs::Excellent::Rake::ExcellentTask.new(:excellent) do |t|
+    t.html  = 'doc/excellent.html' # optional, if you don't specify html, output will be written to $stdout
+    t.paths = %w(app lib)
+  end
+
+== Static analysis
+
+A few words regarding static code analysis: Static code analysis tools like Excellent can never really understand the code. They just search for patterns that *might* inidicate problematic code. The word *might* really has to be stressed here since static analysis will usually return a reasonable number of false positives. For example, there might be pretty good reasons for empty +rescue+ blocks that suppress all errors (Excellent itself does it). So, don't try and code with the aim of passing Excellent with zero warnings. That will most likely make your code a mess. Instead use Excellent as a helper to find *possibly* problematic code early.
+
+== Contribute
+
+If you want to contribute, just fork the repo. Also I would appretiate suggestions for more checks (especially Rails specific checks) - simply open a new issue: http://github.com/simplabs/excellent/issues.
+
+== Author
+
+Copyright (c) 2008-2009 Marco Otte-Witte (http://simplabs.com), released under the MIT license.
+
+Excellent was inspired by roodi (http://github.com/martinjandrews/roodi), reek (http://github.com/kevinrutherford/reek) and flog (http://github.com/seattlerb/flog).

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 5
+:patch: 4

data/bin/excellent

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+require 'simplabs/excellent'
+require 'pathname'
+
+excellent = Simplabs::Excellent::Runner.new
+
+if ARGV.first =~ /html:[^\s]+/
+  begin
+    output = File.open(ARGV.first.sub(/html:/, ''), 'w+')
+    formatter = Simplabs::Excellent::Formatters::Html.new(output)
+    ARGV.shift
+  rescue
+  end
+else
+  formatter = Simplabs::Excellent::Formatters::Text.new
+end
+
+if ARGV.empty?
+  puts "\n  You must specify one or more directories to analyse, e.g.:\n"
+  puts "\n    excellent app/\n\n"
+  exit 1
+end
+
+begin
+  excellent.check_paths(ARGV, formatter)
+rescue ArgumentError
+  puts "\n** Excellent cannot find the paths specified!\n\n"
+  exit 1
+end
+
+exit 0

data/lib/simplabs/excellent.rb

@@ -0,0 +1,16 @@
+require 'simplabs/excellent/checks'
+require 'simplabs/excellent/parsing'
+require 'simplabs/excellent/formatters'
+require 'simplabs/excellent/runner'
+require 'rubygems'
+require 'sexp'
+
+module Simplabs #:nodoc:
+
+  module Excellent #:nodoc:
+
+    VERSION = '1.5.1'
+
+  end
+
+end

data/lib/simplabs/excellent/checks.rb

@@ -0,0 +1,33 @@
+module Simplabs
+
+  module Excellent
+
+    module Checks #:nodoc:
+    end
+
+  end
+
+end
+
+require 'simplabs/excellent/checks/abc_metric_method_check'
+require 'simplabs/excellent/checks/assignment_in_conditional_check'
+require 'simplabs/excellent/checks/case_missing_else_check'
+require 'simplabs/excellent/checks/class_line_count_check'
+require 'simplabs/excellent/checks/class_name_check'
+require 'simplabs/excellent/checks/singleton_variable_check'
+require 'simplabs/excellent/checks/global_variable_check'
+require 'simplabs/excellent/checks/control_coupling_check'
+require 'simplabs/excellent/checks/cyclomatic_complexity_block_check'
+require 'simplabs/excellent/checks/cyclomatic_complexity_method_check'
+require 'simplabs/excellent/checks/empty_rescue_body_check'
+require 'simplabs/excellent/checks/for_loop_check'
+require 'simplabs/excellent/checks/method_line_count_check'
+require 'simplabs/excellent/checks/method_name_check'
+require 'simplabs/excellent/checks/module_line_count_check'
+require 'simplabs/excellent/checks/module_name_check'
+require 'simplabs/excellent/checks/parameter_number_check'
+require 'simplabs/excellent/checks/nested_iterators_check'
+require 'simplabs/excellent/checks/flog_method_check'
+require 'simplabs/excellent/checks/flog_block_check'
+require 'simplabs/excellent/checks/flog_class_check'
+require 'simplabs/excellent/checks/rails'

data/lib/simplabs/excellent/checks/abc_metric_method_check.rb

@@ -0,0 +1,43 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports methods with an ABC metric score that is higher than the threshold. The ABC metric is basically a measure for complexity
+      # and is calculated as:
+      #
+      #  a = number of assignments
+      #  b = number of branches
+      #  c = number of conditions
+      #
+      #  score = Math.sqrt(a*a + b*b + c*c)
+      #
+      # ==== Applies to
+      #
+      # * methods
+      class AbcMetricMethodCheck < Base
+
+        DEFAULT_THRESHOLD = 10
+
+        def initialize(options = {}) #:nodoc:
+          super()
+          @threshold         = options[:threshold] || DEFAULT_THRESHOLD
+          @interesting_nodes = [:defn, :defs]
+        end
+
+        def evaluate(context) #:nodoc:
+          unless context.abc_score <= @threshold
+            add_warning(context, '{{method}} has abc score of {{score}}.', { :method => context.full_name, :score => context.abc_score })
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/assignment_in_conditional_check.rb

@@ -0,0 +1,39 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports conditionals that test an assignment as in
+      #
+      #  something(var) if var = method()
+      #
+      # Assignments in conditions are often typos.
+      #
+      # ==== Applies to
+      #
+      # * +if+
+      # * +else+
+      # * +while+
+      # * +until+
+      class AssignmentInConditionalCheck < Base
+
+        def initialize(options = {}) #:nodoc:
+          super()
+          @interesting_nodes = [:if, :while, :until]
+          @interesting_files = [/\.rb$/, /\.erb$/]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Assignment in condition.') if context.tests_assignment?
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/base.rb

@@ -0,0 +1,62 @@
+require 'simplabs/excellent/warning'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This is the base class for all code checks. All checks must specify +interesting_nodes+. When one of these nodes is processed by Excellent, it
+      # will invoke the +evaluate_node+ method of all checks that specify the node as one if their +interesting_nodes+.
+      class Base
+
+        attr_reader :warnings
+
+        # An array of node types that are interesting for the check. These are symbols as returned by RubyParser (see http://parsetree.rubyforge.org/ruby_parser/),
+        # e.g. <tt>:if</tt> or <tt>:defn</tt>
+        attr_reader :interesting_nodes
+
+        # An array of regular expressions for file names that are interesting for the check. These will usually be path extensions rather than longer
+        # patterns (e.g. *.rb as well as *.erb files or *.rb files only).
+        #
+        # Defaults to /\.rb$/. If you do not specify anything else in custom checks, only *.rb files will be processed
+        attr_reader :interesting_files
+
+        def initialize #:nodoc:
+          @warnings          = []
+          @interesting_files = [/\.rb$/]
+        end
+
+        # This method is called whenever Excellent processes a node that the check specified as one of the nodes it is interested in (see interesting_nodes).
+        #
+        # ==== Parameters
+        #
+        # * <tt>context</tt> - This is the last context the code processor has constructed. It contains all information required to execute the check (see Simplabs::Excellent::Parsing::SexpContext).
+        def evaluate_node(context)
+          evaluate(context)
+        end
+
+        # Adds a warning
+        #
+        # ==== Parameters
+        #
+        # * <tt>context</tt> - The context the check has been executed on.
+        # * <tt>message</tt> - The warning message.
+        # * <tt>info</tt> - The information hash that contains more info on the finding.
+        # * <tt>offset</tt> - The line offset that is added to the context's line property.
+        def add_warning(context, message, info = {}, offset = 0)
+          klass = self.class
+          @warnings << Simplabs::Excellent::Warning.new(klass, message, context.file, context.line + offset, info)
+        end
+  
+        def warnings_for(filename) #:nodoc:
+          warnings.select { |warning| warning.filename == filename }
+        end
+  
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/case_missing_else_check.rb

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports +case+ statements that don't have an +else+ clause that would be executed when no case matches. If the tested value will never
+      # adopt any other values than the ones tested for in the cases, this should be expressed in the code by e.g. throwing an exception in the +else+
+      # clause.
+      #
+      # ==== Applies to
+      #
+      # * +case+ statements
+      class CaseMissingElseCheck < Base
+
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:case]
+          @interesting_files = [/\.rb$/, /\.erb$/]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Case statement is missing else clause.') unless context.has_else_clause?
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/class_line_count_check.rb

@@ -0,0 +1,36 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports classes which have more lines than the threshold. Classes with a large number of lines are hard to read and understand and
+      # often an indicator for badly designed code as well.
+      #
+      # ==== Applies to
+      #
+      # * classes
+      class ClassLineCountCheck < LineCountCheck
+
+        DEFAULT_THRESHOLD = 400
+
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:class], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{class}} has {{count}} lines.', { :class => context.full_name, :count => context.line_count }]
+          end
+
+      end
+
+    end
+
+  end
+
+end