excellent 1.5.4

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

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

@@ -0,0 +1,73 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      module CyclomaticComplexityMeasure #:nodoc:
+
+        COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+        def process_if(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_while(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_until(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_for(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_rescue(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_case(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_when(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_and(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def process_or(exp)
+          add_complexity_score(1)
+          super
+        end
+
+        def cc_score
+          @cc_score + 1 rescue 1
+        end
+
+        private
+
+          def add_complexity_score(score)
+            @cc_score ||= 0
+            @cc_score += score
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,192 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      module FlogMeasure #:nodoc:
+
+        SCORES = Hash.new(1)
+        SCORES.merge!(
+          :define_method              => 5,
+          :eval                       => 5,
+          :module_eval                => 5,
+          :class_eval                 => 5,
+          :instance_eval              => 5,
+          :alias_method               => 2,
+          :extend                     => 2,
+          :include                    => 2,
+          :instance_method            => 2,
+          :instance_methods           => 2,
+          :method_added               => 2,
+          :method_defined?            => 2,
+          :method_removed             => 2,
+          :method_undefined           => 2,
+          :private_class_method       => 2,
+          :private_instance_methods   => 2,
+          :private_method_defined?    => 2,
+          :protected_instance_methods => 2,
+          :protected_method_defined?  => 2,
+          :public_class_method        => 2,
+          :public_instance_methods    => 2,
+          :public_method_defined?     => 2,
+          :remove_method              => 2,
+          :send                       => 3,
+          :undef_method               => 2
+        )
+        BRANCHES = [:and, :case, :else, :if, :or, :rescue, :until, :when, :while]
+
+        def process_alias(exp)
+          add_flog_score(2)
+          super
+        end
+
+        def process_and(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_or(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_attrasgn(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_attrset(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_block_pass(exp)
+          add_flog_score(1)
+          arg = exp.last
+          if arg.is_a?(Sexp)
+            case arg.first
+              when :lit, :call
+                add_flog_score(5)
+              when :iter, :dsym, :dstr, *BRANCHES
+                add_flog_score(10)
+            end
+          end
+          super
+        end
+
+        def process_call(exp)
+          add_flog_score(SCORES[exp[2]])
+          super
+        end
+
+        def process_case(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_dasgn_curr(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_iasgn(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_lasgn(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_else(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_rescue(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_when(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_if(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_iter(exp)
+          add_flog_score 1
+          super
+        end
+
+        def process_lit(exp)
+          value = exp.shift
+          case value
+            when 0, -1
+              # do nothing
+            when Integer
+              add_flog_score(0.25)
+          end
+          super
+        end
+
+        def process_masgn(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_sclass(exp)
+          add_flog_score(5)
+          super
+        end
+
+        def process_super(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_while(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_until(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def process_yield(exp)
+          add_flog_score(1)
+          super
+        end
+
+        def flog_score
+          initialize_values
+          @score
+        end
+
+        private
+
+          def add_flog_score(score)
+            initialize_values
+            @score += (score * @multiplier)
+          end
+
+          def initialize_values
+            @score      ||= 0
+            @multiplier ||= 1
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,15 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ForLoopContext < SexpContext #:nodoc:
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,21 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class GvarContext < SexpContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @name      = exp[1].to_s.sub(/^\$/, '')
+          @full_name = @name
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/parsing/conditional_context'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class IfContext < ConditionalContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @contains_assignment = has_assignment?
+          @tests_parameter     = contains_parameter?
+        end
+
+        def tests_assignment?
+          @contains_assignment
+        end
+
+        def tests_parameter?
+          @tests_parameter
+        end
+
+        private
+
+          def has_assignment?(exp = @exp[1])
+            return false if exp.node_type == :iter
+            super
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

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

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

@@ -0,0 +1,50 @@
+require 'simplabs/excellent/parsing/cyclomatic_complexity_measure'
+require 'simplabs/excellent/parsing/abc_measure'
+require 'simplabs/excellent/parsing/flog_measure'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class MethodContext < SexpContext #:nodoc:
+
+        include CyclomaticComplexityMeasure
+        include AbcMeasure
+        include FlogMeasure
+
+        attr_reader :parameters
+        attr_reader :calls
+        attr_reader :line_count
+
+        def initialize(exp, parent)
+          super
+          @parameters = []
+          @name       = exp[1].to_s
+          @parent.methods << self if @parent && (@parent.is_a?(ClassContext) || @parent.is_a?(ModuleContext))
+          @calls      = Hash.new(0)
+          @line_count = count_lines
+        end
+
+        def has_parameter?(parameter)
+          @parameters.include?(parameter)
+        end
+
+        def full_name
+          parent = @parent.is_a?(BlockContext) ? @parent.parent : @parent
+          return @name if parent.blank?
+          "#{parent.full_name}##{@name}"
+        end
+
+        def record_call_to(context)
+          @calls[context] += 1
+        end
+
+      end
+
+    end
+
+  end
+
+end