duvet 0.3.3 → 0.4.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Joshua Hawxwell
+Copyright (c) 2010-12 Joshua Hawxwell
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,7 +1,7 @@
 # Duvet
 
-Install with
-  
+Install with:
+
 ``` bash
 $ gem install duvet
 ```
@@ -13,23 +13,40 @@ require 'duvet'
 Duvet.start
 ```
 
-You can change the defaults by passing an options hash to Duvet.start, eg
+Because `duvet` won't work for Ruby 1.8 you may want to rescue the error and
+move on,
+
+``` ruby
+begin
+  require 'duvet'
+  Duvet.start
+rescue LoadError
+  # ignore error
+end
+```
+
+You can change the defaults by passing options to `Duvet.start`, for example:
 
 ``` ruby
 Duvet.start :dir => 'coverage', :filter => 'app/lib'
 ```
 
-`:dir` is the directory to write the coverage to.
-`:filter` allows you to display only coverage for files that include the string, or you can
-match against a regular expression for more control.
+Where `:dir` is the directory to write the coverage to and `:filter` is a string
+that a files path must match against. A regular expression can be used for more
+control, but most of the time a simple string will suffice.
 
-You can see what the output of running duvet on itself is [here](http://hawx.github.com/duvet).
+You can see the output of running `duvet` on itself [here][covg].
 
 
 ## Credits
 
-This gem was created because I read this blog post <http://engineering.attinteractive.com/2010/08/code-coverage-in-ruby-1-9/>.
+This gem was created because I read this [blog post][post] on the AT&T
+engineering site by Aaron Patterson.
 
 ## Copyright
 
-Copyright (c) 2010 Joshua Hawxwell. See LICENSE for details.
+Copyright (c) 2010-11 Joshua Hawxwell. See LICENSE for details.
+
+
+[covg]: http://hawx.github.com/duvet
+[post]: http://engineering.attinteractive.com/2010/08/code-coverage-in-ruby-1-9/

data/Rakefile

@@ -1,9 +1,20 @@
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib' << 'test'
-  t.pattern = 'test/**/test_*.rb'
+  t.libs << 'lib' << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
   t.verbose = true
 end
 
+
+task :build do
+  require 'sass'
+  path = File.dirname(__FILE__) + '/templates/css/'
+  content = Sass::Engine.new(IO.read(path + 'styles.sass')).render
+
+  File.open path + 'styles.css', 'w' do |f|
+    f.write content
+  end
+end
+
 task :default => :test

data/lib/duvet.rb

@@ -6,72 +6,130 @@
 
 require 'coverage'
 require 'pathname'
-require 'erubis'
+require 'erb'
 require 'sass'
 
-require 'duvet/core_ext'
 require 'duvet/covs'
 require 'duvet/cov'
 require 'duvet/version'
 
 module Duvet
+  extend self
 
   attr_accessor :opts
-  
-  DEFAULTS = {:dir => 'cov', :style => 'rcov'}
-  
-  TEMPLATE_PATH = Pathname.new(__FILE__).dirname + '..' + 'templates'
-  
+
+  DEFAULTS = {
+    dir:    'cov',
+    style:  'rcov',
+    filter: ''
+  }
+
   TEMPLATE_HASH = {
-    'time' => Time.now,
-    'version' => VERSION,
-    'name' => 'duvet'
+    name:    'duvet',
+    time:    Time.now,
+    version: VERSION
   }
 
-  # Start tracking
-  def self.start(opts={})
+  TEMPLATE_PATH = Pathname.new(__FILE__).dirname + '..' + 'templates'
+
+  # Start coverage tracking, needs to be called before any files are loaded.
+  #
+  # @param opts [Hash]
+  # @option opts [String, Pathname] :dir Directory to write coverage to
+  # @option opts [String, Regexp] :filter Pattern files must match to be written
+  def start(opts={})
     @opts = DEFAULTS.merge(opts)
-    
+    @opts[:filter] = Regexp.new(@opts[:filter])
+    @opts[:dir]    = Pathname.new(@opts[:dir])
+
     Coverage.start
-    @running = true
   end
-  
-  # Get result
-  def self.result
-    cov = Coverage.result if running?
-    if @opts[:filter]
-      filtered = {}
-      @opts[:filter] = /#{@opts[:filter]}/ unless @opts[:filter].is_a?(Regexp)
-      cov.each do |k, v|
-        if @opts[:filter] =~ k
-          filtered[k] = v
-        end
+
+  # Gets the results from the Coverage, filtered against the patterm given to
+  # #start.
+  #
+  # @return [Covs]
+  def result
+    cov = Coverage.result.find_all do |path, c|
+      @opts[:filter] =~ path
+    end
+
+    Duvet::Covs.from_data cov
+  end
+
+  # Creates a class with methods for rendering an ERB template.
+  #
+  # @param obj [Object] Object to create context for
+  # @return [#get_binding] Object which gives a binding for ERB templates
+  def context_for(obj)
+    case obj
+    when Array
+      obj.map {|i| context_for(i) }
+    when Hash
+      klass = Class.new
+      klass.send(:define_method, :get_binding) { binding }
+
+      obj.each do |k,v|
+        klass.send(:define_method, k) { Duvet.context_for(v) }
       end
-      cov = filtered
+
+      klass.new
+    else
+      obj
     end
-    @result ||= Duvet::Covs.new(cov)
-  ensure
-    @running = false
   end
-  
-  # Write results
-  def self.write
-    self.result.write(Pathname.new(@opts[:dir])) if running?
+
+  # Renders a template with the data given.
+  #
+  # @param data [Hash] Data to insert into template
+  # @param template [String] Path to template from TEMPLATE_PATH
+  def format(data, template)
+    t = (TEMPLATE_PATH + template).read
+    vars = context_for TEMPLATE_HASH.merge(data)
+
+    ERB.new(t).result(vars.get_binding)
   end
-  
-  # Proc to call when exiting
-  # @todo Allow user to override block used
-  def self.at_exit
-    Proc.new { self.write }
+
+  # Renders then writes a file based on the url in the data given.
+  #
+  # @param data [Hash] Data to insert into template
+  # @param template [String] Path to template from TEMPLATE_PATH
+  def write(data, template)
+    write_file format(data, template), data[:file][:url]
   end
-  
-  # @return [Boolean] whether coverage is running
-  def self.running?
-    @running
+
+  # Writes a file, creating directories where necessary.
+  #
+  # @param text [String] Text to write to file
+  # @param path [String] Path to write file to
+  def write_file(text, path)
+    write_to = @opts[:dir] + path
+
+    FileUtils.mkdir_p write_to.dirname
+    File.open write_to, 'w' do |f|
+      f.write text
+    end
+  end
+
+  # Writes all the resources to the correct directory.
+  def write_resources
+    paths = %w(css/styles.css js/main.js js/jquery.js js/plugins.js)
+
+    paths.each do |path|
+      path = Pathname.new(TEMPLATE_PATH + path)
+      write_file path.read, path.basename
+    end
+  end
+
+  # Call this on exit so that coverage is written.
+  def finish
+    FileUtils.mkdir_p @opts[:dir]
+    result.write
+    write_resources
   end
 
 end
 
 at_exit do
-  Duvet.at_exit.call
+  Duvet.finish
 end

data/lib/duvet/cov.rb

@@ -1,100 +1,93 @@
 module Duvet
+
+  # A single file along with coverage data.
   class Cov
     attr_accessor :path
-    
+
     def initialize(path, cov)
       @path = Pathname.new(path)
       if @path.to_s.include?(Dir.pwd)
         @path = @path.relative_path_from(Pathname.getwd)
       end
-      
+
       @cov = cov
     end
-    
-    # @return [Array] lines in file
+
+    # @return [Array] Coverage data of lines in the file
     def lines
       @cov
     end
-    
-    # @return [Array] all lines which can be executed
+
+    # @return [Array] Coverage data for all the lines which can be executed
     def code_lines
-      @cov.reject {|i| i.nil?}
+      lines.reject {|i| i.nil?}
     end
-    
-    # @return [Array] all lines which have been ran
+
+    # @return [Array] Coverage data for all the lines which have been ran
     def ran_lines
-      @cov.reject {|i| i.nil? || i.zero?}
-    end
-    
-    # Gives a fraction from 0 to 1 of how many lines of code have 
-    # been executed. It ignores all lines that couldn't be executed
-    # such as comments.
-    #
-    # @return [Float] lines of code executed as a fraction
-    def code_coverage
-      return 0.0 if code_lines.size.zero?
-      ran_lines.size.to_f / code_lines.size.to_f
+      code_lines.reject {|i| i.zero?}
     end
 
-    # Similar to #code_coverage but counts all lines, executable
-    # or not.
+    # Gives a real number between 0 and 1 indicating how many lines have been
+    # executed.
     #
-    # @return [Integer] lines executed as a fraction
+    # @return [Float] lines executed as a fraction
     def total_coverage
       return 0.0 if lines.size.zero?
       ran_lines.size.to_f / lines.size.to_f
     end
-    
-    # @return [String] #code_coverage as ??.??%
-    def code_coverage_percent
-      "%.2f%" % (code_coverage*100)
+
+    # Gives a real number between 0 and 1 indicating how many lines of code have
+    # been executed. It ignores all lines that can not be executed such as
+    # comments.
+    #
+    # @return [Float] lines of code executed as a fraction
+    def code_coverage
+      return 0.0 if code_lines.size.zero?
+      ran_lines.size.to_f / code_lines.size.to_f
     end
-    
-    # @return [String] #total_coverage as ??.??%
-    def total_coverage_percent
-      "%.2f%" % (total_coverage*100)
+
+    # @param [Float] Number to format
+    # @return [String] The number formatted as a percentage, ??.??%
+    def percent(num)
+      "%.2f%" % (num * 100)
     end
-    
-    # @return [String]
+
+    # @return [String] A simple text report of coverage
     def report
-      str = "#{@path}\n"
-      str << "  total: #{total_coverage_percent}\n"
-      str << "  code:  #{code_coverage_percent}\n\n"
-      str
+      <<EOS
+#{@path}
+  total: #{percent(total_coverage)}
+  code:  #{percent(code_coverage)}
+EOS
     end
-    
-    # @return [Hash] a hash of data for templating
+
+    # @return [Hash] Data for templating
     def data
       {
-        "file" => {
-          "path" => @path.to_s,
-          "url" => @path.file_name + '.html',
-          "source" => @path.readlines,
-          "lines" => lines.size,
-          "lines_code" => code_lines.size,
-          "lines_ran" => ran_lines.size
+        file: {
+          path:   @path.to_s,
+          url:    @path.to_s[0..-@path.extname.size] + 'html',
+          root:   '../' * @path.to_s.count('/'),
+          source: @path.readlines,
+        },
+        lines: {
+          total:  lines.size,
+          code:   code_lines.size,
+          ran:    ran_lines.size
         },
-        "coverage" => {
-          "code" => code_coverage_percent,
-          "total" => total_coverage_percent,
-          "lines" => lines
+        coverage: {
+          code:   percent(code_coverage),
+          total:  percent(total_coverage),
+          lines:  lines
         }
       }
     end
-    
-    # Formats the coverage for the file to be written to a html
-    # file, then viewed in a web browser.
-    #
-    # @return [String]
-    def format
-      template = (TEMPLATE_PATH + 'html' + 'file.erb').read
-      Erubis::Eruby.new(template).result(TEMPLATE_HASH.merge(self.data))
-    end
-    
-    def write(dir)
-      path = (dir + @path.file_name).to_s + '.html'
-      File.open(path, 'w') {|f| f.write(self.format) }
+
+    # Writes the file
+    def write
+      Duvet.write data, 'html/file.erb'
     end
-  
+
   end
-end
+end

data/lib/duvet/covs.rb

@@ -1,49 +1,37 @@
 module Duvet
+
+  # A list of Cov objects.
   class Covs < Array
-  
-    def initialize(cov)
-      self.replace []
-      cov.each do |path, c|
-        self << Cov.new(path, c)
-      end
+
+    # Creates a new Covs array from the data given by Coverage.
+    #
+    # @param data [Hash] Data given by Coverage
+    def self.from_data(data)
+      new data.map {|p,c| Cov.new(p, c) }
     end
-  
+
+    # @return [String] A simple text report of coverage
     def report
-      map {|i| i.report }.join('')
+      map(&:report).join("\n") + "\n"
     end
-    
+
+    # @return [Hash] Data used for templating
     def data
-      { 'files' => map {|i| i.data } }
-    end
-    
-    def format
-      template = (TEMPLATE_PATH + 'html' + 'index.erb').read
-      Erubis::Eruby.new(template).result(TEMPLATE_HASH.merge(self.data))
-    end
-    
-    def write(dir)
-      if size > 0
-        FileUtils.mkdir_p(dir)
-        File.open(dir + 'index.html', 'w') {|f| f.write(format) }
-        
-        each {|c| c.write(dir) }
-        write_resources(dir)
-      else
-        warn "No files to create coverage for."
-      end
+      {
+        files: map(&:data),
+        file: {
+          url: 'index.html'
+        }
+      }
     end
 
-    def write_resources(dir)
-      Pathname.glob(TEMPLATE_PATH + 'css' + '*').each do |i|
-        f = File.new(dir + 'styles.css', 'w')
-        f.write Sass::Engine.new(i.read).render
-      end
+    # Writes the index and individual files.
+    def write
+      warn "No files to create coverage for." if empty?
 
-      Pathname.glob(TEMPLATE_PATH + 'js' + '*').each do |i|
-        f = File.new(dir + i.basename, 'w')
-        f.write(i.read)
-      end
+      each &:write
+      Duvet.write data, 'html/index.erb'
     end
-  
+
   end
 end