spade 0.1.0 → 0.1.1.1

data/lib/spade/package/spec/javascript/sandbox/run-command.js

@@ -0,0 +1,21 @@
+// ==========================================================================
+// 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'),
+    Spade = require('spade').Spade,
+    Sandbox = require('spade').Sandbox;
+
+Ct.module('spade: Sandbox runCommand');
+
+// TODO: Add the next 3 tests when adding Ruby and node.js support
+Ct.test('success');
+
+Ct.test('failure');
+
+Ct.test('not supported');
+
+// Not really sure how to test this, other than a bunch of stubbing
+Ct.test('browser');

data/lib/spade/package/spec/javascript/spade/externs.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: Spade externs');
+
+Ct.test('works');
+
+

data/lib/spade/package/spec/javascript/spade/load-factory.js

@@ -0,0 +1,15 @@
+// ==========================================================================
+// 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: Spade loadFactory');
+
+Ct.test('works');
+
+
+

data/lib/spade/package/spec/javascript/spade/misc.js

@@ -0,0 +1,23 @@
+// ==========================================================================
+// 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: Spade miscellaneous');
+
+Ct.test('globalize works');
+
+Ct.test('noConflict works');
+
+Ct.test('sandbox works');
+
+Ct.test('factoryExists works');
+
+Ct.test('package works');
+
+
+

data/lib/spade/package/spec/javascript/spade/ready.js

@@ -0,0 +1,12 @@
+// ==========================================================================
+// 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: Spade ready');
+
+Ct.test('works');

data/lib/spade/package/spec/javascript/spade/register.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: Spade miscellaneous');
+
+Ct.test('register works');
+

data/lib/spade/package/spec/javascript_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "Javascript Tests" do
+  Dir["#{File.dirname(__FILE__)}/javascript/**/*.js"].each do |path|
+    run_core_tests(path)
+  end
+end

data/lib/spade/package/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+Bundler.require :default, :development
+
+require 'support/core_test'

data/lib/spade/package/spec/support/core_test.rb

@@ -0,0 +1,67 @@
+require 'spade/context'
+
+module Spade
+  def self.jspath
+    File.expand_path("../../../lib/spade.js", __FILE__)
+  end
+end
+
+RSpec::Matchers.define :be_ct_success do
+  match do |actual|
+    actual.first == 'passed'
+  end
+
+  failure_message_for_should do |actual|
+    actual.last
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected not to be a success"
+  end
+
+  description do
+    "be a success"
+  end
+end
+
+module RSpecCoreTest
+  def run_core_tests(path, &block)
+    describe "#{path}" do
+      rootdir = File.expand_path(File.join(__FILE__, '/../../../'));
+      context = Spade::MainContext.new(:rootdir => rootdir) do |ctx|
+        ctx['checkRSpec'] = lambda do |status, test_info, message|
+          it "#{test_info.module.name}: #{test_info.name}" do
+            if status == 'warnings' && message == "Not Yet Implemented"
+              pending
+            else
+              [status.to_s, message.to_s].should be_ct_success
+            end
+          end
+        end
+
+        ctx.eval <<END
+var Ct;
+try {
+  Ct = require('core-test');
+} catch (e) { }
+
+if (Ct) {
+  RubyLogger = require('core-test/utils').extend(Ct.DefaultLogger, {
+    add: function(status, testInfo, message){
+      checkRSpec(status, testInfo, message);
+    }
+  });
+  Ct.defaultLogger = new RubyLogger('ruby');
+
+  require('file:#{path}');
+
+  Ct.run();
+} else {
+  console.log("CoreTest is not installed. Use `spade install core-test`.");
+}
+END
+      end
+    end
+  end
+end
+RSpec::Core::ExampleGroup.extend(RSpecCoreTest)

data/lib/spade/reactor.rb

