RubyGems - crazy_ivan - Versions diffs - 0.2.0 - Mend

crazy_ivan 0.2.0

Files changed (133) hide show

data/lib/crazy_ivan.rb ADDED Viewed

@@ -0,0 +1,5 @@
+require 'fileutils'
+require 'yaml'
+require File.join(File.dirname(__FILE__), 'report_assembler')
+require File.join(File.dirname(__FILE__), 'test_runner')
+require File.join(File.dirname(__FILE__), 'html_asset_crush')

data/lib/html_asset_crush.rb ADDED Viewed

@@ -0,0 +1,56 @@
+# Parses an html file's <head> section,
+# looks for <script ... > and <link rel="stylesheet" ... >
+# and crunches them all together into one file
+#
+# Warning: this script is super-ghetto and probably not robust.
+# If you're concerned, use a real lexer/parser.
+require 'strscan'
+module HtmlAssetCrush
+  def self.source_for(asset_path)
+    case asset_path
+    when /js$/
+      <<-JS
+      <script type="text/javascript" charset="utf-8">
+        #{File.open(asset_path).read}
+      </script>
+      JS
+    when /css$/
+      <<-CSS
+      <style type="text/css">
+        #{File.open(asset_path).read}
+      </style>
+      CSS
+    end
+  rescue Errno::ENOENT
+    raise "Could not find #{asset_path} to bring in"
+  end
+  def self.crush(html_filepath)
+    Dir.chdir(File.dirname(html_filepath)) do
+      html = File.open(html_filepath).read
+      crushed_html = ""
+      s = StringScanner.new(html)
+      js = /<script.+? src=['"](.+)['"].+?\/script>/
+      css = /<link .+? href=['"](.+?)['"].+?>/
+      asset = Regexp.union(js, css)
+      while result = s.scan_until(asset) do
+        asset_path = s[2] || s[1]
+        # Weird that pre_match doesn't do this
+        # crushed_html << s.pre_match
+        crushed_html << result[0...(-s.matched_size)]
+        crushed_html << source_for(asset_path) + "\n"
+      end
+      crushed_html << s.rest
+      return crushed_html
+    end
+  end
+end

data/lib/report_assembler.rb ADDED Viewed

@@ -0,0 +1,78 @@
+class ReportAssembler
+  MAXIMUM_RECENTS = 10
+  ROOT_PATH = File.expand_path(File.dirname(__FILE__))
+  TEMPLATES_PATH = File.join(ROOT_PATH, *%w[.. templates])
+  attr_accessor :test_results
+  def initialize(output_directory)
+    @test_results = []
+    @output_directory = output_directory
+  end
+  def generate
+    Dir.chdir(@output_directory) do
+      @test_results.each do |result|
+        update_project(result)
+      end
+      update_projects
+      update_index
+    end
+  end
+  def version(string)
+    string[0..240]
+  end
+  def update_project(result)
+    FileUtils.mkdir_p(result.project_name)
+    Dir.chdir(result.project_name) do
+      File.open("#{version(result.version_output)}.json", 'w+') do |f|
+        f.puts({
+                 "version" => result.version_output,
+                 "timestamp" => result.timestamp,
+                 "update" => result.update_output,
+                 "update_error" => result.update_error,
+                 "test" => result.test_output,
+                 "test_error" => result.test_error
+               }.to_json)
+      end
+      update_recent(result)
+    end
+  end
+  def update_recent(result)
+    recent_versions_json = File.open('recent.json', File::RDWR|File::CREAT).read
+    recent_versions = []
+    if !recent_versions_json.empty?
+      recent_versions = JSON.parse(recent_versions_json)["recent_versions"]
+    end
+    recent_versions << version(result.version_output)
+    recent_versions.shift if recent_versions.size > MAXIMUM_RECENTS
+    File.open('recent.json', 'w+') do |f|
+      f.print "{\"recent_versions\": [#{recent_versions.map {|v| "\"#{v}\""}.join(', ')}]}"
+    end
+  end
+  def update_projects
+    projects = @test_results.map {|r| "\"#{r.project_name}\""}
+    File.open('projects.json', 'w+') do |f|
+      f.print "{\"projects\": [#{projects.join(', ')}]}"
+    end
+  end
+  def update_index
+    index_template = HtmlAssetCrush.crush(File.join(TEMPLATES_PATH, "index.html"))
+    File.open('index.html', 'w+') do |f|
+      f.print index_template
+    end
+  end
+end

