spade-runtime 0.1.0.1

data/lib/spade/runtime/server.rb

@@ -0,0 +1,66 @@
+require 'rack'
+require 'rack/static'
+require 'tempfile'
+require 'child_labor'
+
+module Spade::Runtime
+  module Server
+    def self.run(working, port)
+      rootdir = Spade.discover_root(working)
+      static = Rack::Static.new(nil, :urls => ['/'], :root => rootdir)
+      static = CommandRunner.new(static)
+      static = Rack::ShowStatus.new(Rack::ShowExceptions.new(Rack::Chunked.new(Rack::ContentLength.new(static))))
+
+      Rack::Handler::WEBrick.run static, :Port => port.to_i
+    end
+
+    def self.shutdown
+      Rack::Handler::WEBrick.shutdown
+    end
+
+    class CommandRunner
+      def initialize(app)
+        @app = app
+      end
+
+      #FIXME: This is not very safe, we should have some restrictions
+      def call(env)
+        if env['PATH_INFO'] == '/_spade/command'
+          rack_input = env["rack.input"].read
+          params = Rack::Utils.parse_query(rack_input, "&")
+
+          command_path = params['command']
+          return [500, {}, "command required"] if command_path.nil? || command_path.empty?
+
+          if ((root = params['pkgRoot']) && !root.nil?)
+            command_path = File.expand_path(File.join(command_path), root)
+          end
+
+          tempfile = Tempfile.new('spade-server')
+          tempfile.write(params['code'])
+          tempfile.close
+
+
+          puts "Running: #{command_path}"
+
+          output, error = nil
+          process = ChildLabor.subprocess("#{command_path} < #{tempfile.path}") do |p|
+            output = p.read
+            error = p.read_stderr
+          end
+
+          tempfile.delete
+
+          if process.exit_status == 0
+            [200, {}, output]
+          else
+            [500, {}, error]
+          end
+        else
+          env['PATH_INFO'] == '/index.html' if env['PATH_INFO'] == '/'
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/spade/runtime/shell.rb

@@ -0,0 +1,36 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+# Global object used for the shell.
+module Spade::Runtime
+  class Shell
+    attr_accessor :ctx
+
+    def to_s
+      "[object Shell]"
+    end
+
+    def exit(status=0)
+      ctx.reactor.exit(status)
+    end
+
+    alias_method :quit, :exit
+
+    def help(*args)
+      <<-HELP
+      print(msg)
+      print msg to STDOUT
+
+      exit(status = 0)
+      exit the shell
+      also: quit()
+
+      evalrb(source)
+      evaluate some ruby source
+      HELP
+    end
+  end
+end

data/lib/spade/runtime/version.rb

@@ -0,0 +1,5 @@
+module Spade
+  module Runtime
+    VERSION = '0.1.0.1'
+  end
+end

data/spade-runtime.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'spade/runtime/version'
+
+Gem::Specification.new do |s|
+  s.name        = "spade-runtime"
+  s.version     = Spade::Runtime::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Charles Jolley", "Peter Wagenet"]
+  s.email       = ["charles@sproutcore.com", "peterw@strobecorp.com"]
+  s.homepage    = "http://github.com/strobecorp/spade"
+  s.summary = s.description = "Unified JavaScript runner for browser and command line"
+
+  mswin = RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
+  mri = !mswin && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby")
+
+  s.add_dependency "spade-core",   "~> 0.1.0"
+  s.add_dependency "eventmachine", "~> 0.12.10"
+  s.add_dependency "json_pure",    "~> 1.4.6"
+  s.add_dependency "rack",         "~> 1.2.1"
+  s.add_dependency "thor",         "~> 0.14.3"
+  s.add_dependency "childlabor",   "~> 0.0.3"
+  s.add_dependency "therubyracer", "~> 0.8.0" if mri
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "spade-packager", "~> 0.1.0"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.executables        = ['spaderun']
+  s.require_paths      = ["lib"]
+end
+