@@ -0,0 +1,159 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'eventmachine'
+
+module Spade
+
+  # The reactor exposes some API 
+  class Reactor
+
+    attr_reader :timers, :running, :holds, :stopped
+
+    def initialize(ctx)
+      @timers = []
+      @running = false
+      @stopped = false
+      @holds   = 0
+    end
+
+    # Starts the event loop
+    def start
+      return if @running
+
+      @running = true
+      add_hold # release when finish is called
+
+      EventMachine.run do
+        @running = true
+        @timers.each { |t| t.start unless t.running }
+
+        yield if block_given?
+
+        @stopped = true
+        release_hold
+      end
+
+    end
+
+    def exit(status=0)
+      stop_loop
+      Kernel.exit(status)
+    end
+
+    def next_tick(&block)
+      if @running
+        add_hold
+        EventMachine.next_tick do
+          yield
+          release_hold
+        end
+      else
+        add_timer(0) { yield }
+      end
+    end
+
+    ######################################################
+    ## Holds
+    ##
+    ## Prevents the loop from exiting
+
+    def add_hold
+      @holds = @holds + 1 
+    end
+
+    def release_hold
+      @holds = @holds - 1
+      stop_loop if @stopped && @holds <= 0
+    end
+
+    def stop_loop
+      @running = false
+      EventMachine.stop_event_loop
+    end
+
+
+    ######################################################
+    ## Timers
+    ##
+
+    def add_timer(interval, periodic = false, &block)
+      add_hold
+      Timer.new(self).tap do |timer|
+        timer.periodic = periodic
+        timer.interval = interval
+        timer.callback = block
+        @timers << timer
+        timer.start if @running
+      end
+    end
+
+    def remove_timer(timer)
+      'remove_timer'
+      release_hold if @timers.delete(timer)
+    end
+
+    def set_timeout(callback, interval)
+      add_timer interval, false do
+        callback.methodcall(self)
+      end
+    end
+
+    def set_interval(callback, interval)
+      add_timer interval, true do
+        callback.methodcall(self)
+      end
+    end
+
+    def clear_timeout(timer)
+      timer.cancel
+    end
+
+    def clear_interval(timer)
+      timer.cancel
+    end
+
+    class Timer
+
+      attr_accessor :periodic, :interval, :callback
+      attr_reader :running
+
+      def initialize(reactor)
+        @interval = 0
+        @periodic = false
+        @callback = nil
+        @reactor = reactor
+          @running = false
+      end
+
+      def start
+        @running = true
+        if @periodic
+          @timer = EventMachine.add_periodic_timer(@interval.to_f / 1000) do
+            @callback.call
+          end
+        else
+          @timer = EventMachine.add_timer(@interval.to_f / 1000) do
+            @callback.call
+            @timer = nil
+            @reactor.remove_timer(self)
+          end
+        end
+      end
+
+      def cancel
+        EventMachine.cancel_timer(@timer) if @timer
+        @timer = nil
+        @reactor.remove_timer(self)
+      end    
+    end
+
+
+
+  end
+
+end
+

data/lib/spade/server.rb

@@ -0,0 +1,66 @@
+require 'rack'
+require 'rack/static'
+require 'tempfile'
+require 'child_labor'
+
+module Spade
+  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/shell.rb

@@ -0,0 +1,85 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'readline'
+require 'fileutils'
+
+# Global object used for the shell.
+module Spade
+  class Shell
+
+    METHODS = [:to_s, :exit, :quit, :help, :evalrb, :inspectjs]
+
+    def initialize
+      @history_path = File.expand_path("~/.spadehistory")
+      load_history
+    end
+
+    def inject(ctx)
+      @ctx = ctx
+      METHODS.each{|meth| @ctx[meth.to_s] = method(meth) }
+      true
+    end
+
+    def to_s
+      "[object Shell]"
+    end
+
+    def exit(status=0)
+      save_history
+    ensure
+      @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
+
+    def evalrb(str)
+      Kernel.eval str, binding
+    end
+
+    def inspectjs(obj)
+      # check for exact class match so we don't match things like arrays
+      spacer = (obj.class == V8::Object) ? 2 : nil
+      # the self[] uses the JS version of JSON
+      json = @ctx['JSON'].stringify(obj, nil, spacer)
+      # Some things can't be converted into json
+      json || obj.inspect
+    end
+
+    private
+
+      def load_history
+        return unless File.exist?(@history_path)
+        File.readlines(@history_path).each{|l| Readline::HISTORY << l.chomp }
+      end
+
+      def save_history
+        FileUtils.mkdir_p(File.dirname(@history_path))
+        File.open(@history_path, 'w') do |f|
+          Readline::HISTORY.to_a.last(100).each do |l|
+            l.chomp!
+            next if l.empty?
+            next if l =~ /^(exit|quit)\(/
+            f.puts l
+          end
+        end
+      end
+  end
+end