rspec_log_formatter 0.1.0 → 0.2.0

data/lib/rspec_log_formatter/history_manager.rb

@@ -0,0 +1,46 @@
+require 'csv'
+require 'set'
+
+module RspecLogFormatter
+  class HistoryManager
+    def initialize(filepath)
+      @filepath = filepath
+    end
+
+    def builds
+      results.map{|r| r.build_number.to_i}.reduce(SortedSet.new, &:<<).to_a
+    end
+
+    def truncate(number_of_builds)
+      kept_builds = builds.to_a.last(number_of_builds)
+      sio = StringIO.new
+
+      lines.each do |line|
+        sio.puts line if kept_builds.include? (parse(line).build_number.to_i)
+      end
+
+      sio.rewind
+
+      File.open(@filepath, 'w') do |f|
+        f.write sio.read
+      end
+    end
+
+    def results
+      lines.map do |line|
+        parse(line)
+      end
+    end
+
+    private
+
+    def parse(line)
+      RspecLogFormatter::Analysis::Result.new(*CSV.parse_line(line, col_sep: "\t").first(8))
+    end
+
+
+    def lines
+      File.open(@filepath, 'r').lazy
+    end
+  end
+end

data/lib/rspec_log_formatter/javascripts/chartkick.js

@@ -0,0 +1,678 @@
+/*
+ * Chartkick.js
+ * Create beautiful Javascript charts with minimal code
+ * https://github.com/ankane/chartkick.js
+ * v1.1.1
+ * MIT License
+ */
+
+/*jslint browser: true, indent: 2, plusplus: true, vars: true */
+/*global google, Highcharts, $*/
+
+(function () {
+  'use strict';
+
+  var Chartkick, ISO8601_PATTERN, DECIMAL_SEPARATOR, defaultOptions, hideLegend,
+    setMin, setMax, setStacked, jsOptions, loaded, waitForLoaded, setBarMin, setBarMax, createDataTable, resize;
+
+  // only functions that need defined specific to charting library
+  var renderLineChart, renderPieChart, renderColumnChart, renderBarChart, renderAreaChart;
+
+  // helpers
+
+  function isArray(variable) {
+    return Object.prototype.toString.call(variable) === "[object Array]";
+  }
+
+  function isFunction(variable) {
+    return variable instanceof Function;
+  }
+
+  function isPlainObject(variable) {
+    return !isFunction(variable) && variable instanceof Object;
+  }
+
+  // https://github.com/madrobby/zepto/blob/master/src/zepto.js
+  function extend(target, source) {
+    var key;
+    for (key in source) {
+      if (isPlainObject(source[key]) || isArray(source[key])) {
+        if (isPlainObject(source[key]) && !isPlainObject(target[key])) {
+          target[key] = {};
+        }
+        if (isArray(source[key]) && !isArray(target[key])) {
+          target[key] = [];
+        }
+        extend(target[key], source[key]);
+      } else if (source[key] !== undefined) {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  function merge(obj1, obj2) {
+    var target = {};
+    extend(target, obj1);
+    extend(target, obj2);
+    return target;
+  }
+
+  // https://github.com/Do/iso8601.js
+  ISO8601_PATTERN = /(\d\d\d\d)(\-)?(\d\d)(\-)?(\d\d)(T)?(\d\d)(:)?(\d\d)?(:)?(\d\d)?([\.,]\d+)?($|Z|([\+\-])(\d\d)(:)?(\d\d)?)/i;
+  DECIMAL_SEPARATOR = String(1.5).charAt(1);
+
+  function parseISO8601(input) {
+    var day, hour, matches, milliseconds, minutes, month, offset, result, seconds, type, year;
+    type = Object.prototype.toString.call(input);
+    if (type === '[object Date]') {
+      return input;
+    }
+    if (type !== '[object String]') {
+      return;
+    }
+    if (matches = input.match(ISO8601_PATTERN)) {
+      year = parseInt(matches[1], 10);
+      month = parseInt(matches[3], 10) - 1;
+      day = parseInt(matches[5], 10);
+      hour = parseInt(matches[7], 10);
+      minutes = matches[9] ? parseInt(matches[9], 10) : 0;
+      seconds = matches[11] ? parseInt(matches[11], 10) : 0;
+      milliseconds = matches[12] ? parseFloat(DECIMAL_SEPARATOR + matches[12].slice(1)) * 1000 : 0;
+      result = Date.UTC(year, month, day, hour, minutes, seconds, milliseconds);
+      if (matches[13] && matches[14]) {
+        offset = matches[15] * 60;
+        if (matches[17]) {
+          offset += parseInt(matches[17], 10);
+        }
+        offset *= matches[14] === '-' ? -1 : 1;
+        result -= offset * 60 * 1000;
+      }
+      return new Date(result);
+    }
+  }
+  // end iso8601.js
+
+  function negativeValues(series) {
+    var i, j, data;
+    for (i = 0; i < series.length; i++) {
+      data = series[i].data;
+      for (j = 0; j < data.length; j++) {
+        if (data[j][1] < 0) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  function jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax, setStacked) {
+    return function (series, opts, chartOptions) {
+      var options = merge({}, defaultOptions);
+      options = merge(options, chartOptions || {});
+
+      // hide legend
+      // this is *not* an external option!
+      if (opts.hideLegend) {
+        hideLegend(options);
+      }
+
+      // min
+      if ("min" in opts) {
+        setMin(options, opts.min);
+      } else if (!negativeValues(series)) {
+        setMin(options, 0);
+      }
+
+      // max
+      if ("max" in opts) {
+        setMax(options, opts.max);
+      }
+
+      if (opts.stacked) {
+        setStacked(options);
+      }
+
+      // merge library last
+      options = merge(options, opts.library || {});
+
+      return options;
+    };
+  }
+
+  function setText(element, text) {
+    if (document.body.innerText) {
+      element.innerText = text;
+    } else {
+      element.textContent = text;
+    }
+  }
+
+  function chartError(element, message) {
+    setText(element, "Error Loading Chart: " + message);
+    element.style.color = "#ff0000";
+  }
+
+  function getJSON(element, url, success) {
+    jQuery.ajax({
+      dataType: "json",
+      url: url,
+      success: success,
+      error: function (jqXHR, textStatus, errorThrown) {
+        var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message;
+        chartError(element, message);
+      }
+    });
+  }
+
+  function errorCatcher(element, data, opts, callback) {
+    try {
+      callback(element, data, opts);
+    } catch (err) {
+      chartError(element, err.message);
+      throw err;
+    }
+  }
+
+  function fetchDataSource(element, dataSource, opts, callback) {
+    if (typeof dataSource === "string") {
+      getJSON(element, dataSource, function (data, textStatus, jqXHR) {
+        errorCatcher(element, data, opts, callback);
+      });
+    } else {
+      errorCatcher(element, dataSource, opts, callback);
+    }
+  }
+
+  // type conversions
+
+  function toStr(n) {
+    return "" + n;
+  }
+
+  function toFloat(n) {
+    return parseFloat(n);
+  }
+
+  function toDate(n) {
+    if (typeof n !== "object") {
+      if (typeof n === "number") {
+        n = new Date(n * 1000); // ms
+      } else { // str
+        // try our best to get the str into iso8601
+        // TODO be smarter about this
+        var str = n.replace(/ /, "T").replace(" ", "").replace("UTC", "Z");
+        n = parseISO8601(str) || new Date(n);
+      }
+    }
+    return n;
+  }
+
+  function toArr(n) {
+    if (!isArray(n)) {
+      var arr = [], i;
+      for (i in n) {
+        if (n.hasOwnProperty(i)) {
+          arr.push([i, n[i]]);
+        }
+      }
+      n = arr;
+    }
+    return n;
+  }
+
+  function sortByTime(a, b) {
+    return a[0].getTime() - b[0].getTime();
+  }
+
+  if ("Highcharts" in window) {
+
+    defaultOptions = {
+      chart: {},
+      xAxis: {
+        labels: {
+          style: {
+            fontSize: "12px"
+          }
+        }
+      },
+      yAxis: {
+        title: {
+          text: null
+        },
+        labels: {
+          style: {
+            fontSize: "12px"
+          }
+        }
+      },
+      title: {
+        text: null
+      },
+      credits: {
+        enabled: false
+      },
+      legend: {
+        borderWidth: 0
+      },
+      tooltip: {
+        style: {
+          fontSize: "12px"
+        }
+      },
+      plotOptions: {
+        areaspline: {},
+        series: {
+          marker: {}
+        }
+      }
+    };
+
+    hideLegend = function (options) {
+      options.legend.enabled = false;
+    };
+
+    setMin = function (options, min) {
+      options.yAxis.min = min;
+    };
+
+    setMax = function (options, max) {
+      options.yAxis.max = max;
+    };
+
+    setStacked = function (options) {
+      options.plotOptions.series.stacking = "normal";
+    };
+
+    jsOptions = jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax, setStacked);
+
+    renderLineChart = function (element, series, opts, chartType) {
+      chartType = chartType || "spline";
+      var chartOptions = {};
+      if (chartType === "areaspline") {
+        chartOptions = {
+          plotOptions: {
+            areaspline: {
+              stacking: "normal"
+            },
+            series: {
+              marker: {
+                enabled: false
+              }
+            }
+          }
+        };
+      }
+      var options = jsOptions(series, opts, chartOptions), data, i, j;
+      options.xAxis.type = "datetime";
+      options.chart.type = chartType;
+      options.chart.renderTo = element.id;
+
+      for (i = 0; i < series.length; i++) {
+        data = series[i].data;
+        for (j = 0; j < data.length; j++) {
+          data[j][0] = data[j][0].getTime();
+        }
+        series[i].marker = {symbol: "circle"};
+      }
+      options.series = series;
+      new Highcharts.Chart(options);
+    };
+
+    renderPieChart = function (element, series, opts) {
+      var options = merge(defaultOptions, opts.library || {});
+      options.chart.renderTo = element.id;
+      options.series = [{
+        type: "pie",
+        name: "Value",
+        data: series
+      }];
+      new Highcharts.Chart(options);
+    };
+
+    renderColumnChart = function (element, series, opts, chartType) {
+      chartType = chartType || "column";
+      var options = jsOptions(series, opts), i, j, s, d, rows = [];
+      options.chart.type = chartType;
+      options.chart.renderTo = element.id;
+
+      for (i = 0; i < series.length; i++) {
+        s = series[i];
+
+        for (j = 0; j < s.data.length; j++) {
+          d = s.data[j];
+          if (!rows[d[0]]) {
+            rows[d[0]] = new Array(series.length);
+          }
+          rows[d[0]][i] = d[1];
+        }
+      }
+
+      var categories = [];
+      for (i in rows) {
+        if (rows.hasOwnProperty(i)) {
+          categories.push(i);
+        }
+      }
+      options.xAxis.categories = categories;
+
+      var newSeries = [];
+      for (i = 0; i < series.length; i++) {
+        d = [];
+        for (j = 0; j < categories.length; j++) {
+          d.push(rows[categories[j]][i] || 0);
+        }
+
+        newSeries.push({
+          name: series[i].name,
+          data: d
+        });
+      }
+      options.series = newSeries;
+
+      new Highcharts.Chart(options);
+    };
+
+    renderBarChart = function (element, series, opts) {
+      renderColumnChart(element, series, opts, "bar");
+    };
+
+    renderAreaChart = function (element, series, opts) {
+      renderLineChart(element, series, opts, "areaspline");
+    };
+  } else if ("google" in window) { // Google charts
+    // load from google
+    loaded = false;
+    google.setOnLoadCallback(function () {
+      loaded = true;
+    });
+    var loadOptions = {"packages": ["corechart"]};
+    var config = window.Chartkick || {};
+    if (config.language) {
+      loadOptions.language = config.language;
+    }
+    google.load("visualization", "1.0", loadOptions);
+
+    waitForLoaded = function (callback) {
+      google.setOnLoadCallback(callback); // always do this to prevent race conditions (watch out for other issues due to this)
+      if (loaded) {
+        callback();
+      }
+    };
+
+    // Set chart options
+    defaultOptions = {
+      chartArea: {},
+      fontName: "'Lucida Grande', 'Lucida Sans Unicode', Verdana, Arial, Helvetica, sans-serif",
+      pointSize: 6,
+      legend: {
+        textStyle: {
+          fontSize: 12,
+          color: "#444"
+        },
+        alignment: "center",
+        position: "right"
+      },
+      curveType: "function",
+      hAxis: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        },
+        gridlines: {
+          color: "transparent"
+        },
+        baselineColor: "#ccc",
+        viewWindow: {}
+      },
+      vAxis: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        },
+        baselineColor: "#ccc",
+        viewWindow: {}
+      },
+      tooltip: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        }
+      }
+    };
+
+    hideLegend = function (options) {
+      options.legend.position = "none";
+    };
+
+    setMin = function (options, min) {
+      options.vAxis.viewWindow.min = min;
+    };
+
+    setMax = function (options, max) {
+      options.vAxis.viewWindow.max = max;
+    };
+
+    setBarMin = function (options, min) {
+      options.hAxis.viewWindow.min = min;
+    };
+
+    setBarMax = function (options, max) {
+      options.hAxis.viewWindow.max = max;
+    };
+
+    setStacked = function (options) {
+      options.isStacked = true;
+    };
+
+    jsOptions = jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax, setStacked);
+
+    // cant use object as key
+    createDataTable = function (series, columnType) {
+      var data = new google.visualization.DataTable();
+      data.addColumn(columnType, "");
+
+      var i, j, s, d, key, rows = [];
+      for (i = 0; i < series.length; i++) {
+        s = series[i];
+        data.addColumn("number", s.name);
+
+        for (j = 0; j < s.data.length; j++) {
+          d = s.data[j];
+          key = (columnType === "datetime") ? d[0].getTime() : d[0];
+          if (!rows[key]) {
+            rows[key] = new Array(series.length);
+          }
+          rows[key][i] = toFloat(d[1]);
+        }
+      }
+
+      var rows2 = [];
+      for (i in rows) {
+        if (rows.hasOwnProperty(i)) {
+          rows2.push([(columnType === "datetime") ? new Date(toFloat(i)) : i].concat(rows[i]));
+        }
+      }
+      if (columnType === "datetime") {
+        rows2.sort(sortByTime);
+      }
+      data.addRows(rows2);
+
+      return data;
+    };
+
+    resize = function (callback) {
+      if (window.attachEvent) {
+        window.attachEvent("onresize", callback);
+      } else if (window.addEventListener) {
+        window.addEventListener("resize", callback, true);
+      }
+      callback();
+    };
+
+    renderLineChart = function (element, series, opts) {
+      waitForLoaded(function () {
+        var options = jsOptions(series, opts);
+        var data = createDataTable(series, "datetime");
+        var chart = new google.visualization.LineChart(element);
+        resize(function () {
+          chart.draw(data, options);
+        });
+      });
+    };
+
+    renderPieChart = function (element, series, opts) {
+      waitForLoaded(function () {
+        var chartOptions = {
+          chartArea: {
+            top: "10%",
+            height: "80%"
+          }
+        };
+        var options = merge(merge(defaultOptions, chartOptions), opts.library || {});
+
+        var data = new google.visualization.DataTable();
+        data.addColumn("string", "");
+        data.addColumn("number", "Value");
+        data.addRows(series);
+
+        var chart = new google.visualization.PieChart(element);
+        resize(function () {
+          chart.draw(data, options);
+        });
+      });
+    };
+
+    renderColumnChart = function (element, series, opts) {
+      waitForLoaded(function () {
+        var options = jsOptions(series, opts);
+        var data = createDataTable(series, "string");
+        var chart = new google.visualization.ColumnChart(element);
+        resize(function () {
+          chart.draw(data, options);
+        });
+      });
+    };
+
+    renderBarChart = function (element, series, opts) {
+      waitForLoaded(function () {
+        var chartOptions = {
+          hAxis: {
+            gridlines: {
+              color: "#ccc"
+            }
+          }
+        };
+        var options = jsOptionsFunc(defaultOptions, hideLegend, setBarMin, setBarMax, setStacked)(series, opts, chartOptions);
+        var data = createDataTable(series, "string");
+        var chart = new google.visualization.BarChart(element);
+        resize(function () {
+          chart.draw(data, options);
+        });
+      });
+    };
+
+    renderAreaChart = function (element, series, opts) {
+      waitForLoaded(function () {
+        var chartOptions = {
+          isStacked: true,
+          pointSize: 0,
+          areaOpacity: 0.5
+        };
+        var options = jsOptions(series, opts, chartOptions);
+        var data = createDataTable(series, "datetime");
+        var chart = new google.visualization.AreaChart(element);
+        resize(function () {
+          chart.draw(data, options);
+        });
+      });
+    };
+  } else { // no chart library installed
+    renderLineChart = renderPieChart = renderColumnChart = renderBarChart = renderAreaChart = function () {
+      throw new Error("Please install Google Charts or Highcharts");
+    };
+  }
+
+  // process data
+
+  function processSeries(series, opts, time) {
+    var i, j, data, r, key;
+
+    // see if one series or multiple
+    if (!isArray(series) || typeof series[0] !== "object" || isArray(series[0])) {
+      series = [{name: "Value", data: series}];
+      opts.hideLegend = true;
+    } else {
+      opts.hideLegend = false;
+    }
+
+    // right format
+    for (i = 0; i < series.length; i++) {
+      data = toArr(series[i].data);
+      r = [];
+      for (j = 0; j < data.length; j++) {
+        key = data[j][0];
+        key = time ? toDate(key) : toStr(key);
+        r.push([key, toFloat(data[j][1])]);
+      }
+      if (time) {
+        r.sort(sortByTime);
+      }
+      series[i].data = r;
+    }
+
+    return series;
+  }
+
+  function processLineData(element, data, opts) {
+    renderLineChart(element, processSeries(data, opts, true), opts);
+  }
+
+  function processColumnData(element, data, opts) {
+    renderColumnChart(element, processSeries(data, opts, false), opts);
+  }
+
+  function processPieData(element, data, opts) {
+    var perfectData = toArr(data), i;
+    for (i = 0; i < perfectData.length; i++) {
+      perfectData[i] = [toStr(perfectData[i][0]), toFloat(perfectData[i][1])];
+    }
+    renderPieChart(element, perfectData, opts);
+  }
+
+  function processBarData(element, data, opts) {
+    renderBarChart(element, processSeries(data, opts, false), opts);
+  }
+
+  function processAreaData(element, data, opts) {
+    renderAreaChart(element, processSeries(data, opts, true), opts);
+  }
+
+  function setElement(element, data, opts, callback) {
+    if (typeof element === "string") {
+      element = document.getElementById(element);
+    }
+    fetchDataSource(element, data, opts || {}, callback);
+  }
+
+  // define classes
+
+  Chartkick = {
+    LineChart: function (element, dataSource, opts) {
+      setElement(element, dataSource, opts, processLineData);
+    },
+    PieChart: function (element, dataSource, opts) {
+      setElement(element, dataSource, opts, processPieData);
+    },
+    ColumnChart: function (element, dataSource, opts) {
+      setElement(element, dataSource, opts, processColumnData);
+    },
+    BarChart: function (element, dataSource, opts) {
+      setElement(element, dataSource, opts, processBarData);
+    },
+    AreaChart: function (element, dataSource, opts) {
+      setElement(element, dataSource, opts, processAreaData);
+    }
+  };
+
+  window.Chartkick = Chartkick;
+}());