katsuya-rcov 0.9.7.1

data/lib/rcov/code_coverage_analyzer.rb

@@ -0,0 +1,271 @@
+module Rcov
+  # A CodeCoverageAnalyzer is responsible for tracing code execution and
+  # returning code coverage and execution count information.
+  #
+  # Note that you must <tt>require 'rcov'</tt> before the code you want to
+  # analyze is parsed (i.e. before it gets loaded or required). You can do that
+  # by either invoking ruby with the <tt>-rrcov</tt> command-line option or
+  # just:
+  #  require 'rcov'
+  #  require 'mycode'
+  #  # ....
+  #
+  # == Example
+  #
+  #  analyzer = Rcov::CodeCoverageAnalyzer.new
+  #  analyzer.run_hooked do 
+  #    do_foo  
+  #    # all the code executed as a result of this method call is traced
+  #  end
+  #  # ....
+  #  
+  #  analyzer.run_hooked do 
+  #    do_bar
+  #    # the code coverage information generated in this run is aggregated
+  #    # to the previously recorded one
+  #  end
+  #
+  #  analyzer.analyzed_files   # => ["foo.rb", "bar.rb", ... ]
+  #  lines, marked_info, count_info = analyzer.data("foo.rb")
+  #
+  # In this example, two pieces of code are monitored, and the data generated in
+  # both runs are aggregated. +lines+ is an array of strings representing the 
+  # source code of <tt>foo.rb</tt>. +marked_info+ is an array holding false,
+  # true values indicating whether the corresponding lines of code were reported
+  # as executed by Ruby. +count_info+ is an array of integers representing how
+  # many times each line of code has been executed (more precisely, how many
+  # events where reported by Ruby --- a single line might correspond to several
+  # events, e.g. many method calls).
+  #
+  # You can have several CodeCoverageAnalyzer objects at a time, and it is
+  # possible to nest the #run_hooked / #install_hook/#remove_hook blocks: each
+  # analyzer will manage its data separately. Note however that no special
+  # provision is taken to ignore code executed "inside" the CodeCoverageAnalyzer
+  # class. At any rate this will not pose a problem since it's easy to ignore it
+  # manually: just don't do
+  #   lines, coverage, counts = analyzer.data("/path/to/lib/rcov.rb")
+  # if you're not interested in that information.
+  class CodeCoverageAnalyzer < DifferentialAnalyzer
+    @hook_level = 0
+    # defined this way instead of attr_accessor so that it's covered
+    def self.hook_level      # :nodoc:
+      @hook_level 
+    end
+     
+    def self.hook_level=(x)  # :nodoc: 
+      @hook_level = x 
+    end 
+
+    def initialize
+      @script_lines__ = SCRIPT_LINES__
+      super(:install_coverage_hook, :remove_coverage_hook,
+            :reset_coverage)
+    end
+  
+    # Return an array with the names of the files whose code was executed inside
+    # the block given to #run_hooked or between #install_hook and #remove_hook.
+    def analyzed_files
+      update_script_lines__
+      raw_data_relative.select do |file, lines|
+        @script_lines__.has_key?(file)
+      end.map{|fname,| fname}
+    end
+
+    # Return the available data about the requested file, or nil if none of its
+    # code was executed or it cannot be found.
+    # The return value is an array with three elements:
+    #  lines, marked_info, count_info = analyzer.data("foo.rb")
+    # +lines+ is an array of strings representing the 
+    # source code of <tt>foo.rb</tt>. +marked_info+ is an array holding false,
+    # true values indicating whether the corresponding lines of code were reported
+    # as executed by Ruby. +count_info+ is an array of integers representing how
+    # many times each line of code has been executed (more precisely, how many
+    # events where reported by Ruby --- a single line might correspond to several
+    # events, e.g. many method calls).
+    #
+    # The returned data corresponds to the aggregation of all the statistics
+    # collected in each #run_hooked or #install_hook/#remove_hook runs. You can
+    # reset the data at any time with #reset to start from scratch.
+    def data(filename)
+      raw_data = raw_data_relative
+      update_script_lines__
+      unless @script_lines__.has_key?(filename) && 
+             raw_data.has_key?(filename)
+        return nil 
+      end
+      refine_coverage_info(@script_lines__[filename], raw_data[filename])
+    end
+
+    # Data for the first file matching the given regexp.
+    # See #data.
+    def data_matching(filename_re)
+      raw_data = raw_data_relative
+      update_script_lines__
+
+      match = raw_data.keys.sort.grep(filename_re).first
+      return nil unless match
+
+      refine_coverage_info(@script_lines__[match], raw_data[match])
+    end
+
+    # Execute the code in the given block, monitoring it in order to gather
+    # information about which code was executed.
+    def run_hooked; super end
+
+    # Start monitoring execution to gather code coverage and execution count
+    # information. Such data will be collected until #remove_hook is called.
+    #
+    # Use #run_hooked instead if possible.
+    def install_hook; super end
+
+    # Stop collecting code coverage and execution count information.
+    # #remove_hook will also stop collecting info if it is run inside a
+    # #run_hooked block.
+    def remove_hook; super end
+
+    # Remove the data collected so far. The coverage and execution count
+    # "history" will be erased, and further collection will start from scratch:
+    # no code is considered executed, and therefore all execution counts are 0.
+    # Right after #reset, #analyzed_files will return an empty array, and
+    # #data(filename) will return nil.
+    def reset; super end
+
+    def dump_coverage_info(formatters) # :nodoc:
+      update_script_lines__
+      raw_data_relative.each do |file, lines|
+        next if @script_lines__.has_key?(file) == false
+        lines = @script_lines__[file]
+        raw_coverage_array = raw_data_relative[file]
+
+        line_info, marked_info, 
+          count_info = refine_coverage_info(lines, raw_coverage_array)
+        formatters.each do |formatter|
+          formatter.add_file(file, line_info, marked_info, count_info)
+        end
+      end
+      formatters.each{|formatter| formatter.execute}
+    end
+
+    private
+
+    def data_default; {} end
+
+    def raw_data_absolute
+      Rcov::RCOV__.generate_coverage_info
+    end
+
+    def aggregate_data(aggregated_data, delta)
+      delta.each_pair do |file, cov_arr|
+        dest = (aggregated_data[file] ||= Array.new(cov_arr.size, 0))
+        cov_arr.each_with_index do |x,i| 
+          dest[i] ||= 0
+          dest[i] += x.to_i
+        end
+      end
+    end
+
+    def compute_raw_data_difference(first, last)
+      difference = {}
+      last.each_pair do |fname, cov_arr|
+        unless first.has_key?(fname)
+          difference[fname] = cov_arr.clone
+        else
+          orig_arr = first[fname]
+          diff_arr = Array.new(cov_arr.size, 0)
+          changed = false
+          cov_arr.each_with_index do |x, i|
+            diff_arr[i] = diff = (x || 0) - (orig_arr[i] || 0)
+            changed = true if diff != 0
+          end
+          difference[fname] = diff_arr if changed
+        end
+      end
+      difference
+    end
+
+    def refine_coverage_info(lines, covers)
+      marked_info = []
+      count_info = []
+      lines.size.times do |i|
+        c = covers[i]
+        marked_info << ((c && c > 0) ? true : false)
+        count_info << (c || 0)
+      end
+
+      script_lines_workaround(lines, marked_info, count_info)
+    end
+
+    # Try to detect repeated data, based on observed repetitions in line_info:
+    # this is a workaround for SCRIPT_LINES__[filename] including as many copies
+    # of the file as the number of times it was parsed.
+    def script_lines_workaround(line_info, coverage_info, count_info)
+      is_repeated = lambda do |div|
+        n = line_info.size / div
+        break false unless line_info.size % div == 0 && n > 1
+        different = false
+        n.times do |i|
+        
+          things = (0...div).map { |j| line_info[i + j * n] }
+          if things.uniq.size != 1
+            different = true
+            break
+          end
+        end
+
+        ! different
+      end
+
+      factors = braindead_factorize(line_info.size)
+      factors.each do |n|
+        if is_repeated[n]
+          line_info = line_info[0, line_info.size / n]
+          coverage_info = coverage_info[0, coverage_info.size / n]
+          count_info = count_info[0, count_info.size / n]
+        end
+      end if factors.size > 1   # don't even try if it's prime
+
+      [line_info, coverage_info, count_info]
+    end
+
+    def braindead_factorize(num)
+      return [0] if num == 0
+      return [-1] + braindead_factorize(-num) if num < 0
+      factors = []
+      while num % 2 == 0
+        factors << 2
+        num /= 2
+      end
+      size = num
+      n = 3
+      max = Math.sqrt(num)
+      while n <= max && n <= size
+        while size % n == 0
+          size /= n
+          factors << n
+        end
+        n += 2
+      end
+      factors << size if size != 1
+      factors
+    end
+
+    def update_script_lines__
+      @script_lines__ = @script_lines__.merge(SCRIPT_LINES__)
+    end
+
+    public
+
+    def marshal_dump # :nodoc:
+      # @script_lines__ is updated just before serialization so as to avoid
+      # missing files in SCRIPT_LINES__
+      ivs = {}
+      update_script_lines__
+      instance_variables.each{|iv| ivs[iv] = instance_variable_get(iv)}
+      ivs
+    end
+
+    def marshal_load(ivs) # :nodoc:
+      ivs.each_pair{|iv, val| instance_variable_set(iv, val)}
+    end
+  end # CodeCoverageAnalyzer
+end

