simplabs-excellent 1.0.1 → 1.2.1

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/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/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(exp)
+          @calls[exp] += 1
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,29 @@
+require 'simplabs/excellent/parsing/scopeable'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ModuleContext < SexpContext #:nodoc:
+
+        include Scopeable
+
+        attr_reader :methods
+        attr_reader :line_count
+
+        def initialize(exp, parent)
+          super
+          @name, @full_name = get_names
+          @methods = []
+          @line_count = count_lines
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/{core → parsing}/parser.rb

@@ -6,14 +6,16 @@ module Simplabs
 
   module Excellent
 
-    module Core
+    module Parsing
 
-      class Parser
+      class Parser #:nodoc:
 
         def parse(content, filename)
           silence_stream(STDERR) do 
             return silent_parse(content, filename)
           end
+        rescue
+          #continue on errors
         end
 
         private

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

@@ -0,0 +1,39 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ResbodyContext < SexpContext #:nodoc:
+
+        STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :call, :str, :lit, :hash, :false, :true, :nil]
+
+        def initialize(exp, parent)
+          super
+          @contains_statements = contains_statements?
+        end
+
+        def has_statements?
+          @contains_statements
+        end
+
+        private
+
+          def contains_statements?(exp = @exp)
+            return true if STATEMENT_NODES.include?(exp.node_type)
+            return true if assigning_other_than_exception_to_local_variable?(exp)
+            return true if (exp[1][0] == :array && exp[2][0] == :array rescue false)
+            return true if exp.children.any? { |child| contains_statements?(child) }
+          end
+
+          def assigning_other_than_exception_to_local_variable?(exp)
+            exp.node_type == :lasgn && exp[2].to_a != [:gvar, :$!]
+          end
+
+      end
+
+    end
+
+  end
+
+end