sitediff 0.0.2 → 1.1.1

data/lib/sitediff/files/sitediff.js

@@ -0,0 +1,367 @@
+/**
+ * @file
+ * SiteDiff report behaviors.
+ */
+
+'use strict';
+
+/* global $ */
+/**
+ * SiteDiff namespace.
+ */
+var SiteDiff = SiteDiff || {};
+
+/**
+ * SiteDiff global map of diffs.
+ */
+SiteDiff.diffs = SiteDiff.diffs || {};
+
+SiteDiff.currentDiff = -1;
+
+/**
+ * Scrolls the document to the said position.
+ *
+ * @param options
+ *   Object specifying various options.
+ *
+ *   x: X position.
+ *   y: Y position.
+ *   animate: Whether to animate.
+ *   callback: A function to call after scrolling.
+ */
+SiteDiff.scrollToPosition = function (options) {
+    // Compute vertical and horizontal adjustments, if any.
+    // Example: Fixed elements, etc.
+    var xFix = 0;
+    var yFix = 0 - 100;
+
+    // Determine final x and y offsets.
+    var x = parseInt(options.x) + xFix;
+    x = Math.max(x, 0);
+    var y = parseInt(options.y) + yFix;
+    y = Math.max(y, 0);
+
+    // Perform the scroll with or without animation.
+    window.scrollTo(x, y);
+
+    // Trigger a callback, if any.
+    if (options.callback) {
+        options.callback();
+    }
+};
+
+/**
+ * Scrolls to a DOM element on the page.
+ *
+ * @param el
+ *   The DOM element.
+ *
+ * @param options
+ *   Object specifying various options.
+ *
+ *   "callback" to trigger after scrolling.
+ */
+SiteDiff.scrollToElement = function (el, options) {
+    options = options || {};
+    var callback = options.callback || function () {};
+
+    // See if the element exists.
+    var $el = $(el).first();
+    if ($el.length == 1) {
+        // Inject callback to focus on the element we scroll to.
+        options.x = 0;
+        options.y = $el.offset().top;
+        options.callback = function () {
+            $el.focus();
+            callback.call(el);
+        };
+        SiteDiff.scrollToPosition(options);
+    }
+};
+
+/**
+ * Initialize behaviors.
+ */
+SiteDiff.init = function () {
+    // On the overview page.
+    switch ($(document.body).data('page')) {
+    case 'overview':
+        SiteDiff.initFilterForm();
+        break;
+
+    case 'diff':
+        SiteDiff.jumpToFirstDiff();
+        break;
+    }
+};
+
+/**
+ * Initializes report filters and overlay.
+ */
+SiteDiff.initFilterForm = function () {
+    SiteDiff.initDiffArray();
+    SiteDiff.initStatusFilter();
+    SiteDiff.initSearchFilter();
+    SiteDiff.initOverlay();
+    SiteDiff.initClickHandlers();
+};
+
+/**
+ * Initialize global diff array
+ *
+ */
+SiteDiff.initDiffArray = function() {
+    SiteDiff.diffs = $('.button-diff').map(function (i, element) {
+        var $el = $(element);
+        $el.data('diffindex', i);
+        return {
+            diff: $el.attr('href'),
+            element: $el,
+            index: i,
+            path: $el.parents('.description').find('.path').text()
+        };
+    });
+};
+
+/**
+ * Initializes the "status" filter.
+ */
+SiteDiff.initStatusFilter = function () {
+    $('.form-item--status input')
+        .on('change', function () {
+            // Get a list of applied filters.
+            var appliedFilters = $('.form-item--status input:checked')
+                .map(function () {
+                    return this.getAttribute('value');
+                    // applied.push(this.getAttribute('value'));
+                });
+            // Show only matching results, hide the rest.
+            $('#sitediff-report')
+                .find('.sitediff-result')
+                .each(function () {
+                    var $row = $(this);
+                    var status = $row.data('status');
+                    if (
+                        // Row matches applied filters.
+                        $.inArray(status, appliedFilters) > -1 ||
+                        // No filters are applied.
+                        appliedFilters.length === 0
+                    ) {
+                        $row.removeAttr('hidden');
+                    }
+                    else {
+                        $row.attr('hidden', 'hidden');
+                    }
+                });
+        });
+};
+
+/**
+ * Initializes the "search" filter.
+ */
+SiteDiff.initSearchFilter = function () {
+    $('#input-search')
+        .on('change keyup', function () {
+            var keyword = $(this).val().toLowerCase();
+
+            // Filter the records.
+            // TODO: Trigger one event per 250ms.
+            $('#sitediff-report')
+                .find('.sitediff-result')
+                .each(function () {
+                    var $row = $(this);
+                    var path = $row.find('.path').text();
+
+                    // If keyword matches, keep the row visible.
+                    if (path.toLowerCase().indexOf(keyword) > -1) {
+                        $row.attr('hidden', null);
+                    }
+                    else {
+                        $row.attr('hidden', 'hidden');
+                    }
+                });
+        });
+};
+
+/**
+ * Set up the diff overlay to be displayed.
+ */
+SiteDiff.initOverlay = function () {
+    if (SiteDiff.diffs.length <= 0) return;
+
+    // add overlay
+    $('body').append($(
+        '<div class="overlay" style="display: none;"><div class="overlay__inner"><header>' +
+        '<div class="path"></div>' +
+        '<div class="prev"><a href="#" title="Previous diff (left arrow)">< Prev</a></div>' +
+        '<div class="next"><a href="#" title="Next diff (right arrow)">Next ></a></div>' +
+        '<div class="exit"><a href="#" title="Close diff display (Esc)">Close</a></div>' +
+        '</header><article></article></div></div>'));
+    // add header click handlers
+    $('.overlay header .exit').click(function (event) {
+        event.preventDefault();
+        SiteDiff.destroyOverlay();
+    });
+    $('.overlay header .prev').click(function (event) {
+        event.preventDefault();
+        SiteDiff.prevDiff();
+    });
+    $('.overlay header .next').click(function (event) {
+        event.preventDefault();
+        SiteDiff.nextDiff();
+    });
+
+};
+
+/**
+ * Set up click handlers for all diff buttons
+ */
+SiteDiff.initClickHandlers = function () {
+    SiteDiff.diffs.each( function (i, diff) {
+        diff.element.click({index: i}, function (event) {
+            event.preventDefault();
+            SiteDiff.openOverlay(event.data.index);
+        });
+    });
+};
+
+/**
+ * Set up key handlers for overlay.
+ */
+SiteDiff.initKeyHandlers = function () {
+    $(document).keyup(function (event) {
+        switch (event.which) {
+        case 37:
+            SiteDiff.prevDiff();
+            break;
+        case 39:
+            SiteDiff.nextDiff();
+            break;
+        case 27:
+            SiteDiff.destroyOverlay();
+            break;
+        }
+    });
+};
+
+/**
+ * Remove overlay key handlers.
+ */
+SiteDiff.removeKeyHandlers = function () {
+    $(document).off('keyup');
+};
+
+/**
+ * Open overlay for the diff identified by the `index`.
+ *
+ * @param integer index
+ *      The index of the diff to be viewed.
+ */
+SiteDiff.openOverlay = function (index) {
+    SiteDiff.currentDiff = index;
+    SiteDiff.showDiff();
+    SiteDiff.initKeyHandlers();
+    $('.overlay').fadeIn(300);
+};
+
+/**
+ * Create the iframe to display the current diff.
+ */
+SiteDiff.showDiff = function () {
+    var diff = SiteDiff.diffs[SiteDiff.currentDiff];
+    var iframe = '<iframe src="' + diff.diff + '"></iframe>';
+    $('.overlay header .path').text(diff.path);
+    SiteDiff.setPrevNext();
+    $('.overlay article').html(iframe);
+};
+
+/**
+ * Hide the overlay and clean up.
+ */
+SiteDiff.destroyOverlay = function () {
+    $('.overlay article').empty();
+    SiteDiff.removeKeyHandlers();
+    $('.overlay').fadeOut(300, SiteDiff.scrollToButton);
+};
+
+/**
+ * Display the previous diff.
+ */
+SiteDiff.prevDiff = function () {
+    if (SiteDiff.currentDiff > 0) {
+        SiteDiff.currentDiff--;
+        SiteDiff.showDiff();
+    }
+};
+
+/**
+ * Display the next diff.
+ */
+SiteDiff.nextDiff = function () {
+    if (SiteDiff.currentDiff < SiteDiff.diffs.length - 1) {
+        SiteDiff.currentDiff++;
+        SiteDiff.showDiff();
+    }
+};
+
+/**
+ * Enable or disable prev and next buttons based on current diff.
+ */
+SiteDiff.setPrevNext = function () {
+    if (SiteDiff.currentDiff <= 0) {
+        // set prev disabled
+        $('.overlay header .prev').addClass('disabled');
+    }
+    else {
+        $('.overlay header .prev.disabled').removeClass('disabled');
+    }
+    if (SiteDiff.currentDiff >= SiteDiff.diffs.length - 1) {
+        // set next disabled
+        $('.overlay header .next').addClass('disabled');
+    }
+    else {
+        $('.overlay header .next.disabled').removeClass('disabled');
+    }
+};
+
+/**
+ * Scroll to the button associated with the current diff.
+ */
+SiteDiff.scrollToButton = function () {
+    var $diffButton = SiteDiff.diffs[SiteDiff.currentDiff].element;
+    if (! SiteDiff.isElementVisible($diffButton)) {
+        SiteDiff.scrollToElement($diffButton);
+    }
+};
+
+/**
+ * Check if an element is at least partly visible.
+ * @param element
+ */
+SiteDiff.isElementVisible = function (element) {
+    var topVisible = $(window).scrollTop();
+    var bottomVisible = topVisible + $(window).height();
+    var elemTop = $(element).offset().top;
+    var elemBottom = elemTop + $(element).height();
+    return ((elemBottom <= bottomVisible) && (elemTop >= topVisible));
+};
+
+/**
+ * Jumps to the first diff on the page.
+ */
+SiteDiff.jumpToFirstDiff = function () {
+    // Get the first diff hunk.
+    var $diff = $('#diff-container')
+        .find('.del, .ins')
+        .first();
+    if ($diff.length === 0) {
+        return;
+    }
+
+    // Scroll the window to it!
+    setTimeout(function () {
+        SiteDiff.scrollToElement($diff[0]);
+    }, 250);
+};
+
+$(document).ready(SiteDiff.init);

