spade-runtime 0.1.0.1

data/lib/spade/runtime/context.rb

@@ -0,0 +1,114 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'v8'
+require 'spade/runtime/compiler'
+require 'spade/runtime/console'
+require 'spade/runtime/loader'
+require 'spade/runtime/reactor'
+
+module Spade::Runtime
+  
+  # Creates a basic context suitable for running modules.  The environments
+  # setup in this context will mimic a browser worker thread context, 
+  # including timeouts and a console.  A navigator object is also defined 
+  # that provides some general information about the context.
+  class Context < V8::Context
+
+    attr_reader :reactor
+    attr_reader :verbose
+    
+    def require(mod_name)
+      self.eval("require('#{mod_name}');");
+    end
+    
+    # Load the spade and racer-loader.
+    def initialize(opts={})      
+      @reactor = opts[:reactor]
+      @verbose = opts[:verbose]
+      super(opts) do |ctx|
+        ctx['reactor'] = @reactor
+        ctx['console'] = Console.new
+        ctx['window']  = ctx.scope
+        ctx.eval %[
+          (function() {
+            var r = reactor;
+            setTimeout    = function(c,i) { return r.set_timeout(c,i); };
+            setInterval   = function(c,i) { return r.set_interval(c,i); };
+            clearTimeout  = function(t) { return r.clear_timeout(t); };
+            clearInterval = function(t) { return r.clear_interval(t); };
+            navigator     = {
+              appName: 'spade',
+              appVersion: "#{Spade::Runtime::VERSION}",
+              platform: "#{RUBY_PLATFORM}",
+              userAgent: 'spade #{Spade::Runtime::VERSION}; #{RUBY_PLATFORM}'
+            }
+            
+            exit = function(status) { return r.exit(status || 0); };
+          })();
+        ]
+
+        ctx['reactor'] = nil 
+        
+        yield(ctx) if block_given?
+      end
+    end
+
+  end
+  
+  # The primary context created when running spade exec or spade console.
+  # This context will also automatically start a reactor loop.
+  class MainContext < Context
+
+    attr_accessor :rootdir
+    attr_accessor :caller_id
+    
+    # Load the spade and racer-loader.
+    def initialize(opts={})      
+      env = opts[:env] || ENV
+      @rootdir = opts[:rootdir] || opts['rootdir']
+      @caller_id = opts[:caller_id] || opts['caller_id']
+      @reactor = opts[:reactor] ||= Reactor.new(self)
+      lang = opts[:language] ||= (env['LANG']||'en_US').gsub(/\..*/, '')
+      lang = lang.gsub '_', '-'
+      
+
+      super(opts) do |ctx|
+        ctx['ENV'] = env.to_hash
+        ctx['ENV']['SPADE_PLATFORM'] = { 'ENGINE'   => 'spade' }
+        ctx['ENV']['LANG'] = lang
+         
+        ctx['ARGV'] = opts[:argv] || ARGV
+        
+        # Load spade and patch in compiler and loader plugins
+        ctx.load(Spade::JSPATH)
+        ctx['rubyLoader'] = Loader.new(self)
+        ctx['rubyCompiler'] = Compiler.new(self)
+        
+        ctx.eval %[
+          spade.loader = rubyLoader;
+          spade.compiler = rubyCompiler;
+          spade.defaultSandbox.rootdir = #{@rootdir.to_json};
+          spade.globalize();
+        ]
+
+        ctx.eval("spade.defaultSandbox.callerId = #{@caller_id.to_json};") if @caller_id
+
+        ctx['rubyLoader'] = ctx['rubyCompiler'] = nil
+        
+        @reactor.start do
+          yield(self) if block_given?
+        end
+        
+      end
+    end
+    
+  end
+end
+
+      
+      
+  

data/lib/spade/runtime/exports.rb