data/lib/test_runner.rb ADDED Viewed

@@ -0,0 +1,71 @@
+require 'open3'
+class TestRunner
+  class Result < Struct.new(:project_name, :update_output, :version_output, :test_output, :update_error, :test_error, :timestamp)
+  end
+  def initialize(project_path)
+    @project_path = project_path
+  end
+  def valid?
+    check_script('update')
+    check_script('version')
+    check_script('test')
+    return true
+  end
+  def script_path(name)
+    script_path = File.join('.ci', name)
+  end
+  def check_script(name)
+    script_path = script_path(name)
+    Dir.chdir(@project_path) do
+      if File.exists?(script_path)
+        if !File.stat(script_path).executable?
+          abort "#{@project_path}/.ci/#{name} script not executable"
+        elsif File.open(script_path).read.empty?
+          abort "#{@project_path}/.ci/#{name} script empty"
+        end
+      else
+        abort "#{@project_path}/.ci/#{name} script missing"
+      end
+    end
+  end
+  def run_script(name)
+    output = ''
+    error = ''
+    Dir.chdir(@project_path) do
+      Open3.popen3(script_path(name)) do |stdin, stdout, stderr|
+        stdin.close  # Close to prevent hanging if the script wants input
+        output = stdout.read
+        error = stderr.read
+      end
+    end
+    return output.chomp, error.chomp
+  end
+  def invoke
+    if valid?
+      project_name = @project_path.split(File::SEPARATOR).last
+      results = Result.new(project_name)
+      results.version_output = run_script('version').join
+      results.update_output, results.update_error = run_script('update')
+      if results.update_error.empty?
+        results.test_output, results.test_error = run_script('test')
+      end
+      results.timestamp = Time.now
+      return results
+    end
+  end
+end

data/templates/css/ci.css ADDED Viewed

@@ -0,0 +1,11 @@
+body {
+  margin: 2.5em 3em;
+  padding: 0;
+  background: #fff;
+  color: #333;
+  font: 100%/1.5 Calibri, "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+td {
+  vertical-align: top;
+}

data/templates/index.html ADDED Viewed

