marmara 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a30c4afdfc40d807cee2c3e6dd4f2e02bd895530
-  data.tar.gz: 675fc30f309c95239b6853e7435fadec407773c4
+  metadata.gz: 0e9743576c518a82530bc19f2142fb6b1b797c3b
+  data.tar.gz: f89b1541bfa6c5bdd765f17636937666f1e79312
 SHA512:
-  metadata.gz: 7c635c1f1e7ad3984ef846f31ac06c5ea469040d99d6f7ef9ffe708cbe8966b9f9da8ab9ccd765bc4e9a12cc3e9a03ebdfcefacc5527f6b845eddd2c127d895f
-  data.tar.gz: 7bff9f22acbd90c6c3df8acb5a7712b943449da663b73ff17c1b0f0ab6d9599e0355ab41643156e35c432ac21d1f017ec57e65c7f6db9efba9ecee70d2962e49
+  metadata.gz: 99a0c5b4f8a41f8f6f9361ac1fbd5bf96738ba6fc525b0d8762cf0c0957017c1bd65ac053d493c82574efa7cc73b1c6c3d895a2274f610f298dd08e87735d8a8
+  data.tar.gz: 14d861ac82ea43640662e78dd6aa1b1f3efb1e3495cb10fbc92d20743a1ea8723a77c8700d4701856abab27df8b995cfa52f9f022be5623f0cd7e6dd27b467a1

data/README.md

