excellent 1.5.4

data/lib/simplabs/excellent/formatters/text.rb

@@ -0,0 +1,40 @@
+require 'simplabs/excellent/formatters/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Formatters
+
+      class Text < Base #:nodoc:
+
+        def initialize(stream = $stdout)
+          super
+          @total_warnings = 0
+        end
+
+        def start
+          @stream.puts "\n  Excellent result:\n"
+        end
+
+        def file(filename)
+          @stream.puts "\n  #{filename}\n"
+          yield self
+        end
+
+        def warning(warning)
+          @stream.puts "    * Line #{warning.line_number.to_s.lpad(3)}: \e[33m#{warning.message}\e[0m"
+          @total_warnings += 1
+        end
+
+        def end
+          @stream.puts "\n  Found #{@total_warnings} warnings.\n\n"
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing.rb

@@ -0,0 +1,10 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing #:nodoc:
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/abc_measure.rb

@@ -0,0 +1,52 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      module AbcMeasure #:nodoc:
+
+        CONDITIONS = [:==, :<=, :>=, :<, :>]
+
+        def process_lasgn(exp)
+          @assignments ||= 0
+          @assignments += 1
+          super
+        end
+
+        def process_call(exp)
+          handle_call(exp)
+          super
+        end
+
+        def process_vcall(exp)
+          handle_call(exp)
+          super
+        end
+
+        def abc_score
+          a = @assignments  ||= 0
+          b = @branches     ||= 0
+          c = @conditionals ||= 0
+          Math.sqrt(a * a + b * b + c * c)
+        end
+
+        private
+
+          def handle_call(exp)
+            @branches     ||= 0
+            @conditionals ||= 0
+            if CONDITIONS.include?(exp[2])
+              @conditionals += 1
+            else
+              @branches += 1
+            end
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/block_context.rb

@@ -0,0 +1,43 @@
+require 'simplabs/excellent/parsing/cyclomatic_complexity_measure'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class BlockContext < SexpContext #:nodoc:
+
+        include CyclomaticComplexityMeasure
+        include FlogMeasure
+
+        attr_reader :parameters
+        attr_reader :calls
+
+        def initialize(exp, parent)
+          super
+          @parameters = []
+          @name       = 'block'
+          @line       = exp.line < exp[1].line ? exp.line : exp[1].line
+          @calls      = Hash.new(0)
+        end
+
+        def full_name
+          @name
+        end
+
+        def record_call_to(exp)
+          @calls[exp] += 1
+        end
+
+        def inside_block?
+          @parent.is_a?(BlockContext)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/call_context.rb

@@ -0,0 +1,52 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class CallContext < SexpContext #:nodoc:
+
+        include Comparable
+
+        attr_reader :receiver
+        attr_reader :method
+
+        def initialize(exp, parent)
+          super
+          @receiver  = exp[1].is_a?(Sexp) ? (exp[1][1].nil? ? exp[1][2].to_s : exp[1][1].to_s) : nil
+          @method    = exp[2].to_s
+          @full_name = [@receiver, @method].compact.join('.')
+          record_validation
+          record_call
+        end
+
+        def <=>(other)
+          @full_name <=> other.full_name
+        end
+        alias :eql? :'<=>'
+
+        def hash
+          @full_name.hash
+        end
+
+        private
+
+          def record_call
+            parent = @parent
+            parent = parent.parent until parent.nil? || parent.is_a?(MethodContext) || parent.is_a?(BlockContext) || parent.is_a?(SingletonMethodContext)
+            parent.record_call_to(self) if parent
+          end
+
+          def record_validation
+            if ClassContext::VALIDATIONS.include?(@method) && @parent && @parent.is_a?(ClassContext) && @parent.active_record_model?
+              @parent.validations << @method
+            end
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/case_context.rb

@@ -0,0 +1,31 @@
+require 'simplabs/excellent/parsing/conditional_context'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class CaseContext < ConditionalContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @has_else_clause = exp.last
+          @tests_parameter = contains_parameter?
+        end
+
+        def has_else_clause?
+          @has_else_clause
+        end
+
+        def tests_parameter?
+          @tests_parameter
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/class_context.rb

@@ -0,0 +1,99 @@
+require 'simplabs/excellent/parsing/scopeable'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ClassContext < SexpContext #:nodoc:
+
+        include FlogMeasure
+        include Scopeable
+
+        VALIDATIONS = %w(
+          validates_acceptance_of
+          validates_associated
+          validates_confirmation_of
+          validates_each
+          validates_exclusion_of
+          validates_format_of
+          validates_inclusion_of
+          validates_length_of
+          validates_numericality_of
+          validates_presence_of
+          validates_size_of
+          validates_uniqueness_of
+        )
+
+        attr_reader :methods
+        attr_reader :line_count
+        attr_reader :base_class_name
+        attr_reader :validations
+
+        def initialize(exp, parent)
+          super
+          @name, @full_name = get_names
+          @base_class_name  = get_base_class_name
+          @methods          = []
+          @line_count       = count_lines
+          @attr_accessible  = false
+          @attr_protected   = false
+          @initializer      = false
+          @validations      = []
+        end
+
+        def active_record_model?
+          @base_class_name == 'ActiveRecord::Base'
+        end
+
+        def specifies_attr_accessible?
+          @attr_accessible
+        end
+
+        def specifies_attr_protected?
+          @attr_protected
+        end
+
+        def defines_initializer?
+          @initializer
+        end
+
+        def validating?
+          !@validations.empty? || @methods.any?{ |method| %(validate validate_on_create validate_on_update).include?(method.name) }
+        end
+
+        def process_call(exp)
+          @attr_accessible = true if exp[2] == :attr_accessible
+          @attr_protected = true if exp[2] == :attr_protected
+          super
+        end
+
+        def process_defn(exp)
+          @initializer = true if exp[2] == :initialize
+          super
+        end
+
+        private
+
+          def get_base_class_name
+            base = @exp[2]
+            base_class_name = ''
+            while base.is_a?(Sexp)
+              base_class_name = "#{base.last}::#{base_class_name}"
+              if base[0] == :colon2
+                base = base[1]
+              else
+                break
+              end
+            end
+            base_class_name = base_class_name.empty? ? nil : base_class_name.sub(/::$/, '')
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/code_processor.rb

