RubyGems - metric_fu-Saikuro - Versions diffs - 1.1.1.0 → 1.1.2 - Mend

metric_fu-Saikuro 1.1.1.0 → 1.1.2

Files changed (28) hide show

checksums.yaml +7 -0
data/README +52 -54
data/lib/saikuro.rb +21 -1082
data/lib/saikuro/base_formatter.rb +30 -0
data/lib/saikuro/endable_parse_state.rb +12 -0
data/lib/saikuro/filter.rb +22 -0
data/lib/saikuro/html_stylesheet.rb +82 -0
data/lib/saikuro/html_token_counter_formatter.rb +45 -0
data/lib/saikuro/parse_block.rb +33 -0
data/lib/saikuro/parse_class.rb +27 -0
data/lib/saikuro/parse_comment.rb +15 -0
data/lib/saikuro/parse_cond.rb +6 -0
data/lib/saikuro/parse_def.rb +59 -0
data/lib/saikuro/parse_do_cond.rb +24 -0
data/lib/saikuro/parse_module.rb +6 -0
data/lib/saikuro/parse_state.rb +286 -0
data/lib/saikuro/parse_state_formatter.rb +27 -0
data/lib/saikuro/parse_symbol.rb +13 -0
data/lib/saikuro/result_index_generator.rb +87 -0
data/lib/saikuro/saikuro_cmd_line_runner.rb +166 -0
data/lib/saikuro/state_html_complexity_formatter.rb +38 -0
data/lib/saikuro/token_counter.rb +51 -0
data/lib/saikuro/token_counter_formatter.rb +35 -0
data/lib/saikuro/usage.rb +0 -37
data/lib/saikuro/version.rb +1 -1
metadata +35 -24
data/tests/large_example.rb +0 -70
data/tests/samples.rb +0 -315

data/lib/saikuro/base_formatter.rb ADDED

@@ -0,0 +1,30 @@
+class BaseFormater
+  attr_accessor :warnings, :errors, :current
+  def initialize(out, filter = nil)
+    @out = out
+    @filter = filter
+    reset_data
+  end
+  def warn_error?(num, marker)
+    klass = ""
+    if @filter.error?(num)
+      klass = ' class="error"'
+      @errors<< [@current, marker, num]
+    elsif @filter.warn?(num)
+      klass = ' class="warning"'
+      @warnings<< [@current, marker, num]
+    end
+    klass
+  end
+  def reset_data
+    @warnings = Array.new
+    @errors = Array.new
+    @current = ""
+  end
+end

data/lib/saikuro/endable_parse_state.rb ADDED

@@ -0,0 +1,12 @@
+class EndableParseState < ParseState
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    STDOUT.puts "Starting #{self.class}" if $VERBOSE
+  end
+  def do_end_token(token)
+    end_debug
+    @run = false
+    nil
+  end
+end

data/lib/saikuro/filter.rb ADDED

@@ -0,0 +1,22 @@
+class Filter
+  attr_accessor :limit, :error, :warn
+  def initialize(limit = -1, error = 11, warn = 8)
+    @limit = limit
+    @error = error
+    @warn = warn
+  end
+  def ignore?(count)
+    count < @limit
+  end
+  def warn?(count)
+    count >= @warn
+  end
+  def error?(count)
+    count >= @error
+  end
+end

data/lib/saikuro/html_stylesheet.rb ADDED

