newjs 1.5.1 → 1.7.0

data/vendor/jshoulda/lib/protodoc.rb

@@ -0,0 +1,36 @@
+require 'erb'
+
+class String
+  def lines
+    split $/
+  end
+  
+  def strip_whitespace_at_line_ends
+    lines.map {|line| line.gsub(/\s+$/, '')} * $/
+  end
+end
+
+module Protodoc
+  module Environment
+    def include(*filenames)
+      filenames.map {|filename| Preprocessor.new(filename).to_s}.join("\n")
+    end
+  end
+  
+  class Preprocessor
+    include Environment
+    
+    def initialize(filename)
+      @filename = File.expand_path(filename)
+      @template = ERB.new(IO.read(@filename), nil, '%')
+    end
+    
+    def to_s
+      @template.result(binding).strip_whitespace_at_line_ends
+    end
+  end  
+end
+
+if __FILE__ == $0
+  print Protodoc::Preprocessor.new(ARGV.first)
+end

data/vendor/jshoulda/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:javascript, :javascript_test, :newjs, :newjs_theme]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/vendor/jshoulda/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:javascript, :javascript_test, :newjs, :newjs_theme]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/vendor/jshoulda/script/js_autotest

@@ -0,0 +1 @@
+script/rstakeout "rake test:recent:javascript" test/unit/*_test.html src/*.js

data/vendor/jshoulda/script/rstakeout

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+config = File.dirname(__FILE__) + "/../config/javascript_test_autotest.yml"
+unless File.exists?(config)
+  puts <<-EOS
+Edit config/javascript_test_autotest.yml for the browser(s) to use for autotesting.
+See config/javascript_test_autotest.yml.sample for examples.
+EOS
+  exit
+end
+
+##
+# Originally by Mike Clark.
+#
+# From http://www.pragmaticautomation.com/cgi-bin/pragauto.cgi/Monitor/StakingOutFileChanges.rdoc
+#
+# Runs a user-defined command when files are modified.
+#
+# Like autotest, but more customizable. This is useful when you want to do
+# something other than run tests. For example, generate a PDF book, run
+# a single test, or run a legacy Test::Unit suite in an app that also
+# has an rSpec suite.
+#
+# Can use Ruby's Dir[] to get file glob. Quote your args to take advantage of this.
+#
+#  rstakeout 'rake test:recent' **/*.rb
+#  => Only watches Ruby files one directory down (no quotes)
+#
+#  rstakeout 'rake test:recent' '**/*.rb'
+#  => Watches all Ruby files in all directories and subdirectories
+#
+# Modified (with permission) by Geoffrey Grosenbach to call growlnotify for
+# rspec and Test::Unit output.
+#
+# See the PeepCode screencast on rSpec or other blog articles for instructions on
+# setting up growlnotify.
+
+def growl(title, msg, img, pri=0, sticky="")
+  system "growlnotify -n autotest --image ~/.autotest_images/#{img} -p #{pri} -m #{msg.inspect} #{title} #{sticky}"
+end
+
+def self.growl_fail(output)
+  growl "FAIL", "#{output}", "fail.png", 2
+end
+
+def self.growl_pass(output)
+  growl "Pass", "#{output}", "pass.png"
+end
+
+command = ARGV.shift
+files = {}
+
+ARGV.each do |arg|
+  Dir[arg].each { |file|
+    files[file] = File.mtime(file)
+  }
+end
+
+puts "Watching #{files.keys.join(', ')}\n\nFiles: #{files.keys.length}"
+
+trap('INT') do
+  puts "\nQuitting..."
+  exit
+end
+
+
+loop do
+
+  sleep 1
+
+  changed_file, last_changed = files.find { |file, last_changed|
+    File.mtime(file) > last_changed
+  }
+
+  if changed_file
+    files[changed_file] = File.mtime(changed_file)
+    puts "=> #{changed_file} changed, running #{command}"
+    results = `#{command}`
+    puts results
+
+    if results.include? 'tests'
+      output = results.slice(/(\d+)\s+tests?,\s*(\d+)\s+assertions?,\s*(\d+)\s+failures?(,\s*(\d+)\s+errors)?/)
+      if output
+        $~[3].to_i + $~[5].to_i > 0 ? growl_fail(output) : growl_pass(output)
+      end
+    else
+      output = results.slice(/(\d+)\s+examples?,\s*(\d+)\s+failures?(,\s*(\d+)\s+not implemented)?/)
+      if output
+        $~[2].to_i > 0 ? growl_fail(output) : growl_pass(output)
+      end
+    end
+    # TODO Generic growl notification for other actions
+
+    puts "=> done"
+  end
+
+end

