spade-runtime 0.1.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+tmp
+devbin

data/bin/spaderun

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift(lib) if File.exists?(lib)
+
+require 'spade/runtime'
+
+Spade::Runtime::CLI::Base.start
+
+

data/lib/spade-runtime.rb

@@ -0,0 +1 @@
+require 'spade/runtime'

data/lib/spade/runtime.rb

@@ -0,0 +1,20 @@
+require 'spade/core'
+
+begin
+  require 'spade/packager'
+rescue LoadError
+  # Packager isn't necessary, but we should use it if available
+end
+
+module Spade
+  module Runtime
+    autoload :Bundle,     'spade/runtime/bundle'
+    autoload :Context,    'spade/runtime/context'
+    autoload :MainContext,'spade/runtime/context'
+    autoload :Server,     'spade/runtime/server'
+    autoload :Shell,      'spade/runtime/shell'
+    autoload :CLI,        'spade/runtime/cli'
+    autoload :Namespace,  'spade/runtime/exports'
+    autoload :Exports,    'spade/runtime/exports'
+  end
+end

data/lib/spade/runtime/bundle.rb

@@ -0,0 +1,173 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'json'
+
+module Spade::Runtime
+  BOOT_PATH = File.dirname(Spade::JSPATH)
+
+  module Bundle
+    class << self
+
+      def update(rootdir, opts ={})
+
+        verbose = opts[:verbose]
+        spade_path = File.join(rootdir, Spade::SPADE_DIR)
+        spade_package_path = File.join(spade_path, 'packages')
+        FileUtils.rm_r(spade_path) if File.exists? spade_path
+
+        FileUtils.mkdir_p File.join(spade_package_path)
+
+        FileUtils.ln_s BOOT_PATH, File.join(spade_path, 'boot')
+
+        installed = []
+        package_dirs = []
+
+        # In order of precedence
+        package_dirs += %w[packages vendor/packages vendor/cache].map{|p| File.join(rootdir, p.split('/')) }
+        package_dirs << File.join(LibGems.dir, 'gems') if defined?(Spade::Packager)
+
+        for package_dir in package_dirs
+          Dir.glob(File.join(package_dir, '*')).each do |path|
+            json_file = File.join(path, 'package.json')
+            next unless File.exists?(json_file)
+
+            # How would this happen?
+            next if installed.include? path
+            installed << path
+
+            json = JSON.load File.read(json_file)
+            package_name = json['name']
+            package_version = json['version']
+
+            local = path.index(rootdir) == 0
+
+            # Use relative paths if embedded
+            old_path = if local
+              # Figure out how many levels deep the spade_path is in the project
+              levels = spade_package_path.sub(rootdir, '').split(File::SEPARATOR).reject{|p| p.empty? }.count
+              # Build relative path
+              File.join(['..'] * levels, path.sub(rootdir, ''))
+            else
+              path
+            end
+
+            new_path = File.join(spade_path, 'packages', package_name)
+
+            unless File.exist?(new_path)
+              FileUtils.ln_s old_path, new_path, :force => true
+
+              puts "Installing #{local ? "local" : "remote"} package #{package_name}" if verbose
+            end
+          end
+        end
+
+        File.open(File.join(rootdir, 'spade-boot.js'), 'w+') do |fp|
+          fp.write gen_spade_boot(rootdir, opts)
+        end
+        puts "Wrote spade-boot.js" if verbose
+
+
+      end
+
+      def gen_spade_boot(rootdir, opts={})
+        verbose = opts[:verbose]
+        spade_path = File.join(rootdir, Spade::SPADE_DIR, 'packages', '*')
+        known_packages = Dir.glob(spade_path).map do |path|
+          package_name = File.basename path
+          info = JSON.load File.read(File.join(path, 'package.json'))
+          info["sync"] = true
+          info["root"] = "#{Spade::SPADE_DIR}/packages/#{package_name}"
+          info["files"] = package_file_list(path)
+          info
+        end
+
+        if File.exists? File.join(rootdir, 'package.json')
+          info = JSON.load File.read(File.join(rootdir, 'package.json'))
+        else
+          info = { 
+            "name" => File.basename(rootdir), 
+            "directories" => { "lib" => "lib" } 
+          }
+        end
+
+        info["root"] = '.'
+        info["sync"] = true
+        info["files"] = package_file_list('.')
+
+        packages = resolve_dependencies(info, known_packages)
+
+%[// GENERATED: #{Time.now.to_s}
+// This file is automatically generated by spade.  To update run 
+// 'spade update'. To use this file, reference it in your HTML file.  Base 
+// sure that your base URL is to the top level directory containing all of 
+// your files.
+
+/*globals spade */
+//@ begin boot
+(function() {
+  // load spade itself
+  var script = document.createElement('script');
+  script.src = "#{Spade::SPADE_DIR}/boot/spade.js";
+  script.onload = function() {
+
+    // Register remaining packages with spade
+#{packages.map{|p| %[spade.register("#{p["name"]}", #{JSON.pretty_generate(p)});\n] } * "\n"}
+
+    // find the main module to run
+    var main = null;
+    var scripts = document.scripts || document.getElementsByTagName("script"),
+        len = scripts.length;
+    for(var idx=0;!main && idx<len;idx++) {
+      main = scripts[idx].getAttribute('data-require');
+    }
+    scripts = null; // avoid memory leaks in IE
+
+    if (main) spade.ready(function() { spade.require(main); });
+  };
+
+  var head = document.head || document.body || document;
+  head.appendChild(script);
+
+  script = head = null; // avoid memory leaks in IE
+})();
+//@ end boot
+]
+
+      end
+
+      private
+
+        def package_file_list(path)
+          get_all_files(path).map{|p| p.sub(path+File::SEPARATOR, '') } - %w(package.json spade-boot.js)
+        end
+
+        # Supports recursive, be careful
+        def get_all_files(path)
+          Dir.glob(File.join(path, '**', '*')).
+            map{|p| File.symlink?(p) ? get_all_files(p) : p }.
+            flatten.
+            reject{|p| File.extname(p).empty? }
+        end
+
+        def resolve_dependencies(package, available)
+          # TODO: Should available be a hash to speed lookup?
+          if package["dependencies"]
+            # TODO: Check version numbers
+            dependencies = package["dependencies"].keys
+            packages = available.select{|p| dependencies.include?(p["name"]) }.
+                                 map{|p| resolve_dependencies(p, available) }.
+                                 flatten
+            (packages << package).uniq
+          else
+            [package]
+          end
+        end
+
+    end
+
+  end
+end