@@ -0,0 +1,82 @@
+module HTMLStyleSheet
+  def HTMLStyleSheet.style_sheet
+    out = StringIO.new
+    out.puts "<style>"
+    out.puts 'body {'
+    out.puts '	margin: 20px;'
+    out.puts '	padding: 0;'
+    out.puts '	font-size: 12px;'
+    out.puts '	font-family: bitstream vera sans, verdana, arial, sans serif;'
+    out.puts '	background-color: #efefef;'
+    out.puts '}'
+    out.puts ''
+    out.puts 'table {	'
+    out.puts '	border-collapse: collapse;'
+    out.puts '	/*border-spacing: 0;*/'
+    out.puts '	border: 1px solid #666;'
+    out.puts '	background-color: #fff;'
+    out.puts '	margin-bottom: 20px;'
+    out.puts '}'
+    out.puts ''
+    out.puts 'table, th, th+th, td, td+td  {'
+    out.puts '	border: 1px solid #ccc;'
+    out.puts '}'
+    out.puts ''
+    out.puts 'table th {'
+    out.puts '	font-size: 12px;'
+    out.puts '	color: #fc0;'
+    out.puts '	padding: 4px 0;'
+    out.puts '	background-color: #336;'
+    out.puts '}'
+    out.puts ''
+    out.puts 'th, td {'
+    out.puts '	padding: 4px 10px;'
+    out.puts '}'
+    out.puts ''
+    out.puts 'td {	'
+    out.puts '	font-size: 13px;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.class_name {'
+    out.puts '	font-size: 17px;'
+    out.puts '	margin: 20px 0 0;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.class_complexity {'
+    out.puts 'margin: 0 auto;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.class_complexity>.class_complexity {'
+    out.puts '	margin: 0;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.class_total_complexity, .class_total_lines, .start_token_count, .file_count {'
+    out.puts '	font-size: 13px;'
+    out.puts '	font-weight: bold;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.class_total_complexity, .class_total_lines {'
+    out.puts '	color: #c00;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.start_token_count, .file_count {'
+    out.puts '	color: #333;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.warning {'
+    out.puts '	background-color: yellow;'
+    out.puts '}'
+    out.puts ''
+    out.puts '.error {'
+    out.puts '	background-color: #f00;'
+    out.puts '}'
+    out.puts "</style>"
+    out.string
+  end
+  def style_sheet
+    HTMLStyleSheet.style_sheet
+  end
+end

data/lib/saikuro/html_token_counter_formatter.rb ADDED

@@ -0,0 +1,45 @@
+class HTMLTokenCounterFormater < TokenCounterFormater
+  include HTMLStyleSheet
+  def start(new_out=nil)
+    reset_data
+    @out = new_out if new_out
+    @out.puts "<html>"
+    @out.puts style_sheet
+    @out.puts "<body>"
+  end
+  def start_count(number_of_files)
+    @out.puts "<div class=\"start_token_count\">"
+    @out.puts "Number of files: #{number_of_files}"
+    @out.puts "</div>"
+  end
+  def start_file(file_name)
+    @current = file_name
+    @out.puts "<div class=\"file_count\">"
+    @out.puts "<p class=\"file_name\">"
+    @out.puts "File: #{file_name}"
+    @out.puts "</p>"
+    @out.puts "<table width=\"100%\" border=\"1\">"
+    @out.puts "<tr><th>Line</th><th>Tokens</th></tr>"
+  end
+  def line_token_count(line_number,number_of_tokens)
+    return if @filter.ignore?(number_of_tokens)
+    klass = warn_error?(number_of_tokens, line_number)
+    @out.puts "<tr><td>#{line_number}</td><td#{klass}>#{number_of_tokens}</td></tr>"
+  end
+  def end_file
+    @out.puts "</table>"
+  end
+  def end_count
+  end
+  def end
+    @out.puts "</body>"
+    @out.puts "</html>"
+  end
+end

data/lib/saikuro/parse_block.rb ADDED

@@ -0,0 +1,33 @@
+class ParseBlock < EndableParseState
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @complexity = 1
+    @lbraces = Array.new
+  end
+  # Because the token for a block and hash right brace is the same,
+  # we need to track the hash left braces to determine when an end is
+  # encountered.
+  def parse_token(token)
+    if token.is_a?(TkLBRACE)
+      @lbraces.push(true)
+    elsif token.is_a?(TkRBRACE)
+      if @lbraces.empty?
+        do_right_brace_token(token)
+        #do_end_token(token)
+      else
+        @lbraces.pop
+      end
+    else
+      super(token)
+    end
+  end
+  def do_right_brace_token(token)
+    # we are done ? what about a hash in a block :-/
+    @run = false
+    nil
+  end
+end

