newjs 1.5.1 → 1.7.0

data/features/development.feature

@@ -0,0 +1,13 @@
+Feature: Development processes of newgem itself (rake tasks)
+
+  As a Newgem maintainer or contributor
+  I want rake tasks to maintain and release the gem
+  So that I can spend time on the tests and code, and not excessive time on maintenance processes
+    
+  Scenario: Generate RubyGem
+    Given this project is active project folder
+    And 'pkg' folder is deleted
+    When task 'rake gem' is invoked
+    Then folder 'pkg' is created
+    And file with name matching 'pkg/*.gem' is created else you should run "rake manifest" to fix this
+    And gem spec key 'rdoc_options' contains /--mainREADME.rdoc/

data/features/imported_files_for_generators.feature

@@ -0,0 +1,19 @@
+Feature: Apply the latest distribution files from vendored projects into generators
+  In order to cheaply include latest JS libraries into the generators
+  As a newjs developer/deployer
+  I want to copy into newjs generators the JavaScript files from vendored projects
+
+  Scenario: Copy across jsunittest into generators
+    Given this project is active project folder
+    When task 'rake vendor:update:jsunittest' is invoked
+    Then file 'app_generators/newjs/templates/test/assets/jsunittest.js' is same as file 'vendor/jsunittest/dist/jsunittest.js'  
+    Then file 'app_generators/newjs/templates/test/assets/unittest.css' is same as file 'vendor/jsunittest/dist/unittest.css'  
+    Then file 'app_generators/newjs_iphone/templates/Html/test/assets/jsunittest.js' is same as file 'vendor/jsunittest/dist/jsunittest.js'  
+    Then file 'app_generators/newjs_iphone/templates/Html/test/assets/unittest.css' is same as file 'vendor/jsunittest/dist/unittest.css'  
+    Then file 'rails_generators/javascript_test/templates/assets/jsunittest.js' is same as file 'vendor/jsunittest/dist/jsunittest.js'  
+    Then file 'rails_generators/javascript_test/templates/assets/unittest.css' is same as file 'vendor/jsunittest/dist/unittest.css'  
+
+  Scenario: Copy across jshoulda into generators
+    Given this project is active project folder
+    When task 'rake vendor:update:jshoulda' is invoked
+    Then file 'rails_generators/javascript_test/templates/assets/jshoulda.js' is same as file 'vendor/jshoulda/dist/jshoulda.js'  

data/features/steps/common.rb