@@ -0,0 +1,165 @@
+require 'sexp_processor'
+require 'simplabs/excellent/extensions/sexp'
+require 'simplabs/excellent/parsing/if_context'
+require 'simplabs/excellent/parsing/method_context'
+require 'simplabs/excellent/parsing/singleton_method_context'
+require 'simplabs/excellent/parsing/case_context'
+require 'simplabs/excellent/parsing/block_context'
+require 'simplabs/excellent/parsing/class_context'
+require 'simplabs/excellent/parsing/module_context'
+require 'simplabs/excellent/parsing/for_loop_context'
+require 'simplabs/excellent/parsing/while_context'
+require 'simplabs/excellent/parsing/until_context'
+require 'simplabs/excellent/parsing/cvar_context'
+require 'simplabs/excellent/parsing/gvar_context'
+require 'simplabs/excellent/parsing/ivar_context'
+require 'simplabs/excellent/parsing/resbody_context'
+require 'simplabs/excellent/parsing/call_context'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class CodeProcessor < SexpProcessor #:nodoc:
+
+        def initialize(checks)
+          setup_checks(checks)
+          setup_processors
+          super()
+          @require_empty = @warn_on_default = false
+          @contexts = []
+          @default_method = 'process_default'
+        end
+
+        def process(exp)
+          super
+        rescue
+          #continue on errors
+        end
+
+        def process_class(exp)
+          process_default(exp, ClassContext.new(exp, @contexts.last))
+        end
+
+        def process_module(exp)
+          process_default(exp, ModuleContext.new(exp, @contexts.last))
+        end
+
+        def process_defn(exp)
+          process_default(exp, MethodContext.new(exp, @contexts.last))
+        end
+
+        def process_defs(exp)
+          process_default(exp, SingletonMethodContext.new(exp, @contexts.last))
+        end
+
+        def process_ivar(exp)
+          process_default(exp, IvarContext.new(exp, @contexts.last))
+        end
+
+        def process_cvar(exp)
+          process_default(exp, CvarContext.new(exp, @contexts.last))
+        end
+
+        def process_gvar(exp)
+          process_default(exp, GvarContext.new(exp, @contexts.last))
+        end
+
+        def process_gasgn(exp)
+          process_default(exp, GvarContext.new(exp, @contexts.last))
+        end
+
+        def process_if(exp)
+          process_default(exp, IfContext.new(exp, @contexts.last))
+        end
+
+        def process_while(exp)
+          process_default(exp, WhileContext.new(exp, @contexts.last))
+        end
+
+        def process_until(exp)
+          process_default(exp, UntilContext.new(exp, @contexts.last))
+        end
+
+        def process_for(exp)
+          process_default(exp, ForLoopContext.new(exp, @contexts.last))
+        end
+
+        def process_args(exp)
+          exp[1..-1].each { |parameter| @contexts.last.parameters << parameter if parameter.is_a?(Symbol) }
+          process_default(exp)
+        end
+
+        def process_masgn(exp)
+          exp[1][1..-1].each { |parameter| @contexts.last.parameters << parameter[1] if parameter[1].is_a?(Symbol) } if @contexts.last.is_a?(BlockContext)
+          process_default(exp)
+        end
+
+        def process_case(exp)
+          process_default(exp, CaseContext.new(exp, @contexts.last))
+        end
+
+        def process_iter(exp)
+          process_default(exp, BlockContext.new(exp, @contexts.last))
+        end
+
+        def process_call(exp)
+          process_default(exp, CallContext.new(exp, @contexts.last))
+        end
+
+        def process_resbody(exp)
+          process_default(exp, ResbodyContext.new(exp, @contexts.last))
+        end
+
+        def process_default(exp, context = nil)
+          @contexts.push(context) if context
+          @contexts.each do |c|
+            method = "process_#{exp.node_type}".to_sym
+            c.send(method, exp) if c.respond_to?(method)
+          end
+          exp.children.each { |sub| process(sub) }
+          apply_checks(exp)
+          @contexts.pop if context
+          exp
+        end
+
+        private
+
+          def apply_checks(exp)
+            if exp.is_a?(Sexp)
+              checks = @checks[exp.node_type] || []
+              checks.each { |check| check.evaluate_node(@contexts.last) if check.interesting_files.any? { |pattern| File.basename(exp.file) =~ pattern } }
+            end
+          end
+
+          def setup_checks(checks)
+            @checks = {}
+            checks.each do |check|
+              check.interesting_nodes.each do |node|
+                @checks[node] ||= []
+                @checks[node] << check
+                @checks[node].uniq!
+              end
+            end
+          end
+
+          def setup_processors
+            @checks.each_key do |key|
+              method = "process_#{key.to_s}".to_sym
+              unless self.respond_to?(method)
+                self.class.send(:define_method, method) do |exp| # def process_call(exp)
+                  process_default(exp)                           #   process_default(exp)
+                end                                              # end
+              end
+            end
+          end
+
+      end
+
+    end
+
+  end
+
+end