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

metric_fu-Saikuro 1.1.1.0 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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