data/lib/rcov/coverage_info.rb

@@ -0,0 +1,36 @@
+# Rcov::CoverageInfo is but a wrapper for an array, with some additional
+# checks. It is returned by FileStatistics#coverage.
+class CoverageInfo
+  def initialize(coverage_array)
+    @cover = coverage_array.clone
+  end
+
+  # Return the coverage status for the requested line. There are four possible
+  # return values:
+  # * nil if there's no information for the requested line (i.e. it doesn't exist)
+  # * true if the line was reported by Ruby as executed
+  # * :inferred if rcov inferred it was executed, despite not being reported 
+  #   by Ruby.
+  # * false otherwise, i.e. if it was not reported by Ruby and rcov's
+  #   heuristics indicated that it was not executed
+  def [](line)
+    @cover[line]
+  end
+
+  def []=(line, val) # :nodoc:
+    unless [true, false, :inferred].include? val
+      raise RuntimeError, "What does #{val} mean?" 
+    end
+    return if line < 0 || line >= @cover.size
+    @cover[line] = val
+  end
+
+  # Return an Array holding the code coverage information.
+  def to_a
+    @cover.clone
+  end
+
+  def method_missing(meth, *a, &b) # :nodoc:
+    @cover.send(meth, *a, &b)
+  end
+end

data/lib/rcov/differential_analyzer.rb