data/lib/sitediff/report.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'minitar'
+require 'sitediff'
+require 'sitediff/config'
+require 'zlib'
+
+class SiteDiff
+  ##
+  # SiteDiff Report Helper.
+  class Report
+    attr_reader :results, :cache
+
+    ##
+    # Directory where diffs will be generated.
+    DIFFS_DIR = 'diffs'
+
+    ##
+    # Name of file containing a list of pages with diffs.
+    FAILURES_FILE = 'failures.txt'
+
+    ##
+    # Name of file containing HTML report of diffs.
+    REPORT_FILE_HTML = 'report.html'
+
+    ##
+    # Name of file containing JSON report of diffs.
+    REPORT_FILE_JSON = 'report.json'
+
+    ##
+    # Name of file containing exported file archive.
+    REPORT_FILE_TAR = 'report.tgz'
+
+    ##
+    # Name of directory in which to build the portable report.
+    REPORT_BUILD_DIR = '_tmp_report'
+
+    ##
+    # Name of the portable report directory.
+    REPORT_DIR = 'report'
+
+    ##
+    # Path to settings used for report.
+    SETTINGS_FILE = 'settings.yaml'
+
+    ##
+    # Creates a Reporter object.
+    #
+    # @param [Config] config.
+    # @param [Cache] cache.
+    # @param [Array] results.
+    def initialize(config, cache, results)
+      @config = config
+      @cache = cache
+      @results = results
+    end
+
+    ##
+    # Generates an HTML report.
+    #
+    # @param [String] dir
+    #   The directory in which the report is to be generated.
+    def generate_html(
+      dir,
+      report_before = nil,
+      report_after = nil
+    )
+      report_before ||= @config.before_url
+      report_after ||= @config.after_url
+      @config.before_time = get_timestamp(:before)
+      @config.after_time = get_timestamp(:after)
+
+      dir = SiteDiff.ensure_dir dir
+
+      write_diffs dir
+      write_failures dir
+
+      # Prepare report.
+      report = Diff.generate_html(
+        @results,
+        report_before,
+        report_after,
+        @cache,
+        @config
+      )
+
+      # Write report.
+      report_file = dir + REPORT_FILE_HTML
+      report_file.unlink if report_file.file?
+      report_file.open('w') { |f| f.write(report) }
+
+      write_settings dir, report_before, report_after
+
+      if @config.export
+        package_report(dir)
+      else
+        SiteDiff.log 'Report generated to ' + report_file.expand_path.to_s
+      end
+    end
+
+    ##
+    # Generates a JSON report.
+    #
+    # @param dir
+    #   The directory in which the report is to be generated.
+    def generate_json(dir)
+      dir = SiteDiff.ensure_dir dir
+      write_diffs dir
+      write_failures dir
+
+      # Prepare report.
+      report = {
+        paths_compared: @results.length,
+        paths_diffs: 0,
+        paths: {}
+      }
+      @results.each do |item|
+        report[:paths_diffs] += 1 unless item.success?
+
+        item_report = {
+          path: item.path,
+          status: item.status,
+          message: item.error
+        }
+        report[:paths][item.path] = item_report
+      end
+      report = JSON report
+
+      # Write report.
+      report_file = dir + REPORT_FILE_JSON
+      report_file.unlink if report_file.file?
+      report_file.open('w') { |f| f.write(report) }
+
+      write_settings dir
+
+      SiteDiff.log 'Report generated to ' + report_file.expand_path.to_s
+    end
+
+    ##
+    # Package report for export.
+    def package_report(dir)
+      # Create temporaryreport directories.
+      temp_path = dir + REPORT_BUILD_DIR
+      temp_path.rmtree if temp_path.directory?
+      temp_path.mkpath
+      report_path = temp_path + REPORT_DIR
+      report_path.mkpath
+      files_path = report_path + 'files'
+      files_path.mkpath
+      diffs_path = dir + DIFFS_DIR
+
+      # Move files to place.
+      FileUtils.move(dir + REPORT_FILE_HTML, report_path)
+      FileUtils.move(diffs_path, files_path) if diffs_path.directory?
+
+      # Make tar file.
+      Dir.chdir(temp_path) do
+        Minitar.pack(
+          REPORT_DIR,
+          Zlib::GzipWriter.new(File.open(REPORT_FILE_TAR, 'wb'))
+        )
+      end
+      FileUtils.move(temp_path + REPORT_FILE_TAR, dir)
+      temp_path.rmtree
+      SiteDiff.log 'Archived report generated to ' + dir.join(REPORT_FILE_TAR).to_s
+    end
+
+    ##
+    # Creates diff files in a directory named "diffs".
+    #
+    # If "dir" is /foo/bar, then diffs will be placed in /foo/bar/diffs.
+    #
+    # @param [Pathname] dir
+    #   The directory in which a "diffs" directory is to be generated.
+    def write_diffs(dir)
+      raise Exception 'dir must be a Pathname' unless dir.is_a? Pathname
+
+      # Delete existing "diffs" dir, if exists.
+      diff_dir = dir + DIFFS_DIR
+      diff_dir.rmtree if diff_dir.exist?
+
+      # Write diffs to the diff directory.
+      @results.each { |r| r.dump(dir, @config.export) if r.status == Result::STATUS_FAILURE }
+      SiteDiff.log "All diff files written to #{diff_dir.expand_path}" unless @config.export
+    end
+
+    ##
+    # Writes paths with diffs into a file.
+    #
+    # @param [Pathname] dir
+    #   The directory in which the report is to be generated.
+    def write_failures(dir)
+      raise Exception 'dir must be a Pathname' unless dir.is_a? Pathname
+
+      failures = dir + FAILURES_FILE
+      SiteDiff.log "All failures written to #{failures.expand_path}"
+      failures.open('w') do |f|
+        @results.each { |r| f.puts r.path unless r.success? }
+      end
+    end
+
+    ##
+    # Creates report settings.yaml file.
+    #
+    # TODO: Find a way to avoid having to create this file.
+    #
+    # @param [Pathname] dir
+    #   The directory in which the report is to be generated.
+    def write_settings(dir, report_before = nil, report_after = nil)
+      raise Exception 'dir must be a Pathname' unless dir.is_a? Pathname
+
+      settings = {
+        'before' => report_before,
+        'after' => report_after,
+        'cached' => %w[before after]
+      }
+      dir.+(SETTINGS_FILE).open('w') { |f| YAML.dump(settings, f) }
+    end
+
+    ##
+    # Returns CSS for HTML report.
+    def self.css
+      output = ''
+      output += File.read(File.join(SiteDiff::FILES_DIR, 'normalize.css'))
+      output += File.read(File.join(SiteDiff::FILES_DIR, 'sitediff.css'))
+      output
+    end
+
+    ##
+    # Returns JS for HTML report.
+    def self.js
+      output = ''
+      output += File.read(File.join(SiteDiff::FILES_DIR, 'jquery.min.js'))
+      output += File.read(File.join(SiteDiff::FILES_DIR, 'sitediff.js'))
+      output
+    end
+
+    private
+
+    # Get crawl timestamps
+    def get_timestamp(tag)
+      timestamp_file = File.join(@config.directory, 'snapshot', tag.to_s, SiteDiff::Cache::TIMESTAMP_FILE)
+      if File.exist? timestamp_file
+        file = File::Stat.new(timestamp_file)
+        time = file.mtime
+        time.class == Time ? time.strftime('%Y-%m-%d %H:%M') : ''
+      else
+        'unknown'
+      end
+    end
+  end
+end