marmara 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: caffd5bb8874fcb945d1afd57aa80bf8f214783a
+  data.tar.gz: cd9f49013b3b591c9620d1193cb801832375c7d3
+SHA512:
+  metadata.gz: a6d5ce21997d98f2fc262af141e2bcdc233a03da0c4a23f670f06d0c4d13cb53beb4a831a26e27e2059474ddf4791498721cba33929949e4af094fb1f09344c0
+  data.tar.gz: f34584cfe0a76c92472e4c14d34e537323165b2bf3107f5e5f0b824e06d665c9ce59dbb246e3a501f59e00af1856c24ff504cb2db3ccec0b9074d1a834a00e98

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Michael Godwin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Marmara
+Marmara is a Ruby Gem that analyses your css during UI testing and generates a code coverage report.
+
+![Alt text](https://i.imgur.com/zX9SSuF.png)
+
+## Why is CSS code coverage important?
+CSS code coverage is a little different than traditional code coverage.
+
+### Discovering Unused CSS
+Removing dead CSS code will decrease the number size of your CSS that gets delivered to your user and decreases the number amount of work that client will need to perform once it receives that file, both should lead to an faster website overall and may save you server costs.
+
+While this tool will tell you which CSS rules were untouched during testing, you shouldn't always consider a deeper analysis before modifying your source. Imagine that you have a report that looks ike the following:
+
+```diff
+ /*
+  * Make all links red
+  */
++ a {
++     color: red;
++     opacity: 0.9;
++ }
+
+ /*
+  * We used to colour our links blue, maybe we should remove this rule...
+  */
+- a.my-old-style {
+-     color: blue;
+- }
+
+ /*
+  * Do some old IE fixing
+  */
+- html.ie-9 a {
+-     filter: alpha(opacity=90);
+- }
+```
+
+As you can see here, the first `a` rule was used, so we definitely want to keep it but there is an older rule `a.my-old-style` which can probably be safely removed. The last rule however is a fix for older browsers, so we should probably consider keeping it.
+
+### Safer CSS Refactoring
+Sometimes our CSS files become monoliths when it would be much better to split up a file into smaller modules. By running a subset of your tests, you can safely determine where files can be split.
+
+### Discovering Untested Features
+With traditional code coverage, this is the most important factor in improving your code base, with CSS testing it is still important but to a lesser degree. If you look back at the first example, the fact that these rules are not covered may mean that you are actually not testing important features. You may want to consider adding tests for IE by using a different user agent or setting the html class programmatically.
+
+## Set up
+This project has yet only been set up in a Rails Capybara/Poltergeist environment, more work may need to be done to get it woking in other environment.
+
+It is important to run `Marmara.start_recording` before you run any tests and `Marmara.stop_recording` after testing is complete but currently the call to `Marmara.stop_recording` needs to happen before poltergeist as closed its connection with phantomjs. It would probably be best for us to spin up our own process to avoid this.
+
+### 1. Create a Rake task
+
+I'm using Cucumber, so I added a new rake task that looks like this:
+
+```ruby
+task "css:cover" do
+  Marmara.start_recording
+  Rake::Task[:cucumber].execute
+end
+```
+
+### 2. Capture your output
+
+```ruby
+AfterStep do
+  Marmara.record(page) if Marmara.recording?
+end
+```
+
+Since I also want to capture used selectors for mobile, my after step looks more like this:
+
+```ruby
+AfterStep do
+  if Marmara.recording?
+    Marmara.record(page)
+    old_size = page.driver.browser.client.window_size
+    page.driver.resize_window(600, 400)
+    Marmara.record(page)
+    page.driver.resize_window(*old_size)
+  end
+end
+```
+
+### 3. Stop recording and generate your output
+
+```ruby
+at_exit do
+  Marmara.stop_recording if Marmara.recording?
+end
+```
+
+## Development plan
+This project is currently in a "works in my project" stage, there's still work to be done to make it more vendable so I welcome pull requests. In addition, there are probably a lot of tweaks required to the parser and a lot of features that would be nice to have.

data/Rakefile

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/marmara/style-sheet.html

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html>
+  <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>
+  </head>
+  <body>
+    <div id="lines">
+      <pre>%{lines}</pre>
+    </div>
+    <div id="code">%{style_sheet}</div>
+  </body>
+</html>

data/lib/marmara.rb

@@ -0,0 +1,512 @@
+require 'open-uri'
+require 'cgi'
+require 'cgi'
+require 'css_parser'
+
+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
+
+    def start_recording
+      FileUtils.rm_rf(output_directory)
+      ENV['_marmara_record'] = '1'
+    end
+    
+    def stop_recording
+      ENV['_marmara_record'] = nil
+      log "\nCompiling CSS coverage report..."
+      FileUtils.mkdir_p(output_directory)
+      analyze
+    end
+    
+    def recording?
+      return ENV['_marmara_record'] == '1'
+    end
+
+    def record(driver)
+      sheets = []
+      @last_html ||= nil
+      html = driver.html
+
+      # don't do anything if the page hasn't changed
+      return if @last_html == html
+
+      # cache the page so we can check again next time
+      @last_html = html
+
+      # look for all the stylesheets
+      driver.all('link[rel="stylesheet"]', visible: false).each do |sheet|
+        sheets << sheet[:href]
+      end
+
+      @style_sheets ||= {}
+      @style_sheet_rules ||= {}
+
+      # 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::Parser.new
+            parser.load_uri!(sheet, capture_offsets: true)
+          rescue
+            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.first == '@'
+                    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|;?$)/]
+                    end
+
+                    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
+                  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
+                      }
+                  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: download_style_sheet(sheet),
+              all_selectors: all_selectors,
+              all_at_rules: all_at_rules,
+              included_with: Set.new
+            }
+          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
+
+        # 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 }
+
+          # 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
+      end
+    end
+
+    def get_safe_selector(sel)
+      sel.gsub!(/:+(.+)([^\-\w]|$)/) do |match|
+        ending = Regexp.last_match[2]
+        Regexp.last_match[1] =~ PSEUDO_CLASSES ? match : ending
+      end
+      sel.length > 0 ? sel : '*'
+    end
+
+    def get_style_sheet_html
+      @style_sheet_html ||= File.read(File.join(File.dirname(__FILE__), 'marmara', 'style-sheet.html'))
+    end
+
+    def evaluate_script(script, driver = @last_driver)
+      @last_driver = driver
+      @last_driver.evaluate_script(script)
+    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 }
+        }
+
+      # go through all of the style sheets found
+      #get_latest_results.each do |uri, rules|
+      @style_sheet_rules.each do |uri, rules|
+        # download the style sheet
+        original_sheet = (@style_sheets[uri] || {})[:css]
+
+        if original_sheet
+          # if we can download it calculate the overage
+          coverage = get_coverage(uri) #original_sheet, rules)
+          # 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]
+              }
+            })
+
+          # 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]
+
+          # save the report
+          save_report(uri, html)
+        end
+      end
+
+      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)
+        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) }
+    end
+
+    def get_report_path(uri)
+      File.join(output_directory, get_report_filename(uri) + '.html')
+    end
+
+    def get_report_filename(uri)
+      File.basename(uri)
+    end
+
+    def is_property_covered(sheets, property, valueRegex)
+      # iterate over each sheet
+      sheets.each do |uri|
+        # each rule in each sheet
+        @style_sheet_rules[uri].each do |rule|
+          # check to see if this property and value matches
+          if rule[:type] == :rule
+            # if at least one selector was covered we can return true now
+            valueRegexs = [*valueRegex]
+            [*property].each_with_index do |prop, i|
+              if rule[:rule].get_value(prop) =~ valueRegexs[i] && rule[:used_selectors].reduce(&:|)
+                return true
+              end
+            end
+          end
+        end
+      end
+
+      # the rule wasn't covered
+      return false
+    end
+
+    def get_coverage(uri)
+      total_selectors = 0
+      covered_selectors = 0
+
+      total_rules = @style_sheet_rules[uri].count
+      covered_rules = 0
+
+      total_declarations = 0
+      covered_declarations = 0
+
+      sheet_covered_rules = []
+      @style_sheet_rules[uri].each do |rule|
+        coverage = {
+            offset: [
+                rule[:rule].offset.first,
+                rule[:rule].offset.last                
+              ],
+          }
+
+        if rule[:type] == :at_rule
+          covered = is_property_covered(@style_sheets[uri][:included_with], rule[:property], rule[:valueRegex])
+          
+          total_selectors += 1
+          total_rules += 1
+          total_declarations += 1
+
+          if covered
+            covered_selectors += 1
+            covered_rules += 1
+            covered_declarations += 1
+            coverage[:state] = :covered
+          else
+            coverage[:state] = :not_covered
+          end
+        elsif rule[:type] == :rule
+          some_covered = rule[:used_selectors].reduce(&:|)
+          total_selectors += rule[:used_selectors].count
+
+          if some_covered
+            covered_rules += 1
+            
+            rule[:rule].each_declaration do
+              total_declarations += 1
+              covered_declarations += 1
+            end
+
+            coverage[:state] = :covered
+            if rule[:used_selectors].reduce(&:&)
+              covered_selectors += rule[:used_selectors].count
+            else
+              original_selectors, = @style_sheets[uri][:css].byteslice(rule[:rule].offset).split(/\s*\{/, 2)
+              selector_i = 0
+
+              original_selectors.scan(/(?<=^|,)\s*(.*?)\s*(?=,|$)/m) do |match|
+                is_covered = rule[:used_selectors][selector_i] ? :covered : :not_covered
+                covered_selectors += 1 if is_covered
+                sheet_covered_rules << {
+                  offset: [
+                      coverage[:offset][0] + Regexp.last_match.offset(0).first,
+                      coverage[:offset][0] + Regexp.last_match.offset(0).last
+                    ],
+                  state: is_covered
+                }
+                selector_i += 1
+              end
+              coverage[:offset][0] += original_selectors.length + 1
+            end
+          else
+            rule[:rule].each_declaration do
+              total_declarations += 1
+            end
+            
+            coverage[:state] = :not_covered
+          end
+        end
+        sheet_covered_rules << coverage
+      end
+
+      {
+        covered_rules: organize_rules(sheet_covered_rules),
+        total_rules: total_rules,
+        matched_rules: covered_rules,
+        total_selectors: total_selectors,
+        matched_selectors: covered_selectors,
+        total_declarations: total_declarations,
+        matched_declarations: covered_declarations,
+      }
+    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
+
+      # collect the sheet html
+      coverage.each do |rule|
+        sheet_html += wrap_code(original_sheet.byteslice(last_index...rule[:offset][0]), :ignored)
+        sheet_html += wrap_code(original_sheet.byteslice(rule[:offset][0]..rule[:offset][1]), rule[:state])
+        last_index = rule[:offset][1] + 1
+      end
+
+      sheet_html += wrap_code(original_sheet[last_index..original_sheet.length], :ignored)
+      sheet_html.gsub!(/\n/, '<br>')
+      lines = (1..original_sheet.lines.count).to_a.map do |line|
+        "<a href=\"#L#{line}\" id=\"L#{line}\">#{line}</a>"
+      end
+      get_style_sheet_html.gsub('%{lines}', lines.join('')).gsub('%{style_sheet}', sheet_html)
+    end
+
+    def wrap_code(str, state)
+      return '' unless str && str.length > 0
+
+      @state_attr ||= {
+        covered: 'class="covered"',
+        ignored: 'class="ignored"',
+        not_covered: 'class="not-covered"'
+      }
+      "<pre #{@state_attr[state]}><span>#{CGI.escapeHTML(str)}</span></pre>"
+    end
+
+    def rules_equal?(rule_a, rule_b)
+      # sometimes the normalizer isn't very predictable, reset some equivalent rules ere
+      @rule_replacements ||= {
+        '(\soutline:)\s*(?:0px|0|rgb\(0,\s*0,\s*0\));' => '\1 0;'
+      }
+      
+      # make the necessary replacements
+      @rule_replacements.each do |regex, replacement|
+        rule_a.gsub!(Regexp.new(regex), replacement)
+        rule_b.gsub!(Regexp.new(regex), replacement)
+      end
+
+      # and test for equivalence
+      return rule_a == rule_b
+    end
+
+    def log_stats(title, report)
+      log "\n    #{title}:"
+
+      report.each do |header, data|
+        percent = ((data[:match_count] * 100.0) / data[:total]).round(2)
+        log "          #{header}: #{data[:match_count]}/#{data[:total]} (#{percent}%)"
+      end
+    end
+
+    def log(str)
+      puts str
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: marmara
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Godwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: css_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0.pre
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: rspec
+  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: yard
+  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
+email:
+- goodgodwin@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/marmara.rb
+- lib/marmara/style-sheet.html
+homepage: http://bikecollectives.org
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Analyses your css for code coverage
+test_files: []