@@ -0,0 +1,116 @@
+module Rcov
+  class DifferentialAnalyzer
+    require 'thread'
+    @@mutex = Mutex.new
+
+    def initialize(install_hook_meth, remove_hook_meth, reset_meth)
+      @cache_state = :wait
+      @start_raw_data = data_default
+      @end_raw_data = data_default
+      @aggregated_data = data_default
+      @install_hook_meth = install_hook_meth
+      @remove_hook_meth= remove_hook_meth
+      @reset_meth= reset_meth
+    end
+
+    # Execute the code in the given block, monitoring it in order to gather
+    # information about which code was executed.
+    def run_hooked
+      install_hook
+      yield
+    ensure
+      remove_hook
+    end
+
+    # Start monitoring execution to gather information. Such data will be
+    # collected until #remove_hook is called.
+    #
+    # Use #run_hooked instead if possible.
+    def install_hook
+      @start_raw_data = raw_data_absolute
+      Rcov::RCOV__.send(@install_hook_meth)
+      @cache_state = :hooked
+      @@mutex.synchronize{ self.class.hook_level += 1 }
+    end
+
+    # Stop collecting information.
+    # #remove_hook will also stop collecting info if it is run inside a
+    # #run_hooked block.
+    def remove_hook
+      @@mutex.synchronize do 
+        self.class.hook_level -= 1
+        Rcov::RCOV__.send(@remove_hook_meth) if self.class.hook_level == 0
+      end
+      @end_raw_data = raw_data_absolute
+      @cache_state = :done
+      # force computation of the stats for the traced code in this run;
+      # we cannot simply let it be if self.class.hook_level == 0 because 
+      # some other analyzer could install a hook, causing the raw_data_absolute
+      # to change again.
+      # TODO: lazy computation of raw_data_relative, only when the hook gets
+      # activated again.
+      raw_data_relative
+    end
+
+    # Remove the data collected so far. Further collection will start from
+    # scratch.
+    def reset
+      @@mutex.synchronize do
+        if self.class.hook_level == 0
+          # Unfortunately there's no way to report this as covered with rcov:
+          # if we run the tests under rcov self.class.hook_level will be >= 1 !
+          # It is however executed when we run the tests normally.
+          Rcov::RCOV__.send(@reset_meth)
+          @start_raw_data = data_default
+          @end_raw_data = data_default
+        else
+          @start_raw_data = @end_raw_data = raw_data_absolute
+        end
+        @raw_data_relative = data_default
+        @aggregated_data = data_default
+      end
+    end
+
+    protected
+
+    def data_default
+      raise "must be implemented by the subclass"
+    end
+
+    def self.hook_level
+      raise "must be implemented by the subclass"
+    end
+
+    def raw_data_absolute
+      raise "must be implemented by the subclass"
+    end
+
+    def aggregate_data(aggregated_data, delta)
+      raise "must be implemented by the subclass"
+    end
+
+    def compute_raw_data_difference(first, last)
+      raise "must be implemented by the subclass"
+    end
+
+    private
+
+    def raw_data_relative
+      case @cache_state
+      when :wait
+        return @aggregated_data
+      when :hooked
+        new_start = raw_data_absolute
+        new_diff = compute_raw_data_difference(@start_raw_data, new_start)
+        @start_raw_data = new_start
+      when :done
+        @cache_state = :wait
+        new_diff = compute_raw_data_difference(@start_raw_data, 
+                                               @end_raw_data)
+      end
+
+      aggregate_data(@aggregated_data, new_diff)
+      @aggregated_data
+    end
+  end
+end