data/vendor/jshoulda/site/asset_defaults.yaml

@@ -0,0 +1,6 @@
+# Built-in 
+extension: dat
+filters: []
+binary: true
+
+# Custom

data/vendor/jshoulda/site/config.yaml

@@ -0,0 +1,3 @@
+output_dir:  "output"
+data_source: "filesystem"
+router:      "default"

data/vendor/jshoulda/site/content/content.html

@@ -0,0 +1,27 @@
+<p><strong>jShoulda</strong> acts as a wrapper to the <a href="http://github.com/drnic/jsunittest/">JsUnitTest</a> library, allowing you to write JavaScript unit tests in a <a href="http://www.thoughtbot.com/projects/shoulda">Shoulda</a>-like language.</p>
+
+
+<h2>What you write</h2>
+
+<%= highlight(render('home_test'), 'javascript', {:id => 'editable-test'}) %>
+
+
+<h2>... is what you test</h2>
+  
+<div id="testlog"><p>The tests results will be displayed here.</p></div>
+
+<script type="text/javascript">
+<%= render('home_test') %>
+</script>
+
+
+<p class="download"><a href="/dl/jshoulda.zip">Download jShoulda</a></p>
+
+<p>Interested? Check our <a href="/tutorial/">tutorial on jShoulda</a> (or this <a href="http://www.vimeo.com/2324738">screencast with Spanish audio track</a>). </p>
+
+<div class="new">
+  <p>Still writing too much? <a href="http://www.vimeo.com/2049956">Watch</a> and <a href="/dl/jshoulda-tmbundle.zip">get the jShoulda TextMate Bundle</a>.</p>
+</div>
+
+<p>jShoulda has been created by <a href="http://choangalvez.nom.es/">Choan Galvez</a> and is freely distributable under the terms of a MIT-style license. The source code resides in a <a href="http://github.com/choan/jshoulda/">Git repository at github</a>.</p>
+

data/vendor/jshoulda/site/content/content.yaml

@@ -0,0 +1,4 @@
+# Built-in
+
+# Custom 
+title: jShoulda - Shoulda for JavaScript

data/vendor/jshoulda/site/content/tutorial/tutorial.html

