Module: Saikuro

Defined in:
lib/saikuro.rb,
lib/saikuro/version.rb

Constant Summary collapse

VERSION = 
"1.1.3"

Class Method Summary collapse

Class Method Details

.analyze(files, state_formater, token_count_formater, output_dir) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/saikuro.rb', line 83

def Saikuro.analyze(files, state_formater, token_count_formater, output_dir)

  idx_states = Array.new
  idx_tokens = Array.new

  # parse each file
  files.each do |file|
    begin
      STDOUT.puts "Parsing #{file}"
      # create top state
      top = ParseState.make_top_state
      STDOUT.puts "TOP State made" if $VERBOSE
      token_counter = TokenCounter.new
      ParseState.set_token_counter(token_counter)
      token_counter.set_current_file(file)

      STDOUT.puts "Setting up Lexer" if $VERBOSE
      lexer = RubyLex.new
      # Turn of this, because it aborts when a syntax error is found...
      lexer.exception_on_syntax_error = false
      lexer.set_input(File.new(file,"rb"))
      top.lexer = lexer
      STDOUT.puts "Parsing" if $VERBOSE
      top.parse


      fdir_path = seperate_file_from_path(file)
      FileUtils.makedirs("#{output_dir}/#{fdir_path}")

      if state_formater
        # output results
        state_io = StringIO.new
        state_formater.start(state_io)
        top.compute_state(state_formater)
        state_formater.end

        fname = "#{file}_cyclo.html"
        puts "writing cyclomatic #{file}" if $VERBOSE
        File.open("#{output_dir}/#{fname}","w") do |f|
          f.write state_io.string
        end
        idx_states<< [
          fname,
          state_formater.warnings.dup,
          state_formater.errors.dup,
        ]
      end

      if token_count_formater
        token_io = StringIO.new
        token_count_formater.start(token_io)
        token_counter.list_tokens_per_line(token_count_formater)
        token_count_formater.end

        fname = "#{file}_token.html"
        puts "writing token #{file}" if $VERBOSE
        File.open("#{output_dir}/#{fname}","w") do |f|
          f.write token_io.string
        end
        idx_tokens<< [
          fname,
          token_count_formater.warnings.dup,
          token_count_formater.errors.dup,
        ]
      end

    rescue RubyLex::SyntaxError => synerr
      STDOUT.puts "Lexer error for file #{file} on line #{lexer.line_no}"
      STDOUT.puts "#{synerr.class.name} : #{synerr.message}"
    rescue StandardError => err
      STDOUT.puts "Error while parsing file : #{file}"
      STDOUT.puts err.class,err.message,err.backtrace.join("\n")
    rescue Exception => ex
      STDOUT.puts "Error while parsing file : #{file}"
      STDOUT.puts ex.class,ex.message,ex.backtrace.join("\n")
    end
  end

  [idx_states, idx_tokens]
end

.seperate_file_from_path(path) ⇒ Object

Returns the path without the file



74
75
76
77
78
79
80
81
 
# File 'lib/saikuro.rb', line 74

def Saikuro.seperate_file_from_path(path)
  res = path.split("/")
  if res.size == 1
    ""
  else
    res[0..res.size - 2].join("/")
  end
end