data/lib/rcov/file_statistics.rb

@@ -0,0 +1,355 @@
+module Rcov
+  # A FileStatistics object associates a filename to:
+  # 1. its source code
+  # 2. the per-line coverage information after correction using rcov's heuristics
+  # 3. the per-line execution counts
+  #
+  # A FileStatistics object can be therefore be built given the filename, the
+  # associated source code, and an array holding execution counts (i.e. how many
+  # times each line has been executed).
+  #
+  # FileStatistics is relatively intelligent: it handles normal comments,
+  # <tt>=begin/=end</tt>, heredocs, many multiline-expressions... It uses a
+  # number of heuristics to determine what is code and what is a comment, and to
+  # refine the initial (incomplete) coverage information.
+  #
+  # Basic usage is as follows:
+  #  sf = FileStatistics.new("foo.rb", ["puts 1", "if true &&", "   false", 
+  #                                 "puts 2", "end"],  [1, 1, 0, 0, 0])
+  #  sf.num_lines        # => 5
+  #  sf.num_code_lines   # => 5
+  #  sf.coverage[2]      # => true
+  #  sf.coverage[3]      # => :inferred
+  #  sf.code_coverage    # => 0.6
+  #                    
+  # The array of strings representing the source code and the array of execution
+  # counts would normally be obtained from a Rcov::CodeCoverageAnalyzer.
+  class FileStatistics
+    attr_reader :name, :lines, :coverage, :counts
+    def initialize(name, lines, counts, comments_run_by_default = false)
+      @name = name
+      @lines = lines
+      initial_coverage = counts.map{|x| (x || 0) > 0 ? true : false }
+      @coverage = CoverageInfo.new initial_coverage
+      @counts = counts
+      @is_begin_comment = nil
+      # points to the line defining the heredoc identifier
+      # but only if it was marked (we don't care otherwise)
+      @heredoc_start = Array.new(lines.size, false)
+      @multiline_string_start = Array.new(lines.size, false)
+      extend_heredocs
+      find_multiline_strings
+      precompute_coverage comments_run_by_default
+    end
+
+    # Merge code coverage and execution count information.
+    # As for code coverage, a line will be considered
+    # * covered for sure (true) if it is covered in either +self+ or in the 
+    #   +coverage+ array
+    # * considered <tt>:inferred</tt> if the neither +self+ nor the +coverage+ array
+    #   indicate that it was definitely executed, but it was <tt>inferred</tt>
+    #   in either one 
+    # * not covered (<tt>false</tt>) if it was uncovered in both
+    #
+    # Execution counts are just summated on a per-line basis.
+    def merge(lines, coverage, counts)
+      coverage.each_with_index do |v, idx|
+        case @coverage[idx]
+        when :inferred 
+          @coverage[idx] = v || @coverage[idx]
+        when false 
+          @coverage[idx] ||= v
+        end
+      end
+      counts.each_with_index{|v, idx| @counts[idx] += v }
+      precompute_coverage false
+    end
+
+    # Total coverage rate if comments are also considered "executable", given as
+    # a fraction, i.e. from 0 to 1.0.
+    # A comment is attached to the code following it (RDoc-style): it will be
+    # considered executed if the the next statement was executed.
+    def total_coverage
+      return 0 if @coverage.size == 0
+      @coverage.inject(0.0) {|s,a| s + (a ? 1:0) } / @coverage.size
+    end
+
+    # Code coverage rate: fraction of lines of code executed, relative to the
+    # total amount of lines of code (loc). Returns a float from 0 to 1.0.
+    def code_coverage
+      indices = (0...@lines.size).select{|i| is_code? i }
+      return 0 if indices.size == 0
+      count = 0
+      indices.each {|i| count += 1 if @coverage[i] }
+      1.0 * count / indices.size
+    end
+
+    def code_coverage_for_report
+      code_coverage * 100
+    end
+
+    def total_coverage_for_report
+      total_coverage * 100
+    end
+
+    # Number of lines of code (loc).
+    def num_code_lines
+      (0...@lines.size).select{|i| is_code? i}.size
+    end
+
+    # Total number of lines.
+    def num_lines
+      @lines.size
+    end
+
+    # Returns true if the given line number corresponds to code, as opposed to a
+    # comment (either # or =begin/=end blocks).
+    def is_code?(lineno)
+      unless @is_begin_comment
+        @is_begin_comment = Array.new(@lines.size, false)
+        pending = []
+        state = :code
+        @lines.each_with_index do |line, index|
+          case state
+          when :code
+            if /^=begin\b/ =~ line
+              state = :comment
+              pending << index
+            end
+          when :comment
+            pending << index
+            if /^=end\b/ =~ line
+              state = :code
+              pending.each{|idx| @is_begin_comment[idx] = true}
+              pending.clear
+            end
+          end
+        end
+      end
+      @lines[lineno] && !@is_begin_comment[lineno] && @lines[lineno] !~ /^\s*(#|$)/ 
+    end
+
+    private
+
+    def find_multiline_strings
+      state = :awaiting_string
+      wanted_delimiter = nil
+      string_begin_line = 0
+      @lines.each_with_index do |line, i|
+        matching_delimiters = Hash.new{|h,k| k} 
+        matching_delimiters.update("{" => "}", "[" => "]", "(" => ")")
+        case state
+        when :awaiting_string
+          # very conservative, doesn't consider the last delimited string but
+          # only the very first one
+          if md = /^[^#]*%(?:[qQ])?(.)/.match(line)
+            if !/"%"/.match(line)
+              wanted_delimiter = /(?!\\).#{Regexp.escape(matching_delimiters[md[1]])}/
+              # check if closed on the very same line
+              # conservative again, we might have several quoted strings with the
+              # same delimiter on the same line, leaving the last one open
+              unless wanted_delimiter.match(md.post_match)
+                state = :want_end_delimiter
+                string_begin_line = i
+              end
+            end
+          end
+        when :want_end_delimiter
+          @multiline_string_start[i] = string_begin_line
+          if wanted_delimiter.match(line)
+            state = :awaiting_string
+          end
+        end
+      end
+    end
+    
+    def is_nocov?(line)
+      line =~ /#:nocov:/
+    end
+    
+    def mark_nocov_regions(nocov_line_numbers, coverage)
+      while nocov_line_numbers.size > 0
+        begin_line, end_line = nocov_line_numbers.shift, nocov_line_numbers.shift
+        next unless begin_line && end_line
+        (begin_line..end_line).each do |line_num|
+          coverage[line_num] ||= :inferred
+        end
+      end
+    end
+
+    def precompute_coverage(comments_run_by_default = true)
+      changed = false
+      lastidx = lines.size - 1
+      if (!is_code?(lastidx) || /^__END__$/ =~ @lines[-1]) && !@coverage[lastidx]
+        # mark the last block of comments
+        @coverage[lastidx] ||= :inferred
+        (lastidx-1).downto(0) do |i|
+          break if is_code?(i)
+          @coverage[i] ||= :inferred
+        end
+      end
+      nocov_line_numbers = []
+      
+      (0...lines.size).each do |i|
+        nocov_line_numbers << i if is_nocov?(@lines[i])
+
+        next if @coverage[i]
+        line = @lines[i]
+        if /^\s*(begin|ensure|else|case)\s*(?:#.*)?$/ =~ line && next_expr_marked?(i) or
+          /^\s*(?:end|\})\s*(?:#.*)?$/ =~ line && prev_expr_marked?(i) or
+          /^\s*(?:end\b|\})/ =~ line && prev_expr_marked?(i) && next_expr_marked?(i) or
+          /^\s*rescue\b/ =~ line && next_expr_marked?(i) or
+          /(do|\{)\s*(\|[^|]*\|\s*)?(?:#.*)?$/ =~ line && next_expr_marked?(i) or
+          prev_expr_continued?(i) && prev_expr_marked?(i) or
+          comments_run_by_default && !is_code?(i) or 
+          /^\s*((\)|\]|\})\s*)+(?:#.*)?$/ =~ line && prev_expr_marked?(i) or
+          prev_expr_continued?(i+1) && next_expr_marked?(i)
+          @coverage[i] ||= :inferred
+          changed = true
+        end
+        
+      end
+
+      mark_nocov_regions(nocov_line_numbers, @coverage)
+      
+      (@lines.size-1).downto(0) do |i|
+        next if @coverage[i]
+        if !is_code?(i) and @coverage[i+1] 
+          @coverage[i] = :inferred
+          changed = true
+        end
+      end
+
+      extend_heredocs if changed
+
+      # if there was any change, we have to recompute; we'll eventually
+      # reach a fixed point and stop there
+      precompute_coverage(comments_run_by_default) if changed
+    end
+
+    require 'strscan'
+    def extend_heredocs
+      i = 0
+      while i < @lines.size
+        unless is_code? i
+          i += 1
+          next
+        end
+        #FIXME: using a restrictive regexp so that only <<[A-Z_a-z]\w*
+        # matches when unquoted, so as to avoid problems with 1<<2
+        # (keep in mind that whereas puts <<2 is valid, puts 1<<2 is a
+        # parse error, but  a = 1<<2  is of course fine)
+        scanner = StringScanner.new(@lines[i])
+        j = k = i
+        loop do
+          scanned_text = scanner.search_full(/<<(-?)(?:(['"`])((?:(?!\2).)+)\2|([A-Z_a-z]\w*))/, true, true)
+          # k is the first line after the end delimiter for the last heredoc
+          # scanned so far
+          unless scanner.matched?
+            i = k
+            break
+          end
+          term = scanner[3] || scanner[4]
+          # try to ignore symbolic bitshifts like  1<<LSHIFT
+          ident_text = "<<#{scanner[1]}#{scanner[2]}#{term}#{scanner[2]}"
+          if scanned_text[/\d+\s*#{Regexp.escape(ident_text)}/]
+            # it was preceded by a number, ignore
+            i = k
+            break
+          end
+          must_mark = []
+          end_of_heredoc = (scanner[1] == "-") ? /^\s*#{Regexp.escape(term)}$/ : /^#{Regexp.escape(term)}$/
+          loop do
+            break if j == @lines.size
+            must_mark << j
+            if end_of_heredoc =~ @lines[j]
+              must_mark.each do |n|
+                @heredoc_start[n] = i
+              end
+              if (must_mark + [i]).any?{|lineidx| @coverage[lineidx]}
+                @coverage[i] ||= :inferred
+                must_mark.each{|lineidx| @coverage[lineidx] ||= :inferred}
+              end
+              # move the "first line after heredocs" index
+              if @lines[j+=1] =~ /^\s*\n$/
+                k = j
+              end
+              break
+            end
+            j += 1
+          end
+        end
+
+        i += 1
+      end
+    end
+
+    def next_expr_marked?(lineno)
+      return false if lineno >= @lines.size
+      found = false
+      idx = (lineno+1).upto(@lines.size-1) do |i|
+        next unless is_code? i
+        found = true
+        break i
+      end
+      return false unless found
+      @coverage[idx]
+    end
+
+    def prev_expr_marked?(lineno)
+      return false if lineno <= 0
+      found = false
+      idx = (lineno-1).downto(0) do |i|
+        next unless is_code? i
+        found = true
+        break i
+      end
+      return false unless found
+      @coverage[idx]
+    end
+
+    def prev_expr_continued?(lineno)
+      return false if lineno <= 0
+      return false if lineno >= @lines.size
+      found = false
+      if @multiline_string_start[lineno] && 
+        @multiline_string_start[lineno] < lineno
+        return true
+      end
+      # find index of previous code line
+      idx = (lineno-1).downto(0) do |i|
+        if @heredoc_start[i]
+          found = true
+          break @heredoc_start[i] 
+        end
+        next unless is_code? i
+        found = true
+        break i
+      end
+      return false unless found
+      #TODO: write a comprehensive list
+      if is_code?(lineno) && /^\s*((\)|\]|\})\s*)+(?:#.*)?$/.match(@lines[lineno])
+        return true
+      end
+      #FIXME: / matches regexps too
+      # the following regexp tries to reject #{interpolation}
+      r = /(,|\.|\+|-|\*|\/|<|>|%|&&|\|\||<<|\(|\[|\{|=|and|or|\\)\s*(?:#(?![{$@]).*)?$/.match @lines[idx]
+      # try to see if a multi-line expression with opening, closing delimiters
+      # started on that line
+      [%w!( )!].each do |opening_str, closing_str| 
+        # conservative: only consider nesting levels opened in that line, not
+        # previous ones too.
+        # next regexp considers interpolation too
+        line = @lines[idx].gsub(/#(?![{$@]).*$/, "")
+        opened = line.scan(/#{Regexp.escape(opening_str)}/).size
+        closed = line.scan(/#{Regexp.escape(closing_str)}/).size
+        return true if opened - closed > 0
+      end
+      if /(do|\{)\s*\|[^|]*\|\s*(?:#.*)?$/.match @lines[idx]
+        return false
+      end
+
+      r
+    end
+  end
+end