simplabs-excellent 1.0.1 → 1.2.1

data/lib/simplabs/excellent/parsing.rb

@@ -0,0 +1,12 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing #:nodoc:
+    end
+
+  end
+
+end
+
+require 'simplabs/excellent/runner'

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,36 @@
+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('.')
+        end
+
+        def <=>(other)
+          @full_name <=> other.full_name
+        end
+        alias :eql? :'<=>'
+
+        def hash
+          @full_name.hash
+        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,68 @@
+require 'simplabs/excellent/parsing/scopeable'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ClassContext < SexpContext #:nodoc:
+
+        include FlogMeasure
+        include Scopeable
+
+        attr_reader :methods
+        attr_reader :line_count
+        attr_reader :base_class_name
+
+        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
+        end
+
+        def activerecord_model?
+          @base_class_name == 'ActiveRecord::Base'
+        end
+
+        def specifies_attr_accessible?
+          @attr_accessible
+        end
+
+        def specifies_attr_protected?
+          @attr_protected
+        end
+
+        def process_call(exp)
+          @attr_accessible = true if exp[2] == :attr_accessible
+          @attr_protected = true if exp[2] == :attr_protected
+          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,154 @@
+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/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_cvar(exp)
+          process_default(exp, CvarContext.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)
+          if @contexts.last.is_a?(MethodContext) || @contexts.last.is_a?(BlockContext) || @contexts.last.is_a?(SingletonMethodContext)
+            @contexts.last.record_call_to(CallContext.new(exp, @contexts.last))
+          end
+          process_default(exp)
+        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) } unless checks.nil?
+            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

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

@@ -0,0 +1,25 @@
+require 'simplabs/excellent/parsing/sexp_context'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ConditionalContext < SexpContext #:nodoc:
+
+        protected
+
+          def contains_parameter?
+            return false unless @parent.is_a?(MethodContext)
+            return @exp[1][1] if @exp[1][0] == :lvar and @parent.has_parameter?(@exp[1][1])
+            false
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,28 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class CvarContext < SexpContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @name = exp[1].to_s.sub(/^@+/, '')
+        end
+
+        def full_name
+          return @name if @parent.blank?
+          full_name = @name
+          parent = @parent
+          parent = parent.parent until parent.is_a?(ClassContext) || parent.is_a?(ModuleContext)
+          full_name = "#{parent.full_name}.#{full_name}"
+        end
+
+      end
+
+    end
+
+  end
+
+end