data/lib/saikuro/parse_class.rb ADDED

@@ -0,0 +1,27 @@
+class ParseClass < EndableParseState
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @type_name = "Class"
+  end
+  def do_constant_token(token)
+    @name = token.name if @name.empty?
+    nil
+  end
+  def compute_state(formater)
+    # Seperate the Module and Class Children out
+    cnm_children, @children = @children.partition do |child|
+      child.kind_of?(ParseClass)
+    end
+    formater.start_class_compute_state(@type_name,@name,self.calc_complexity,self.calc_lines)
+    super(formater)
+    formater.end_class_compute_state(@name)
+    cnm_children.each do |child|
+      child.name = @name + "::" + child.name
+      child.compute_state(formater)
+    end
+  end
+end

data/lib/saikuro/parse_comment.rb ADDED

@@ -0,0 +1,15 @@
+# Read and consume tokens in comments until a new line.
+class ParseComment < ParseState
+  # While in a comment state do not count the tokens.
+  def count_tokens?
+    false
+  end
+  def parse_token(token)
+    if token.is_a?(TkNL)
+      @lines += 1
+      @run = false
+    end
+  end
+end

data/lib/saikuro/parse_cond.rb ADDED

@@ -0,0 +1,6 @@
+class ParseCond < EndableParseState
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @complexity = 1
+  end
+end

data/lib/saikuro/parse_def.rb ADDED

@@ -0,0 +1,59 @@
+class ParseDef < EndableParseState
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @complexity = 1
+    @looking_for_name = true
+    @first_space = true
+  end
+  # This way I don't need to list all possible overload
+  # tokens.
+  def create_def_name(token)
+    case token
+    when TkSPACE
+      # mark first space so we can stop at next space
+      if @first_space
+	@first_space = false
+      else
+	@looking_for_name = false
+      end
+    when TkNL,TkLPAREN,TkfLPAREN,TkSEMICOLON
+      # we can also stop at a new line or left parenthesis
+      @looking_for_name = false
+    when TkDOT
+      @name<< "."
+    when TkCOLON2
+      @name<< "::"
+    when TkASSIGN
+      @name<< "="
+    when TkfLBRACK
+      @name<< "["
+    when TkRBRACK
+      @name<< "]"
+    else
+      begin
+	@name<< token.name.to_s
+      rescue Exception => err
+	#what is this?
+	STDOUT.puts @@token_counter.current_file
+	STDOUT.puts @name
+	STDOUT.puts token.inspect
+	STDOUT.puts err.message
+	exit 1
+      end
+    end
+  end
+  def parse_token(token)
+    if @looking_for_name
+      create_def_name(token)
+    end
+    super(token)
+  end
+  def compute_state(formater)
+    formater.def_compute_state(@name, self.calc_complexity, self.calc_lines)
+    super(formater)
+  end
+end

data/lib/saikuro/parse_do_cond.rb ADDED

@@ -0,0 +1,24 @@
+class ParseDoCond < ParseCond
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @looking_for_new_line = true
+  end
+  # Need to consume the do that can appear at the
+  # end of these control structures.
+  def parse_token(token)
+    if @looking_for_new_line
+      if token.is_a?(TkDO)
+        nil
+      else
+        if token.is_a?(TkNL)
+          @looking_for_new_line = false
+        end
+        super(token)
+      end
+    else
+      super(token)
+    end
+  end
+end

data/lib/saikuro/parse_module.rb ADDED

@@ -0,0 +1,6 @@
+class ParseModule < ParseClass
+  def initialize(lexer,parent=nil)
+    super(lexer,parent)
+    @type_name = "Module"
+  end
+end

data/lib/saikuro/parse_state.rb ADDED

