dirty_history 0.5.2 → 0.5.3

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/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/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/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/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/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/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/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/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rcov-0.9.9/lib/rcov/lowlevel.rb

@@ -1,146 +0,0 @@
-# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
-#
-# See LEGAL and LICENSE for licensing information.
-
-require 'rcov/version'
-
-module Rcov
-
-# RCOV__ performs the low-level tracing of the execution, gathering code
-# coverage information in the process. The C core made available through the
-# rcovrt extension will be used if possible. Otherwise the functionality
-# will be emulated using set_trace_func, but this is very expensive and
-# will fail if other libraries (e.g. breakpoint) change the trace_func.
-#
-# Do not use this module; it is very low-level and subject to frequent
-# changes. Rcov::CodeCoverageAnalyzer offers a much more convenient and
-# stable interface.
-
-module RCOV__
-  COVER = {}
-  CALLSITES = {}
-  DEFSITES = {}
-  pure_ruby_impl_needed = true
-  unless defined? $rcov_do_not_use_rcovrt 
-    begin
-      require 'rcovrt'
-      abi = [0,0,0]
-      begin
-        abi = RCOV__.ABI
-        raise if abi[0] != RCOVRT_ABI[0] || abi[1] < RCOVRT_ABI[1]
-        pure_ruby_impl_needed = false
-      rescue
-        $stderr.puts <<-EOF
-The rcovrt extension I found was built for a different version of rcov.
-The required ABI is:              #{RCOVRT_ABI.join(".")}
-Your current rcovrt extension is: #{abi.join(".")}
-
-Please delete rcovrt.{so,bundle,dll,...} and install the required one.
-        EOF
-        raise LoadError
-      end
-    rescue LoadError
-      $stderr.puts <<-EOF
-
-Since the rcovrt extension couldn't be loaded, rcov will run in pure-Ruby
-mode, which is about two orders of magnitude slower.
-
-If you're on win32, you can find a pre-built extension (usable with recent
-One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
-
-      EOF
-    end
-  end
-
-  if pure_ruby_impl_needed
-    methods = %w[install_coverage_hook remove_coverage_hook reset_coverage 
-                 install_callsite_hook remove_callsite_hook reset_callsite 
-                 generate_coverage_info generate_callsite_info]
-    sklass = class << self; self end
-    (methods & sklass.instance_methods).each do |meth|
-      sklass.class_eval{ remove_method meth }
-    end
-
-    @coverage_hook_activated = @callsite_hook_activated = false
-
-    def self.install_coverage_hook # :nodoc:
-      install_common_hook
-      @coverage_hook_activated = true
-    end
-
-    def self.install_callsite_hook # :nodoc:
-      install_common_hook
-      @callsite_hook_activated = true
-    end
-
-    def self.install_common_hook # :nodoc:
-      set_trace_func lambda {|event, file, line, id, binding, klass|
-        next unless SCRIPT_LINES__.has_key? file
-        case event
-        when 'call'
-          if @callsite_hook_activated
-            receiver = eval("self", binding)
-            klass = class << klass; self end unless klass === receiver
-            begin
-              DEFSITES[[klass.to_s, id.to_s]] = [file, line]
-            rescue Exception
-            end
-            caller_arr = self.format_backtrace_array(caller[1,1])
-            begin
-              hash = CALLSITES[[klass.to_s, id.to_s]] ||= {}
-              hash[caller_arr] ||= 0
-              hash[caller_arr] += 1
-              #puts "#{event} #{file} #{line} #{klass.inspect} " +
-              #     "#{klass.object_id} #{id} #{eval('self', binding)}"
-            rescue Exception
-            end
-          end
-        when 'c-call', 'c-return', 'class'
-          return
-        end
-        if @coverage_hook_activated
-          COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
-          COVER[file][line - 1] ||= 0
-          COVER[file][line - 1] += 1
-        end
-      }
-    end
-
-    def self.remove_coverage_hook # :nodoc:
-      @coverage_hook_activated = false
-      set_trace_func(nil) if !@callsite_hook_activated
-    end
-
-    def self.remove_callsite_hook # :nodoc:
-      @callsite_hook_activated = false
-      set_trace_func(nil) if !@coverage_hook_activated
-    end
-
-    def self.reset_coverage # :nodoc:
-      COVER.replace({})
-    end
-
-    def self.reset_callsite # :nodoc:
-      CALLSITES.replace({})
-      DEFSITES.replace({})
-    end
-
-    def self.generate_coverage_info # :nodoc:
-      Marshal.load(Marshal.dump(COVER))
-    end
-
-    def self.generate_callsite_info # :nodoc:
-      [CALLSITES, DEFSITES]
-    end
-
-    def self.format_backtrace_array(backtrace)
-      backtrace.map do |line|
-        md = /^([^:]*)(?::(\d+)(?::in `(.*)'))?/.match(line)
-        raise "Bad backtrace format" unless md
-        [nil, md[3] ? md[3].to_sym : nil, md[1], (md[2] || '').to_i]
-      end
-    end
-  end
-end 
-
-end