search_biomodel 0.1.2 → 1.0.0

data/search_biomodel/ruby/1.8/gems/rcov-0.9.9/ext/rcovrt/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = 1.8/
+topdir = /usr/lib/ruby/1.8/x86_64-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/usr
+sharedstatedir = $(prefix)/com
+mandir = $(prefix)/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(prefix)/lib/ruby1.8
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(prefix)/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(DESTDIR)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fPIC -fno-strict-aliasing -g -g -O2  -fPIC $(cflags) 
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -Wl,-Bsymbolic-functions -rdynamic -Wl,-export-dynamic
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = x86_64-linux
+sitearch = x86_64-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -lrt -ldl -lcrypt -lm   -lc
+SRCS = rcovrt.c callsite.c
+OBJS = rcovrt.o callsite.o
+TARGET = rcovrt
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR = /home/cspc018/Work/Repos/gems/search_biomodel/search_biomodel/ruby/1.8/gems/rcov-0.9.9/lib$(target_prefix)
+RUBYARCHDIR = /home/cspc018/Work/Repos/gems/search_biomodel/search_biomodel/ruby/1.8/gems/rcov-0.9.9/lib$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/search_biomodel/ruby/1.8/gems/rcov-0.9.9/ext/rcovrt/extconf.rb

@@ -0,0 +1,21 @@
+require 'mkmf'
+
+dir_config("gcov")
+if ENV["USE_GCOV"] and Config::CONFIG['CC'] =~ /gcc/ and 
+  have_library("gcov", "__gcov_open")
+
+  $CFLAGS << " -fprofile-arcs -ftest-coverage"
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+    create_makefile("rcovrt", "1.9/")
+  else
+    create_makefile("rcovrt", "1.8/")
+  end
+else
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+    create_makefile("rcovrt", "1.9/")
+  else
+    create_makefile("rcovrt", "1.8/")
+  end
+end

data/search_biomodel/ruby/1.8/gems/rcov-0.9.9/lib/rcov.rb

@@ -0,0 +1,33 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# See LICENSE for licensing information.
+
+# NOTE: if you're reading this in the XHTML code coverage report generated by
+# rcov, you'll notice that only code inside methods is reported as covered,
+# very much like what happens when you run it with --test-unit-only.
+# This is due to the fact that we're running rcov on itself: the code below is
+# already loaded before coverage tracing is activated, so only code inside
+# methods is actually executed under rcov's inspection.
+
+require 'rcov/version'
+require 'rcov/formatters'
+require 'rcov/coverage_info'
+require 'rcov/file_statistics'
+require 'rcov/differential_analyzer'
+require 'rcov/code_coverage_analyzer'
+require 'rcov/call_site_analyzer'
+
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+module Rcov
+  # TODO: Move to Ruby 1.8.6 Backport module
+  unless RUBY_VERSION =~ /1.9/  
+    class ::String
+      def lines
+        map
+      end
+    end
+  end
+
+  autoload :RCOV__, "rcov/lowlevel.rb"
+end

data/search_biomodel/ruby/1.8/gems/rcov-0.9.9/lib/rcov/call_site_analyzer.rb