@@ -0,0 +1,286 @@
+# Main class and structure used to compute the
+# cyclomatic complexity of Ruby programs.
+class ParseState
+  include RubyToken
+  attr_accessor :name, :children, :complexity, :parent, :lines
+  @@top_state = nil
+  def ParseState.make_top_state()
+    @@top_state = ParseState.new(nil)
+    @@top_state.name = "__top__"
+    @@top_state
+  end
+  @@token_counter = TokenCounter.new
+  def ParseState.set_token_counter(counter)
+    @@token_counter = counter
+  end
+  def ParseState.get_token_counter
+    @@token_counter
+  end
+  def initialize(lexer,parent=nil)
+    @name = ""
+    @children = Array.new
+    @complexity = 0
+    @parent = parent
+    @lexer = lexer
+    @run = true
+    # To catch one line def statements, We always have one line.
+    @lines = 0
+    @last_token_line_and_char = Array.new
+  end
+  def top_state?
+    self == @@top_state
+  end
+  def lexer=(lexer)
+    @run = true
+    @lexer = lexer
+  end
+  def make_state(type,parent = nil)
+    cstate = type.new(@lexer,self)
+    parent.children<< cstate
+    cstate
+  end
+  def calc_complexity
+    complexity = @complexity
+    children.each do |child|
+      complexity += child.calc_complexity
+    end
+    complexity
+  end
+  def calc_lines
+    lines = @lines
+    children.each do |child|
+      lines += child.calc_lines
+    end
+    lines
+  end
+  def compute_state(formater)
+    if top_state?
+      compute_state_for_global(formater)
+    end
+    @children.each do |s|
+      s.compute_state(formater)
+    end
+  end
+  def compute_state_for_global(formater)
+    global_def, @children = @children.partition do |s|
+      !s.kind_of?(ParseClass)
+    end
+    return if global_def.empty?
+    gx = global_def.inject(0) { |c,s| s.calc_complexity }
+    gl = global_def.inject(0) { |c,s| s.calc_lines }
+    formater.start_class_compute_state("Global", "", gx, gl)
+    global_def.each do |s|
+      s.compute_state(formater)
+    end
+    formater.end_class_compute_state("")
+  end
+  # Count the tokens parsed if true else ignore them.
+  def count_tokens?
+    true
+  end
+  def parse
+    while @run do
+      tok = @lexer.token
+      @run = false if tok.nil?
+      if lexer_loop?(tok)
+        STDERR.puts "Lexer loop at line : #{@lexer.line_no} char #{@lexer.char_no}."
+        @run = false
+      end
+      @last_token_line_and_char<< [@lexer.line_no.to_i, @lexer.char_no.to_i, tok]
+      if $VERBOSE
+	puts "DEBUG: #{@lexer.line_no} #{tok.class}:#{tok.name if tok.respond_to?(:name)}"
+      end
+      @@token_counter.count_token(@lexer.line_no, tok) if count_tokens?
+      parse_token(tok)
+    end
+  end
+  # Ruby-Lexer can go into a loop if the file does not end with a newline.
+  def lexer_loop?(token)
+    return false if @last_token_line_and_char.empty?
+    loop_flag = false
+    last = @last_token_line_and_char.last
+    line = last[0]
+    char = last[1]
+    ltok = last[2]
+    if ( (line == @lexer.line_no.to_i) &&
+           (char == @lexer.char_no.to_i) &&
+           (ltok.class == token.class) )
+      # We are potentially in a loop
+      if @last_token_line_and_char.size >= 3
+        loop_flag = true
+      end
+    else
+      # Not in a loop so clear stack
+      @last_token_line_and_char = Array.new
+    end
+    loop_flag
+  end
+  def do_begin_token(token)
+    make_state(EndableParseState, self)
+  end
+  def do_class_token(token)
+    make_state(ParseClass,self)
+  end
+  def do_module_token(token)
+    make_state(ParseModule,self)
+  end
+  def do_def_token(token)
+    make_state(ParseDef,self)
+  end
+  def do_constant_token(token)
+    nil
+  end
+  def do_identifier_token(token)
+    if (token.name == "__END__" && token.char_no.to_i == 0)
+      # The Ruby code has stopped and the rest is data so cease parsing.
+      @run = false
+    end
+    nil
+  end
+  def do_right_brace_token(token)
+    nil
+  end
+  def do_end_token(token)
+    end_debug
+    nil
+  end
+  def do_block_token(token)
+    make_state(ParseBlock,self)
+  end
+  def do_conditional_token(token)
+    make_state(ParseCond,self)
+  end
+  def do_conditional_do_control_token(token)
+    make_state(ParseDoCond,self)
+  end
+  def do_case_token(token)
+    make_state(EndableParseState, self)
+  end
+  def do_one_line_conditional_token(token)
+    # This is an if with no end
+    @complexity += 1
+    #STDOUT.puts "got IF_MOD: #{self.to_yaml}" if $VERBOSE
+    #if state.type != "class" && state.type != "def" && state.type != "cond"
+    #STDOUT.puts "Changing IF_MOD Parent" if $VERBOSE
+    #state = state.parent
+    #@run = false
+    nil
+  end
+  def do_else_token(token)
+    STDOUT.puts "Ignored/Unknown Token:#{token.class}" if $VERBOSE
+    nil
+  end
+  def do_comment_token(token)
+    make_state(ParseComment, self)
+  end
+  def do_symbol_token(token)
+    make_state(ParseSymbol, self)
+  end
+  def parse_token(token)
+    state = nil
+    case token
+    when TkCLASS
+      state = do_class_token(token)
+    when TkMODULE
+      state = do_module_token(token)
+    when TkDEF
+      state = do_def_token(token)
+    when TkCONSTANT
+      # Nothing to do with a constant at top level?
+      state = do_constant_token(token)
+    when TkIDENTIFIER,TkFID
+      # Nothing to do at top level?
+      state = do_identifier_token(token)
+    when TkRBRACE
+      # Nothing to do at top level
+      state = do_right_brace_token(token)
+    when TkEND
+      state = do_end_token(token)
+      # At top level this might be an error...
+    when TkDO,TkfLBRACE
+      state = do_block_token(token)
+    when TkIF,TkUNLESS
+      state = do_conditional_token(token)
+    when TkWHILE,TkUNTIL,TkFOR
+      state = do_conditional_do_control_token(token)
+    when TkELSIF #,TkELSE
+      @complexity += 1
+    when TkELSE
+      # Else does not increase complexity
+    when TkCASE
+      state = do_case_token(token)
+    when TkWHEN
+      @complexity += 1
+    when TkBEGIN
+      state = do_begin_token(token)
+    when TkRESCUE
+      # Maybe this should add complexity and not begin
+      @complexity += 1
+    when TkIF_MOD, TkUNLESS_MOD, TkUNTIL_MOD, TkWHILE_MOD, TkQUESTION
+      state = do_one_line_conditional_token(token)
+    when TkNL
+      #
+      @lines += 1
+    when TkRETURN
+      # Early returns do not increase complexity as the condition that
+      # calls the return is the one that increases it.
+    when TkCOMMENT
+      state = do_comment_token(token)
+    when TkSYMBEG
+      state = do_symbol_token(token)
+    when TkError
+      STDOUT.puts "Lexer received an error for line #{@lexer.line_no} char #{@lexer.char_no}"
+    else
+      state = do_else_token(token)
+    end
+    state.parse if state
+  end
+  def end_debug
+    STDOUT.puts "got an end: #{@name} in #{self.class.name}" if $VERBOSE
+    if @parent.nil?
+      STDOUT.puts "DEBUG: Line #{@lexer.line_no}"
+      STDOUT.puts "DEBUG: #{@name}; #{self.class}"
+      # to_yaml can cause an infinite loop?
+      #STDOUT.puts "TOP: #{@@top_state.to_yaml}"
+      #STDOUT.puts "TOP: #{@@top_state.inspect}"
+      # This may not be an error?
+      #exit 1
+    end
+  end
+end