simplabs-excellent 1.0.0

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

@@ -0,0 +1,39 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class CyclomaticComplexityCheck < Base
+
+        COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+        def initialize(threshold)
+          super()
+          @threshold = threshold
+        end
+
+        protected
+
+          def count_complexity(node)
+            count_branches(node) + 1
+          end
+
+        private
+
+          def count_branches(node)
+            count = 0
+            count = count + 1 if COMPLEXITY_NODE_TYPES.include? node.node_type
+            node.children.each { |child| count += count_branches(child) }
+            count
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,33 @@
+require 'simplabs/excellent/checks/cyclomatic_complexity_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck
+
+        DEFAULT_THRESHOLD = 8
+
+        def initialize(options = {})
+          complexity = options[:threshold] || DEFAULT_THRESHOLD
+          super(complexity)
+        end
+
+        def interesting_nodes
+          [:defn]
+        end
+
+        def evaluate(node)
+          score = count_complexity(node)
+          add_error('Method {{method}} has cyclomatic complexity of {{score}}.', { :method => node[1], :score => score }) unless score <= @threshold
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,39 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class EmptyRescueBodyCheck < Base
+
+        STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :call, :str, :lit]
+
+        def interesting_nodes
+          [:resbody]
+        end
+
+        def evaluate(node)
+          add_error('Rescue block is empty.', {}, -1) unless has_statement?(node)
+        end
+
+        private
+
+          def has_statement?(node)
+            return true if STATEMENT_NODES.include?(node.node_type)
+            return true if assigning_other_than_exception_to_local_variable?(node) 
+            return true if node.children.any? { |child| has_statement?(child) }
+          end
+
+          def assigning_other_than_exception_to_local_variable?(node)
+            node.node_type == :lasgn && node[2].to_a != [:gvar, :$!]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,25 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ForLoopCheck < Base
+
+        def interesting_nodes
+          [:for]
+        end
+
+        def evaluate(node)
+          add_error('For loop used.')
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class LineCountCheck < Base
+
+        def initialize(interesting_nodes, threshold)
+          super()
+          @interesting_nodes = interesting_nodes
+          @threshold         = threshold
+        end
+
+        def interesting_nodes
+          @interesting_nodes
+        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
+
+  end
+
+end

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

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class MethodLineCountCheck < LineCountCheck
+
+        DEFAULT_THRESHOLD = 20
+
+        def initialize(options = {})
+          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 }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class MethodNameCheck < NameCheck
+
+        DEFAULT_PATTERN = /^[_a-z<>=\[|+-\/\*\~\%\&`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+
+        def initialize(options = {})
+          pattern = options['pattern'] || DEFAULT_PATTERN
+          super([:defn], pattern)
+        end
+
+        def find_name(node)
+          node[1]
+        end
+
+        protected
+
+          def error_args(node)
+            ['Bad method name {{method}}.', { :method => node[1] }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ModuleLineCountCheck < LineCountCheck
+
+        DEFAULT_THRESHOLD = 300
+
+        def initialize(options = {})
+          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 }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ModuleNameCheck < NameCheck
+
+        DEFAULT_PATTERN = /^[A-Z][a-zA-Z0-9]*$/
+
+        def initialize(options = {})
+          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] }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class NameCheck < Base
+
+        def initialize(interesting_nodes, pattern)
+          super()
+          @interesting_nodes = interesting_nodes
+          @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
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,37 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ParameterNumberCheck < Base
+
+        DEFAULT_THRESHOLD = 3
+
+        def initialize(options = {})
+          super()
+          @threshold = options[:threshold] || DEFAULT_THRESHOLD
+        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 })
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core.rb

@@ -0,0 +1,2 @@
+require 'simplabs/excellent/core/parse_tree_runner'
+require 'simplabs/excellent/core/extensions/underscore'

data/lib/simplabs/excellent/core/checking_visitor.rb

@@ -0,0 +1,34 @@
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      class CheckingVisitor
+
+        def initialize(*checks)
+          @checks ||= {}
+          checks.first.each do |check|
+            nodes = check.interesting_nodes
+            nodes.each do |node|
+              @checks[node] ||= []
+              @checks[node] << check
+              @checks[node].uniq!
+            end
+          end
+        end
+
+        def visit(node)
+          @last_newline = node if node.node_type == :newline
+          checks = @checks[node.node_type]
+          checks.each { |check| check.evaluate_node(node) } unless checks.nil?
+          nil
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core/error.rb

@@ -0,0 +1,31 @@
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      class Error
+
+        attr_reader :check, :info, :filename, :line_number, :message, :message_template
+
+        def initialize(check, message, filename, line_number, info)
+          @check       = check.to_s.underscore.to_sym
+          @info        = info
+          @filename    = filename
+          @line_number = line_number.to_i
+
+          @message = ''
+          if !message.nil?
+            @message_template = message
+            @info.each { |key, value| message.gsub!(/\{\{#{key}\}\}/, value.to_s) }
+            @message = message
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end