@@ -0,0 +1,105 @@
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>Crazy Ivan: CI straight up.</title>
+    <link rel="stylesheet" href="css/ci.css" type="text/css" charset="utf-8">
+    <script type="text/javascript" src="javascript/prototype.js"></script>
+    <script type="text/javascript" src="javascript/json-template.js"></script>
+    <script type="text/javascript">
+      var init = function() {
+        render('index.jsont', projects());
+      }
+      var projects = function() {
+        var projects = [];
+        var project_names = [];
+        new Ajax.Request('projects.json', {
+          asynchronous: false,
+          onSuccess: function(transport) {
+            project_names = transport.responseText.evalJSON().projects;
+          }
+        });
+        project_names.each(function(project_name) {
+          var reports = [];
+          reports = recent_versions(project_name).map(function(version) {
+            return version_test_report(project_name, version);
+          })
+          project = {name: project_name, reports: reports};
+          projects.push(project);
+        })
+        return {"projects": projects};
+      }
+      var recent_versions = function(project) {
+        var recent_versions = [];
+        new Ajax.Request(project + '/recent.json', {
+          asynchronous: false,
+          onSuccess: function(transport) {
+            recent_versions = transport.responseText.evalJSON().recent_versions;
+          }
+        });
+        return recent_versions;
+      }
+      var version_test_report = function(project, version) {
+        var report = {};
+        url = project + '/' + version + '.json';
+        new Ajax.Request(url, {
+          asynchronous: false,
+          onSuccess: function(transport) {
+            report = transport.responseText.evalJSON();
+          }
+        });
+        return report;
+      }
+      var render = function(template_name, json) {
+        var template = jsontemplate.Template("                                             \
+          {.section projects}                                                              \
+            {.repeated section @}                                                          \
+              <h2>{name}</h2>                                                              \
+              {.section reports}                                                           \
+                <table>                                                                    \
+                  <tr>                                                                     \
+                    <th>Version</th>                                                       \
+                    <th>Update Result</th>                                                 \
+                    <th>Update Errors</th>                                                 \
+                    <th>Test Result</th>                                                   \
+                    <th>Test Errors</th>                                                   \
+                  </tr>                                                                    \
+                  {.repeated section @}                                                    \
+                    <tr>                                                                   \
+                      <td>{timestamp}</td>                                                 \
+                      <td>{version}</td>                                                   \
+                      <td>{update}</td>                                                    \
+                      <td>{update_error}</td>                                              \
+                      <td>{test}</td>                                                      \
+                      <td>{test_error}</td>                                                \
+                    </tr>                                                                  \
+                  {.end}                                                                   \
+                </table>                                                                   \
+              {.or}                                                                        \
+                <p>No test reports found. Please run the `ci` executable.</p>              \
+              {.end}                                                                       \
+            {.end}                                                                         \
+          {.or}                                                                            \
+            <p>No projects found.</p>                                                      \
+          {.end}                                                                           \
+        ");
+        var html = template.expand(json);
+        $("replace").update(html);
+      }
+    </script>
+  </head>
+  <body onload="init();">
+    <div id="replace"></div>
+  </body>
+</html>

data/templates/javascript/json-template.js ADDED Viewed

