search_biomodel 1.0.0 → 1.0.1

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

@@ -1,274 +0,0 @@
-module Rcov
-  class HTMLCoverage < BaseFormatter # :nodoc:
-    require 'fileutils'
-
-    DEFAULT_OPTS = {:color => false, :fsr => 30, :destdir => "coverage",
-                    :callsites => false, :cross_references => false,
-                    :charset => nil }
-
-    def initialize(opts = {})
-      options = DEFAULT_OPTS.clone.update(opts)
-      super(options)
-      @dest = options[:destdir]
-      @css = options[:css]
-      @color = options[:color]
-      @fsr = options[:fsr]
-      @do_callsites = options[:callsites]
-      @do_cross_references = options[:cross_references]
-      @span_class_index = 0
-      @charset = options[:charset]
-    end
-
-    def execute
-      return if @files.empty?
-      FileUtils.mkdir_p @dest
-      
-      # Copy collaterals
-      ['screen.css','print.css','rcov.js','jquery-1.3.2.min.js','jquery.tablesorter.min.js'].each do |_file|
-        _src = File.expand_path("#{File.dirname(__FILE__)}/../templates/#{_file}")
-        FileUtils.cp(_src, File.join(@dest, "#{_file}"))
-      end
-
-      # Copy custom CSS, if any
-      if @css
-        begin
-          _src = File.expand_path("#{@dest}/../#{@css}")
-          FileUtils.cp(_src, File.join(@dest, "custom.css"))
-        rescue
-          @css = nil
-        end
-      end
-      
-      create_index(File.join(@dest, "index.html"))
-
-      each_file_pair_sorted do |filename, fileinfo|
-        create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
-      end
-    end
-
-    private
-
-    class SummaryFileInfo  # :nodoc:
-      def initialize(obj)
-        @o = obj 
-      end
-
-      def num_lines
-        @o.num_lines
-      end
-
-      def num_code_lines
-        @o.num_code_lines
-      end
-
-      def code_coverage
-        @o.code_coverage
-      end
-
-      def code_coverage_for_report
-        code_coverage * 100
-      end
-
-      def total_coverage
-        @o.total_coverage
-      end
-
-      def total_coverage_for_report
-        total_coverage * 100
-      end
-
-      def name
-        "TOTAL" 
-      end
-    end
-
-    def create_index(destname)
-
-      doc = Rcov::Formatters::HtmlErbTemplate.new('index.html.erb',
-        :project_name => project_name,
-        :generated_on => Time.now,
-        :css => @css,
-        :rcov => Rcov,
-        :formatter => self,
-        :output_threshold => @output_threshold,
-        :total => SummaryFileInfo.new(self),
-        :files => each_file_pair_sorted.map{|k,v| v}
-      )
-      File.open(destname, "w") { |f| f.puts doc.render }
-    end
-
-    def create_file(destfile, fileinfo)
-      doc = Rcov::Formatters::HtmlErbTemplate.new('detail.html.erb',
-        :project_name => project_name,
-        :rcov_page_title => fileinfo.name, 
-        :css => @css,
-        :generated_on => Time.now,
-        :rcov => Rcov,
-        :formatter => self,
-        :output_threshold => @output_threshold,
-        :fileinfo => fileinfo
-      )
-      File.open(destfile, "w")  { |f| f.puts doc.render }
-    end
-    
-    private
-    
-    def project_name
-      Dir.pwd.split('/')[-1].split(/[^a-zA-Z0-9]/).map{|i| i.gsub(/[^a-zA-Z0-9]/,'').capitalize} * " " || ""
-    end
-    
-  end
-
-  class HTMLProfiling < HTMLCoverage # :nodoc:
-    DEFAULT_OPTS = {:destdir => "profiling"}
-    def initialize(opts = {})
-      options = DEFAULT_OPTS.clone.update(opts)
-      super(options)
-      @max_cache = {}
-      @median_cache = {}
-    end
-
-    def default_title
-      "Bogo-profile information"
-    end
-
-    def default_color
-      if @color
-        "rgb(179,205,255)"
-      else
-        "rgb(255, 255, 255)"
-      end
-    end
-
-    def output_color_table?
-      false
-    end
-
-    def span_class(sourceinfo, marked, count)
-      full_scale_range = @fsr # dB
-      nz_count = sourceinfo.counts.select{|x| x && x != 0}
-      nz_count << 1 # avoid div by 0
-      max = @max_cache[sourceinfo] ||= nz_count.max
-      #avg = @median_cache[sourceinfo] ||= 1.0 *
-      #    nz_count.inject{|a,b| a+b} / nz_count.size
-      median = @median_cache[sourceinfo] ||= 1.0 * nz_count.sort[nz_count.size/2]
-      max ||= 2
-      max = 2 if max == 1
-      if marked == true
-        count = 1 if !count || count == 0
-        idx = 50 + 1.0 * (500/full_scale_range) * Math.log(count/median) / Math.log(10)
-        idx = idx.to_i
-        idx = 0 if idx < 0
-        idx = 100 if idx > 100
-        "run#{idx}"
-      else
-        nil
-      end
-    end
-  end
-
-  class RubyAnnotation < BaseFormatter # :nodoc:
-    DEFAULT_OPTS = { :destdir => "coverage" }
-    def initialize(opts = {})
-      options = DEFAULT_OPTS.clone.update(opts)
-      super(options)
-      @dest = options[:destdir]
-      @do_callsites = true
-      @do_cross_references = true
-
-      @mangle_filename = Hash.new{ |h,base|
-        h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".rb"
-      }
-    end
-
-    def execute
-      return if @files.empty?
-      FileUtils.mkdir_p @dest
-      each_file_pair_sorted do |filename, fileinfo|
-        create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
-      end
-    end
-
-    private
-
-    def format_lines(file)
-      result = ""
-      format_line = "%#{file.num_lines.to_s.size}d"
-      file.num_lines.times do |i|
-        line = file.lines[i].chomp
-        marked = file.coverage[i]
-        count = file.counts[i]
-        result << create_cross_refs(file.name, i+1, line, marked) + "\n"
-      end
-      result
-    end
-
-    def create_cross_refs(filename, lineno, linetext, marked)
-      return linetext unless @callsite_analyzer && @do_callsites
-      ref_blocks = []
-      _get_defsites(ref_blocks, filename, lineno, linetext, ">>") do |ref|
-        if ref.file
-          ref.file.sub!(%r!^./!, '')
-          where = "at #{mangle_filename(ref.file)}:#{ref.line}"
-        else
-          where = "(C extension/core)"
-        end
-        "#{ref.klass}##{ref.mid} " + where + ""
-      end
-      _get_callsites(ref_blocks, filename, lineno, linetext, "<<") do |ref| # "
-        ref.file.sub!(%r!^./!, '')
-        "#{mangle_filename(ref.file||'C code')}:#{ref.line} " + "in #{ref.klass}##{ref.mid}"
-      end
-
-      create_cross_reference_block(linetext, ref_blocks, marked)
-    end
-
-    def create_cross_reference_block(linetext, ref_blocks, marked)
-      codelen = 75
-      if ref_blocks.empty?
-        if marked
-          return "%-#{codelen}s #o" % linetext
-        else
-          return linetext
-        end
-      end
-      ret = ""
-      @cross_ref_idx ||= 0
-      @known_files ||= sorted_file_pairs.map{|fname, finfo| normalize_filename(fname)}
-      ret << "%-#{codelen}s # " % linetext
-      ref_blocks.each do |refs, toplabel, label_proc|
-        unless !toplabel || toplabel.empty?
-          ret << toplabel << " "
-        end
-        refs.each do |dst|
-          dstfile = normalize_filename(dst.file) if dst.file
-          dstline = dst.line
-          label = label_proc.call(dst)
-          if dst.file && @known_files.include?(dstfile)
-            ret << "[[" << label << "]], "
-          else
-            ret << label << ", "
-          end
-        end
-      end
-      ret
-    end
-
-    def create_file(destfile, fileinfo)
-      #body = format_lines(fileinfo)
-      #File.open(destfile, "w") do |f|
-        #f.puts body
-        #f.puts footer(fileinfo)
-      #end
-    end
-
-    def footer(fileinfo)
-      s  = "# Total lines    : %d\n" % fileinfo.num_lines
-      s << "# Lines of code  : %d\n" % fileinfo.num_code_lines
-      s << "# Total coverage : %3.1f%%\n" % [ fileinfo.total_coverage*100 ]
-      s << "# Code coverage  : %3.1f%%\n\n" % [ fileinfo.code_coverage*100 ]
-      # prevents false positives on Emacs
-      s << "# Local " "Variables:\n" "# mode: " "rcov-xref\n" "# End:\n"
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Rcov
-  module Formatters
-    class HtmlErbTemplate
-      attr_accessor :local_variables
-
-      def initialize(template_file, locals={})
-        require "erb"
-
-        template_path = File.expand_path("#{File.dirname(__FILE__)}/../templates/#{template_file}")
-        @template = ERB.new(File.read(template_path))
-        @local_variables = locals
-        @path_relativizer = Hash.new{|h,base|
-          h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
-        }
-      end
-
-      def render
-        @template.result(get_binding)
-      end
-
-      def coverage_threshold_classes(percentage)
-        return 110 if percentage == 100
-        return (1..10).find_all{|i| i * 10 > percentage}.map{|i| i.to_i * 10} * " " 
-      end
-      
-      def code_coverage_html(code_coverage_percentage, is_total=false)
-        %{<div class="percent_graph_legend"><tt class='#{ is_total ? 'coverage_total' : ''}'>#{ "%3.2f" % code_coverage_percentage }%</tt></div>
-          <div class="percent_graph">
-            <div class="covered" style="width:#{ code_coverage_percentage.round }px"></div>
-            <div class="uncovered" style="width:#{ 100 - code_coverage_percentage.round }px"></div>
-          </div>}
-      end
-
-      def file_filter_classes(file_path)
-        file_path.split('/')[0..-2] * " "
-      end
-      
-      def relative_filename(path)
-        @path_relativizer[path]
-      end
-    
-      def line_css(line_number)
-        case fileinfo.coverage[line_number]
-        when true
-          "marked"
-        when :inferred
-          "inferred"
-        else
-          "uncovered"
-        end
-      end
-
-      def method_missing(key, *args)
-        local_variables.has_key?(key) ? local_variables[key] : super
-      end
-
-      def get_binding
-        binding 
-      end
-    end
-  end
-end

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

