spade 0.1.0 → 0.1.1.1

data/.gitignore

@@ -1,13 +1,2 @@
 tmp
-.bundle
 devbin
-spade-boot.js
-.spade
-examples/web-app/spade-boot.js
-examples/web-app/tests/ct-runner.js
-examples/web-app/.spade
-tests/ct-runner.js
-packages/sproutcore-runtime/tests/ct-runner.js
-*.swp
-.DS_Store
-node_modules

data/.gitmodules

@@ -1,6 +1,3 @@
-[submodule "vendor/spade-packager/packages/optparse"]
-	path = vendor/spade-packager/packages/optparse
-	url = https://github.com/qrush/optparse-js.git
-[submodule "vendor/spade-packager/packages/coffee-script"]
-	path = vendor/spade-packager/packages/coffee-script
-	url = https://github.com/charlesjolley/coffee-script.git
+[submodule "lib/spade/package"]
+	path = lib/spade/package
+	url = git://github.com/sproutcore/spade

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+if ENV["BPM_PATH"]
+  gem 'bpm', :path => ENV["BPM_PATH"]
+else
+  gem 'bpm', :git => "git://github.com/sproutcore/bpm"
+end
+
+gemspec
+

data/bin/spade

@@ -2,6 +2,8 @@
 lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
 $:.unshift(lib) if File.exists?(lib)
 
-require 'spade/cli'
+require 'spade'
 
 Spade::CLI::Base.start
+
+

data/lib/spade.rb

@@ -1,2 +1,72 @@
+require 'spade/version'
+
+begin
+  require 'bpm'
+rescue LoadError
+  # BPM isn't necessary, but we should use it if available
+end
+
 module Spade
+  SPADE_DIR = '.spade'
+
+  autoload :Bundle,     'spade/bundle'
+  autoload :Context,    'spade/context'
+  autoload :MainContext,'spade/context'
+  autoload :Server,     'spade/server'
+  autoload :Shell,      'spade/shell'
+  autoload :CLI,        'spade/cli'
+  autoload :Namespace,  'spade/exports'
+  autoload :Exports,    'spade/exports'
+  autoload :Packager,   'spade/packager'
+  autoload :Reactor,    'spade/reactor'
+  autoload :Console,    'spade/console'
+  autoload :Loader,     'spade/loader'
+  autoload :Evaluator,  'spade/evaluator'
+
+  def self.jspath
+    File.expand_path("../spade/package/lib/spade.js", __FILE__)
+  end
+
+  def self.boot_path
+    File.dirname(Spade.jspath)
+  end
+
+  # find the current path with a package.json or .packages or cur_path
+  def self.discover_root(cur_path)
+    ret = File.expand_path(cur_path)
+    while ret != '/' && ret != '.'
+      return ret if File.exists?(File.join(ret,'package.json')) || File.exists?(File.join(ret,'.spade'))
+      ret = File.dirname ret
+    end
+
+    return cur_path
+  end
+
+  def self.current_context
+    @current_context
+  end
+
+  def self.current_context=(ctx)
+    @current_context = ctx
+  end
+
+  def self.exports=(klass)
+    exports(klass, nil)
+  end
+
+  def self.exports(klass, path = nil)
+    path = @current_path if path.nil?
+    @exports ||= {}
+    @exports[path] = klass
+  end
+
+  def self.exports_for(path)
+    @current_path = path
+    require path
+    @current_path = nil
+
+    @exports ||= {}
+    @exports[path]
+  end
+
 end

data/lib/spade/bundle.rb

@@ -0,0 +1,180 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'json'
+
+module Spade
+  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 Spade.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?(BPM)
+
+        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";
+
+  function boot() {
+    // 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); });
+  };
+
+  script.onload = boot;
+  // IE doesn't support onload for scripts
+  script.onreadystatechange = function(){
+    if (script.readyState === 'loaded' || script.readyState === 'complete') {
+      boot();
+      script = null; // avoid memory leaks in IE
+    }
+  };
+
+  var head = document.head || document.body || document;
+  head.appendChild(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, '') }.reject{|p| p =~ %r{packages/} } - %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/cli.rb

@@ -1,21 +1,5 @@
-# ==========================================================================
-# Project:   Spade - CommonJS Runtime
-# Copyright: ©2010 Strobe Inc. All rights reserved.
-# License:   Licened under MIT license (see LICENSE)
-# ==========================================================================
-
-require 'thor'
-require 'spade/packager'
-require 'spade/runtime'
-
 module Spade
   module CLI
-    class Base < Thor
-      desc "package", "Manage packages"
-      subcommand "package", Spade::Packager::CLI::Base
-
-      desc "runtime", "Run Spade packages and applications"
-      subcommand "runtime", Spade::Runtime::CLI::Base
-    end
+    autoload :Base, 'spade/cli/base'
   end
 end

data/lib/spade/cli/base.rb

@@ -0,0 +1,182 @@
+require 'thor'
+
+module Spade
+  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::Shell.new
+
+        context do |ctx|
+          shell.inject(ctx)
+          puts "help() for help. quit() to quit."
+          puts "Spade #{Spade::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/server'
+        trap("SIGINT") { Spade::Server.shutdown }
+        Spade::Server.run(options[:working], options[:port]);
+      end
+
+      desc "update", "Update package info in the current project"
+      def update
+        Spade::Bundle.update(options[:working], :verbose => options[:verbose])
+      end
+
+      private
+
+        def repl(ctx)
+          ctx.reactor.next_tick do
+            line = Readline.readline("spade> ", true)
+            unless line.chomp.empty?
+              begin
+                result = ctx.eval(line, '<console>')
+                puts ctx['inspectjs'].call(result)
+              rescue V8::JSError => e
+                puts e.message
+                puts e.backtrace(:javascript)
+              rescue StandardError => e
+                puts e
+                puts e.backtrace.join("\n")
+              end
+            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::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