@@ -0,0 +1,544 @@
+// Copyright (C) 2009 Andy Chu
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// $Id: json-template.js 271 2009-05-31 19:35:43Z andy@chubot.org $
+//
+// JavaScript implementation of json-template.
+//
+// This is predefined in tests, shouldn't be defined anywhere else.  TODO: Do
+// something nicer.
+var log = log || function() {};
+var repr = repr || function() {};
+// The "module" exported by this script is called "jsontemplate":
+var jsontemplate = function() {
+// Regex escaping for common metacharacters (note that JavaScript needs 2 \\ --
+// no raw strings!
+var META_ESCAPE = {
+  '{': '\\{',
+  '}': '\\}',
+  '{{': '\\{\\{',
+  '}}': '\\}\\}',
+  '[': '\\[',
+  ']': '\\]'
+};
+function _MakeTokenRegex(meta_left, meta_right) {
+  // TODO: check errors
+  return new RegExp(
+      '(' +
+      META_ESCAPE[meta_left] +
+      '.+?' +
+      META_ESCAPE[meta_right] +
+      '\n?)', 'g');  // global for use with .exec()
+}
+//
+// Formatters
+//
+function HtmlEscape(s) {
+  return s.replace(/&/g,'&amp;').
+           replace(/>/g,'&gt;').
+           replace(/</g,'&lt;');
+}
+function HtmlTagEscape(s) {
+  return s.replace(/&/g,'&amp;').
+           replace(/>/g,'&gt;').
+           replace(/</g,'&lt;').
+           replace(/"/g,'&quot;');
+}
+// Default ToString can be changed
+function ToString(s) {
+  return s.toString();
+}
+var DEFAULT_FORMATTERS = {
+  'html': HtmlEscape,
+  'htmltag': HtmlTagEscape,
+  'html-attr-value': HtmlTagEscape,
+  'str': ToString,
+  'raw': function(x) {return x;}
+};
+//
+// Template implementation
+//
+function _ScopedContext(context, undefined_str) {
+  // The stack contains:
+  //   The current context (an object).
+  //   An iteration index.  -1 means we're NOT iterating.
+  var stack = [{context: context, index: -1}];
+  return {
+    PushSection: function(name) {
+      log('PushSection '+name);
+      if (name === undefined || name === null) {
+        return null;
+      }
+      var new_context = stack[stack.length-1].context[name] || null;
+      stack.push({context: new_context, index: -1});
+      return new_context;
+    },
+    Pop: function() {
+      stack.pop();
+    },
+    next: function() {
+      var stacktop = stack[stack.length-1];
+      // Now we're iterating -- push a new mutable object onto the stack
+      if (stacktop.index == -1) {
+        stacktop = {context: null, index: 0};
+        stack.push(stacktop);
+      }
+      // The thing we're iterating over
+      var context_array = stack[stack.length - 2].context;
+      // We're already done
+      if (stacktop.index == context_array.length) {
+        stack.pop();
+        log('next: null');
+        return null;  // sentinel to say that we're done
+      }
+      log('next: ' + stacktop.index);
+      stacktop.context = context_array[stacktop.index++];
+      log('next: true');
+      return true;  // OK, we mutated the stack
+    },
+    CursorValue: function() {
+      return stack[stack.length - 1].context;
+    },
+    _Undefined: function(name) {
+      if (undefined_str === undefined) {
+        throw {
+          name: 'UndefinedVariable', message: name + ' is not defined'
+        };
+      } else {
+        return undefined_str;
+      }
+    },
+    _LookUpStack: function(name) {
+      var i = stack.length - 1;
+      while (true) {
+        var context = stack[i].context;
+        log('context '+repr(context));
+        if (typeof context !== 'object') {
+          i--;
+        } else {
+          var value = context[name];
+          if (value === undefined || value === null) {
+            i--;
+          } else {
+            return value;
+          }
+        }
+        if (i <= -1) {
+          return this._Undefined(name);
+        }
+      }
+    },
+    Lookup: function(name) {
+      var parts = name.split('.');
+      var value = this._LookUpStack(parts[0]);
+      if (parts.length > 1) {
+        for (var i=1; i<parts.length; i++) {
+          value = value[parts[i]];
+          if (value === undefined) {
+            return this._Undefined(parts[i]);
+          }
+        }
+      }
+      return value;
+    }
+  };
+}
+function _Section(section_name) {
+  var current_clause = [];
+  var statements = {'default': current_clause};
+  return {
+    section_name: section_name, // public attribute
+    Statements: function(clause) {
+      clause = clause || 'default';
+      return statements[clause] || [];
+    },
+    NewClause: function(clause_name) {
+      var new_clause = [];
+      statements[clause_name] = new_clause;
+      current_clause = new_clause;
+    },
+    Append: function(statement) {
+      current_clause.push(statement);
+    }
+  };
+}
+function _Execute(statements, context, callback) {
+  var i;
+  for (i=0; i<statements.length; i++) {
+    statement = statements[i];
+    //log('Executing ' + statement);
+    if (typeof(statement) == 'string') {
+      callback(statement);
+    } else {
+      var func = statement[0];
+      var args = statement[1];
+      func(args, context, callback);
+    }
+  }
+}
+function _DoSubstitute(statement, context, callback) {
+  log('Substituting: '+ statement.name);
+  var value;
+  if (statement.name == '@') {
+    value = context.CursorValue();
+  } else {
+    value = context.Lookup(statement.name);
+  }
+  // Format values
+  for (i=0; i<statement.formatters.length; i++) {
+    value = statement.formatters[i](value);
+  }
+  callback(value);
+}
+// for [section foo]
+function _DoSection(args, context, callback) {
+  var block = args;
+  var value = context.PushSection(block.section_name);
+  var do_section = false;
+  // "truthy" values should have their sections executed.
+  if (value) {
+    do_section = true;
+  }
+  // Except: if the value is a zero-length array (which is "truthy")
+  if (value && value.length === 0) {
+    do_section = false;
+  }
+  if (do_section) {
+    _Execute(block.Statements(), context, callback);
+    context.Pop();
+  } else {  // Empty list, None, False, etc.
+    context.Pop();
+    _Execute(block.Statements('or'), context, callback);
+  }
+}
+function _DoRepeatedSection(args, context, callback) {
+  var block = args;
+  var pushed;
+  if (block.section_name == '@') {
+    // If the name is @, we stay in the enclosing context, but assume it's a
+    // list, and repeat this block many times.
+    items = context.CursorValue();
+    // TODO: check that items is an array; apparently this is hard in JavaScript
+    //if type(items) is not list:
+    //  raise EvaluationError('Expected a list; got %s' % type(items))
+    pushed = false;
+  } else {
+    items = context.PushSection(block.section_name);
+    pushed = true;
+  }
+  //log('ITEMS: '+showArray(items));
+  if (items && items.length > 0) {
+    // Execute the statements in the block for every item in the list.
+    // Execute the alternate block on every iteration except the last.  Each
+    // item could be an atom (string, integer, etc.) or a dictionary.
+    var last_index = items.length - 1;
+    var statements = block.Statements();
+    var alt_statements = block.Statements('alternate');
+    for (var i=0; context.next() !== null; i++) {
+      log('_DoRepeatedSection i: ' +i);
+      _Execute(statements, context, callback);
+      if (i != last_index) {
+        log('ALTERNATE');
+        _Execute(alt_statements, context, callback);
+      }
+    }
+  } else {
+    log('OR: '+block.Statements('or'));
+    _Execute(block.Statements('or'), context, callback);
+  }
+  if (pushed) {
+    context.Pop();
+  }
+}
+var _SECTION_RE = /(repeated)?\s*(section)\s+(\S+)?/;
+// TODO: The compile function could be in a different module, in case we want to
+// compile on the server side.
+function _Compile(template_str, options) {
+  var more_formatters = options.more_formatters ||
+                        function (x) { return null; };
+  // We want to allow an explicit null value for default_formatter, which means
+  // that an error is raised if no formatter is specified.
+  var default_formatter;
+  if (options.default_formatter === undefined) {
+    default_formatter = 'str';
+  } else {
+    default_formatter = options.default_formatter;
+  }
+  function GetFormatter(format_str) {
+    var formatter = more_formatters(format_str) ||
+                    DEFAULT_FORMATTERS[format_str];
+    if (formatter === undefined) {
+      throw {
+        name: 'BadFormatter',
+        message: format_str + ' is not a valid formatter'
+      };
+    }
+    return formatter;
+  }
+  var format_char = options.format_char || '|';
+  if (format_char != ':' && format_char != '|') {
+    throw {
+      name: 'ConfigurationError',
+      message: 'Only format characters : and | are accepted'
+    };
+  }
+  var meta = options.meta || '{}';
+  var n = meta.length;
+  if (n % 2 == 1) {
+    throw {
+      name: 'ConfigurationError',
+      message: meta + ' has an odd number of metacharacters'
+    };
+  }
+  var meta_left = meta.substring(0, n/2);
+  var meta_right = meta.substring(n/2, n);
+  var token_re = _MakeTokenRegex(meta_left, meta_right);
+  var current_block = _Section();
+  var stack = [current_block];
+  var strip_num = meta_left.length;  // assume they're the same length
+  var token_match;
+  var last_index = 0;
+  while (true) {
+    token_match = token_re.exec(template_str);
+    log('match:', token_match);
+    if (token_match === null) {
+      break;
+    } else {
+      var token = token_match[0];
+    }
+    log('last_index: '+ last_index);
+    log('token_match.index: '+ token_match.index);
+    // Add the previous literal to the program
+    if (token_match.index > last_index) {
+      var tok = template_str.slice(last_index, token_match.index);
+      current_block.Append(tok);
+      log('tok: "'+ tok+'"');
+    }
+    last_index = token_re.lastIndex;
+    log('token0: "'+ token+'"');
+    var had_newline = false;
+    if (token.slice(-1) == '\n') {
+      token = token.slice(null, -1);
+      had_newline = true;
+    }
+    token = token.slice(strip_num, -strip_num);
+    if (token.charAt(0) == '#') {
+      continue;  // comment
+    }
+    if (token.charAt(0) == '.') {  // Keyword
+      token = token.substring(1, token.length);
+      var literal = {
+          'meta-left': meta_left,
+          'meta-right': meta_right,
+          'space': ' ',
+          'tab': '\t',
+          'newline': '\n'
+          }[token];
+      if (literal !== undefined) {
+        current_block.Append(literal);
+        continue;
+      }
+      var section_match = token.match(_SECTION_RE);
+      if (section_match) {
+        var repeated = section_match[1];
+        var section_name = section_match[3];
+        var func = repeated ? _DoRepeatedSection : _DoSection;
+        log('repeated ' + repeated + ' section_name ' + section_name);
+        var new_block = _Section(section_name);
+        current_block.Append([func, new_block]);
+        stack.push(new_block);
+        current_block = new_block;
+        continue;
+      }
+      if (token == 'alternates with') {
+        current_block.NewClause('alternate');
+        continue;
+      }
+      if (token == 'or') {
+        current_block.NewClause('or');
+        continue;
+      }
+      if (token == 'end') {
+        // End the block
+        stack.pop();
+        if (stack.length > 0) {
+          current_block = stack[stack.length-1];
+        } else {
+          throw {
+            name: 'TemplateSyntaxError',
+            message: 'Got too many {end} statements'
+          };
+        }
+        continue;
+      }
+    }
+    // A variable substitution
+    var parts = token.split(format_char);
+    var formatters;
+    var name;
+    if (parts.length == 1) {
+      if (default_formatter === null) {
+          throw {
+            name: 'MissingFormatter',
+            message: 'This template requires explicit formatters.'
+          };
+      }
+      // If no formatter is specified, the default is the 'str' formatter,
+      // which the user can define however they desire.
+      formatters = [GetFormatter(default_formatter)];
+      name = token;
+    } else {
+      formatters = [];
+      for (var j=1; j<parts.length; j++) {
+        formatters.push(GetFormatter(parts[j]));
+      }
+      name = parts[0];
+    }
+    current_block.Append(
+        [_DoSubstitute, { name: name, formatters: formatters}]);
+    if (had_newline) {
+      current_block.Append('\n');
+    }
+  }
+  // Add the trailing literal
+  current_block.Append(template_str.slice(last_index));
+  if (stack.length !== 1) {
+    throw {
+      name: 'TemplateSyntaxError',
+      message: 'Got too few {end} statements'
+    };
+  }
+  return current_block;
+}
+// The Template class is defined in the traditional style so that users can add
+// methods by mutating the prototype attribute.  TODO: Need a good idiom for
+// inheritance without mutating globals.
+function Template(template_str, options) {
+  // Add 'new' if we were not called with 'new', so prototyping works.
+  if(!(this instanceof Template)) {
+    return new Template(template_str, options);
+  }
+  this._options = options || {};
+  this._program = _Compile(template_str, this._options);
+}
+Template.prototype.render = function(data_dict, callback) {
+  // options.undefined_str can either be a string or undefined
+  var context = _ScopedContext(data_dict, this._options.undefined_str);
+  _Execute(this._program.Statements(), context, callback);
+};
+Template.prototype.expand = function(data_dict) {
+  var tokens = [];
+  this.render(data_dict, function(x) { tokens.push(x); });
+  return tokens.join('');
+};
+// We just export one name for now, the Template "class".
+// We need HtmlEscape in the browser tests, so might as well export it.
+return {Template: Template, HtmlEscape: HtmlEscape};
+}();