README.rdoc lib/simplabs/excellent/parsing.rb lib/simplabs/excellent/warning.rb @@ -1,4 +1,4 @@ -Copyright (c) 2008 Marco Otte-Witte +Copyright (c) 2008-2009 Marco Otte-Witte Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the MIT-LICENSE @@ -27,6 +27,15 @@ Spec::Rake::SpecTask.new('spec') do |t| t.spec_files = FileList['spec/**/*_spec.rb'] end +desc 'Generate documentation for the Excellent gem.' +Rake::RDocTask.new(:rdoc) do |rdoc| + rdoc.rdoc_dir = 'doc' + rdoc.title = 'Excellent' + rdoc.options << '--line-numbers' << '--inline-source' + rdoc.rdoc_files.include('README.rdoc') + rdoc.rdoc_files.include('lib/**/*.rb') +end + desc 'Run Excellent against all source files' task :excellent do puts `bin/excellent "lib/**/*.rb"` Rakefile @@ -1,4 +1,4 @@ --- :major: 1 -:minor: 1 +:minor: 2 :patch: 0 VERSION.yml @@ -18,12 +18,12 @@ ARGV.each do |arg| end end -unless excellent.errors.empty? - puts "\n Errors:\n\n" - excellent.errors.each do |error| - puts " * File #{error.filename}, line #{error.line_number}: #{error.message}" +unless excellent.warnings.empty? + puts "\n Warnings:\n\n" + excellent.warnings.each do |warning| + puts " * File #{warning.filename}, line #{warning.line_number}: #{warning.message}" end end -puts "\n Found #{excellent.errors.size} errors.\n\n" +puts "\n Found #{excellent.warnings.size} warnings.\n\n" exit 0 bin/excellent @@ -1,14 +1,13 @@ require 'simplabs/excellent/checks' -require 'simplabs/excellent/error' -require 'simplabs/excellent/runner' +require 'simplabs/excellent/parsing' require 'rubygems' require 'sexp' -module Simplabs +module Simplabs #:nodoc: - module Excellent + module Excellent #:nodoc: - VERSION = '1.1.0' + VERSION = '1.2.0' end lib/simplabs/excellent.rb @@ -1,3 +1,14 @@ +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' lib/simplabs/excellent/checks.rb @@ -6,22 +6,31 @@ module Simplabs 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 = {}) + def initialize(options = {}) #:nodoc: super() - @threshold = options[:threshold] || DEFAULT_THRESHOLD + @threshold = options[:threshold] || DEFAULT_THRESHOLD + @interesting_nodes = [:defn, :defs] end - def interesting_nodes - [:defn, :defs] - end - - def evaluate(context) + def evaluate(context) #:nodoc: unless context.abc_score <= @threshold - add_error(context, '{{method}} has abc score of {{score}}.', { :method => context.full_name, :score => context.abc_score }) + add_warning(context, '{{method}} has abc score of {{score}}.', { :method => context.full_name, :score => context.abc_score }) end end lib/simplabs/excellent/checks/abc_metric_method_check.rb @@ -6,18 +6,27 @@ module Simplabs 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 = {}) + def initialize(options = {}) #:nodoc: super() + @interesting_nodes = [:if, :while, :until] end - def interesting_nodes - [:if, :while, :until] - end - - def evaluate(context) - add_error(context, 'Assignment in condition.') if context.tests_assignment? + def evaluate(context) #:nodoc: + add_warning(context, 'Assignment in condition.') if context.tests_assignment? end end lib/simplabs/excellent/checks/assignment_in_conditional_check.rb @@ -1,4 +1,4 @@ -require 'simplabs/excellent/error' +require 'simplabs/excellent/warning' module Simplabs @@ -6,21 +6,40 @@ module Simplabs 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 :errors + attr_reader :warnings - def initialize - @errors = [] + # 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 + + def initialize #:nodoc: + @warnings = [] 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 - - def add_error(context, message, info = {}, offset = 0) + + # 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 - @errors << Simplabs::Excellent::Error.new(klass, message, context.file, context.line + offset, info) + @warnings << Simplabs::Excellent::Warning.new(klass, message, context.file, context.line + offset, info) end end lib/simplabs/excellent/checks/base.rb @@ -6,14 +6,22 @@ module Simplabs 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 interesting_nodes - [:case] + def initialize #:nodoc: + super + @interesting_nodes = [:case] end - - def evaluate(context) - add_error(context, 'Case statement is missing else clause.') unless context.has_else_clause? + + def evaluate(context) #:nodoc: + add_warning(context, 'Case statement is missing else clause.') unless context.has_else_clause? end end lib/simplabs/excellent/checks/case_missing_else_check.rb @@ -6,18 +6,24 @@ module Simplabs 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 = 300 + DEFAULT_THRESHOLD = 400 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:class], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{class}} has {{count}} lines.', { :class => context.full_name, :count => context.line_count }] end lib/simplabs/excellent/checks/class_line_count_check.rb @@ -6,18 +6,26 @@ module Simplabs module Checks + # This check reports classes with bad names. Badly named classes make reading and understanding the code much harder. Class names regarded as bad + # are for example: + # + # * names that are not Pascal cased (camel cased, starting with an upper case letter) + # + # ==== Applies to + # + # * classes class ClassNameCheck < NameCheck DEFAULT_PATTERN = /^[A-Z]{1}[a-zA-Z0-9]*$/ - def initialize(options = {}) + def initialize(options = {}) #:nodoc: pattern = options[:pattern] || DEFAULT_PATTERN super([:class], pattern) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, 'Bad class name {{class}}.', { :class => context.full_name }] end lib/simplabs/excellent/checks/class_name_check.rb @@ -6,15 +6,23 @@ module Simplabs module Checks + # This check reports methods that check the value of a parameter to decide which execution path to take. Control Coupling introduces a + # dependency between the caller and the callee. Any changes to the possible values of the parameter must be reflected at the caller side + # as well as at the called method. + # + # ==== Applies to + # + # * methods class ControlCouplingCheck < Base - def interesting_nodes - [:if, :case] + def initialize #:nodoc: + super + @interesting_nodes = [:if, :case] end - def evaluate(context) + def evaluate(context) #:nodoc: if tested_parameter = context.tests_parameter? - add_error(context, '{{method}} is coupled to {{argument}}.', { :method => context.parent.full_name, :argument => tested_parameter.to_s }, -2) + add_warning(context, '{{method}} is coupled to {{argument}}.', { :method => context.parent.full_name, :argument => tested_parameter.to_s }, -2) end end lib/simplabs/excellent/checks/control_coupling_check.rb @@ -6,21 +6,36 @@ module Simplabs module Checks + # This check reports code with a cyclomatic complexity metric score that is higher than the threshold. The cyclomatic complexity metric counts + # the number of linearly independent paths through the code. This is basically the number of the following statements + 1: + # + # * +if+ + # * +else+ + # * unless + # * +while+ + # * +until+ + # * +for+ + # * +rescue+ + # * +case+ + # * +when+ + # * +and+ + # * +or+ + # + # ==== Applies to + # + # * blocks class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck DEFAULT_THRESHOLD = 4 - def initialize(options = {}) - super(options[:threshold] || DEFAULT_THRESHOLD) + def initialize(options = {}) #:nodoc: + threshold = options[:threshold] || DEFAULT_THRESHOLD + super([:iter], threshold) end - def interesting_nodes - [:iter] - end - - def evaluate(context) + def evaluate(context) #:nodoc: unless context.cc_score <= @threshold - add_error(context, '{{block}} has cyclomatic complexity of {{score}}.', { :block => context.full_name, :score => context.cc_score }) + add_warning(context, '{{block}} has cyclomatic complexity of {{score}}.', { :block => context.full_name, :score => context.cc_score }) end end lib/simplabs/excellent/checks/cyclomatic_complexity_block_check.rb @@ -6,11 +6,12 @@ module Simplabs module Checks - class CyclomaticComplexityCheck < Base + class CyclomaticComplexityCheck < Base #:nodoc: - def initialize(threshold) + def initialize(interesting_nodes, threshold) super() - @threshold = threshold + @interesting_nodes = interesting_nodes + @threshold = threshold end end lib/simplabs/excellent/checks/cyclomatic_complexity_check.rb @@ -6,21 +6,36 @@ module Simplabs module Checks + # This check reports code with a cyclomatic complexity metric score that is higher than the threshold. The cyclomatic complexity metric counts + # the number of linearly independent paths through the code. This is basically the number of the following statements + 1: + # + # * +if+ + # * +else+ + # * unless + # * +while+ + # * +until+ + # * +for+ + # * +rescue+ + # * +case+ + # * +when+ + # * +and+ + # * +or+ + # + # ==== Applies to + # + # * methods class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck DEFAULT_THRESHOLD = 8 - def initialize(options = {}) - super(options[:threshold] || DEFAULT_THRESHOLD) + def initialize(options = {}) #:nodoc: + threshold = options[:threshold] || DEFAULT_THRESHOLD + super([:defn, :defs], threshold) end - def interesting_nodes - [:defn, :defs] - end - - def evaluate(context) + def evaluate(context) #:nodoc: unless context.cc_score <= @threshold - add_error(context, '{{method}} has cyclomatic complexity of {{score}}.', { :method => context.full_name, :score => context.cc_score }) + add_warning(context, '{{method}} has cyclomatic complexity of {{score}}.', { :method => context.full_name, :score => context.cc_score }) end end lib/simplabs/excellent/checks/cyclomatic_complexity_method_check.rb @@ -6,23 +6,30 @@ module Simplabs module Checks + # This check reports duplicated code. It currently finds repeated identical method calls such as: + # + # def method + # other_method + other_method + # end + # + # ==== Applies to + # + # * methods + # * blocks class DuplicationCheck < Base DEFAULT_THRESHOLD = 1 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: super() - @threshold = options[:threshold] || DEFAULT_THRESHOLD + @threshold = options[:threshold] || DEFAULT_THRESHOLD + @interesting_nodes = [:defn, :defs, :iter] end - def interesting_nodes - [:defn, :defs, :iter] - end - - def evaluate(context) + def evaluate(context) #:nodoc: context.calls.each do |call, number| if number > @threshold && call.method != 'new' - add_error( + add_warning( context, '{{method}} calls {{statement}} {{duplication_number}} times.', { :method => context.full_name, lib/simplabs/excellent/checks/duplication_check.rb @@ -6,14 +6,20 @@ module Simplabs module Checks + # This check reports empty rescue blocks. Empty rescue blocks suppress all errors which is usually not a good technique. + # + # ==== Applies to + # + # * +rescue+ blocks class EmptyRescueBodyCheck < Base - def interesting_nodes - [:resbody] + def initialize #:nodoc: + super + @interesting_nodes = [:resbody] end - def evaluate(context) - add_error(context, 'Rescue block is empty.', {}, -1) unless context.has_statements? + def evaluate(context) #:nodoc: + add_warning(context, 'Rescue block is empty.', {}, -1) unless context.has_statements? end end lib/simplabs/excellent/checks/empty_rescue_body_check.rb @@ -6,18 +6,28 @@ module Simplabs module Checks + # This check reports code with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity + # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or + # +class_eval+ are weighted higher than regular method calls. + # + # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see + # http://github.com/seattlerb/flog. + # + # ==== Applies to + # + # * blocks class FlogBlockCheck < FlogCheck DEFAULT_THRESHOLD = 15 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:iter], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{block}} has flog score of {{score}}.', { :block => context.full_name, :score => context.flog_score }] end lib/simplabs/excellent/checks/flog_block_check.rb @@ -6,7 +6,7 @@ module Simplabs module Checks - class FlogCheck < Base + class FlogCheck < Base #:nodoc: def initialize(interesting_nodes, threshold) super() @@ -14,12 +14,8 @@ module Simplabs @threshold = threshold end - def interesting_nodes - @interesting_nodes - end - def evaluate(context) - add_error(*error_args(context)) unless context.flog_score <= @threshold + add_warning(*warning_args(context)) unless context.flog_score <= @threshold end end lib/simplabs/excellent/checks/flog_check.rb @@ -6,18 +6,28 @@ module Simplabs module Checks + # This check reports code with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity + # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or + # +class_eval+ are weighted higher than regular method calls. + # + # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see + # http://github.com/seattlerb/flog. + # + # ==== Applies to + # + # * classes class FlogClassCheck < FlogCheck DEFAULT_THRESHOLD = 300 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:class], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{class}} has flog score of {{score}}.', { :class => context.full_name, :score => context.flog_score }] end lib/simplabs/excellent/checks/flog_class_check.rb @@ -6,18 +6,28 @@ module Simplabs module Checks + # This check reports code with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity + # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or + # +class_eval+ are weighted higher than regular method calls. + # + # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see + # http://github.com/seattlerb/flog. + # + # ==== Applies to + # + # * methods class FlogMethodCheck < FlogCheck DEFAULT_THRESHOLD = 30 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:defn, :defs], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{method}} has flog score of {{score}}.', { :method => context.full_name, :score => context.flog_score }] end lib/simplabs/excellent/checks/flog_method_check.rb @@ -6,14 +6,30 @@ module Simplabs module Checks + # This check reports code that uses +for+ loops as in: + # + # for user in @users + # do_something(user) + # end + # + # The use of for loops in Ruby is contrary to the language's basic concept of iterators. The above statement would better be written as: + # + # @users.each do |user| + # do_something(user) + # end + # + # ==== Applies to + # + # * +for+ loops class ForLoopCheck < Base - def interesting_nodes - [:for] + def initialize #:nodoc: + super + @interesting_nodes = [:for] end - def evaluate(context) - add_error(context, 'For loop used.') + def evaluate(context) #:nodoc: + add_warning(context, 'For loop used.') end end lib/simplabs/excellent/checks/for_loop_check.rb @@ -6,7 +6,7 @@ module Simplabs module Checks - class LineCountCheck < Base + class LineCountCheck < Base #:nodoc: def initialize(interesting_nodes, threshold) super() @@ -14,12 +14,8 @@ module Simplabs @threshold = threshold end - def interesting_nodes - @interesting_nodes - end - def evaluate(context) - add_error(*error_args(context)) unless context.line_count <= @threshold + add_warning(*warning_args(context)) unless context.line_count <= @threshold end end lib/simplabs/excellent/checks/line_count_check.rb @@ -6,18 +6,24 @@ module Simplabs module Checks + # This check reports methods which have more lines than the threshold. Methods with a large number of lines are hard to read and understand + # and often an indicator for badly designed code as well. + # + # ==== Applies to + # + # * methods class MethodLineCountCheck < LineCountCheck DEFAULT_THRESHOLD = 20 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:defn], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{method}} has {{count}} lines.', { :method => context.full_name, :count => context.line_count }] end lib/simplabs/excellent/checks/method_line_count_check.rb @@ -6,18 +6,26 @@ module Simplabs module Checks + # This check reports methods with bad names. Badly named methods make reading and understanding the code much harder. Method names regarded as bad + # are for example: + # + # * names that are camel cased + # + # ==== Applies to + # + # * methods class MethodNameCheck < NameCheck DEFAULT_PATTERN = /^[_a-z<>=\[|+-\/\*\~\%\&`\|\^]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ - def initialize(options = {}) + def initialize(options = {}) #:nodoc: pattern = options['pattern'] || DEFAULT_PATTERN super([:defn, :defs], pattern) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, 'Bad method name {{method}}.', { :method => context.full_name }] end lib/simplabs/excellent/checks/method_name_check.rb @@ -6,18 +6,24 @@ module Simplabs module Checks + # This check reports modules which have more lines than the threshold. Modules with a large number of lines are hard to read and understand + # and often an indicator for badly designed code as well. + # + # ==== Applies to + # + # * modules class ModuleLineCountCheck < LineCountCheck DEFAULT_THRESHOLD = 300 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: threshold = options[:threshold] || DEFAULT_THRESHOLD super([:module], threshold) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, '{{module}} has {{count}} lines.', { :module => context.full_name, :count => context.line_count }] end lib/simplabs/excellent/checks/module_line_count_check.rb @@ -6,18 +6,26 @@ module Simplabs module Checks + # This check reports modules with bad names. Badly named modules make reading and understanding the code much harder. Module names regarded as bad + # are for example: + # + # * names that are not Pascal cased (camel cased, starting with an upper case letter) + # + # ==== Applies to + # + # * modules class ModuleNameCheck < NameCheck DEFAULT_PATTERN = /^[A-Z][a-zA-Z0-9]*$/ - def initialize(options = {}) + def initialize(options = {}) #:nodoc: pattern = options['pattern'] || DEFAULT_PATTERN super([:module], pattern) end protected - def error_args(context) + def warning_args(context) #:nodoc: [context, 'Bad module name {{module}}.', { :module => context.full_name }] end lib/simplabs/excellent/checks/module_name_check.rb @@ -6,7 +6,7 @@ module Simplabs module Checks - class NameCheck < Base + class NameCheck < Base #:nodoc: def initialize(interesting_nodes, pattern) super() @@ -14,12 +14,8 @@ module Simplabs @pattern = pattern end - def interesting_nodes - @interesting_nodes - end - def evaluate(context) - add_error(*error_args(context)) unless context.name.to_s =~ @pattern + add_warning(*warning_args(context)) unless context.name.to_s =~ @pattern end end lib/simplabs/excellent/checks/name_check.rb @@ -6,15 +6,21 @@ module Simplabs module Checks + # This check reports nested iterators. Nested iterators lead to introduce performance issues. + # + # ==== Applies to + # + # * blocks class NestedIteratorsCheck < Base - def interesting_nodes - [:iter] + def initialize #:nodoc: + super + @interesting_nodes = [:iter] end - def evaluate(context) + def evaluate(context) #:nodoc: if context.inside_block? - add_error(context, '{{block}} inside of {{parent}}.', { :block => context.full_name, :parent => context.parent.full_name }) + add_warning(context, '{{block}} inside of {{parent}}.', { :block => context.full_name, :parent => context.parent.full_name }) end end lib/simplabs/excellent/checks/nested_iterators_check.rb @@ -6,22 +6,26 @@ module Simplabs module Checks + # This check reports method and blocks that have more parameters than the threshold. Methods with long parameter lists are harder to understand + # and often an indicator for bad design as well. + # + # ==== Applies to + # + # * methods + # * blocks class ParameterNumberCheck < Base DEFAULT_THRESHOLD = 3 - def initialize(options = {}) + def initialize(options = {}) #:nodoc: super() - @threshold = options[:threshold] || DEFAULT_THRESHOLD + @threshold = options[:threshold] || DEFAULT_THRESHOLD + @interesting_nodes = [:defn, :iter, :defs] end - def interesting_nodes - [:defn, :iter, :defs] - end - - def evaluate(context) + def evaluate(context) #:nodoc: unless context.parameters.length <= @threshold - add_error(context, '{{method}} has {{parameters}} parameters.', { :method => context.full_name, :parameters => context.parameters.length }) + add_warning(context, '{{method}} has {{parameters}} parameters.', { :method => context.full_name, :parameters => context.parameters.length }) end end lib/simplabs/excellent/checks/parameter_number_check.rb @@ -1,2 +1,17 @@ +module Simplabs + + module Excellent + + module Checks + + module Rails #:nodoc: + end + + end + + end + +end + require 'simplabs/excellent/checks/rails/attr_accessible_check' require 'simplabs/excellent/checks/rails/attr_protected_check' lib/simplabs/excellent/checks/rails.rb @@ -8,14 +8,23 @@ module Simplabs module Rails + # This check reports +ActiveRecord+ models that do not specify +attr_accessible+. Specifying +attr_accessible+ is viable to protect models from + # mass assignment attacks (see http://guides.rubyonrails.org/security.html#mass-assignment). +attr_accessible+ specifies a list of properties + # that are writeable by mass assignments. For a +User+ model for example, that list would possibly include properties like +first_name+ and + # +last_name+ while it should not include properties like +is_admin+. + # + # ==== Applies to + # + # * +ActiveRecord+ models class AttrAccessibleCheck < Base - def interesting_nodes - [:class] + def initialize #:nodoc: + super + @interesting_nodes = [:class] end - def evaluate(context) - add_error(context, '{{class}} does not specify attr_accessible.', { :class => context.full_name }) if context.activerecord_model? && !context.specifies_attr_accessible? + def evaluate(context) #:nodoc: + add_warning(context, '{{class}} does not specify attr_accessible.', { :class => context.full_name }) if context.activerecord_model? && !context.specifies_attr_accessible? end end lib/simplabs/excellent/checks/rails/attr_accessible_check.rb @@ -8,14 +8,23 @@ module Simplabs module Rails + # This check reports +ActiveRecord+ models that specify +attr_protected+. Like +attr_accessible+, +attr_protected+ is a helper to secure + # +ActiveRecord+ models against mass assignment attacks, but instead of specifying a white list of properties that are writeable by mass + # assignments as +attr_accessible+ does, +attr_protected+ specifies a black list. Such a black list approach is usually less secure since + # the list has to be updated for every new property that is introduced, which is easy to forget. + # + # ==== Applies to + # + # * +ActiveRecord+ models class AttrProtectedCheck < Base - def interesting_nodes - [:class] + def initialize #:nodoc: + super + @interesting_nodes = [:class] end - def evaluate(context) - add_error(context, '{{class}} specifies attr_protected.', { :class => context.full_name }) if context.activerecord_model? && context.specifies_attr_protected? + def evaluate(context) #:nodoc: + add_warning(context, '{{class}} specifies attr_protected.', { :class => context.full_name }) if context.activerecord_model? && context.specifies_attr_protected? end end lib/simplabs/excellent/checks/rails/attr_protected_check.rb @@ -6,14 +6,21 @@ module Simplabs module Checks + # This check reports class variables. Class variables in Ruby have a very complicated inheritance policy that often leads to errors. Usually class + # variables can be replaced with another construct which will also lead to better design. + # + # ==== Applies to + # + # * class variables class SingletonVariableCheck < Base - def interesting_nodes - [:cvar] + def initialize #:nodoc: + super + @interesting_nodes = [:cvar] end - def evaluate(context) - add_error(context, 'Singleton variable {{variable}} used.', { :variable => context.full_name }) + def evaluate(context) #:nodoc: + add_warning(context, 'Singleton variable {{variable}} used.', { :variable => context.full_name }) end end lib/simplabs/excellent/checks/singleton_variable_check.rb @@ -2,7 +2,7 @@ module Simplabs module Excellent - module Extensions + module Extensions #:nodoc: ::Sexp.class_eval do lib/simplabs/excellent/extensions/sexp.rb @@ -2,7 +2,7 @@ module Simplabs module Excellent - module Extensions + module Extensions #:nodoc: ::String.class_eval do lib/simplabs/excellent/extensions/string.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - module AbcMeasure + module AbcMeasure #:nodoc: CONDITIONS = [:==, :<=, :>=, :<, :>] lib/simplabs/excellent/parsing/abc_measure.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class BlockContext < SexpContext + class BlockContext < SexpContext #:nodoc: include CyclomaticComplexityMeasure include FlogMeasure lib/simplabs/excellent/parsing/block_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class CallContext < SexpContext + class CallContext < SexpContext #:nodoc: include Comparable lib/simplabs/excellent/parsing/call_context.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class CaseContext < ConditionalContext + class CaseContext < ConditionalContext #:nodoc: def initialize(exp, parent) super lib/simplabs/excellent/parsing/case_context.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class ClassContext < SexpContext + class ClassContext < SexpContext #:nodoc: include FlogMeasure include Scopeable lib/simplabs/excellent/parsing/class_context.rb @@ -20,7 +20,7 @@ module Simplabs module Parsing - class CodeProcessor < SexpProcessor + class CodeProcessor < SexpProcessor #:nodoc: def initialize(checks) setup_checks(checks) lib/simplabs/excellent/parsing/code_processor.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class ConditionalContext < SexpContext + class ConditionalContext < SexpContext #:nodoc: protected lib/simplabs/excellent/parsing/conditional_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class CvarContext < SexpContext + class CvarContext < SexpContext #:nodoc: def initialize(exp, parent) super lib/simplabs/excellent/parsing/cvar_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - module CyclomaticComplexityMeasure + module CyclomaticComplexityMeasure #:nodoc: COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or] lib/simplabs/excellent/parsing/cyclomatic_complexity_measure.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - module FlogMeasure + module FlogMeasure #:nodoc: SCORES = Hash.new(1) SCORES.merge!( lib/simplabs/excellent/parsing/flog_measure.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class ForLoopContext < SexpContext + class ForLoopContext < SexpContext #:nodoc: end lib/simplabs/excellent/parsing/for_loop_context.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class IfContext < ConditionalContext + class IfContext < ConditionalContext #:nodoc: def initialize(exp, parent) super lib/simplabs/excellent/parsing/if_context.rb @@ -8,7 +8,7 @@ module Simplabs module Parsing - class MethodContext < SexpContext + class MethodContext < SexpContext #:nodoc: include CyclomaticComplexityMeasure include AbcMeasure lib/simplabs/excellent/parsing/method_context.rb @@ -6,7 +6,7 @@ module Simplabs module Parsing - class ModuleContext < SexpContext + class ModuleContext < SexpContext #:nodoc: include Scopeable lib/simplabs/excellent/parsing/module_context.rb @@ -8,7 +8,7 @@ module Simplabs module Parsing - class Parser + class Parser #:nodoc: def parse(content, filename) silence_stream(STDERR) do lib/simplabs/excellent/parsing/parser.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class ResbodyContext < SexpContext + class ResbodyContext < SexpContext #:nodoc: STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :call, :str, :lit, :hash, :false, :true, :nil] lib/simplabs/excellent/parsing/resbody_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - module Scopeable + module Scopeable #:nodoc: private lib/simplabs/excellent/parsing/scopeable.rb @@ -4,13 +4,81 @@ module Simplabs module Parsing + # For most nodes the Excellent processor processes, it will create the corresponding context that contains meta information of the processed + # node. This is the base class for all these contexts. + # + # === Example + # + # For a method like the following: + # + # module Shop + # class Basket + # def buy_product(product) + # other_method + # end + # end + # end + # + # four context will be generated: + # + # ModuleContext + # name: 'Shop' + # full_name: 'Shop' + # parent: nil + # ClassContext + # name: 'Basket' + # full_name: 'Shop::Basket' + # parent: ModuleContext + # MethodContext + # name: 'buy_product' + # full_name: 'Shop::Basket#buy_product' + # parent: ClassContext + # parameters: [:product] + # CallContext (other_method) + # name: nil + # full_name: nil + # parent: MethodContext + # method: :other_method + # + # === Custom Processors + # + # The Excelent processor will also invoke custom processor methods on the contexts if they are defined. To process call nodes in the context for + # example, you could simply define a +process_call+ method in the context that will be invoked with each call Sexp (S-expression, see + # http://en.wikipedia.org/wiki/S_expression) that is processed by the Excellent processor. + # + # def process_call(exp) + # super + # do_something() + # end + # + # Custom <b>processor methods must always call +super+</b> since there might be several processor methods defined in several modules that are in the + # included in the context and all of these have to be invoked. Also <b>processor methods must not modify the passed Sexp</b> since other processor + # methods also need the complete Sexp. If you have to modify the Sexp in a processor method, deep clone it: + # + # exp = exp.deep_clone + # class SexpContext + # The parent context attr_reader :parent + + # The name of the code fragment the context is bound to (e.g. 'User' for a +class+) attr_reader :name + + # The file the code fragment was read from attr_reader :file + + # The line the code fragment is located at attr_reader :line + # Initializes a SexpContext. + # + # Always call +super+ in inherited custom contexts! + # + # === Parameters + # + # * <tt>exp</tt> - The Sexp (S-expression, see http://en.wikipedia.org/wiki/S_expression) the context is created for. + # * <tt>parent</tt> - The parent context. def initialize(exp, parent = nil) @exp = exp @parent = parent @@ -19,13 +87,15 @@ module Simplabs @full_name = nil end + # Gets the full name of the code fragment the context is bound to. For a method +name+ might be '+add_product+' while +full_name+ might be + # 'Basket#add_product'. def full_name return @full_name if @full_name return @name if @parent.blank? "#{@parent.full_name}::#{@name}" end - def method_missing(method, *args) + def method_missing(method, *args) #:nodoc: return if method.to_s =~ /^process_[a-zA-Z0-9_]+$/ super end lib/simplabs/excellent/parsing/sexp_context.rb @@ -7,7 +7,7 @@ module Simplabs module Parsing - class SingletonMethodContext < MethodContext + class SingletonMethodContext < MethodContext #:nodoc: include CyclomaticComplexityMeasure include AbcMeasure lib/simplabs/excellent/parsing/singleton_method_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class UntilContext < SexpContext + class UntilContext < SexpContext #:nodoc: def initialize(exp, parent) super lib/simplabs/excellent/parsing/until_context.rb @@ -4,7 +4,7 @@ module Simplabs module Parsing - class WhileContext < SexpContext + class WhileContext < SexpContext #:nodoc: def initialize(exp, parent) super lib/simplabs/excellent/parsing/while_context.rb @@ -1,6 +1,5 @@ require 'pp' require 'yaml' - require 'simplabs/excellent/parsing/parser' require 'simplabs/excellent/parsing/code_processor' @@ -8,6 +7,8 @@ module Simplabs module Excellent + # The Runner is the interface to invoke parsing and processing of source code. You can pass either a String containing the code to process or the + # name of a file to read the code to process from. class Runner DEFAULT_CONFIG = { @@ -31,39 +32,61 @@ module Simplabs :'Rails::AttrProtectedCheck' => { }, :'Rails::AttrAccessibleCheck' => { } } - - attr_writer :config + attr_accessor :config #:nodoc: + + # Initializes a Runner + # + # ==== Parameters + # + # * <tt>checks</tt> - The checks to apply - passed instances of the various check classes. If no checks are specified, all checks will be applied. def initialize(*checks) @config = DEFAULT_CONFIG @checks = checks unless checks.empty? @parser = Parsing::Parser.new end - def check(filename, content) + # Processes the +code+ and sets the file name of the warning to +filename+ + # + # ==== Parameters + # + # * <tt>filename</tt> - The name of the file the code was read from. + # * <tt>code</tt> - The code to process (String). + def check(filename, code) @checks ||= load_checks @processor ||= Parsing::CodeProcessor.new(@checks) - node = parse(filename, content) + node = parse(filename, code) @processor.process(node) end - def check_content(content) - check('dummy-file.rb', content) + # Processes the +code+, setting the file name of the warnings to '+dummy-file.rb+' + # + # ==== Parameters + # + # * <tt>code</tt> - The code to process (String). + def check_code(code) + check('dummy-file.rb', code) end + # Processes the file +filename+. The code will be read from the file. + # + # ==== Parameters + # + # * <tt>filename</tt> - The name of the file to read the code from. def check_file(filename) check(filename, File.read(filename)) end - def errors + # Gets the warnings that were produced by the checks. + def warnings @checks ||= [] - @checks.collect { |check| check.errors }.flatten + @checks.collect { |check| check.warnings }.flatten end private - def parse(filename, content) - @parser.parse(content, filename) + def parse(filename, code) + @parser.parse(code, filename) end def load_checks lib/simplabs/excellent/runner.rb @@ -98,12 +98,12 @@ describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'Class.method_name', :score => 1.0 } - errors[0].line_number.should == 2 - errors[0].message.should == "Class.method_name has abc score of 1.0." + warnings.should_not be_empty + warnings[0].info.should == { :method => 'Class.method_name', :score => 1.0 } + warnings[0].line_number.should == 2 + warnings[0].message.should == "Class.method_name has abc score of 1.0." end end @@ -111,12 +111,12 @@ describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do def verify_content_score(content, a, b, c) score = Math.sqrt(a*a + b*b + c*c) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'method_name', :score => score } - errors[0].line_number.should == 1 - errors[0].message.should == "method_name has abc score of #{score}." + warnings.should_not be_empty + warnings[0].info.should == { :method => 'method_name', :score => score } + warnings[0].line_number.should == 1 + warnings[0].message.should == "method_name has abc score of #{score}." end end spec/checks/abc_metric_method_check_spec.rb @@ -14,7 +14,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept block parameters in an if clause' do @@ -23,7 +23,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject assignments of results of blocks in an if clause' do @@ -31,7 +31,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do return true if value = exp.children.find { |child| contains_statements?(child) } END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an assignment inside an if clause' do @@ -39,7 +39,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do call_foo if bar = bam END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an assignment inside an unless clause' do @@ -47,7 +47,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do call_foo unless bar = bam END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an assignment inside a while clause' do @@ -55,7 +55,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do call_foo while bar = bam END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an assignment inside an until clause' do @@ -63,7 +63,7 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do call_foo until bar = bam END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an assignment inside a ternary operator check clause' do @@ -72,19 +72,19 @@ describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do END #RubyParser sets line number 2 here - verify_error_found(content, 2) + verify_warning_found(content, 2) end end - def verify_error_found(content, line_number = nil) + def verify_warning_found(content, line_number = nil) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == {} - errors[0].line_number.should == (line_number || 1) - errors[0].message.should == 'Assignment in condition.' + warnings.should_not be_empty + warnings[0].info.should == {} + warnings[0].line_number.should == (line_number || 1) + warnings[0].message.should == 'Assignment in condition.' end end spec/checks/assignment_in_conditional_check_spec.rb @@ -16,9 +16,9 @@ describe Simplabs::Excellent::Checks::CaseMissingElseCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should reject case statements that do not have an else clause' do @@ -29,12 +29,12 @@ describe Simplabs::Excellent::Checks::CaseMissingElseCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == {} - errors[0].line_number.should == 2 - errors[0].message.should == 'Case statement is missing else clause.' + warnings.should_not be_empty + warnings[0].info.should == {} + warnings[0].line_number.should == 2 + warnings[0].message.should == 'Case statement is missing else clause.' end end spec/checks/case_missing_else_check_spec.rb @@ -14,7 +14,7 @@ describe Simplabs::Excellent::Checks::ClassLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept classes with the same number of lines as the threshold' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::ClassLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should not count blank lines' do @@ -38,7 +38,7 @@ describe Simplabs::Excellent::Checks::ClassLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject classes with more lines than the threshold' do @@ -49,12 +49,12 @@ describe Simplabs::Excellent::Checks::ClassLineCountCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'FourLineClass', :count => 4 } - errors[0].line_number.should == 1 - errors[0].message.should == 'FourLineClass has 4 lines.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'FourLineClass', :count => 4 } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'FourLineClass has 4 lines.' end end spec/checks/class_line_count_check_spec.rb @@ -14,7 +14,7 @@ describe Simplabs::Excellent::Checks::ClassNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should be able to parse scoped class names' do @@ -26,7 +26,7 @@ describe Simplabs::Excellent::Checks::ClassNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject class names with underscores' do @@ -35,12 +35,12 @@ describe Simplabs::Excellent::Checks::ClassNameCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'Bad_ClassName' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Bad class name Bad_ClassName.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'Bad_ClassName' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Bad class name Bad_ClassName.' end end spec/checks/class_name_check_spec.rb @@ -15,9 +15,9 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should accept methods with ternary operators using an instance variable' do @@ -28,9 +28,9 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should accept methods with ternary operators using a local variable' do @@ -42,9 +42,9 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end %w(if unless).each do |conditional| @@ -58,7 +58,7 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do end END - verify_error_found(content) + verify_warning_found(content) end end @@ -70,7 +70,7 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do end END - verify_error_found(content) + verify_warning_found(content) end it "should reject methods with case statements using a parameter" do @@ -85,19 +85,19 @@ describe Simplabs::Excellent::Checks::ControlCouplingCheck do end END - verify_error_found(content) + verify_warning_found(content) end end - def verify_error_found(content) + def verify_warning_found(content) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'write', :argument => 'quoted' } - errors[0].line_number.should == 1 - errors[0].message.should == 'write is coupled to quoted.' + warnings.should_not be_empty + warnings[0].info.should == { :method => 'write', :argument => 'quoted' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'write is coupled to quoted.' end end spec/checks/control_coupling_check_spec.rb @@ -36,12 +36,12 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityBlockCheck do def verify_content_complexity(content, score) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :block => 'block', :score => score } - errors[0].line_number.should == 1 - errors[0].message.should == "block has cyclomatic complexity of #{score}." + warnings.should_not be_empty + warnings[0].info.should == { :block => 'block', :score => score } + warnings[0].line_number.should == 1 + warnings[0].message.should == "block has cyclomatic complexity of #{score}." end end spec/checks/cyclomatic_complexity_block_check_spec.rb @@ -187,24 +187,24 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'Class.method_name', :score => 5 } - errors[0].line_number.should == 2 - errors[0].message.should == "Class.method_name has cyclomatic complexity of 5." + warnings.should_not be_empty + warnings[0].info.should == { :method => 'Class.method_name', :score => 5 } + warnings[0].line_number.should == 2 + warnings[0].message.should == "Class.method_name has cyclomatic complexity of 5." end end def verify_content_complexity(content, score) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'method_name', :score => score } - errors[0].line_number.should == 1 - errors[0].message.should == "method_name has cyclomatic complexity of #{score}." + warnings.should_not be_empty + warnings[0].info.should == { :method => 'method_name', :score => score } + warnings[0].line_number.should == 1 + warnings[0].message.should == "method_name has cyclomatic complexity of #{score}." end end spec/checks/cyclomatic_complexity_method_check_spec.rb @@ -15,9 +15,9 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should reject multiple calls to the same method and receiver' do @@ -27,7 +27,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, '@other.thing') + verify_warning_found(content, '@other.thing') end it 'should reject multiple calls to the same lvar' do @@ -37,7 +37,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing.[]') + verify_warning_found(content, 'thing.[]') end it 'should reject multiple calls to the same singleton method' do @@ -47,7 +47,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'Class.thing') + verify_warning_found(content, 'Class.thing') end it 'should reject multiple calls to the same method without a receiver' do @@ -57,7 +57,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing') + verify_warning_found(content, 'thing') end it 'should reject multiple calls to the same method with the same parameters' do @@ -67,7 +67,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing') + verify_warning_found(content, 'thing') end it 'should reject multiple calls to the same method with different parameters' do @@ -77,7 +77,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing') + verify_warning_found(content, 'thing') end it 'should work with singleton methods on objects' do @@ -87,7 +87,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing', 'object.double_thing') + verify_warning_found(content, 'thing', 'object.double_thing') end it 'should work with singleton methods on classes' do @@ -97,7 +97,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing', 'Class.double_thing') + verify_warning_found(content, 'thing', 'Class.double_thing') end it 'should work with singleton methods on classes' do @@ -109,7 +109,7 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing', 'Class.double_thing', 2) + verify_warning_found(content, 'thing', 'Class.double_thing', 2) end it 'should also work with blocks' do @@ -121,19 +121,19 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do end END - verify_error_found(content, 'thing', 'block', 2) + verify_warning_found(content, 'thing', 'block', 2) end end - def verify_error_found(content, statement, method = 'double_thing', line = 1) + def verify_warning_found(content, statement, method = 'double_thing', line = 1) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => method, :statement => statement, :duplication_number => 2 } - errors[0].line_number.should == line - errors[0].message.should == "#{method} calls #{statement} 2 times." + warnings.should_not be_empty + warnings[0].info.should == { :method => method, :statement => statement, :duplication_number => 2 } + warnings[0].line_number.should == line + warnings[0].message.should == "#{method} calls #{statement} 2 times." end end spec/checks/duplication_check_spec.rb @@ -18,7 +18,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept a rescue body with a return' do @@ -31,7 +31,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it "should accept a virtual method call" do @@ -44,7 +44,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept a rescue body with content and a parameter' do @@ -57,7 +57,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept a rescue body with an assignment' do @@ -70,7 +70,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept a rescue body with an attribute assignment' do @@ -83,7 +83,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept an inline rescue statement' do @@ -92,7 +92,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept an empty array as a statement' do @@ -102,7 +102,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept an empty hash as a statement' do @@ -112,7 +112,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept a boolean as a statement' do @@ -121,7 +121,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept nil as a statement' do @@ -130,7 +130,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject an empty rescue block with no parameter' do @@ -141,7 +141,7 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do end END - verify_error_found(content) + verify_warning_found(content) end it 'should reject an empty rescue block with a parameter' do @@ -152,19 +152,19 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do end END - verify_error_found(content) + verify_warning_found(content) end end - def verify_error_found(content) + def verify_warning_found(content) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == {} - errors[0].line_number.should == 3 - errors[0].message.should == 'Rescue block is empty.' + warnings.should_not be_empty + warnings[0].info.should == {} + warnings[0].line_number.should == 3 + warnings[0].message.should == 'Rescue block is empty.' end end spec/checks/empty_rescue_body_check_spec.rb @@ -15,12 +15,12 @@ describe Simplabs::Excellent::Checks::FlogBlockCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :block => 'block', :score => 3 } - errors[0].line_number.should == 1 - errors[0].message.should == "block has flog score of 3." + warnings.should_not be_empty + warnings[0].info.should == { :block => 'block', :score => 3 } + warnings[0].line_number.should == 1 + warnings[0].message.should == "block has flog score of 3." end end spec/checks/flog_block_check_spec.rb @@ -15,12 +15,12 @@ describe Simplabs::Excellent::Checks::FlogClassCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'User', :score => 1 } - errors[0].line_number.should == 1 - errors[0].message.should == "User has flog score of 1." + warnings.should_not be_empty + warnings[0].info.should == { :class => 'User', :score => 1 } + warnings[0].line_number.should == 1 + warnings[0].message.should == "User has flog score of 1." end end spec/checks/flog_class_check_spec.rb @@ -35,12 +35,12 @@ describe Simplabs::Excellent::Checks::FlogMethodCheck do def verify_content_score(content, score) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'method_name', :score => score } - errors[0].line_number.should == 1 - errors[0].message.should == "method_name has flog score of #{score}." + warnings.should_not be_empty + warnings[0].info.should == { :method => 'method_name', :score => score } + warnings[0].line_number.should == 1 + warnings[0].message.should == "method_name has flog score of #{score}." end end spec/checks/flog_method_check_spec.rb @@ -14,9 +14,9 @@ describe Simplabs::Excellent::Checks::ForLoopCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should reject for loops on ranges' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::ForLoopCheck do end END - verify_error_found(content) + verify_warning_found(content) end it 'should reject for loops on enumerations' do @@ -34,19 +34,19 @@ describe Simplabs::Excellent::Checks::ForLoopCheck do end END - verify_error_found(content) + verify_warning_found(content) end end - def verify_error_found(content) + def verify_warning_found(content) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == {} - errors[0].line_number.should == 1 - errors[0].message.should == 'For loop used.' + warnings.should_not be_empty + warnings[0].info.should == {} + warnings[0].line_number.should == 1 + warnings[0].message.should == 'For loop used.' end end spec/checks/for_loop_check_spec.rb @@ -15,7 +15,7 @@ describe Simplabs::Excellent::Checks::MethodLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept methods with the same number of lines as the threshold' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::MethodLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject methods with more lines than the threshold' do @@ -36,12 +36,12 @@ describe Simplabs::Excellent::Checks::MethodLineCountCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'four_line_method', :count => 4 } - errors[0].line_number.should == 1 - errors[0].message.should == 'four_line_method has 4 lines.' + warnings.should_not be_empty + warnings[0].info.should == { :method => 'four_line_method', :count => 4 } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'four_line_method has 4 lines.' end end spec/checks/method_line_count_check_spec.rb @@ -15,7 +15,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept method names with numbers' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept method names ending with a question mark' do @@ -35,7 +35,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept method names ending with an exclamation mark' do @@ -45,7 +45,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept method names ending an equals sign' do @@ -55,7 +55,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end ['<<', '>>', '==', '<', '<=', '>', '>=', '[]', '[]=', '+', '-', '*', '~', '/', '%', '&', '^', '|'].each do |operator| @@ -67,7 +67,7 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end end @@ -80,12 +80,12 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => 'badMethodName' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Bad method name badMethodName.' + warnings.should_not be_empty + warnings[0].info.should == { :method => 'badMethodName' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Bad method name badMethodName.' end it "should correctly return the method's full name" do @@ -98,15 +98,15 @@ describe Simplabs::Excellent::Checks::MethodNameCheck do end END @excellent.check_content(content) - errors = @excellent.errors - - errors.should_not be_empty - errors[0].info.should == { :method => 'Class#badMethodName' } - errors[0].line_number.should == 2 - errors[0].message.should == 'Bad method name Class#badMethodName.' - errors[1].info.should == { :method => 'Class.badMethodName2' } - errors[1].line_number.should == 4 - errors[1].message.should == 'Bad method name Class.badMethodName2.' + warnings = @excellent.warnings + + warnings.should_not be_empty + warnings[0].info.should == { :method => 'Class#badMethodName' } + warnings[0].line_number.should == 2 + warnings[0].message.should == 'Bad method name Class#badMethodName.' + warnings[1].info.should == { :method => 'Class.badMethodName2' } + warnings[1].line_number.should == 4 + warnings[1].message.should == 'Bad method name Class.badMethodName2.' end end spec/checks/method_name_check_spec.rb @@ -14,7 +14,7 @@ describe Simplabs::Excellent::Checks::ModuleLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept modules with the same number of lines as the threshold' do @@ -24,7 +24,7 @@ describe Simplabs::Excellent::Checks::ModuleLineCountCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject modules with more lines than the threshold' do @@ -35,12 +35,12 @@ describe Simplabs::Excellent::Checks::ModuleLineCountCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :module => 'FourLinesModule', :count => 4 } - errors[0].line_number.should == 1 - errors[0].message.should == 'FourLinesModule has 4 lines.' + warnings.should_not be_empty + warnings[0].info.should == { :module => 'FourLinesModule', :count => 4 } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'FourLinesModule has 4 lines.' end end spec/checks/module_line_count_check_spec.rb @@ -15,7 +15,7 @@ describe Simplabs::Excellent::Checks::ModuleNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept namespaced modules' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::ModuleNameCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject module names with underscores' do @@ -34,12 +34,12 @@ describe Simplabs::Excellent::Checks::ModuleNameCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :module => 'Bad_ModuleName' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Bad module name Bad_ModuleName.' + warnings.should_not be_empty + warnings[0].info.should == { :module => 'Bad_ModuleName' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Bad module name Bad_ModuleName.' end it 'should correctly report bad names of namespaced modules' do @@ -48,12 +48,12 @@ describe Simplabs::Excellent::Checks::ModuleNameCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :module => 'Outer::Inner::Bad_ModuleName' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Bad module name Outer::Inner::Bad_ModuleName.' + warnings.should_not be_empty + warnings[0].info.should == { :module => 'Outer::Inner::Bad_ModuleName' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Bad module name Outer::Inner::Bad_ModuleName.' end end spec/checks/module_name_check_spec.rb @@ -16,12 +16,12 @@ describe Simplabs::Excellent::Checks::NestedIteratorsCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :block => 'block', :parent => 'block' } - errors[0].line_number.should == 2 - errors[0].message.should == 'block inside of block.' + warnings.should_not be_empty + warnings[0].info.should == { :block => 'block', :parent => 'block' } + warnings[0].line_number.should == 2 + warnings[0].message.should == 'block inside of block.' end it 'should accept 2 blocks inside a method that are not nested' do @@ -34,9 +34,9 @@ describe Simplabs::Excellent::Checks::NestedIteratorsCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end end spec/checks/nested_iterators_check_spec.rb @@ -15,7 +15,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should accept methods with the same number of parameters as the threshold' do @@ -25,7 +25,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do END @excellent.check_content(content) - @excellent.errors.should be_empty + @excellent.warnings.should be_empty end it 'should reject methods with more parameters than the threshold' do @@ -34,7 +34,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'two_parameter_method') + verify_warning_found(content, 'two_parameter_method') end it 'should work with default values on parameters' do @@ -43,7 +43,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'two_parameter_method') + verify_warning_found(content, 'two_parameter_method') end it 'should work with methods defined on objects' do @@ -52,7 +52,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'object.two_parameter_method') + verify_warning_found(content, 'object.two_parameter_method') end it 'should work with methods defined directly on classes' do @@ -61,7 +61,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'Class.two_parameter_method') + verify_warning_found(content, 'Class.two_parameter_method') end it 'should reject yield calls with more parameters than the threshold' do @@ -70,7 +70,7 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'block') + verify_warning_found(content, 'block') end it 'should reject yield calls on a receiver with more parameters than the threshold' do @@ -79,19 +79,19 @@ describe Simplabs::Excellent::Checks::ParameterNumberCheck do end END - verify_error_found(content, 'block') + verify_warning_found(content, 'block') end end - def verify_error_found(content, name) + def verify_warning_found(content, name) @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :method => name, :parameters => 2 } - errors[0].line_number.should == 1 - errors[0].message.should == "#{name} has 2 parameters." + warnings.should_not be_empty + warnings[0].info.should == { :method => name, :parameters => 2 } + warnings[0].line_number.should == 1 + warnings[0].message.should == "#{name} has 2 parameters." end end spec/checks/parameter_number_check_spec.rb @@ -14,9 +14,9 @@ describe Simplabs::Excellent::Checks::Rails::AttrAccessibleCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should reject an active record model that does not specify attr_accessible' do @@ -25,12 +25,12 @@ describe Simplabs::Excellent::Checks::Rails::AttrAccessibleCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'User' } - errors[0].line_number.should == 1 - errors[0].message.should == 'User does not specify attr_accessible.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'User' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'User does not specify attr_accessible.' end it 'should reject an active record model that does specify attr_protected' do @@ -40,12 +40,12 @@ describe Simplabs::Excellent::Checks::Rails::AttrAccessibleCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'User' } - errors[0].line_number.should == 1 - errors[0].message.should == 'User does not specify attr_accessible.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'User' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'User does not specify attr_accessible.' end it 'should accept an active record model that does specify attr_accessible' do @@ -55,9 +55,9 @@ describe Simplabs::Excellent::Checks::Rails::AttrAccessibleCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should also work with namespaced models' do @@ -66,12 +66,12 @@ describe Simplabs::Excellent::Checks::Rails::AttrAccessibleCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'Backend::User' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Backend::User does not specify attr_accessible.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'Backend::User' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Backend::User does not specify attr_accessible.' end end spec/checks/rails/attr_accessible_check_spec.rb @@ -14,9 +14,9 @@ describe Simplabs::Excellent::Checks::Rails::AttrProtectedCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should reject an active record model that does specify attr_protected' do @@ -26,12 +26,12 @@ describe Simplabs::Excellent::Checks::Rails::AttrProtectedCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'User' } - errors[0].line_number.should == 1 - errors[0].message.should == 'User specifies attr_protected.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'User' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'User specifies attr_protected.' end it 'should accept an active record model that does specify attr_accessible' do @@ -41,9 +41,9 @@ describe Simplabs::Excellent::Checks::Rails::AttrProtectedCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should accept an active record model that specifies neither attr_accessible not attr_protected' do @@ -52,9 +52,9 @@ describe Simplabs::Excellent::Checks::Rails::AttrProtectedCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should be_empty + warnings.should be_empty end it 'should also work with namespaced models' do @@ -64,12 +64,12 @@ describe Simplabs::Excellent::Checks::Rails::AttrProtectedCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :class => 'Backend::User' } - errors[0].line_number.should == 1 - errors[0].message.should == 'Backend::User specifies attr_protected.' + warnings.should_not be_empty + warnings[0].info.should == { :class => 'Backend::User' } + warnings[0].line_number.should == 1 + warnings[0].message.should == 'Backend::User specifies attr_protected.' end end spec/checks/rails/attr_protected_check_spec.rb @@ -13,12 +13,12 @@ describe Simplabs::Excellent::Checks::SingletonVariableCheck do @@foo END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :variable => 'foo' } - errors[0].line_number.should == 2 - errors[0].message.should == 'Singleton variable foo used.' + warnings.should_not be_empty + warnings[0].info.should == { :variable => 'foo' } + warnings[0].line_number.should == 2 + warnings[0].message.should == 'Singleton variable foo used.' end it 'should also work for namespaced classes' do @@ -32,12 +32,12 @@ describe Simplabs::Excellent::Checks::SingletonVariableCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :variable => 'Outer::Inner::Class.foo' } - errors[0].line_number.should == 5 - errors[0].message.should == 'Singleton variable Outer::Inner::Class.foo used.' + warnings.should_not be_empty + warnings[0].info.should == { :variable => 'Outer::Inner::Class.foo' } + warnings[0].line_number.should == 5 + warnings[0].message.should == 'Singleton variable Outer::Inner::Class.foo used.' end it 'should also work for singleton variables that occur within methods' do @@ -53,12 +53,12 @@ describe Simplabs::Excellent::Checks::SingletonVariableCheck do end END @excellent.check_content(content) - errors = @excellent.errors + warnings = @excellent.warnings - errors.should_not be_empty - errors[0].info.should == { :variable => 'Outer::Inner::Class.foo' } - errors[0].line_number.should == 6 - errors[0].message.should == 'Singleton variable Outer::Inner::Class.foo used.' + warnings.should_not be_empty + warnings[0].info.should == { :variable => 'Outer::Inner::Class.foo' } + warnings[0].line_number.should == 6 + warnings[0].message.should == 'Singleton variable Outer::Inner::Class.foo used.' end end spec/checks/singleton_variable_check_spec.rb README.markdown lib/simplabs/excellent/error.rb 9591164f51d5f3d30118899e15c42258b39ce8d7 Marco Otte-Witte marco.otte-witte@simplabs.com http://github.com/marcoow/excellent/commit/5ca35a9b9d9f24bc7bfb02f5bc41e55ed0dede53 5ca35a9b9d9f24bc7bfb02f5bc41e55ed0dede53 2009-05-20T06:34:07-07:00 2009-05-20T06:34:07-07:00 added documentation; renamed Error to Warning d5a49847e17362efcf07631bb7454a97508af1fa Marco Otte-Witte marco.otte-witte@simplabs.com