data/lib/spade/runtime/cli.rb

@@ -0,0 +1,7 @@
+module Spade
+  module Runtime
+    module CLI
+      autoload :Base, 'spade/runtime/cli/base'
+    end
+  end
+end

data/lib/spade/runtime/cli/base.rb

@@ -0,0 +1,181 @@
+require 'thor'
+
+module Spade
+  module Runtime
+    module CLI
+      class Base < Thor
+
+        class_option :working, :required => false,
+          :default => Spade.discover_root(Dir.pwd),
+          :aliases => ['-w'],
+          :desc    => 'Root working directory.'
+
+        class_option :verbose, :type => :boolean, :default => false,
+          :aliases => ['-V'],
+          :desc => 'Show additional debug information while running'
+
+        class_option :require, :type => :array, :required => false,
+          :aliases => ['-r'],
+          :desc => "optional JS files to require before invoking main command"
+
+        map  "-i" => "console", "--interactive" => "console"
+        desc "console", "Opens an interactive JavaScript console"
+        def console
+          require 'readline'
+
+          shell = Spade::Runtime::Shell.new
+          context(:with => shell) do |ctx|
+            shell.ctx = ctx
+            puts "help() for help. quit() to quit."
+            puts "Spade #{Spade::Runtime::VERSION} (V8 #{V8::VERSION})"
+            puts "WORKING=#{options[:working]}" if options[:verbose]
+
+            trap("SIGINT") { puts "^C" }
+            repl ctx
+          end
+        end
+
+        map  "-e" => "exec"
+        desc "exec [FILENAME]", "Executes filename or stdin"
+        def exec(*)
+          exec_args = ARGV.dup
+          arg = exec_args.shift while arg != "exec" && !exec_args.empty?
+
+          filename = exec_args.shift
+          puts "Filename: #{filename}" if options[:verbose]
+
+          if filename
+            puts "Working: #{options[:working]}" if options[:verbose]
+            filename = File.expand_path filename, Dir.pwd
+            throw "#{filename} not found" unless File.exists?(filename)
+            fp      = File.open filename
+            source  = File.basename filename
+            rootdir = Spade.discover_root filename
+
+            caller_id = nil
+            if rootdir
+              json_path = File.join(rootdir, 'package.json')
+              if File.exist?(json_path)
+                package_json = JSON.parse(File.read(json_path))
+                caller_id = "#{package_json['name']}/main"
+              end
+            end
+
+            # peek at first line.  If it is poundhash, skip. else rewind file
+            unless fp.readline =~ /^\#\!/
+              fp.rewind
+            end
+
+            # Can't set pos on STDIN so we can only do this for files
+            if options[:verbose]
+              pos = fp.pos
+              puts fp.read
+              fp.pos = pos
+            end
+          else
+            fp = $stdin
+            source = '<stdin>'
+            rootdir = options[:working]
+            caller_id = nil
+          end
+
+          if options[:verbose]
+            puts "source: #{source}"
+            puts "rootdir: #{rootdir}"
+            puts "caller_id: #{caller_id}"
+          end
+
+          begin
+            # allow for poundhash
+            context(:argv => exec_args, :rootdir => rootdir, :caller_id => caller_id) do |ctx|
+              ctx.eval(fp, source) # eval the rest
+            end
+          rescue Interrupt => e
+            puts; exit
+          end
+        end
+
+        map  "server" => "preview"
+        desc "preview", "Starts a preview server for testing"
+        long_desc %[
+          The preview command starts a simple file server that can be used to
+          load JavaScript-based apps in the browser.  This is a convenient way to
+          run apps in the browser instead of having to setup Apache on your
+          local machine.  If you are already loading apps through your own web
+          server (for ex using Rails) the preview server is not required.
+        ]
+        method_option :port, :type => :string, :default => '4020',
+          :aliases => ['-p'],
+          :desc => 'Port number'
+        def preview
+          require 'spade/runtime/server'
+          trap("SIGINT") { Spade::Runtime::Server.shutdown }
+          Spade::Runtime::Server.run(options[:working], options[:port]);
+        end
+
+        desc "update", "Update package info in the current project"
+        def update
+          Spade::Runtime::Bundle.update(options[:working], :verbose => options[:verbose])
+        end
+
+        private
+
+          def repl(ctx)
+            ctx.reactor.next_tick do
+              line = Readline.readline("spade> ", true)
+              begin
+                result = ctx.eval(line, '<console>')
+                puts result unless result.nil?
+              rescue V8::JSError => e
+                puts e.message
+                puts e.backtrace(:javascript)
+              rescue StandardError => e
+                puts e
+                puts e.backtrace.join("\n")
+              end
+              repl(ctx)
+            end
+          end
+
+          # Loads a JS file into the context.  This is not a require; just load
+          def load(cxt, libfile)
+            begin
+              content = File.readlines(libfile)
+              content.shift if content.first && (content.first =~ /^\#\!/)
+              cxt.eval(content*'')
+              #cxt.load(libfile)
+            rescue V8::JSError => e
+              puts e.message
+              puts e.backtrace(:javascript)
+            rescue StandardError => e
+              puts e
+            end
+          end
+
+          # Initialize a context to work against.  This will load also handle 
+          # autorequires
+          def context(opts={})
+            opts[:rootdir] ||= options[:working]
+            opts[:verbose] = options[:verbose]
+            Spade::Runtime::MainContext.new(opts) do |ctx|
+
+              requires = opts[:require]
+              requires.each { |r| load(ctx, r) } if requires
+
+              yield(ctx) if block_given?
+            end
+          end
+
+          def method_missing(meth, *)
+            if File.exist?(meth.to_s)
+              ARGV.unshift("exec")
+              invoke :exec
+            else
+              super
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/spade/runtime/compiler.rb

@@ -0,0 +1,34 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+module Spade::Runtime
+
+  # Compiler plugin for the default context.  Know how to create a new
+  # isolated context for the object
+  class Compiler
+    
+    def initialize(ctx)
+      @ctx = ctx
+    end
+    
+    def setup(sandbox)
+      if sandbox['isIsolated']
+        sandbox['ctx'] = Context.new :reactor => @ctx.reactor
+      end
+    end
+    
+    def compile(data, sandbox, filename)
+      ctx = sandbox['ctx'] || @ctx
+      ctx.eval("(#{data})", filename)
+    end
+    
+    def teardown(sandbox)
+      sandbox['ctx'] = nil
+    end
+    
+  end
+  
+end

data/lib/spade/runtime/console.rb

@@ -0,0 +1,39 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+
+module Spade::Runtime
+  
+  class Console
+    
+    def debug(*args)
+      puts "\033[35mDEBUG: #{args * ','}\033[m"
+      nil
+    end
+    
+    def info(*args)
+      puts args * ','
+      nil
+    end
+
+    def error(*args)
+      puts "\033[31mERROR: #{args * ','}\033[m"
+      nil
+    end
+    
+    def warn(*args)
+      puts "\033[33mWARN: #{args * ','}\033[m"
+      nil
+    end
+    
+    def log(*args)
+      puts args * ','
+      nil
+    end
+    
+  end
+  
+end