harmony 0.5

data/vendor/envjs/lib/envjs/net.rb

@@ -0,0 +1,3 @@
+require 'envjs'
+
+module Envjs::Net; end

data/vendor/envjs/lib/envjs/net/cgi.rb

@@ -0,0 +1,94 @@
+require 'net/protocol'
+
+require 'envjs/net'
+
+class Envjs::Net::CGI
+
+  def save_and_set k, v
+    @saved[k] = ENV[k]
+    ENV[k] = v
+  end
+
+  def restore
+    @saved.keys.each do |k|
+      ENV[k] = @saved[k]
+    end
+    @saved = {}
+  end
+
+  def initialize xhr, data
+    if (match = %r((.*\.php)(\?(.*))?).match xhr.url).nil?
+      raise "Not CGI"
+    end
+
+    @saved = {}
+
+    begin
+
+      # p match[0]
+
+      path = match[1]
+      path.sub! %r(^file://), ""
+
+      save_and_set( "GATEWAY_INTERFACE", "CGI/1.1" )
+
+      save_and_set( "REQUEST_METHOD", xhr["method"] )
+      if ( match[3] )
+        save_and_set( "QUERY_STRING", match[3] )
+      end
+
+      if ct = xhr["headers"]["Content-Type"]
+        save_and_set( "CONTENT_TYPE", ct )
+      end
+
+      if data
+        save_and_set( "CONTENT_LENGTH", data.length.to_s )
+      end
+
+      xhr["headers"].each do |k,v|
+        k.gsub!("-","_")
+        k = "HTTP_"  + k
+        save_and_set( k, v )
+      end
+
+      result = nil
+
+      save_and_set( "PATH_INFO",  path )
+      save_and_set( "PATH_TRANSLATED",  path )
+      save_and_set( "REDIRECT_STATUS", "200" )
+
+      open("|php-cgi", "r+") do |php|
+        if data
+          php.write data
+          php.flush
+        end
+        result = php.read
+      end
+
+      result && result = result.split("\r\n")
+      @headers = {}
+      while line = result.shift
+        break if line == ""
+        match = /([^:]*):\s*(.*)/.match line
+        @headers[match[1]]=match[2]
+      end
+      # p "q", result.join("\r\n")
+      @body = result.join("\r\n")
+    ensure
+      restore
+    end
+
+  end
+
+  def each 
+    @headers.each do |k,v|
+      yield k, v
+    end
+  end
+
+  def finish
+  end
+
+  attr_reader :body
+
+end

data/vendor/envjs/lib/envjs/net/file.rb

@@ -0,0 +1,75 @@
+require 'net/protocol'
+
+require 'envjs/net'
+
+class Envjs::Net::File < Net::Protocol
+
+  class << self
+    attr_accessor :on_open
+  end
+
+  class Get
+    attr_accessor :path
+    def initialize path
+      @path = path
+    end
+  end
+
+  def initialize host, port
+  end
+
+  def self.start host, port
+    new( host, port ).start
+  end
+
+  def start
+    self
+  end
+
+  def finish
+  end
+
+  def request request
+    Response.new request.path
+  end
+
+  class Response
+    def initialize path
+      @path = path
+      on_open = Envjs::Net::File.on_open
+      on_open and on_open.call( path )
+      @file = File.new @path
+      @body = @file.read
+      @code = @file.nil? ? "404" : "200";
+      @file.close
+    end
+
+    def [] *args
+      nil
+    end
+
+    def each &block
+    end
+
+    def getHeaderFields
+      []
+    end
+
+    def getContentEncoding
+      nil
+    end
+
+    def getResponseCode
+      @file.nil? ? 404 : 200;
+    end
+
+
+    def getInputStream
+      self
+    end
+
+    attr_reader :body, :code
+
+  end
+
+end

data/vendor/envjs/lib/envjs/options.rb

@@ -0,0 +1,11 @@
+require 'optparse'
+
+$envjsrb_deps = nil
+
+OptionParser.new do |o|
+
+  o.on("--deps path") do |path|
+    $envjsrb_deps = path
+  end
+
+end.parse!

data/vendor/envjs/lib/envjs/runtime.rb

@@ -0,0 +1,351 @@
+require 'envjs'
+require "open-uri"
+require 'pathname'
+begin
+  require 'fsdb'
+rescue LoadError; end
+require 'envjs/net/file'
+
+module Envjs::Runtime
+
+  def self.extended object
+    object.instance_eval do
+
+      evaluate <<'EOJS'
+print = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby.print(s);
+    if( i < l-1 ) {
+      Ruby.print(" ");
+    }
+  }
+  Ruby.print("\n");
+  Ruby['$stdout'].flush();
+};
+EOJS
+
+      evaluate <<'EOJS'
+debug = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby['$stderr'].print(s);
+    if( i < l-1 ) {
+      Ruby['$stderr'].print(" ");
+    }
+  }
+  Ruby['$stderr'].print("\n");
+};
+EOJS
+
+      evaluate <<'EOJS'
+puts = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby.print(s);
+    Ruby.eval("$stdout.flush")
+  }
+};
+EOJS
+
+      master = global["$master"] = evaluate("new Object")
+      master.symbols = [ "Johnson", "Ruby", "print", "debug", "puts", "load", "reload", "whichInterpreter", "multiwindow" ]
+      master.symbols.each { |symbol| master[symbol] = global[symbol] }
+
+      master.whichInterpreter = "Johnson"
+
+      master.multiwindow = true
+
+      # calling this from JS is hosed; the ruby side is confused, maybe because HTTPHeaders is mixed in?
+      master.add_req_field = lambda { |r,k,v| r.add_field(k,v) }
+
+      db = lambda do
+        $envjsrb_deps && ( @db ||= FSDB::Database.new $envjsrb_deps )
+      end
+
+      top_level_js = nil
+
+      add_dep = nil
+      
+      clear_deps = lambda do |w|
+        begin
+          if db.call
+            loc = w
+            begin loc = w.location; rescue; end
+            loc && ( loc = loc.to_s )
+            if ( loc !~ %r((http?s|file|about):) )
+              begin
+                loc = "file://" + Pathname(loc).realpath.to_s
+              rescue Errno::ENOENT; end
+            end
+            # $stderr.puts "clear", loc
+            if loc and loc != "about:blank"
+              paths = db.call[loc+".on.yml"] || []
+              paths.each do |path|
+                # $stderr.print "#{path} not by #{loc}\n";
+                db.call[path+".by.yml"].delete loc
+              end
+              # $stderr.print "#{loc} not on anything\n";
+              db.call.delete loc+".on.yml"
+            end
+          end
+          add_dep.call( nil, loc )
+        rescue Exception => e; $stderr.puts e, e.class; $stderr.puts e.backtrace; end
+      end
+
+      if $envjsrb_deps
+        Envjs::Net::File.on_open = clear_deps
+      end
+      
+      add_dep = lambda do |w, f|
+        if db.call
+          loc = nil
+          begin loc = w.location; rescue Exception; end
+          loc && ( loc = loc.to_s )
+          if ( loc && loc !~ %r((http?s|file|about):) )
+            loc = "file://" + Pathname(loc).realpath.to_s
+          end
+          path = f
+          if ( path !~ %r((http?s|file|about):) )
+            begin
+              path = "file://" + Pathname(path).realpath.to_s
+            rescue Errno::ENOENT
+              return
+            end
+          end
+          if !loc || loc == "about:blank"
+            uri = URI.parse top_level_js
+            if uri.scheme == nil
+              uri.scheme = "file"
+              begin
+                uri.path = Pathname.new(uri.path).realpath.to_s
+              rescue Errno::ENOENT; end
+              uri = URI.parse uri.to_s
+            end
+            uri_s = uri.to_s.sub %r(^file:/([^/])), 'file:///\1'
+
+            # tll = "file://" + Pathname(top_level_js).realpath.to_s
+
+            tll = uri_s
+
+            if ( tll != path ) 
+              loc = tll
+            end
+          end
+          if loc and loc != "about:blank"
+            on = db.call[loc+".on.yml"] || []
+            on << path
+            on.uniq!
+            db.call[loc+".on.yml"] = on
+            by = db.call[path+".by.yml"] || []
+            by << loc
+            by.uniq!
+            db.call[path+".by.yml"] = by
+            # $stderr.print "#{loc} on #{path}: #{db.call[loc+'.on.yml'].join(' ')}\n"
+            # $stderr.print "#{path} by #{loc}: #{db.call[path+'.by.yml'].join(' ')}\n"
+          end
+        end
+      end
+
+      (class << self; self; end).send :define_method, :top_level_load do |path|
+        # $stderr.print "tll #{path}\n"
+        top_level_js = path
+        clear_deps.call( path )
+      end
+
+      master.load = lambda { |*files|
+        if files.length == 2 && !(String === files[1])
+          f = files[0]
+          w = files[1]
+
+          # Hmmm ...
+          uri = URI.parse f
+
+          if uri.scheme == nil
+            uri.scheme = "file"
+            begin
+              uri.path = Pathname.new(uri.path).realpath.to_s
+            rescue Errno::ENOENT; end
+            uri = URI.parse uri.to_s
+          end
+
+          uri_s = uri.to_s.sub %r(^file:/([^/])), 'file:///\1'
+
+          if uri.scheme == "file"
+            uri_s = uri.path
+          elsif uri.scheme == "data"
+            raise "implement 0"
+          end
+
+          v = open(uri_s).read.gsub(/\A#!.*$/, '')
+          loc = nil
+          add_dep.call w, f
+          evaluate(v, f, 1, w, w, f)
+        else
+          load *files
+        end
+      }
+
+      def load *files
+        files.map { |f|
+          # Hmmm ...
+
+          uri = URI.parse f
+          if uri.scheme == nil
+            uri.scheme = "file"
+            begin
+              uri.path = Pathname.new(uri.path).realpath.to_s
+            rescue Errno::ENOENT; end
+            uri = URI.parse uri.to_s
+          end
+          uri_s = uri.to_s.sub %r(^file:/([^/])), 'file:///\1'
+          
+          if uri.scheme == "file"
+            super uri.path
+          elsif uri.scheme == "data"
+            raise "implement 1"
+          else
+            raise "hell 1"
+          end
+
+          # v = open(uri_s).read.gsub(/\A#!.*$/, '')
+          # loc = nil
+          # add_dep.call w, f
+          # evaluate(v, f, 1, w, w, f)
+          # evaluate(File.read(f).gsub(/\A#!.*$/, ''), f, 1)
+
+        }.last
+      end
+
+      master.reload = lambda { |*files|
+        if files.length == 2 && !(String === files[1])
+          f = files[0]
+          w = files[1]
+          v = open(f).read.gsub(/\A#!.*$/, '')
+          loc = nil
+          add_dep.call w, f
+          reevaluate(v, f, 1, w, w, f)
+        else
+          reload *files
+        end
+      }
+
+      master.evaluate = lambda { |v,w|
+        evaluate(v,"inline",1,w,w);
+      }
+
+      master.new_split_global_outer = lambda { new_split_global_outer }
+      master.new_split_global_inner = lambda { |outer,_| new_split_global_inner outer }
+
+      # create an proto window object and proxy
+
+      outer = new_split_global_outer
+      window = inner = new_split_global_inner( outer )
+
+      master.symbols.each do |symbol|
+        window[symbol] = master[symbol]
+      end
+
+      master.first_script_window = window
+
+      window["$master"] = master
+      window["$options"] = evaluate("new Object");
+      window["$options"].proxy = outer
+
+      window.evaluate = lambda { |s|
+        return master.evaluate.call(s,window);
+      }
+
+      window.load = lambda { |*files|
+        files.each do |f|
+          master.load.call f, window
+        end
+      }
+
+      window.reload = lambda { |*files|
+        files.each do |f|
+          master.reload.call f, window
+        end
+      }
+
+      ( class << self; self; end ).send :define_method, :wait do
+        master["finalize"] && master.finalize.call
+        master.timers && master.timers.wait
+      end
+
+      scripts = {}
+
+      ( class << self; self; end ).send :define_method, :become_first_script_window do
+        # p "heh", inner, master.first_script_window
+        inner = master.first_script_window
+      end
+
+      ( class << self; self; end ).send :define_method, :evaluate do |*args|
+        ( script, file, line, global, scope, fn ) = *args
+        # print "eval in " + script[0,50].inspect + (scope ? scope.toString() : "nil") + "\n"
+        global = nil
+        scope ||= inner
+        if fn
+          compiled_script = scripts[fn]
+        end
+        # compiled_script = compile(script, file, line, global)
+        compiled_script ||= compile(script, file, line, global)
+        if fn && !scripts[fn]
+          scripts[fn] = compiled_script
+        end
+        # p "?", script
+        evaluate_compiled_script(compiled_script,scope)
+      end
+
+      ( class << self; self; end ).send :define_method, :reevaluate do |*args|
+        ( script, file, line, global, scope, fn ) = *args
+        # print "eval in " + script[0,50].inspect + (scope ? scope.toString() : "nil") + "\n"
+        global = nil
+        scope ||= inner
+        compiled_script = compile(script, file, line, global)
+        if fn
+          scripts[fn] = compiled_script
+        end
+        evaluate_compiled_script(compiled_script,scope)
+      end
+
+      @envjs = inner
+
+      ( class << self; self; end ).send :define_method, :"[]" do |key|
+        key == "this" && evaluate("this") || @envjs[key]
+      end
+
+      ( class << self; self; end ).send :define_method, :"[]=" do |k,v|
+        @envjs[k] = v
+      end
+
+      load Envjs::ENVJS
+
+    end
+  end
+
+end