excellent 1.5.4

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

@@ -0,0 +1,27 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class LineCountCheck < Base #:nodoc:
+
+        def initialize(interesting_nodes, threshold)
+          super()
+          @interesting_nodes = interesting_nodes
+          @threshold         = threshold
+        end
+
+        def evaluate(context)
+          add_warning(*warning_args(context)) unless context.line_count <= @threshold
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,36 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:defn], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{method}} has {{count}} lines.', { :method => context.full_name, :count => context.line_count }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          pattern = options['pattern'] || DEFAULT_PATTERN
+          super([:defn, :defs], pattern)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, 'Bad method name {{method}}.', { :method => context.full_name }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,36 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:module], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{module}} has {{count}} lines.', { :module => context.full_name, :count => context.line_count }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          pattern = options['pattern'] || DEFAULT_PATTERN
+          super([:module], pattern)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, 'Bad module name {{module}}.', { :module => context.full_name }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,27 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class NameCheck < Base #:nodoc:
+
+        def initialize(interesting_nodes, pattern)
+          super()
+          @interesting_nodes = interesting_nodes
+          @pattern           = pattern
+        end
+
+        def evaluate(context)
+          add_warning(*warning_args(context)) unless context.name.to_s =~ @pattern
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,34 @@
+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]
+          @interesting_files = [/\.rb$/, /\.erb$/]
+        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

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          super()
+          @threshold         = options[:threshold] || DEFAULT_THRESHOLD
+          @interesting_nodes = [:defn, :iter, :defs]
+        end
+
+        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
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,22 @@
+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'
+require 'simplabs/excellent/checks/rails/instance_var_in_partial_check'
+require 'simplabs/excellent/checks/rails/validations_check'
+require 'simplabs/excellent/checks/rails/params_hash_in_view_check'
+require 'simplabs/excellent/checks/rails/session_hash_in_view_check'
+require 'simplabs/excellent/checks/rails/custom_initialize_method_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.active_record_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.active_record_model? && context.specifies_attr_protected?
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,37 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      module Rails
+
+        # This check reports +ActiveRecord+ models that define a custom +initialize+ method. Since +ActiveRecord+ does not always call +new+ to
+        # create instances, these custom +initialize+ methods might not always be called, which makes the behavior of the application very hard to
+        # understand.
+        #
+        # ==== Applies to
+        #
+        # * +ActiveRecord+ models
+        class CustomInitializeMethodCheck < Base
+
+          def initialize #:nodoc:
+            super
+            @interesting_nodes = [:class]
+          end
+
+          def evaluate(context) #:nodoc:
+            add_warning(context, '{{class}} defines initialize method.', { :class => context.full_name }) if context.active_record_model? && !context.defines_initializer?
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,37 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      module Rails
+
+        # This check reports partials that use instance variables. Using instance variables in partials couples the partial to the controller action or
+        # template that includes the partial and that has to define the instance variable.
+        #
+        # ==== Applies to
+        #
+        # * partials
+        class InstanceVarInPartialCheck < Base
+
+          def initialize #:nodoc:
+            super
+            @interesting_nodes = [:ivar]
+            @interesting_files = [/^_.*\.erb$/]
+          end
+
+          def evaluate(context) #:nodoc:
+            add_warning(context, 'Instance variable {{variable}} used in partial.', { :variable => context.full_name })
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end