@@ -0,0 +1,86 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+module Spade
+  module Runtime
+    module Namespace
+      
+      def [](name)
+        begin
+          self.class.const_defined?(name) ? self.class.const_get(name) : yield
+        rescue NameError => e
+          yield
+        end
+      end
+
+    end
+    
+    class Exports
+      
+      attr_reader :context
+      
+      def initialize(ctx)
+        @context = ctx
+      end
+
+      def [](name)
+        
+        begin
+          if self.class.const_defined?(name)
+            ret = self.class.const_get(name)
+            
+            # If we are returning a class, create a custom subclass the first 
+            # time that also exposes the current context.
+            if ret.instance_of? Class
+              @klass_cache ||= {}
+              unless @klass_cache[name]
+
+                proc1 = proc { @context } 
+                @klass_cache[name] = Class.new(ret) do
+                  
+                  @context = proc1.call
+
+                  def self.context
+                    @context
+                  end
+                  
+                end
+
+              end
+              
+              @klass_cache[name]
+            else
+              ret
+            end
+              
+          else
+            yield
+          end
+          
+        rescue NameError => e
+          yield
+        end
+      end
+      
+    end
+  end
+
+  module Namespace
+    include Runtime::Namespace
+
+    def self.included(base)
+      warn("Spade::Namespace is deprecated. Use Spade::Runtime::Namespace instead. From #{base.name}")
+    end
+  end
+
+  class Exports < Runtime::Exports
+    def self.inherited(subclass)
+      warn("Spade::Exports is deprecated. Used Spade::Runtime::Exports instead. From #{subclass.name}")
+    end
+  end
+
+end
+

data/lib/spade/runtime/loader.rb