data/spec/cli/update_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe "spade update" do
+  before do
+    # prep the application
+    goto_home
+
+    FileUtils.mkdir_p (@app_path = tmp.join("update_test"))
+    FileUtils.mkdir_p (@app_packages_path = @app_path.join("packages"))
+    FileUtils.mkdir_p (@app_vendor_packages_path = @app_path.join("vendor/packages"))
+    app_package_file_path = @app_path.join("package.json")
+    File.open(app_package_file_path, 'w') do |f2|
+      f2.puts '{"name":"update_test","dependencies":{"fake_package": null}}'
+    end
+    cd(@app_path)
+
+  end
+  after do
+    cd(home)
+    FileUtils.rm_r @app_path
+  end
+
+  it "should use required packages if they are in the application's packages folder" do
+    FileUtils.mkdir_p (package_path = @app_packages_path.join("fake_package"))
+    package_file_path = package_path.join("package.json")
+    File.open(package_file_path, 'w') do |f|
+      f.puts '{"name": "fake_package"}'
+    end
+    spade("runtime","update", "--working=#{@app_path.to_s}")
+    wait()
+    "fake_package".should be_linked_to("../../packages/fake_package")
+  end
+
+  it "should use required packages if they are in the application's vendor/packages folder" do
+    FileUtils.mkdir_p (package_path = @app_vendor_packages_path.join("fake_package"))
+    package_file_path = package_path.join("package.json")
+    File.open(package_file_path, 'w') do |f|
+      f.puts '{"name": "fake_package"}'
+    end
+    spade("runtime","update", "--working=#{@app_path.to_s}")
+    wait()
+    "fake_package".should be_linked_to("../../vendor/packages/fake_package")
+  end
+  it "should use required packages if they are in the home spade directory" do
+    FileUtils.mkdir_p (package_path = spade_dir.join("gems","fake_package"))
+    package_file_path = package_path.join("package.json")
+    File.open(package_file_path, 'w') do |f|
+      f.puts '{"name": "fake_package"}'
+    end
+    unthreaded_spade("runtime","update", "--working=#{@app_path.to_s}")
+    "fake_package".should be_linked_to(package_path)
+  end
+
+  it "shoudl not try to choose from the home spade directory if Packager is not installed"
+  it "should install from the network repository if it does not exist elsewhere"
+  it "should raise an error if the package is in none of the locations"
+  it "should not link to a package if it is the incorrect version"
+  it "shoudl not try to install the package if Packager is not installed"
+  it "should install the correct version"
+  it "should raise an error if the package is only available in the wrong version"
+  it "should select packages in the correct order if there are multiple equal editions"
+  it "should create a spade-boot.js"
+  it "should record the versions in spade-boot.js"
+end

data/spec/javascript/async-test.js

