shenandoah 0.1.3 → 0.2.0

data/.gitignore

@@ -5,3 +5,4 @@ rdoc
 pkg
 spec/tmp
 *.gemspec
+.sass-cache

data/ChangeLog.markdown

@@ -1,3 +1,12 @@
+0.2.0
+=====
+
+* Running multiple specs in-browser using iframes (issue #5)
+* Use a single stylesheet for single specs, multirunner, and index page
+* Allow override of the default runner stylesheet using a file at the root of spec_path; either shenandoah.sass or shenandoah.css
+* Stop publishing the gem to rubyforge (but continue deploying rdoc there)
+* Basic full-execution test coverage with cucumber features
+
 0.1.3
 =====
 

data/Rakefile

@@ -18,6 +18,7 @@ begin
     gem.add_runtime_dependency('haml', '>= 2.0.9')
     gem.add_runtime_dependency('rake')
     gem.add_runtime_dependency('rails', '>= 2.1.0')
+    gem.add_runtime_dependency('compass')
 
     # Have to use rspec 1.2.4 for buildr compat
     gem.add_development_dependency('rspec', '= 1.2.4')
@@ -25,7 +26,7 @@ begin
     gem.add_development_dependency('hpricot', '>= 0.8.1')
     gem.add_development_dependency('rspec_hpricot_matchers', '>= 1.0.0')
     gem.add_development_dependency('braid', '>= 0.5.0')
-    
+
     # These are the dependencies for the vendored buildr (used for testing)
     gem.add_development_dependency('rake', '= 0.8.4')
     gem.add_development_dependency('net-ssh', '= 2.0.11')
@@ -62,6 +63,20 @@ Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.rcov_opts = ['--exclude', "spec/*,/Library/Ruby/*"]
 end
 
+begin
+  require 'cucumber'
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format pretty"
+  end
+rescue LoadError
+  desc 'Cucumber rake task not available'
+  task :features do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
+end
+
 task :default => :spec
 
 def version
@@ -88,6 +103,10 @@ end
 
 # Disable github release since I don't want to commit the gemspec
 Rake::Task[:release].prerequisites.delete 'github:release'
+# Disable rubyforge releasing, but keep rdoc deployment task
+Rake::Task[:release].prerequisites.delete 'rubyforge:release'
 
 task :build => [:gemspec]
-task :install => [:uninstall]
+task :install => [:uninstall]
+
+task :ci => [:features, :spec]

data/VERSION.yml

@@ -1,4 +1,5 @@
 --- 
 :major: 0
-:minor: 1
-:patch: 3
+:minor: 2
+:build: 
+:patch: 0

data/features/buildr.feature

@@ -0,0 +1,29 @@
+Feature: Testing buildr projects
+
+  Scenario: Defined tasks
+    Given a buildr project
+    When I list the available buildr tasks
+    Then the task list should include life:shen:serve
+      And the task list should include life:shen:generate
+      And the task list should include life:shen:shell
+
+  Scenario: Running the server
+    Given a buildr project
+    When I execute `buildr life:shen:serve`
+    Then the server should be running
+
+  Scenario: Running all specs
+    Given a buildr project
+    When I execute `buildr test`
+    Then 49 specs should run
+
+  Scenario: Running one spec
+    Given a buildr project
+    When I execute `buildr test:life_spec`
+    Then 1 spec should run
+
+  Scenario: Generating a spec
+    Given a buildr project
+    When I execute `buildr life:shen:generate[pre_view]`
+    Then the file "src/spec/javascript/pre_view_spec.js" should exist
+      And the file "src/spec/javascript/pre_view.html" should exist

data/features/example_projects/base/Rakefile

@@ -0,0 +1,7 @@
+begin
+  dev_shen = File.expand_path('../../..', File.dirname(__FILE__))
+  $LOAD_PATH.unshift(File.join(dev_shen, 'lib'))
+end
+
+require 'shenandoah/tasks'
+Shenandoah::Tasks.new

data/features/example_projects/base/lib/cells.js

@@ -0,0 +1,105 @@
+Cell = function (initialState) {
+  this.willSurvive = true;
+  this.age = (initialState && initialState.age) || 0;
+
+  this.alive = function () {
+    return this.age > 0;
+  };
+
+  this.advance = function () {
+    if (this.willSurvive) {
+      this.age += 1;
+    } else {
+      this.age = 0;
+    }
+  };
+};
+
+Cells = function () {
+  var matrix;
+
+  function buildMatrix(rows, columns) {
+    matrix = new Array(rows);
+    var i, j;
+    for (i = 0 ; i < rows ; i++) {
+      matrix[i] = new Array(columns);
+      for (j = 0 ; j < columns ; j++) {
+        matrix[i][j] = new Cell();
+      }
+    }
+  }
+
+  function initializeMatrix(args) {
+    if (args.length == 1) {
+      var input = args[0];
+      var rows = input.length; var cols = input[0].length;
+      buildMatrix(rows, cols);
+      var i, j, item;
+      for (i = 0 ; i < rows ; i++) {
+        for (j = 0 ; j < cols ; j++) {
+          item = input[i][j];
+          age = 0;
+          if (item) {
+            if (!isNaN(parseInt(item))) {
+              age = parseInt(item);
+            } else if (item === '+') {
+              age = 1;
+            } else if (item === '.') {
+              age = 0;
+            } else if (item.match) {
+              age = item.match(/\S/) ? 1 : 0;
+            } else {
+              age = 1;
+            }
+          }
+          matrix[i][j].age = age;
+        }
+      }
+    } else if (args.length == 2) {
+      buildMatrix(args[0], args[1]);
+    }
+  }
+
+  this.get = function (r, c) {
+    if (r < 0 || r >= this.rowCount()) {
+      return null;
+    }
+    return matrix[r][c];
+  };
+
+  this.getAdjacency = function (r, c) {
+    return new Adjacency({
+      nw: this.get(r - 1, c - 1), n: this.get(r - 1, c), ne: this.get(r - 1, c + 1),
+       w: this.get(r, c - 1),                             e: this.get(r, c + 1),
+      sw: this.get(r + 1, c - 1), s: this.get(r + 1, c), se: this.get(r + 1, c + 1),
+    });
+  };
+
+  this.rowCount = function () {
+    return matrix.length;
+  };
+
+  this.columnCount = function () {
+    return matrix[0].length;
+  };
+
+  initializeMatrix(arguments);
+};
+
+Adjacency = function (adjacentCells) {
+  var EDGES = ['nw', 'n', 'ne', 'e', 'se', 's', 'sw', 'w'];
+
+  var self = this;
+  var liveCount = 0;
+
+  jQuery.each(EDGES, function (i, v) {
+    self[v] = adjacentCells[v] || new Cell();
+    if (self[v].alive()) {
+      liveCount += 1;
+    }
+  });
+
+  this.liveCount = function () {
+    return liveCount;
+  }
+};

data/features/example_projects/base/lib/life.js

@@ -0,0 +1,30 @@
+Life = function (cells) {
+  var self = this;
+  
+  this.cells = cells;
+
+  function willLive(r, c) {
+    var adj = self.cells.getAdjacency(r, c);
+    switch (adj.liveCount()) {
+      case 2: // no change
+        return self.cells.get(r, c).alive();
+      case 3: // always live
+        return true;
+      default: // alwaysDie
+        return false;
+    }
+  }
+
+  this.step = function () {
+    for (var r = 0 ; r < this.cells.rowCount() ; r++) {
+      for (var c = 0 ; c < this.cells.columnCount() ; c++) {
+        this.cells.get(r, c).willSurvive = willLive(r, c);
+      }
+    }
+    for (var r = 0 ; r < this.cells.rowCount() ; r++) {
+      for (var c = 0 ; c < this.cells.columnCount() ; c++) {
+        this.cells.get(r, c).advance();
+      }
+    }
+  };
+}

data/features/example_projects/base/spec/cells.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+  <title>cells.js | JavaScript Testing Results</title>
+  <link rel="stylesheet" href="/shenandoah.css" type="text/css" charset="utf-8" />
+  <script type="text/javascript" src="/shenandoah/browser-runner.js"></script>
+</head>
+
+<body>
+  <!-- Put any HTML fixture elements here. -->
+</body>
+</html>

data/features/example_projects/base/spec/cells_spec.js

@@ -0,0 +1,234 @@
+require_main('cells.js');
+
+Screw.Unit(function () {
+  describe('Cell', function () {
+    describe("initialization", function () {
+      it("defaults to a dead cell", function () {
+        expect((new Cell()).age).to(equal, 0);
+      });
+
+      it("accepts an initial age", function () {
+        expect((new Cell({ age: 3 })).age).to(equal, 3);
+      });
+    });
+
+    it("is alive if its age is positive", function () {
+      expect((new Cell({ age: 4 })).alive()).to(be_true);
+    });
+
+    it("is not alive if its age is zero", function () {
+      expect((new Cell({ age: 0 })).alive()).to(be_false);
+    });
+
+    describe("#advance", function () {
+      var cell;
+
+      before(function () {
+        cell = new Cell({ age: 5 });
+      })
+
+      it("increments the age if it will survive", function () {
+        cell.willSurvive = true;
+        cell.advance();
+        expect(cell.age).to(equal, 6);
+      });
+
+      it("resets the age if it will not survive", function () {
+        cell.willSurvive = false;
+        cell.advance();
+        expect(cell.age).to(equal, 0);
+      });
+    });
+  });
+
+  describe('Cells', function () {
+    describe("initialization", function () {
+      var board;
+      describe("from an array of arrays", function () {
+        before(function () {
+          board = new Cells([
+            [true, false, null],
+            [0, 1, 2],
+            [undefined, "", "s"]
+          ]);
+        });
+
+        it("has the right number of rows", function () {
+          expect(board.rowCount()).to(equal, 3);
+        });
+
+        it("has the right number of columns", function () {
+          expect(board.columnCount()).to(equal, 3);
+        });
+
+        it("treats true as set", function () {
+          expect(board.get(0, 0).age).to(equal, 1);
+        });
+
+        it("treats false as not set", function () {
+          expect(board.get(0, 1).age).to(equal, 0);
+        });
+
+        it("treats null as not set", function () {
+          expect(board.get(0, 2).age).to(equal, 0);
+        });
+
+        it("treats 0 as not set", function () {
+          expect(board.get(1, 0).age).to(equal, 0);
+        });
+
+        it("treats 1 as set", function () {
+          expect(board.get(1, 1).age).to(equal, 1);
+        });
+
+        it("treats other numbers as an age", function () {
+          expect(board.get(1, 2).age).to(equal, 2);
+        });
+
+        it("treats undefined as not set", function () {
+          expect(board.get(2, 0).age).to(equal, 0);
+        });
+
+        it("treats an empty string as not set", function () {
+          expect(board.get(2, 1).age).to(equal, 0);
+        });
+
+        it("treats a non-empty string as set", function () {
+          expect(board.get(2, 2).age).to(equal, 1);
+        });
+      });
+
+      describe("from an array of strings", function () {
+        before(function () {
+          board = new Cells([
+            ".++..",
+            "..+ .",
+            "4.+++"
+          ]);
+        });
+
+        it("finds the correct number of rows", function () {
+          expect(board.rowCount()).to(equal, 3);
+        });
+
+        it("finds the correct number of columns", function () {
+          expect(board.columnCount()).to(equal, 5);
+        });
+
+        it("treats + as set", function () {
+          expect(board.get(2, 3).age).to(equal, 1);
+        });
+
+        it("treats a digit as an age", function () {
+          expect(board.get(2, 0).age).to(equal, 4);
+        });
+
+        it("treats a . as not set", function () {
+          expect(board.get(0, 4).age).to(equal, 0);
+        });
+
+        it("treats a space as not set", function () {
+          expect(board.get(1, 3).age).to(equal, 0);
+        });
+      });
+
+      describe("from dimensions", function () {
+        before(function () {
+          board = new Cells(2, 3);
+        });
+
+        it("has the correct number of rows", function () {
+          expect(board.rowCount()).to(equal, 2);
+        });
+
+        it("has the correct number of columns", function () {
+          expect(board.columnCount()).to(equal, 3);
+        });
+
+        it("initializes the board with empty cells", function () {
+          expect(board.get(0, 0).age).to(equal, 0);
+          expect(board.get(0, 1).age).to(equal, 0);
+          expect(board.get(0, 2).age).to(equal, 0);
+          expect(board.get(1, 0).age).to(equal, 0);
+          expect(board.get(1, 1).age).to(equal, 0);
+          expect(board.get(1, 2).age).to(equal, 0);
+        });
+      });
+    });
+
+    describe("#get", function () {
+      var board;
+
+      before(function () {
+        board = new Cells(3, 2);
+      });
+
+      jQuery.each([
+        ['top',     [-1,  1]],
+        ['right',   [ 0,  3]],
+        ['bottom',  [ 4,  0]],
+        ['left',    [ 1, -1]]
+      ], function (i, v) {
+        it("returns null for off-board " + v[0], function () {
+          expect(board.get.apply(board, v[1])).to(equal, null);
+        });
+      });
+    });
+
+    describe("#getAdjacency", function () {
+      var board;
+
+      before(function () {
+        board = new Cells([
+          ".1..",
+          "...2",
+          ".543"
+        ]);
+      });
+
+      describe("for an interior cell", function () {
+        var actual;
+
+        before(function () {
+          actual = board.getAdjacency(1, 2);
+        });
+
+        jQuery.each([
+          ['nw', 1], ['n', 0], ['ne', 0],
+          [ 'w', 0],           [ 'e', 2],
+          ['sw', 5], ['s', 4], ['se', 3]
+        ], function (i, v) {
+          it("has the right cell for " + v[0], function () {
+            expect(actual[v[0]].age).to(equal, v[1]);
+          });
+        });
+
+        it("has the correct adjacency count", function () {
+          expect(actual.liveCount()).to(equal, 5);
+        });
+      });
+
+      describe("for an edge cell", function () {
+        var actual;
+
+        before(function () {
+          actual = board.getAdjacency(2, 3);
+        });
+
+        jQuery.each([
+          ['nw', 0], ['n', 2], ['ne', 0],
+          [ 'w', 4],           [ 'e', 0],
+          ['sw', 0], ['s', 0], ['se', 0]
+        ], function (i, v) {
+          it("has the right cell for " + v[0], function () {
+            expect(actual[v[0]].age).to(equal, v[1]);
+          });
+        });
+
+        it("has the correct adjacency count", function () {
+          expect(actual.liveCount()).to(equal, 2);
+        });
+      });
+    });
+  });
+});