@@ -1,4 +1,4 @@
-# Marmara
+# Marmara [![Build Status](https://travis-ci.org/lingua_franca/marmara.png?branch=master)](https://travis-ci.org/lingua_franca/marmara) [![Gem Version](https://badge.fury.io/rb/marmara.svg)](https://badge.fury.io/rb/marmara)
 Marmara is a Ruby Gem that analyses your css during UI testing and generates a code coverage report.
 
 ![Example screenshot of Marmara output](https://i.imgur.com/N7J6wjD.png)
@@ -136,4 +136,58 @@ Marmara.output_directory = '../build/logs'
 Marmara.start_recording
 ```
 
+You can also pass the output directory as an value to the options hash:
+
+```Ruby
+Marmara.options = {
+  output_directory: '../build/logs'
+}
+```
+
 Set the `output_directory` before you start recording and you should find your HTML reports located in the directory you provided. *Note that this directory will removed and re-created each time the tests are run.*
+
+### Ignoring Files
+You can ignore files by passing a string, regular expression, or array or strings or regular expressions using the `:ignore` option:
+
+```Ruby
+# Ignore all files coming from http://fonts.googleapis.com/
+Marmara.options = {
+  ignore: 'http://fonts.googleapis.com/'
+}
+
+# Ignore all files containing 'google'
+Marmara.options = {
+  ignore: /google/
+}
+
+# Ignore all files containing google or adobe
+Marmara.options = {
+  ignore: [/google/, /adobe/]
+}
+
+# Ignore a specific file
+Marmara.options = {
+  ignore: /font\-awesome\.css$/
+}
+```
+
+### Setting minimum coverage
+By default Marmara will not cause your tests to fail even if you have 0% coverage. To enable this, set the `:minimum` option:
+
+```Ruby
+Marmara.options = {
+  minimum: {
+    rules: 80,
+    selectors: 90,
+    declarations: 90
+  }
+ }
+```
+
+The values represent persentages and each value is optional, if a value is not present the resepctive assertion will not be made.
+
+If the respective overall coverage percentage doest not meet your minimum, your tests should fail and you should see a message that looks like:
+
+```bash
+Failed to meet minimum CSS rule coverage of 80%
+```

data/lib/marmara.rb

@@ -1,24 +1,24 @@
 require 'open-uri'
 require 'cgi'
 require 'marmara/parser'
+require 'marmara/config'
+require 'marmara/exceptions'
 
 module Marmara
 
   PSEUDO_CLASSES = /^((first|last|nth|nth\-last)\-(child|of\-type)|not|empty)/
 
   class << self
-    
-    def output_directory
-      @output_directory || 'log/css'
-    end
-
-    def output_directory=(dir)
-      @output_directory = dir
-    end
+    include Config    
 
     def start_recording
       FileUtils.rm_rf(output_directory)
       ENV['_marmara_record'] = '1'
+
+      @last_html = nil
+      @style_sheets = {}
+      @style_sheet_rules = {}
+      @last_driver = nil
     end
     
     def stop_recording
@@ -53,113 +53,115 @@ module Marmara
 
       # now parse each style sheet
       sheets.each do |sheet|
-        unless @style_sheets[sheet] && @style_sheet_rules[sheet]
-          @style_sheet_rules[sheet] = []
-          all_selectors = {}
-          all_at_rules = []
-
-          parser = nil
-          begin
-            parser = CssParser::MarmaraParser.new
-            parser.load_uri!(sheet, capture_offsets: true)
-          rescue Exception => e
-            puts e.to_s
-            puts "\t" + e.backtrace.join("\n\t")
-            log "Error reading #{sheet}"
-          end
-
-          unless parser.nil?
-            # go over each rule in the sheet
-            parser.each_rule_set do |rule, media_types|
-              selectors = []
-              rule.each_selector do |sel, dec, spec|
-                if sel.length > 0
-                  # we need to look for @keyframes and @font-face coverage differently
-                  if sel[0] == '@'
-                    rule_type = sel[1..-1]
-                    at_rule = {
-                        rule: rule,
-                        type: :at_rule,
-                        at_rule_type: rule_type
-                      }
-                    case rule_type
-                    when 'font-face'
-                      at_rule[:property] = 'font-family'
-                      at_rule[:value] = rule.get_value('font-family').gsub(/^\s*"(.*?)"\s*;?\s*$/, '\1')
-                    when /^(\-\w+\-)?keyframes\s+(.*?)\s*$/
-                      at_rule[:property] = ["#{$1}animation-name", "#{$1}animation"]
-                      at_rule[:value] = $2
-                      at_rule[:valueRegex] = [/(?:^|,)\s*(?:#{Regexp.escape(at_rule[:value])})\s*(?:,|;?$)/, /(?:^|\s)(?:#{Regexp.escape(at_rule[:value])})(?:\s|;?$)/]
-                    when /^(\-moz\-document|supports)/
-                      # ignore these types
-                      at_rule[:used] = true
-                    end
+        unless ignore?(sheet)
+          unless @style_sheets[sheet] && @style_sheet_rules[sheet]
+            @style_sheet_rules[sheet] = []
+            all_selectors = {}
+            all_at_rules = []
+
+            parser = nil
+            begin
+              parser = CssParser::MarmaraParser.new
+              parser.load_uri!(sheet, capture_offsets: true)
+            rescue Exception => e
+              puts e.to_s
+              puts "\t" + e.backtrace.join("\n\t")
+              log "Error reading #{sheet}"
+            end
 
-                    if at_rule[:value]
-                      at_rule[:valueRegex] ||= /(?:^|,)\s*(?:#{Regexp.escape(at_rule[:value])}|\"#{Regexp.escape(at_rule[:value])}\")\s*(?:,|;?$)/
+            unless parser.nil?
+              # go over each rule in the sheet
+              parser.each_rule_set do |rule, media_types|
+                selectors = []
+                rule.each_selector do |sel, dec, spec|
+                  if sel.length > 0
+                    # we need to look for @keyframes and @font-face coverage differently
+                    if sel[0] == '@'
+                      rule_type = sel[1..-1]
+                      at_rule = {
+                          rule: rule,
+                          type: :at_rule,
+                          at_rule_type: rule_type
+                        }
+                      case rule_type
+                      when 'font-face'
+                        at_rule[:property] = 'font-family'
+                        at_rule[:value] = rule.get_value('font-family').gsub(/^\s*"(.*?)"\s*;?\s*$/, '\1')
+                      when /^(\-\w+\-)?keyframes\s+(.*?)\s*$/
+                        at_rule[:property] = ["#{$1}animation-name", "#{$1}animation"]
+                        at_rule[:value] = $2
+                        at_rule[:valueRegex] = [/(?:^|,)\s*(?:#{Regexp.escape(at_rule[:value])})\s*(?:,|;?$)/, /(?:^|\s)(?:#{Regexp.escape(at_rule[:value])})(?:\s|;?$)/]
+                      when /^(\-moz\-document|supports)/
+                        # ignore these types
+                        at_rule[:used] = true
+                      end
+
+                      if at_rule[:value]
+                        at_rule[:valueRegex] ||= /(?:^|,)\s*(?:#{Regexp.escape(at_rule[:value])}|\"#{Regexp.escape(at_rule[:value])}\")\s*(?:,|;?$)/
+
+                        # store all the info that we collected about the rule
+                        @style_sheet_rules[sheet] << at_rule
+                      end
+                    else
+                      # just a regular selector, collect it
+                      selectors << {
+                          original: sel,
+                          queryable: get_safe_selector(sel)
+                        }
+                      all_selectors[get_safe_selector(sel)] ||= false
 
                       # store all the info that we collected about the rule
-                      @style_sheet_rules[sheet] << at_rule
+                      @style_sheet_rules[sheet] << {
+                          rule: rule,
+                          type: :rule,
+                          selectors: selectors,
+                          used_selectors: [false] * selectors.count
+                        }
                     end
                   else
-                    # just a regular selector, collect it
-                    selectors << {
-                        original: sel,
-                        queryable: get_safe_selector(sel)
-                      }
-                    all_selectors[get_safe_selector(sel)] ||= false
-
                     # store all the info that we collected about the rule
                     @style_sheet_rules[sheet] << {
                         rule: rule,
-                        type: :rule,
-                        selectors: selectors,
-                        used_selectors: [false] * selectors.count
+                        type: :unknown
                       }
                   end
-                else
-                  # store all the info that we collected about the rule
-                  @style_sheet_rules[sheet] << {
-                      rule: rule,
-                      type: :unknown
-                    }
                 end
               end
-            end
 
-            # store info about the stylesheet
-            @style_sheets[sheet] = {
-              css: parser.last_file_contents,
-              all_selectors: all_selectors,
-              all_at_rules: all_at_rules,
-              included_with: Set.new
-            }
+              # store info about the stylesheet
+              @style_sheets[sheet] = {
+                css: parser.last_file_contents,
+                all_selectors: all_selectors,
+                all_at_rules: all_at_rules,
+                included_with: Set.new
+              }
+            end
+            @style_sheets[sheet][:included_with] += sheets
           end
-          @style_sheets[sheet][:included_with] += sheets
-        end
 
-        # gather together only the selectors that haven't been spotted yet
-        selectors_to_find = @style_sheets[sheet][:all_selectors].select{|k,v|!v}.keys
+          # gather together only the selectors that haven't been spotted yet
+          selectors_to_find = @style_sheets[sheet][:all_selectors].select{|k,v|!v}.keys
 
-        # don't do anything unless we have to
-        if selectors_to_find.length > 0
-          # and search for them in this document
-          found_selectors = evaluate_script("(function(selectors) {
-              var results = {};
-              for (var i = 0; i < selectors.length; i++) {
-                results[selectors[i]] = !!document.querySelector(selectors[i]);
-              }
-              return results;
-            })(#{selectors_to_find.to_json})", driver)
+          # don't do anything unless we have to
+          if selectors_to_find.length > 0
+            # and search for them in this document
+            found_selectors = evaluate_script("(function(selectors) {
+                var results = {};
+                for (var i = 0; i < selectors.length; i++) {
+                  results[selectors[i]] = !!document.querySelector(selectors[i]);
+                }
+                return results;
+              })(#{selectors_to_find.to_json})", driver)
 
-          # now merge the results back in
-          found_selectors.each { |k,v| @style_sheets[sheet][:all_selectors][k] ||= v }
+            # now merge the results back in
+            found_selectors.each { |k,v| @style_sheets[sheet][:all_selectors][k] ||= v }
 
-          # and mark each as used if found
-          @style_sheet_rules[sheet].each_with_index do |rule, rule_index|
-            if rule[:type] == :rule
-              rule[:selectors].each_with_index do |sel, sel_index|
-                @style_sheet_rules[sheet][rule_index][:used_selectors][sel_index] ||= @style_sheets[sheet][:all_selectors][sel[:queryable]]
+            # and mark each as used if found
+            @style_sheet_rules[sheet].each_with_index do |rule, rule_index|
+              if rule[:type] == :rule
+                rule[:selectors].each_with_index do |sel, sel_index|
+                  @style_sheet_rules[sheet][rule_index][:used_selectors][sel_index] ||= @style_sheets[sheet][:all_selectors][sel[:queryable]]
+                end
               end
             end
           end
@@ -176,7 +178,11 @@ module Marmara
     end
 
     def get_style_sheet_html
-      @style_sheet_html ||= File.read(File.join(File.dirname(__FILE__), 'marmara', 'style-sheet.html'))
+      @style_sheet_html ||= File.read((options || {})[:html_file] || File.join(File.dirname(__FILE__), 'marmara', 'style-sheet.html'))
+    end
+
+    def get_style_sheet_css
+      @style_sheet_css ||= File.read((options || {})[:css_file] || File.join(File.dirname(__FILE__), 'marmara', 'style-sheet.css'))
     end
 
     def evaluate_script(script, driver = @last_driver)
@@ -184,13 +190,17 @@ module Marmara
       @last_driver.evaluate_script(script)
     end
 
+    def stat_types
+      @stat_types ||= ['Rule', 'Selector', 'Declaration']
+    end
+
     def analyze
       # start compiling the overall stats
-      overall_stats = {
-          'Rules' => { match_count: 0, total: 0 },
-          'Selectors' => { match_count: 0, total: 0 },
-          'Declarations' => { match_count: 0, total: 0 }
-        }
+      overall_stats = {}
+
+      stat_types.each do |type|
+        overall_stats["#{type}s"] = { match_count: 0, total: 0 }
+      end
 
       # go through all of the style sheets found
       #get_latest_results.each do |uri, rules|
@@ -204,29 +214,20 @@ module Marmara
           # and generate the report
           html = generate_html_report(original_sheet, coverage[:covered_rules])
 
-          # output stats for this file
-          log_stats(get_report_filename(uri), {
-              'Rules' => {
-                match_count: coverage[:matched_rules],
-                total: coverage[:total_rules]
-              },
-              'Selectors' => {
-                match_count: coverage[:matched_selectors],
-                total: coverage[:total_selectors]
-              },
-              'Declarations' => {
-                match_count: coverage[:matched_declarations],
-                total: coverage[:total_declarations]
+          stats_to_log = {}
+          stat_types.each do |type|
+            stats_to_log["#{type}s"] = {
+                match_count: coverage["matched_#{type.downcase}s".to_sym],
+                total: coverage["total_#{type.downcase}s".to_sym]
               }
-            })
 
-          # add to the overall stats
-          overall_stats['Rules'][:match_count] += coverage[:matched_rules]
-          overall_stats['Rules'][:total] += coverage[:total_rules]
-          overall_stats['Selectors'][:match_count] += coverage[:matched_selectors]
-          overall_stats['Selectors'][:total] += coverage[:total_selectors]
-          overall_stats['Declarations'][:match_count] += coverage[:matched_declarations]
-          overall_stats['Declarations'][:total] += coverage[:total_declarations]
+            # add to the overall stats
+            overall_stats["#{type}s"][:match_count] += coverage["matched_#{type.downcase}s".to_sym]
+            overall_stats["#{type}s"][:total] += coverage["total_#{type.downcase}s".to_sym]
+          end
+
+          # output stats for this file
+          log_stats(get_report_filename(uri), stats_to_log)
 
           # save the report
           save_report(uri, html)
@@ -235,65 +236,28 @@ module Marmara
 
       log_stats('Overall', overall_stats)
       log "\n"
-    end
 
-    def download_style_sheet(uri)
-      open_attempts = 0
-      begin
-        open_attempts += 1
-        uri = Addressable::URI.parse(uri.to_s)
-
-        # remote file
-        if uri.scheme == 'https'
-          uri.port = 443 unless uri.port
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        else
-          http = Net::HTTP.new(uri.host, uri.port)
+      # check for minimum coverage
+      if options && options[:minimum]
+        stat_types.each do |type|
+          Marmara.const_get("Minimum#{type}CoverageNotMet").assert(
+              options[:minimum]["#{type.downcase}s".to_sym],
+              ((overall_stats["#{type}s"][:match_count] * 100.0) / overall_stats["#{type}s"][:total]).round(2)
+            )
         end
-
-        res = http.get(uri.request_uri, {'Accept-Encoding' => 'gzip'})
-        src = res.body.force_encoding("UTF-8")
-
-        case res['content-encoding']
-          when 'gzip'
-            io = Zlib::GzipReader.new(StringIO.new(res.body))
-            src = io.read
-          when 'deflate'
-            io = Zlib::Inflate.new
-            src = io.inflate(res.body)
-        end
-
-        if String.method_defined?(:encode)
-          src.encode!('UTF-8', 'utf-8')
-        else
-          ic = Iconv.new('UTF-8//IGNORE', 'utf-8')
-          src = ic.iconv(src)
-        end
-
-        return src
-      rescue Exception => e
-        sleep(1)
-        retry if open_attempts < 4
-        log "\tFailed to open #{uri}"
-        log e.to_s
       end
-      return nil
     end
 
     def save_report(uri, html)
-      File.open(get_report_path(uri), 'wb:UTF-8') { |f| f.write(html) }
+      path = get_report_path(uri)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'wb:UTF-8') { |f| f.write(html) }
     end
 
     def get_report_path(uri)
       File.join(output_directory, get_report_filename(uri) + '.html')
     end
 
-    def get_report_filename(uri)
-      File.basename(uri).gsub(/^(.*?)\?.*$/, '\1')
-    end
-
     def is_property_covered(sheets, property, valueRegex)
       # iterate over each sheet
       sheets.each do |uri|
@@ -320,7 +284,7 @@ module Marmara
       total_selectors = 0
       covered_selectors = 0
 
-      total_rules = @style_sheet_rules[uri].count
+      total_rules = 0
       covered_rules = 0
 
       total_declarations = 0
@@ -351,6 +315,7 @@ module Marmara
             coverage[:state] = :not_covered
           end
         elsif rule[:type] == :rule
+          total_rules += 1
           some_covered = rule[:used_selectors].reduce(&:|)
           total_selectors += rule[:used_selectors].count
 
@@ -409,57 +374,6 @@ module Marmara
       }
     end
 
-    def organize_rules(rules)
-      # first sort the rules by the starting index
-      rules.sort_by! { |r| r[:offset].first }
-
-      # then remove unnecessary regions
-      i = 0
-      rules_removed = false
-      while i < rules.length - 1
-        # look for empty regions
-        if rules[i][:offset][1] <= rules[i][:offset][0]
-          # so that we don't lose our place, set the value to nil, then we'll strip the array of nils
-          rules[i] = nil
-          rules_removed = true
-        # look for regions that should be connected
-        elsif (next_rule = rules[i + 1]) && rules[i][:offset][1] == next_rule[:offset][0] && rules[i][:state] == next_rule[:state]
-          # back up the next rule to start where ours does
-          rules[i + 1][:offset][0] = rules[i][:offset][0]
-          # and get rid of ourselves
-          rules[i] = nil
-          rules_removed = true
-        end
-        i += 1
-      end
-
-      # strip the array of nil values we may have set in the previous step
-      rules.compact! if rules_removed
-
-      # look for overlapping rules
-      i = 0
-      while i < rules.length
-        next_rule = rules[i + 1]
-        if next_rule && rules[i][:offset][1] > next_rule[:offset][0]
-          # we found an overlapping rule
-          # slice up this rule and add the remaining to the end of the array
-          rules << {
-            offset: [next_rule[:offset][1], rules[i][:offset][1]],
-            state: rules[i][:state]
-          }
-          # and shorten the length of this rule
-          rules[i][:offset][1] = next_rule[:offset][0]
-
-          # start again
-          return organize_rules(rules)
-        end
-        i += 1
-      end
-      
-      # we're done!
-      return rules
-    end
-
     def generate_html_report(original_sheet, coverage)
       sheet_html = ''
       last_index = 0
@@ -476,14 +390,15 @@ module Marmara
         sheet_html += wrap_code(original_sheet[last_index...original_sheet.length], :ignored)
       end
 
-      # replace line returns with HTML line breaks
-      sheet_html.gsub!(/\r?\n/, '<br>')
-
       # build the lines section
-      lines = (1..original_sheet.lines.count + 1).to_a.map do |line|
+      lines = (0..original_sheet.count("\n")).to_a.map do |_line|
+        line = _line + 1
         "<a href=\"#L#{line}\" id=\"L#{line}\">#{line}</a>"
       end
-      get_style_sheet_html.gsub('%{lines}', lines.join('')).gsub('%{style_sheet}', sheet_html)
+
+      get_style_sheet_html.gsub('%{style}', get_style_sheet_css)
+                          .gsub('%{lines}', lines.join(''))
+                          .gsub('%{style_sheet}', sheet_html)
     end
 
     def wrap_code(str, state)
@@ -494,7 +409,8 @@ module Marmara
         ignored: 'class="ignored"',
         not_covered: 'class="not-covered"'
       }
-      "<pre #{@state_attr[state]}><span>#{CGI.escapeHTML(str)}</span></pre>"
+      str = CGI.escapeHTML(str).gsub(/\r?\n/, '<br>')
+      "<pre #{@state_attr[state]}><span>#{str}</span></pre>"
     end
 
     def rules_equal?(rule_a, rule_b)
@@ -522,8 +438,48 @@ module Marmara
       end
     end
 
-    def log(str)
-      puts str
+    def organize_rules(rules)
+      # first sort the rules by the starting index
+      rules.sort_by! { |r| r[:offset].first }
+
+      # then remove unnecessary regions
+      i = 0
+      rules_removed = false
+      while i < rules.length - 1
+        # look for empty regions
+        if rules[i][:offset][1] <= rules[i][:offset][0]
+          # so that we don't lose our place, set the value to nil, then we'll strip the array of nils
+          rules[i] = nil
+          rules_removed = true
+        end
+        i += 1
+      end
+
+      # strip the array of nil values we may have set in the previous step
+      rules.compact! if rules_removed
+
+      # look for overlapping rules
+      i = 0
+      while i < rules.length
+        next_rule = rules[i + 1]
+        if next_rule && rules[i][:offset][1] > next_rule[:offset][0]
+          # we found an overlapping rule
+          # slice up this rule and add the remaining to the end of the array
+          rules << {
+            offset: [next_rule[:offset][1], rules[i][:offset][1]],
+            state: rules[i][:state]
+          }
+          # and shorten the length of this rule
+          rules[i][:offset][1] = next_rule[:offset][0]
+
+          # start again
+          return organize_rules(rules)
+        end
+        i += 1
+      end
+      
+      # we're done!
+      return rules
     end
   end
 end

data/lib/marmara/config.rb

@@ -0,0 +1,62 @@
+module Marmara
+  module Config
+    attr_reader :options
+
+    def options=(opts)
+      if @options
+        if @options[:output_directory]
+          opts[:output_directory] ||= @options[:output_directory]
+        end
+      end
+
+      @options = opts
+    end
+
+    def output_directory
+      (options || {})[:output_directory] || 'log/css'
+    end
+
+    def output_directory=(dir)
+      @options ||= {}
+      @options[:output_directory] = dir
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def log(str, method = :info)
+      if @logger
+        @logger.send(method, str)
+      elsif @logger.nil?
+        puts str
+      end
+    end
+
+    def ignore?(file)
+      return false unless options
+
+      [*options[:ignore]].each do |matcher|
+        if matcher.is_a?(Regexp)
+          return true if file =~ matcher
+        else
+          return true if file.start_with?(matcher)
+        end
+      end
+
+      return false
+    end
+
+    def get_report_filename(uri)
+      if options && options[:rewrite]
+        rewrite_rules = options[:rewrite]
+        rewrite_rules = [rewrite_rules] unless rewrite_rules.is_a?(Array)
+        rewrite_rules.each do |rule|
+          return uri.gsub(rule[:from], rule[:to]) if uri =~ rule[:from]
+        end
+      end
+
+      return File.basename(uri).gsub(/^(.*?)\?.*$/, '\1')
+    end
+  end
+end

data/lib/marmara/exceptions.rb

@@ -0,0 +1,38 @@
+module Marmara
+  class MinimumCoverageNotMetBase < Exception
+    attr_reader :expected
+    attr_reader :actual
+
+    def initialize(expected, actual)
+      @expected = expected
+      @actual = actual
+      super("Failed to meet minimum CSS #{type} coverage of #{expected}%")
+    end
+
+    def type
+      raise "This exception class is abstract"
+    end
+
+    def self.assert(expected, actual)
+      raise Object.const_get(self.name).new(expected, actual) if expected && expected > actual
+    end
+  end
+  
+  class MinimumRuleCoverageNotMet < MinimumCoverageNotMetBase
+    def type
+      'rule'
+    end
+  end
+  
+  class MinimumSelectorCoverageNotMet < MinimumCoverageNotMetBase
+    def type
+      'selector'
+    end
+  end
+  
+  class MinimumDeclarationCoverageNotMet < MinimumCoverageNotMetBase
+    def type
+      'declaration'
+    end
+  end
+end

data/lib/marmara/style-sheet.css

@@ -0,0 +1,78 @@
+body {
+  margin: 0;
+  font-size: 18px;
+  background-color: #FBF3E9;
+}
+
+#code {
+  white-space: nowrap;
+}
+
+#lines {
+  position: relative;
+  float: left;
+  padding: 0 0.75em 0 0.5em;
+  text-align: right;
+  font-weight: bold;
+  color: rgba(0, 0, 0, 0.125);
+  letter-spacing: -0.125em;
+  transition: color 150ms ease-in-out;
+  cursor:  default;
+}
+
+#lines:hover, #lines a:target {
+  color: rgba(0, 0, 0, 0.75);
+}
+
+#lines a {
+  color: inherit;
+  text-decoration: none;
+  display: block;
+}
+
+#lines a:hover::after, #lines a:target::after {
+  content: '';
+  position: absolute;
+  left: 0;
+  width: 100vw;
+  background-color: #00BFFF;
+  height: 1.6em;
+  opacity: 0.25;
+}
+
+#lines a:hover::after {
+  background-color: #BDB76B;
+}
+
+pre {
+  font-family: 'Cutive Mono', monospace;
+  display: inline;
+  margin: 0;
+  padding: 0;
+  line-height: 1.65em;
+}
+
+pre > span {
+  position: relative;
+  z-index: 1;
+  color: #333;
+}
+
+.covered {
+  color: #AEE6B0;
+}
+
+.not-covered {
+  color: #F79B95;
+}
+
+.covered, .not-covered {
+  background-color: currentColor;
+  text-shadow: 0 0 0.25em #FFF;
+  font-weight: bold;
+  padding: 0.25em 0;
+}
+
+.ignored {
+  color: #888;
+}

data/lib/marmara/style-sheet.html

@@ -3,74 +3,7 @@
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
     <link href="https://fonts.googleapis.com/css?family=Cutive+Mono" rel="stylesheet">
-    <style type="text/css">
-      body {
-          margin: 0;
-          font-size: 18px;
-          background-color: #FBF3E9;
-      }
-      #code {
-          white-space: nowrap;
-      }
-      #lines {
-        position: relative;
-        float: left;
-        padding: 0 0.75em 0 0.5em;
-        text-align: right;
-        font-weight: bold;
-        color: rgba(0, 0, 0, 0.125);
-        letter-spacing: -0.125em;
-        transition: color 150ms ease-in-out;
-        cursor:  default;
-      }
-      #lines:hover, #lines a:target {
-        color: rgba(0, 0, 0, 0.75);
-      }
-      #lines a {
-        color: inherit;
-        text-decoration: none;
-        display: block;
-      }
-      #lines a:hover::after, #lines a:target::after {
-        content: '';
-        position: absolute;
-        left: 0;
-        width: 100vw;
-        background-color: #00BFFF;
-        height: 1.6em;
-        opacity: 0.25;
-      }
-      #lines a:hover::after {
-        background-color: #BDB76B;
-      }
-      pre {
-        font-family: 'Cutive Mono', monospace;
-          display: inline;
-          margin: 0;
-          padding: 0;
-          line-height: 1.65em;
-      }
-      pre > span {
-        position: relative;
-        z-index: 1;
-        color: #333;
-      }
-      .covered {
-        color: #AEE6B0;
-      }
-      .not-covered {
-        color: #F79B95;
-      }
-      .covered, .not-covered {
-        background-color: currentColor;
-        text-shadow: 0 0 0.25em #FFF;
-        font-weight: bold;
-        padding: 0.25em 0;
-      }
-      .ignored {
-        color: #888;
-      }
-    </style>
+    <style type="text/css">%{style}</style>
   </head>
   <body>
     <div id="lines">

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: marmara
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Godwin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-15 00:00:00.000000000 Z
+date: 2017-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: css_parser
@@ -80,35 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: capybara
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: poltergeist
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Generates a CSS coverage report
+description: Generates a CSS coverage report and tests for minimum coverage
 email:
 - goodgodwin@hotmail.com
 executables: []
@@ -119,7 +91,10 @@ files:
 - README.md
 - Rakefile
 - lib/marmara.rb
+- lib/marmara/config.rb
+- lib/marmara/exceptions.rb
 - lib/marmara/parser.rb
+- lib/marmara/style-sheet.css
 - lib/marmara/style-sheet.html
 homepage: http://bikecollectives.org
 licenses:
@@ -133,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="