@@ -0,0 +1,225 @@
+module Rcov
+  # A CallSiteAnalyzer can be used to obtain information about:
+  # * where a method is defined ("+defsite+")
+  # * where a method was called from ("+callsite+")
+  #
+  # == Example
+  # <tt>example.rb</tt>:
+  #  class X
+  #    def f1; f2 end
+  #    def f2; 1 + 1 end
+  #    def f3; f1 end
+  #  end
+  #
+  #  analyzer = Rcov::CallSiteAnalyzer.new
+  #  x = X.new
+  #  analyzer.run_hooked do 
+  #    x.f1 
+  #  end
+  #  # ....
+  #  
+  #  analyzer.run_hooked do 
+  #    x.f3
+  #    # the information generated in this run is aggregated
+  #    # to the previously recorded one
+  #  end
+  #
+  #  analyzer.analyzed_classes        # => ["X", ... ]
+  #  analyzer.methods_for_class("X")  # => ["f1", "f2", "f3"]
+  #  analyzer.defsite("X#f1")         # => DefSite object
+  #  analyzer.callsites("X#f2")       # => hash with CallSite => count
+  #                                   #    associations
+  #  defsite = analyzer.defsite("X#f1")
+  #  defsite.file                     # => "example.rb"
+  #  defsite.line                     # => 2
+  #
+  # You can have several CallSiteAnalyzer 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 CallSiteAnalyzer
+  # class. 
+  #
+  # +defsite+ information is only available for methods that were called under
+  # the inspection of the CallSiteAnalyzer, i.o.w. you will only have +defsite+
+  # information for those methods for which callsite information is
+  # available.
+  class CallSiteAnalyzer < DifferentialAnalyzer
+    # A method definition site.
+    class DefSite < Struct.new(:file, :line)
+    end
+
+    # Object representing a method call site.
+    # It corresponds to a part of the callstack starting from the context that
+    # called the method.   
+    class CallSite < Struct.new(:backtrace)
+      # The depth of a CallSite is the number of stack frames
+      # whose information is included in the CallSite object.
+      def depth
+        backtrace.size
+      end
+
+      # File where the method call originated.
+      # Might return +nil+ or "" if it is not meaningful (C extensions, etc).
+      def file(level = 0)
+        stack_frame = backtrace[level]
+        stack_frame ? stack_frame[2] : nil
+      end
+
+      # Line where the method call originated.
+      # Might return +nil+ or 0 if it is not meaningful (C extensions, etc).
+      def line(level = 0)
+        stack_frame = backtrace[level]
+        stack_frame ? stack_frame[3] : nil
+      end
+
+      # Name of the method where the call originated.
+      # Returns +nil+ if the call originated in +toplevel+.
+      # Might return +nil+ if it could not be determined.
+      def calling_method(level = 0)
+        stack_frame = backtrace[level]
+        stack_frame ? stack_frame[1] : nil
+      end
+
+      # Name of the class holding the method where the call originated.
+      # Might return +nil+ if it could not be determined.
+      def calling_class(level = 0)
+        stack_frame = backtrace[level]
+        stack_frame ? stack_frame[0] : nil
+      end
+    end
+
+    @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
+      super(:install_callsite_hook, :remove_callsite_hook,
+            :reset_callsite)
+    end
+
+    # Classes whose methods have been called.
+    # Returns an array of strings describing the classes (just klass.to_s for
+    # each of them). Singleton classes are rendered as:
+    #   #<Class:MyNamespace::MyClass>
+    def analyzed_classes
+      raw_data_relative.first.keys.map{|klass, meth| klass}.uniq.sort
+    end
+
+    # Methods that were called for the given class. See #analyzed_classes for
+    # the notation used for singleton classes.
+    # Returns an array of strings or +nil+
+    def methods_for_class(classname)
+      a = raw_data_relative.first.keys.select{|kl,_| kl == classname}.map{|_,meth| meth}.sort
+      a.empty? ? nil : a
+    end
+    alias_method :analyzed_methods, :methods_for_class
+
+    # Returns a hash with <tt>CallSite => call count</tt> associations or +nil+
+    # Can be called in two ways:
+    #   analyzer.callsites("Foo#f1")         # instance method
+    #   analyzer.callsites("Foo.g1")         # singleton method of the class
+    # or
+    #   analyzer.callsites("Foo", "f1")
+    #   analyzer.callsites("#<class:Foo>", "g1")
+    def callsites(classname_or_fullname, methodname = nil)
+      rawsites = raw_data_relative.first[expand_name(classname_or_fullname, methodname)]
+      return nil unless rawsites
+      ret = {}
+      # could be a job for inject but it's slow and I don't mind the extra loc
+      rawsites.each_pair do |backtrace, count|
+        ret[CallSite.new(backtrace)] = count
+      end
+      ret
+    end
+
+    # Returns a DefSite object corresponding to the given method
+    # Can be called in two ways:
+    #   analyzer.defsite("Foo#f1")         # instance method
+    #   analyzer.defsite("Foo.g1")         # singleton method of the class
+    # or
+    #   analyzer.defsite("Foo", "f1")
+    #   analyzer.defsite("#<class:Foo>", "g1")
+    def defsite(classname_or_fullname, methodname = nil)
+      file, line = raw_data_relative[1][expand_name(classname_or_fullname, methodname)]
+      return nil unless file && line
+      DefSite.new(file, line)
+    end
+
+    private
+
+    def expand_name(classname_or_fullname, methodname = nil)
+      if methodname.nil?
+        case classname_or_fullname
+        when /(.*)#(.*)/ then classname, methodname = $1, $2
+        when /(.*)\.(.*)/ then classname, methodname = "#<Class:#{$1}>", $2
+        else
+          raise ArgumentError, "Incorrect method name"
+        end
+
+        return [classname, methodname]
+      end
+
+      [classname_or_fullname, methodname]
+    end
+
+    def data_default; [{}, {}] end
+
+    def raw_data_absolute
+      raw, method_def_site = RCOV__.generate_callsite_info
+      ret1 = {}
+      ret2 = {}
+      raw.each_pair do |(klass, method), hash|
+        begin  
+          key = [klass.to_s, method.to_s]
+          ret1[key] = hash.clone #Marshal.load(Marshal.dump(hash))
+          ret2[key] = method_def_site[[klass, method]]
+        #rescue Exception
+        end
+      end
+
+      [ret1, ret2]
+    end
+
+    def aggregate_data(aggregated_data, delta)
+      callsites1, defsites1 = aggregated_data
+      callsites2, defsites2 = delta
+    
+      callsites2.each_pair do |(klass, method), hash|
+        dest_hash = (callsites1[[klass, method]] ||= {})
+        hash.each_pair do |callsite, count|
+          dest_hash[callsite] ||= 0
+          dest_hash[callsite] += count
+        end
+      end
+
+      defsites1.update(defsites2)
+    end
+
+    def compute_raw_data_difference(first, last)
+      difference = {}
+      default = Hash.new(0)
+
+      callsites1, defsites1 = *first
+      callsites2, defsites2 = *last
+
+      callsites2.each_pair do |(klass, method), hash|
+        old_hash = callsites1[[klass, method]] || default
+        hash.each_pair do |callsite, count|
+          diff = hash[callsite] - (old_hash[callsite] || 0)
+          if diff > 0
+            difference[[klass, method]] ||= {}
+            difference[[klass, method]][callsite] = diff
+          end
+        end
+      end
+
+      [difference, defsites1.update(defsites2)]
+    end
+  end
+end

data/search_biomodel/ruby/1.8/gems/rcov-0.9.9/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