@@ -0,0 +1,123 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+/*globals Ct */
+
+require('core-test');
+
+var Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: async require');
+
+Ct.setup(function(t, done) {
+  t.spade = new Spade(); 
+  
+  // preload a module
+  t.spade.register('foo/baz', function(require,e) { 
+    e.id = 'foo/baz'; 
+    e.async = require.async; // export for testing
+  });
+  
+  // dummy loader loads only foo/bar on demand after delay
+  t.spade.loader = {
+    
+    requests: 0, 
+    
+    loadFactory: function(spade, id, formats, done) {
+      this.requests++;
+      if (id === 'foo/bar') {
+        setTimeout(function() {
+          spade.register(id, function(r,e) { e.id='foo/bar'; });
+          done();
+        }, 10);
+
+      } else {
+        done('Not Found'); // immediately
+      }
+    }
+  };
+  
+  done();
+});
+
+Ct.teardown(function(t, done) { 
+  delete t.spade;
+  done();
+});
+
+Ct.test('should not talk to loader if registered', function(t, done) {
+  var spade = t.spade;
+
+  t.timeout(1000);
+  
+  spade.async('foo/baz', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 0, 'loader should not have been called');
+    t.equal(spade.require('foo/baz').id, 'foo/baz', 'should find foo');
+    done();
+  });
+  
+});
+
+Ct.test('should let loader register', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('foo/bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should normalize id', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('/./foo/baz/../bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should expose async inside of module', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+
+  var async = spade.require('foo/baz').async;
+  t.ok(async, 'should have an async function');
+  
+  // normalize relative to async
+  async('./bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should return err if loader does not register', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('imaginary/bar', function(err) {
+    t.equal(err, 'Not Found');
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+
+    t.throws(function() {
+      spade.require('imaginary/bar');
+    });
+    done();
+  });
+  
+});
+

data/spec/javascript/compiler/javascript.js

@@ -0,0 +1,13 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2011 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+//
+
+var Ct = require('core-test/sync');
+
+Ct.module('spade: Compiler JavaScript');
+
+Ct.test('works');
+

data/spec/javascript/compiler/ruby.js

@@ -0,0 +1,14 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2011 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+//
+
+var Ct = require('core-test/sync');
+
+Ct.module('spade: Compiler Ruby');
+
+Ct.test('works');
+
+

data/spec/javascript/loader-test.js

@@ -0,0 +1,64 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: basic require');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+    
+  // preload a module
+  t.spade.register('foo/main', function(r, e) { e.id = 'foo'; });
+  
+  // dummy loader loads only foo/bar on demand
+  t.spade.loader = {
+    
+    requests: 0, 
+    
+    loadFactory: function(spade, id, formats, done) {
+      this.requests++;
+      if (id === 'foo/bar') {
+        spade.register(id, function(r,e) { e.id='foo/bar'; });
+      }
+      if (done) throw "should not be passed done"
+    }
+  };
+  
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('should not talk to loader if module is registered', function(t) {
+  var spade = t.spade;
+  t.equal(spade.require('foo').id, 'foo', 'should find foo');
+  t.equal(spade.loader.requests, 0, 'loader should not have been called');
+});
+
+Ct.test('should let loader register', function(t) {
+  var spade = t.spade;
+  t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+  t.equal(spade.loader.requests, 1, 'loader should have been called');
+});
+
+Ct.test('should throw if loader does not register', function(t) {
+  var spade = t.spade;
+  t.throws(function() {
+    spade.require('imaginary/bar');
+  });
+  t.equal(spade.loader.requests, 1, 'loader should have been called');
+});
+
+
+
+Ct.run();

data/spec/javascript/normalize-test.js

@@ -0,0 +1,73 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: normalize');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('normalize', function(t) {
+  var spade = t.spade;
+  t.equal(spade.normalize('foo/bar'), 'foo/bar');
+  t.equal(spade.normalize('./foo', 'bar/baz'), 'bar/foo');
+  t.equal(spade.normalize('../foo', 'bar/baz'), 'foo/main');
+  t.equal(spade.normalize('foo/../bar//foo/./baz', 'bar/baz'), 'bar/foo/baz');
+
+  t.equal(spade.normalize('/foo/./bar'), 'foo/bar');
+  t.equal(spade.normalize('foo/../bar/'), 'bar/main');
+  t.equal(spade.normalize('/foo/../bar/'), 'bar/main');
+
+  t.equal(spade.normalize('/foo/bar'), 'foo/bar');
+  t.equal(spade.normalize('foo/bar/'), 'foo/bar');
+  t.equal(spade.normalize('/foo/bar/'), 'foo/bar');
+  
+  t.equal(spade.normalize('PKG/foo/bar'), 'PKG/foo/bar');
+  t.equal(spade.normalize('BAR/foo', 'PKG/bar/baz'), 'BAR/foo');
+  t.equal(spade.normalize('./foo', 'PKG/bar/baz'), 'PKG/bar/foo');
+  t.equal(spade.normalize('../foo', 'PKG/bar/baz'), 'PKG/foo');
+  t.equal(spade.normalize('./foo/../../bar//foo/./baz', 'PKG/bar/baz'), 'PKG/bar/foo/baz');
+  
+});
+
+Ct.test('normalize package', function(t) {
+  var spade = t.spade;
+  spade.register('sproutcore', {}); // register as a package
+  t.equal(spade.normalize('sproutcore'), 'sproutcore/main');
+  t.equal(spade.normalize('foo/sproutcore'), 'foo/sproutcore');
+});
+
+Ct.test('normalize relative require from main', function(t) {
+  // I think this is a valid test, but not certain
+  var spade = t.spade, mainRequire, otherRequire;
+  spade.register('foo', { main: './lib/foo', directories: { lib: './lib/foo' } });
+  spade.register('foo/main', 'return require;');
+  spade.register('foo/other/main', 'return require;');
+  mainRequire = spade.require('foo/main');
+  otherRequire = spade.require('foo/other/main');
+  t.equal(mainRequire.normalize('./foo/adfadf'), 'foo/adfadf', 'works for real main');
+  t.equal(otherRequire.normalize('./foo/core'), 'foo/other/foo/core', "no difference for fake main");
+});
+
+Ct.test('normalize tilde paths with lib', function(t){
+  var spade = t.spade, fooRequire;
+  spade.register('foo', { directories: { lib: './lib' }}); // register as a package
+  spade.register('foo/main', 'return require;');
+  fooRequire = spade.require('foo');
+  t.equal(fooRequire.normalize('foo/~lib/main'), 'foo/main');
+  t.equal(fooRequire.normalize('foo/~lib/core'), 'foo/core');
+});