@@ -0,0 +1,209 @@
+# ==========================================================================
+# Project:   Spade - CommonJS Runtime
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'json'
+
+
+module Spade::Runtime
+
+  class Loader
+
+    def initialize(ctx)
+      @ctx = ctx
+    end
+
+    def discoverRoot(path)
+      Spade.discover_root path
+    end
+
+    def root(path=nil)
+      return @ctx.rootdir if path.nil?
+      @ctx.rootdir = path 
+      @packages = nil
+    end
+
+    # exposed to JS.  Find the JS file on disk and register the module
+    def loadFactory(spade, id, formats, done=nil)
+      formats = formats.to_a # We may get a V8::Array, we want a normal one
+
+      # load individual files
+      if id =~ /^file:\//
+        js_path = id[5..-1]
+        if File.exists? js_path
+          load_module id, js_path, ['js'], js_path
+        end
+        return nil
+      end
+
+      parts = id.split '/'
+      package_name = parts.shift
+      package_info = packages[package_name]
+      skip_module  = false
+
+      return nil if package_info.nil?
+
+      if parts.size==1 && parts[0] == '~package'
+        skip_module = true
+      elsif parts.size==1 && parts[0] == 'main'
+        parts = (package_info[:json]['main'] || 'lib/main').split('/')
+        dirname = parts[0...-1]
+        parts   = [parts[-1]]
+      else
+        dirname = extract_dirname(parts, package_info)
+      end
+
+      # register the package first - also make sure dependencies are 
+      # registered since they are needed for loading plugins
+      unless package_info[:registered]
+        package_info[:registered] = true
+        @ctx.eval "spade.register('#{package_name}', #{package_info[:json].to_json});"
+        
+        deps = package_info[:json]['dependencies'] || [];
+        deps.each do |dep_name, ignored|
+          dep_package_info = packages[dep_name]
+          next unless dep_package_info && !dep_package_info[:registered]
+          dep_package_info[:registered] = true
+          @ctx.eval "spade.register('#{dep_name}', #{dep_package_info[:json].to_json});"
+
+          # Add new formats if they are specified in our dependencies
+          dep_formats = dep_package_info[:json]['plugin:formats']
+          formats.unshift(*dep_formats.keys).uniq! if dep_formats
+        end
+              
+      end
+      
+      unless skip_module
+        filename = parts.pop
+        base_path = package_info[:path]
+        formats << ['js'] if formats.empty?
+        formats.each do |fmt|
+          cur_path = File.join(base_path, dirname, parts, filename+'.'+fmt)
+          if File.exist? cur_path
+            load_module id, cur_path, fmt, cur_path
+            return nil
+          end
+        end
+        
+        rb_path = File.join(package_info[:path],dirname,parts, filename+'.rb')
+        if File.exists? rb_path
+          load_ruby id, rb_path
+          return nil
+        end
+        
+      end
+      
+      return nil
+    end
+
+    # exposed to JS.  Determines if the named id exists in the system
+    def exists(spade, id, formats)
+      
+      # individual files
+      return File.exists?(id[5..-1]) if id =~ /^file:\//
+
+      parts = id.split '/'
+      package_name = parts.shift
+      package_info = packages[package_name]
+      
+      return false if package_info.nil?
+      return true if parts.size==1 && parts[0] == '~package'
+      
+      dirname = extract_dirname(parts, package_info)
+      
+      
+      filename = parts.pop
+      base_path = package_info[:path]
+      formats = ['js'] if formats.nil?
+      formats.each do |fmt|
+        cur_path = File.join(base_path, dirname, parts, filename+'.'+fmt)
+        return true if File.exist? cur_path
+      end
+      
+      rb_path = File.join(package_info[:path],dirname,parts, filename+'.rb')
+      return File.exists? rb_path
+    end
+    
+    def load_module(id, module_path, format, path)
+      module_contents = File.read(module_path).to_json # encode as string
+      @ctx.eval("spade.register('#{id}',#{module_contents}, { format: #{format.to_s.to_json}, filename: #{path.to_s.to_json} });")
+      nil
+    end
+
+    def load_ruby(id, rb_path)
+
+      klass = Spade.exports_for rb_path
+      exports = klass.nil? ? {} : klass.new(@ctx)
+      @ctx['$__rb_exports__'] = exports
+
+      @ctx.eval(%[(function() { 
+        var exp = $__rb_exports__; 
+        spade.register('#{id}', function(r,e,m) { m.exports = exp; }); 
+      })();])
+
+      @ctx['$__rb_exports__'] = nil
+    end
+
+    def packages
+      @packages unless @packages.nil?
+      @packages = {}
+
+      if defined?(Spade::Packager)
+        package_paths = Dir.glob(File.join(LibGems.dir, 'gems', '*'))
+        package_paths.each{|path| add_package(path) }
+      end
+
+      # in reverse order of precedence
+      %w[.spade/packages vendor/cache vendor/packages packages].each do |p|
+        package_paths = Dir.glob File.join(@ctx.rootdir, p.split('/'), '*')
+        package_paths.each { |path| add_package(path) }
+      end
+
+      # add self
+      add_package @ctx.rootdir
+
+      @packages
+    end
+
+    private
+
+    def extract_dirname(parts, package_info)
+      if parts.size>0 && parts[0].chars.first == '~'
+        dirname = parts.shift[1..-1]
+        if package_info[:directories][dirname]
+          dirname = package_info[:directories][dirname]
+        else
+          dirname = dirname
+        end
+      else
+        dirname = package_info[:directories]['lib']
+        dirname = 'lib' if dirname.nil?
+      end
+      
+      dirname
+    end
+
+    def add_package(path)
+      json_package = File.join(path, 'package.json')
+      return unless File.exists?(json_package)
+
+      json = JSON.load(File.read(json_package)) rescue nil
+      return if json.nil?
+
+      directories = json["directories"] || { "lib" => "lib" }
+      json["root"] = "file:/"+File.split(path).join('/')
+      @packages[json["name"]] = { 
+        :registered => false,
+        :path => path, 
+        :directories => directories,
+        :json => json 
+      }
+
+    end
+
+  end
+
+
+end

data/lib/spade/runtime/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::Runtime
+
+  # 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
+