@@ -1,193 +0,0 @@
-module Rcov
-  class TextCoverageDiff < BaseFormatter # :nodoc:
-    FORMAT_VERSION = [0, 1, 0]
-    DEFAULT_OPTS = { :textmode => :coverage_diff, :coverage_diff_mode => :record,
-                     :coverage_diff_file => "coverage.info", :diff_cmd => "diff", 
-                     :comments_run_by_default => true }
-    HUNK_HEADER = /@@ -\d+,\d+ \+(\d+),(\d+) @@/
-  
-    def SERIALIZER
-      # mfp> this was going to be YAML but I caught it failing at basic
-      # round-tripping, turning "\n" into "" and corrupting the data, so
-      # it must be Marshal for now
-      Marshal
-    end
-
-    def initialize(opts = {})
-      options = DEFAULT_OPTS.clone.update(opts)
-      @textmode = options[:textmode]
-      @color = options[:color]
-      @mode = options[:coverage_diff_mode]
-      @state_file = options[:coverage_diff_file]
-      @diff_cmd = options[:diff_cmd]
-      @gcc_output = options[:gcc_output]
-      super(options)
-    end
-
-    def execute
-      case @mode
-      when :record
-        record_state
-      when :compare
-        compare_state
-      else
-        raise "Unknown TextCoverageDiff mode: #{mode.inspect}."
-      end
-    end
-
-    def record_state
-      state = {}
-      each_file_pair_sorted do |filename, fileinfo|
-        state[filename] = {:lines    => SCRIPT_LINES__[filename], :coverage => fileinfo.coverage.to_a,:counts   => fileinfo.counts}
-      end
-      File.open(@state_file, "w") do |f|
-        self.SERIALIZER.dump([FORMAT_VERSION, state], f)
-      end
-    rescue
-      $stderr.puts <<-EOF
-      Couldn't save coverage data to #{@state_file}.
-      EOF
-    end # '
-
-    require 'tempfile'
-    def compare_state
-      return unless verify_diff_available
-      begin
-        format, prev_state = File.open(@state_file){|f| self.SERIALIZER.load(f) }
-      rescue
-        $stderr.puts <<-EOF
-        Couldn't load coverage data from #{@state_file}.
-        EOF
-        return # '
-      end
-      if !(Array === format) or
-        FORMAT_VERSION[0] != format[0] || FORMAT_VERSION[1] < format[1]
-        $stderr.puts <<-EOF
-        Couldn't load coverage data from #{@state_file}.
-        The file is saved in the format  #{format.inspect[0..20]}.
-        This rcov executable understands #{FORMAT_VERSION.inspect}.
-        EOF
-        return # '
-      end
-      each_file_pair_sorted do |filename, fileinfo|
-        old_data = Tempfile.new("#{mangle_filename(filename)}-old")
-        new_data = Tempfile.new("#{mangle_filename(filename)}-new")
-        if prev_state.has_key? filename
-          old_code, old_cov = prev_state[filename].values_at(:lines, :coverage)
-          old_code.each_with_index do |line, i|
-            prefix = old_cov[i] ? "   " : "!! "
-            old_data.write "#{prefix}#{line}"
-          end
-        else
-          old_data.write ""
-        end
-        old_data.close
-        SCRIPT_LINES__[filename].each_with_index do |line, i|
-          prefix = fileinfo.coverage[i] ? "   " : "!! "
-          new_data.write "#{prefix}#{line}"
-        end
-        new_data.close
-
-        diff = `#{@diff_cmd} -u "#{old_data.path}" "#{new_data.path}"`
-        new_uncovered_hunks = process_unified_diff(filename, diff)
-        old_data.close!
-        new_data.close!
-        display_hunks(filename, new_uncovered_hunks)
-      end
-    end
-
-    def display_hunks(filename, hunks)
-      return if hunks.empty?
-      puts
-      puts "=" * 80
-      puts "!!!!! Uncovered code introduced in #{filename}"
-
-      hunks.each do |offset, lines|
-        if @gcc_output
-          lines.each_with_index do |line,i|
-            lineno = offset + i
-            flag = (/^!! / !~ line) ? "-" : ":"
-            prefix = "#{filename}#{flag}#{lineno}#{flag}"
-            puts "#{prefix}#{line[3..-1]}"
-          end
-        elsif @color
-          puts "### #{filename}:#{offset}"
-          lines.each do |line|
-            prefix = (/^!! / !~ line) ? "\e[32;40m" : "\e[31;40m"
-            puts "#{prefix}#{line[3..-1].chomp}\e[37;40m"
-          end
-        else
-          puts "### #{filename}:#{offset}"
-          puts lines
-        end
-      end
-    end
-
-    def verify_diff_available
-      old_stderr = STDERR.dup
-      old_stdout = STDOUT.dup
-      new_stderr = Tempfile.new("rcov_check_diff")
-      STDERR.reopen new_stderr.path
-      STDOUT.reopen new_stderr.path
-
-      retval = system "#{@diff_cmd} --version"
-      unless retval
-        old_stderr.puts <<EOF
-  The '#{@diff_cmd}' executable seems not to be available.
-  You can specify which diff executable should be used with --diff-cmd.
-  If your system doesn't have one, you might want to use Diff::LCS's:
-  gem install diff-lcs
-  and use --diff-cmd=ldiff.
-EOF
-        return false
-      end
-      true
-    ensure
-      STDOUT.reopen old_stdout
-      STDERR.reopen old_stderr
-      new_stderr.close!
-    end
-
-    def process_unified_diff(filename, diff)
-      current_hunk = []
-      current_hunk_start = 0
-      keep_current_hunk = false
-      state = :init
-      interesting_hunks = []
-      diff.each_with_index do |line, i|
-        #puts "#{state} %5d #{line}" % i
-        case state
-        when :init
-          if md = HUNK_HEADER.match(line)
-            current_hunk = []
-            current_hunk_start = md[1].to_i
-            state = :body
-          end
-        when :body
-          case line
-          when HUNK_HEADER
-            new_start = $1.to_i
-            if keep_current_hunk
-              interesting_hunks << [current_hunk_start, current_hunk]
-            end
-            current_hunk_start = new_start
-            current_hunk = []
-            keep_current_hunk = false
-          when /^-/
-            # ignore
-          when /^\+!! /
-            keep_current_hunk = true
-            current_hunk << line[1..-1]
-          else
-            current_hunk << line[1..-1]
-          end
-        end
-      end
-      if keep_current_hunk
-        interesting_hunks << [current_hunk_start, current_hunk]
-      end
-
-      interesting_hunks
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Rcov
-  class TextReport < TextSummary # :nodoc:
-    def execute
-      print_lines
-      print_header
-      print_lines
-
-      each_file_pair_sorted do |fname, finfo|
-        name = fname.size < 52 ? fname : "..." + fname[-48..-1]
-        print_info(name, finfo.num_lines, finfo.num_code_lines,
-        finfo.code_coverage)
-      end
-
-      print_lines
-      print_info("Total", num_lines, num_code_lines, code_coverage)
-      print_lines
-      puts summary
-    end
-
-    def print_info(name, lines, loc, coverage)
-      puts "|%-51s | %5d | %5d | %5.1f%% |" % [name, lines, loc, 100 * coverage]
-    end
-
-    def print_lines
-      puts "+----------------------------------------------------+-------+-------+--------+"
-    end
-
-    def print_header
-      puts "|                  File                              | Lines |  LOC  |  COV   |"
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Rcov
-  class TextSummary < BaseFormatter # :nodoc:
-    def execute
-      puts summary
-    end
-
-    def summary
-      "%.1f%%   %d file(s)   %d Lines   %d LOC" % [code_coverage * 100, @files.size, num_lines, num_code_lines]
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'rcov/formatters/html_erb_template'
-require 'rcov/formatters/base_formatter'
-require 'rcov/formatters/text_summary'
-require 'rcov/formatters/text_report'
-require 'rcov/formatters/text_coverage_diff'
-require 'rcov/formatters/full_text_report'
-require 'rcov/formatters/html_coverage'
-require 'rcov/formatters/failure_report'
-
-module Rcov
-  module Formatters
-  end
-end