@@ -0,0 +1,268 @@
+<p>jShoulda, just as the <a href="http://www.thoughtbot.com/projects/shoulda" title="thoughtbot: Shoulda testing plugin">Shoulda</a> testing plugin it's inspired on, <q>makes it easy to write elegant, understandable, and maintainable tests.</q> JavaScript.</p>
+
+
+<h2>A minimal test document</h2>
+
+<p>You need the following files to use jShoulda:</p>
+
+<ul>
+  <li><a href="http://jsunittest.com/dist/jsunittest.js">jsunittest.js</a>, from the <a href="http://jsunittest.com/">JsUnitTest</a> project. If you're using <a href="http://www.prototypejs.org/" title="Prototype JavaScript framework: Easy Ajax and DOM manipulation for dynamic web applications">prototype</a>, you may use <a href="http://github.com/sstephenson/prototype/tree/master%2Ftest%2Flib%2Fassets%2Funittest.js?raw=true">unittest.js</a> instead.</li>
+  <li><a href="/js/jshoulda.js">jshoulda.js</a>, from the <a href="/">jShoulda</a> project.</li>
+</ul>
+
+<p>Create an HTML document which references both scripts. Include a <code>div</code> element with <code>id</code> <var>testlog</var>, then your testing code. <a href="/example/minimal.html">Run it</a>, enjoy.
+
+<%= example('minimal.html', false) %>
+
+<h2>jShoulda syntax</h2>
+
+<p>By default, jShoulda exports two methods to the global space: <code>context</code> and <code>should</code>.</p>
+
+<p>To create a test runner (which will be automatically executed on <code>window.onload</code>), invoke <code>context</code>, then execute the result:</p>
+
+<%
+code =<<-EOD
+context('The name of the context')();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<p>The first argument to <code>context</code> is the base name for actual tests derived from it. The second is an (optional) object which may include <code>setup</code> and <code>teardown</code> methods:</p>
+
+<%
+code =<<-EOD
+context('The name of the context', {
+  setup: function() {
+    // `this` is a Test.Unit.Testcase instance
+    this.foo = 1;
+  },
+  teardown: function() {
+    // you don't need to clean up `this`'s properties,
+    // the Test.Unit.TestCase is brand new for every actual test
+  }
+  }
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<p>Hint: You can use <code>before</code>/<code>after</code> instead of <code>setup</code>/<code>teardown</code> if it makes you feel better.</p>
+
+<p>Include <code>should</code> calls after the (optional) configuration object to create actual tests:</p>
+
+<%
+code =<<-EOD
+context('A context', {
+  setup: function() {
+    this.foo = 1;
+  }
+  },
+  should('run its setup function', function() {
+    this.assertEqual(1, this.foo);
+  })
+)();
+
+// if you don't need setup/teardown methods
+context('A context',
+  should('run its setup function', function() {
+    this.assertEqual(1, this.foo);
+  })
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<p>Every call to <code>should</code> must pass a name and a callback as arguments. Assertions are run inside the callback, where <code>this</code> points to a <code>Test.Unit</code> instance (the same you can manipulate on <code>setup</code>/<code>teardown</code>).</p>
+
+<p>To create new contexts (on which every <code>setup</code>/<code>teardown</code> function from parent contexts is ran), pass a call to <code>context</code> as an argument:</p>
+
+<%
+code =<<-EOD
+context('A context', {
+  setup: function() {
+    this.foo = 1;
+  }
+  },
+  should('run its setup function', function() {
+    this.assertEqual(1, this.foo);
+  }),
+  context('which is a "nested" context', {
+    setup: function() {
+      this.foo +=1;
+    }
+    },
+    should('run both setup functions', function() {
+      this.assertEqual(2, this.foo);
+    })
+  )
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<p>You can nest as much contexts as you like.</p>
+
+<h2>Assertions</h2>
+
+<p>Assertions come from the JsUnitTest library. Almost every assertion accepts three arguments: the expected value, the actual one and an optional message. An intentionally incomplete list of possible assertions follows:</p>
+
+<ul>
+  <li>assert</li>
+  <li>assertEqual</li>
+  <li>assertNotEqual</li>
+  <li>assertEnumEqual</li>
+  <li>assertEnumNotEqual</li>
+  <li>assertHashEqual</li>
+  <li>assertHashNotEqual</li>
+  <li>assertIdentical</li>
+  <li>assertNotIdentical</li>
+  <li>assertNull</li>
+  <li>assertNotNull</li>
+  <li>assertUndefined</li>
+  <li>assertNotUndefined</li>
+</ul>
+
+
+<h2>Customizing the Test Runner</h2>
+
+<p>The progress and results of your tests are shown, by default, on a <code>div</code> element whose <code>id</code> equals <var>testlog</var>. If you want to modify the behaviour of the runner, pass a configuration object when invocating the root context call result:
+  
+<%
+code =<<-EOD
+context('A context',
+  should('run a test', function() {
+    this.assert('Yay!');
+  }),
+)({ testLog: 'my_test_log_div_id' });
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<h2 id="aliasing">Aliasing</h2>
+
+<p>You can easily create alias to <code>context</code> and <code>should</code> methods. In fact, they are alias themselves.</p>
+
+<p>Say you wanted to use <code>some</code>/<code>must</code> instead of (actually, in addition) to <code>context</code>/<code>should</code>. You could just do:</p>
+
+<%
+code = <<-EOD
+jShoulda
+  .setShouldAlias('must')
+  .setContextAlias('some');
+
+some('context',
+  must('run a test', function() {
+    this.assert('Yay!');
+  })
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<p>Both <code>setBlahAlias</code> create methods which works just as <code>context</code> and <code>should</code> do. But instead of getting a “should” connector, you get a connector named as the method, that is, the full name of the test we've created in the previous example, would be “A context must run a test”.</p>
+
+<p>Pass a second argument to <code>setShouldAlias</code> if you want a different connector (or no connector at all). Pass a second argument to <code>setContextAlias</code> if you want a prefix for your context.</p>
+
+<% 
+code = <<-EOD
+jShoulda
+  .setShouldAlias('it', '')
+  .setContextAlias('describe');
+
+describe('A context',
+  it('runs a test', function() {
+    this.assert('Yay!');
+  })
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+
+<p>or</p>
+
+<%=
+highlight(<<-EOD, 'javascript')
+jShoulda
+  .setContextAlias('un', 'Un')
+  .setContextAlias('para', 'para')
+  .setShouldAlias('deberia', 'debería');
+
+un("programador",
+  para("ser feliz",
+    deberia("poder comer melocotones de Calanda todo el año", function() {
+    })
+  )
+)();
+EOD
+%>
+
+<p>In this last case, the outputted name for our test will be “Un programador para ser feliz debería poder comer melocotones de Calanda todo el año”.</p>
+
+<p>Of course, you can mix as much aliases as you like.</p>
+
+<h2 id="extra-properties">Extending the test cases (new in 1.2)</h2>
+
+<p>Properties in the configuration object (other than setup/teardown/before/after) are copied to each <code>Test.Unit.Testcase</code> inside the context—that is, are accesible through <code>this</code> inside the <code>should</code> callbacks.</p>
+
+<% 
+code = <<-EOD
+context("A 'should' execution", {
+  assertLocalYipiyay : function(actual, msg) {
+    this.assertEqual('yipiyay', actual, msg);
+  }
+  },
+  should("get access to extra properties defined on the configuration object", function() {
+    this.assertLocalYipiyay('yipiyay');
+  })
+)();
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+<h2 id="unifying-test-runners">Unifying test runners (new in 1.2)</h2>
+
+<p>By default, each root contexts creates a new <code>Test.Unit.Runner</code> instance, so if you're not using different loggers, headers may report wrong results. And, if you are using the rake tasks provided with <strong>newjs</strong> or <strong>rails</strong>, only the results of one of the contexts would get logged.</p>
+
+<p>Not a problem? Well... in addition, you can't load tests from multiple files! Isn't that a problem?</p>
+
+<p>jShoulda provides the method <code>unifyRunners</code>. It saves the world.</p>
+
+<p>There are three ways to use the method:</p>
+
+<% 
+code = <<-EOD
+// with no arguments
+// every next root context inherits the runner
+// from the previous (if any) root context
+jShoulda
+  .unifyRunners();
+
+
+// with option arguments
+// every next root context uses a new
+// runner created from the options
+jShoulda
+  .unifyRunners({testLog: 'testlog2'});
+
+// if you've created a testRunner through the
+// traditional syntax, you can reuse it
+var runner = new Test.Unit.Runner({
+  testDummy : function() {
+    this.assert(true);
+  }
+});
+jShoulda
+  .unifyRunners(runners);
+EOD
+%>
+<%= highlight(code, 'javascript') %>
+
+
+
+
+<h2>Questions?</h2>
+
+<p>Feel free to ask on the <a href="http://groups.google.com/group/jshoulda">jShoulda Google Group</a>.</p>
+
+<p><a href="/">jShoulda home page</a>.</p>