@@ -0,0 +1,205 @@
+def in_project_folder(&block)
+  project_folder = @active_project_folder || @tmp_root
+  FileUtils.chdir(project_folder, &block)
+end
+
+def in_home_folder(&block)
+  FileUtils.chdir(@home_path, &block)
+end
+
+Given %r{^a safe folder} do
+  FileUtils.rm_rf   @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  FileUtils.mkdir_p @tmp_root
+  FileUtils.mkdir_p @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  Given "env variable $HOME set to '#{@home_path}'"
+end
+
+Given %r{^this project is active project folder} do
+  Given "a safe folder"
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given %r{^env variable \$([\w_]+) set to '(.*)'} do |env_var, value|
+  ENV[env_var] = value
+end
+
+def force_local_lib_override(project_name = @project_name)
+  rakefile = File.read(File.join(project_name, 'Rakefile'))
+  File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+    f << "$:.unshift('#{@lib_path}')\n"
+    f << rakefile
+  end
+end
+
+def setup_active_project_folder project_name
+  @active_project_folder = File.join(@tmp_root, project_name)
+  @project_name = project_name
+end
+
+Given %r{'(.*)' folder is deleted} do |folder|
+  in_project_folder do
+    FileUtils.rm_rf folder
+  end
+end
+
+When %r{^'(.*)' generator is invoked with arguments '(.*)'$} do |generator, arguments|
+  @stdout = StringIO.new
+  FileUtils.chdir(@active_project_folder) do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When %r{run executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run project executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{run local executable '(.*)' with arguments '(.*)'} do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When %r{^task 'rake (.*)' is invoked$} do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then %r{^folder '(.*)' (is|is not) created} do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file '(.*)' (is|is not) created} do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then %r{^file with name matching '(.*)' is created} do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then %r{^file '(.*)' is same as file '(.*)'} do |file1, file2|
+  in_project_folder do
+    File.exists?(file1)
+    File.exists?(file2)
+    file1_contents = File.read(file1)
+    file2_contents = File.read(file2)
+    file1_contents.should == file2_contents
+  end
+end
+
+
+Then %r{gem file '(.*)' and generated file '(.*)' should be the same} do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then %r{^output same as contents of '(.*)'$} do |file|
+  expected_output = File.read(File.join(File.dirname(__FILE__) + "/../expected_outputs", file))
+  actual_output = File.read(@stdout)
+  actual_output.should == expected_output
+end
+
+Then %r{^(does|does not) invoke generator '(.*)'$} do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then %r{help options '(.*)' and '(.*)' are displayed} do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then %r{^output (does|does not) match \/(.*)\/} do |does, regex|
+  actual_output = File.read(@stdout)
+  (does == 'does') ?
+    actual_output.should(match(/#{regex}/)) :
+    actual_output.should_not(match(/#{regex}/)) 
+end
+
+Then %r{^contents of file '(.*)' (does|does not) match \/(.*)\/} do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then %r{^all (\d+) tests pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^all (\d+) examples pass} do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then %r{^yaml file '(.*)' contains (\{.*\})} do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then %r{^Rakefile can display tasks successfully} do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  FileUtils.chdir(@active_project_folder) do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then %r{^task 'rake (.*)' is executed successfully} do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then %r{^gem spec key '(.*)' contains \/(.*)\/} do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/steps/env.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/../../lib/newjs"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'

data/javascript_test_generators/functional_test/functional_test_generator.rb

@@ -1,6 +1,6 @@
 class FunctionalTestGenerator < RubiGen::Base
   
-  attr_reader :name, :dist_name
+  attr_reader :name, :dist_name, :testing_lib
   
   def initialize(runtime_args, runtime_options = {})
     super
@@ -15,6 +15,12 @@ class FunctionalTestGenerator < RubiGen::Base
       # Ensure appropriate folder(s) exists
       m.directory 'test/functional'
 
+      if testing_lib == 'jshoulda'
+        # Ensure jshoulda exists. TODO Should be moved to the newjs generator?
+        m.directory 'test/assets'
+        m.file 'test/assets/jshoulda.js', 'test/assets/jshoulda.js', :collision => :skip
+      end
+
       # Create stubs
       m.template "test/test.html.erb",  "test/functional/#{name}_test.html"
     end
@@ -43,6 +49,7 @@ EOS
       #         "Some comment about this option",
       #         "Default: none") { |options[:author]| }
       # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+      opts.on("--jshoulda", "Use jShoulda to write the test") { |v| options[:testing_lib] = 'jshoulda'}
     end
     
     def extract_options
@@ -50,5 +57,6 @@ EOS
       # Templates can access these value via the attr_reader-generated methods, but not the
       # raw instance variable value.
       # @author = options[:author]
+      @testing_lib = options[:testing_lib]
     end
 end

data/javascript_test_generators/functional_test/templates/test/assets/jshoulda.js

@@ -0,0 +1,186 @@
+/*  jShoulda, version 1.2.1
+ *  (c) 2008 Choan Galvez
+ *
+ *  jShoulda is freely distributable under
+ *  the terms of an MIT-style license.
+ *  For details, see the web site: http://jshoulda.scriptia.net
+ *
+ *--------------------------------------------------------------------------*/
+
+var jShoulda = function() {
+  // the test runner
+  var tr,
+  // handle all testcases with the same testrunner
+  unique = false,
+  // styles definitions
+  styles = {};
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after, ext) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after, ext);
+      if (tests)
+        tr.tests.push(tests);
+    }
+    before.pop();
+    after.pop();
+  }
+
+  function makeBatch(fn_a) {
+    var copy = fn_a.slice(0);
+    return function() {
+      for (var i = 0; i < copy.length; i += 1) {
+        copy[i].call(this);
+      }
+    };
+  }
+
+  function getContextAlias(prefix) {
+    if (prefix) prefix += ' ';
+    return function (name, config, args) {
+      var queue = Array.prototype.slice.call(arguments, 0);
+      var cName = '';
+      var obj = {};
+      // shift arguments if the first one is a string
+      if (typeof queue[0] == 'string') {
+        if (name) { cName += prefix; }
+        cName += queue.shift();
+      }
+      if (typeof queue[0] === 'object') {
+        obj = queue.shift();
+      }
+
+      obj.before = obj.setup || obj.before || dummy;
+      obj.after = obj.teardown || obj.after || dummy;
+      var beforeQueue;
+      var afterQueue;
+      var extensions = merge({}, obj || {});
+
+      return function(outerName, before, after, ext) {
+        // the root context gets no outerName or a configuration object
+        // as its first argument
+        var prefix = outerName;
+        var is_root = !!(outerName == undefined || typeof outerName == 'object');
+        if (is_root) {
+          tr = (tr && unique) ? tr : new Test.Unit.Runner({}, outerName || {});
+          prefix = '';
+        }
+        // shift arguments if the second one is a
+        // configuration object
+        beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+        afterQueue = after ? after.push(obj.after) && after : [obj.after];
+        runQueue(queue, [prefix, cName].join(' ').replace(/^\s+/, ''), beforeQueue, afterQueue, merge(extensions, ext));
+        if (is_root) {
+          return tr;
+        }
+        return false; // do not add to the tests queue
+      };
+    };
+  };
+
+  function merge(sub, sup) {
+    for (var i in sup) {
+      if (i.search(/^(before|after|setup|teardown)$/) != -1) continue;
+      if (sup.hasOwnProperty(i)) {
+        sub[i] = sup[i];
+      }
+    }
+    return sub;
+  }
+
+
+  function getShouldAlias(connector) {
+    return function (name, fn) {
+      return function(prefix, before, after, extensions) {
+        var beforeBatch = makeBatch(before);
+        var afterBatch = makeBatch(after);
+        var unit = new Test.Unit.Testcase([prefix, name].join(' ' + connector + ' '), fn, beforeBatch, afterBatch);
+        merge(unit, extensions);
+        return unit;
+      };
+    };
+  }
+
+  function setShouldAlias(name, host) {
+    var connector = name;
+    if (typeof host == 'string') {
+      connector = host;
+      host = arguments[2];
+    }
+    host = host || window;
+    host[name] = getShouldAlias(connector);
+    return jShoulda;
+  }
+
+  function setContextAlias(name, host) {
+    var prefix = '';
+    if (typeof host == 'string') {
+      prefix = host;
+      host = arguments[2];
+    }
+    host = host || window;
+    host[name] = getContextAlias(prefix);
+    return jShoulda;
+  }
+
+  function useStyle(name) {
+    var style, i;
+    if (name in styles) {
+      style = styles[name];
+      if ('context' in style) {
+        for (i = 0; i < style.context.length; i += 2) {
+          setContextAlias(style.context[i], style.context[i+1]);
+        }
+      }
+      if ('should' in style) {
+        for (i = 0; i < style.should.length; i += 2) {
+          setShouldAlias(style.should[i], style.should[i+1]);
+        }
+      }
+      if (style.unify) unifyRunners();
+    }
+    else throw { name: 'UndefinedStyle', message: 'There is not "'+name+'" style defined' };
+    return jShoulda;
+  }
+
+  function defineStyle(name, opts, aliases) {
+    styles[name] = opts;
+    for (var i = 2; i < arguments.length; i += 1) {
+      styles[arguments[i]] = opts;
+    }
+    return jShoulda;
+  }
+
+  function unifyRunners (options) {
+    if (options) {
+      tr = options instanceof Test.Unit.Runner ? options : new Test.Unit.Runner({}, options || {});
+    }
+    unique = true;
+    return jShoulda;
+  }
+
+  return {
+    setShouldAlias : setShouldAlias,
+    setContextAlias : setContextAlias,
+    unifyRunners : unifyRunners,
+    useStyle : useStyle,
+    defineStyle: defineStyle
+  };
+
+}();
+
+jShoulda
+  .defineStyle('describe', {
+    context: [ 'describe', '' ],
+    should: [ 'it', '' ],
+    unify: false
+  }, 'it')
+  .defineStyle('context', {
+    context : [ 'context', '' ],
+    should : [ 'should', 'should' ],
+    unify : false
+  }, 'should')
+  .useStyle('should');