simplabs-excellent 1.0.1 → 1.2.1

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

@@ -6,7 +6,7 @@ module Simplabs
 
     module Checks
 
-      class LineCountCheck < Base
+      class LineCountCheck < Base #:nodoc:
 
         def initialize(interesting_nodes, threshold)
           super()
@@ -14,28 +14,10 @@ module Simplabs
           @threshold         = threshold
         end
 
-        def interesting_nodes
-          @interesting_nodes
+        def evaluate(context)
+          add_warning(*warning_args(context)) unless context.line_count <= @threshold
         end
 
-        def evaluate(node)
-          line_count = count_lines(node_to_count(node)) - 1
-          add_error(*error_args(node, line_count)) unless line_count <= @threshold
-        end
-
-        protected
-  
-          def node_to_count(node)
-            node
-          end
-  
-          def count_lines(node, line_numbers = [])
-            count = 0
-            line_numbers << node.line
-            node.children.each { |child| count += count_lines(child, line_numbers) }
-            line_numbers.uniq.length
-          end
-
       end
 
     end

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

@@ -6,23 +6,25 @@ 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 node_to_count(node)
-            node[3][1]
-          end
-
-          def error_args(node, line_count)
-            ['Method {{method}} has {{count}} lines.', { :method => node[1], :count => line_count }]
+          def warning_args(context) #:nodoc:
+            [context, '{{method}} has {{count}} lines.', { :method => context.full_name, :count => context.line_count }]
           end
 
       end

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

@@ -6,23 +6,27 @@ 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_<>=~@\[\]]*[=!\?]?$/
+        DEFAULT_PATTERN = /^[_a-z<>=\[|+-\/\*\~\%\&`\|\^]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
 
-        def initialize(options = {})
+        def initialize(options = {}) #:nodoc:
           pattern = options['pattern'] || DEFAULT_PATTERN
-          super([:defn], pattern)
-        end
-
-        def find_name(node)
-          node[1]
+          super([:defn, :defs], pattern)
         end
 
         protected
 
-          def error_args(node)
-            ['Bad method name {{method}}.', { :method => node[1] }]
+          def warning_args(context) #:nodoc:
+            [context, 'Bad method name {{method}}.', { :method => context.full_name }]
           end
 
       end

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

@@ -6,23 +6,25 @@ 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 node_to_count(node)
-            node[2]
-          end
-
-          def error_args(node, line_count)
-            ['Module {{module}} has {{count}} lines.', { :module => node[1], :count => line_count }]
+          def warning_args(context) #:nodoc:
+            [context, '{{module}} has {{count}} lines.', { :module => context.full_name, :count => context.line_count }]
           end
 
       end

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

@@ -6,23 +6,27 @@ 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
 
-        def find_name(node)
-          node[1].class == Symbol ? node[1] : node[1].last
-        end
-
         protected
 
-          def error_args(node)
-            ['Bad module name {{module}}.', { :module => node[1] }]
+          def warning_args(context) #:nodoc:
+            [context, 'Bad module name {{module}}.', { :module => context.full_name }]
           end
 
       end

data/lib/simplabs/excellent/checks/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,13 +14,8 @@ module Simplabs
           @pattern           = pattern
         end
 
-        def interesting_nodes
-          @interesting_nodes
-        end
-
-        def evaluate(node)
-          name = find_name(node)
-          add_error(*error_args(node)) unless name.to_s =~ @pattern
+        def evaluate(context)
+          add_warning(*warning_args(context)) unless context.name.to_s =~ @pattern
         end
 
       end

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

@@ -0,0 +1,33 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports nested iterators. Nested iterators lead to introduce performance issues.
+      #
+      # ==== Applies to
+      #
+      # * blocks
+      class NestedIteratorsCheck < Base
+
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:iter]
+        end
+
+        def evaluate(context) #:nodoc:
+          if context.inside_block?
+            add_warning(context, '{{block}} inside of {{parent}}.', { :block => context.full_name, :parent => context.parent.full_name })
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -6,25 +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]
-        end
-
-        def evaluate(node)
-          method_name = node[1]
-          parameters = node[2][1..-1]
-          parameter_count = parameters.inject(0) { |count, each| count = count + (each.class == Symbol ? 1 : 0) }
-          unless parameter_count <= @threshold
-            add_error('Method {{method}} has {{parameter_count}} parameters.', { :method => method_name, :parameter_count => parameter_count })
+        def evaluate(context) #:nodoc:
+          unless context.parameters.length <= @threshold
+            add_warning(context, '{{method}} has {{parameters}} parameters.', { :method => context.full_name, :parameters => context.parameters.length })
           end
         end
 

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

@@ -0,0 +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'

data/lib/simplabs/excellent/checks/rails/attr_accessible_check.rb

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      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 initialize #:nodoc:
+            super
+            @interesting_nodes = [:class]
+          end
+
+          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
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/rails/attr_protected_check.rb

@@ -0,0 +1,39 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      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 (see http://guides.rubyonrails.org/security.html#mass-assignment), 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 initialize #:nodoc:
+            super
+            @interesting_nodes = [:class]
+          end
+
+          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
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 initialize #:nodoc:
+          super
+          @interesting_nodes = [:cvar]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Singleton variable {{variable}} used.', { :variable => context.full_name })
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/extensions/sexp.rb

@@ -0,0 +1,21 @@
+module Simplabs
+
+  module Excellent
+
+    module Extensions #:nodoc:
+
+      ::Sexp.class_eval do
+
+        def children
+          sexp_body.select { |child| child.is_a?(Sexp) }
+        rescue
+          []
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/extensions/string.rb

@@ -0,0 +1,23 @@
+module Simplabs
+
+  module Excellent
+
+    module Extensions #:nodoc:
+
+      ::String.class_eval do
+
+        def underscore
+          to_s.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+        end
+
+      end
+
+    end
+
+  end
+
+end