RubyGems - crazy_ivan - Versions diffs - 0.2.0 - Mend

crazy_ivan 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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};
+}();