jscmd 0.0.2 → 0.1.0

data/test/{test_jscmd.rb → test_proxyserver.rb}

@@ -1,42 +1,38 @@
-$port = 19000
+require File.dirname(__FILE__) + '/test_helper.rb'
 
-$proxy_stdin, $proxy_stdin_writer = IO.pipe
-$proxy_stdout_reader, $proxy_stdout = IO.pipe
-
-$shell_pid = fork do
-  at_exit {} # prevent TestRunner from running
-  $stdin.reopen($proxy_stdin)
-  $stdout.reopen($proxy_stdout)
-  require File.dirname(__FILE__) + '/test_helper.rb'
-  server = JSCommander::Broker.new(:Port => $port, :AccessLog => [])
-  server.start
-end
-
-require "net/http"
 require "open-uri"
-require "test/unit"
-require "zlib"
 
-# wait until the server starts up
-60.times do
-  begin
-    Net::HTTP.get("localhost", "/", $port)
-    break
-  rescue Exception => e
+class TestProxyServer < Test::Unit::TestCase
+  PORT = 19000
+
+  def setup
+    unless $jscmd_proxy
+      $jscmd_broker = JSCommander::InProcessBroker.new
+      $jscmd_proxy = JSCommander::ProxyServer.new($jscmd_broker, 
+                                                  :Port => PORT, :AccessLog => [], :ProxyVia => nil)
+      Thread.start { $jscmd_proxy.start }
+      60.times do
+        begin
+          Net::HTTP.get("localhost", "/", PORT)
+          break
+        rescue Exception => e
+        end
+        puts "waiting..."
+        sleep 0.5
+      end
+    end
+    @proxy = $jscmd_proxy
+    @broker = $jscmd_broker
   end
-  puts "waiting..."
-  sleep 0.5
-end
 
-class TestJscmd < Test::Unit::TestCase
   def test_proxy
-    open("http://www.google.co.jp/", :proxy => "http://localhost:#{$port}/") do |f|
+    open("http://www.google.co.jp/", :proxy => "http://localhost:#{PORT}/") do |f|
       assert_match %r{/_remote_js_proxy/agent.js}, f.read
     end
   end
-
+  
   def test_proxy_with_gzip_compression
-    body = Net::HTTP.start("www.google.co.jp", 80, "localhost", $port) do |h|
+    body = Net::HTTP.start("www.google.co.jp", 80, "localhost", PORT) do |h|
       res = h.get("/", 
                   "Accept-Encoding" => "gzip",
                   "User-Agent" => "Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; ja-JP-mac; rv:1.8.1.3) Gecko/20070309 Firefox/2.0.0.3")
@@ -47,28 +43,32 @@ class TestJscmd < Test::Unit::TestCase
   end
 
   def test_get_script
-    open("http://www.google.com/_remote_js_proxy/agent.js", :proxy => "http://localhost:#{$port}/") do |f|
+    open("http://www.google.com/_remote_js_proxy/agent.js", :proxy => "http://localhost:#{PORT}/") do |f|
       assert_equal File.read("lib/jscmd/agent.js"), f.read
     end
   end
 
   def test_poll_and_get_command
-    $proxy_stdin_writer.puts "window"
-    # assert_equal "> window\n", $proxy_stdout_reader.readline
-    open("http://www.google.com/_remote_js_proxy/poll", :proxy => "http://localhost:#{$port}/") do |f|
-      assert_equal "Ewindow", f.read
+    @broker.send "commands", JSCommander::Message.new("window", :type => "eval")
+    open("http://www.google.com/_remote_js_proxy/poll", :proxy => "http://localhost:#{PORT}/") do |f|
+      assert_equal "window", f.read
     end
   end
-
+  
   def test_poll_and_post_value
     begin
+      q = Queue.new
+      s = @broker.subscribe("events") do |msg|
+        q.push msg.body
+      end
       body = nil
       t = Thread.start do
         # browser thread
         begin
-          Net::HTTP.start("www.google.com", 80, "localhost", $port) do |h|
+          Net::HTTP.start("www.google.com", 80, "localhost", PORT) do |h|
             # (1) send value from browser to shell
-            body = h.post("/_remote_js_proxy/poll", "Vabc", 
+            body = h.post("/_remote_js_proxy/poll", "abc", 
+                          "X-JSCmd-Type" => "value",
                           "Content-Type" => "application/x-www-form-urlencoded").body
             # (4) received another command and long-poll terminates
           end
@@ -76,19 +76,13 @@ class TestJscmd < Test::Unit::TestCase
           p e
         end
       end
-      assert_match(/(sleep|run)/, t.status)
       # (2) read value sent from browser
-      assert_equal "abc\n", $proxy_stdout_reader.readline
-      assert_match(/(sleep|run)/, t.status)
+      assert_equal "abc", q.pop
     ensure
       # (3) send another command to finish long-poll in browser
-      $proxy_stdin_writer.puts "window"
+      @broker.send("commands", JSCommander::Message.new("document", :type => "eval"))
       t.join
-      assert_equal "Ewindow", body
+      assert_equal "document", body
     end
   end
 end
-
-END { Process.kill "TERM", $shell_pid; Process.waitall }
-
-exit Test::Unit::AutoRunner.run

data/test/test_shell.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestShell < Test::Unit::TestCase
+  def setup
+    @broker = JSCommander::InProcessBroker.new
+    @shell = JSCommander::Shell.new(@broker)
+    @output_reader, output = IO.pipe
+    input, @input_writer = IO.pipe
+    console = JSCommander::Shell::SimpleConsole.new(input)
+    @shell.instance_variable_set(:@console, console)
+    @shell.instance_variable_set(:@output, output)
+    def @shell.puts(msg)
+      @output.puts msg
+    end
+    @thread = Thread.start do
+      begin
+        @shell.run
+      rescue Exception
+        p $!
+      end
+    end
+  end
+
+  def teardown
+    @input_writer.close
+    @thread.join
+  end
+
+  def test_complete_property
+    @broker.subscribe("commands") do |msg|
+      assert_equal "this", msg.body
+      assert_equal "properties", msg.attributes["type"]
+      id = msg.attributes["id"]
+      @broker.send("events", JSCommander::Message.new("alert,abc,def", :type => "value",
+                                                      "in-reply-to" => id))
+    end
+    assert_equal %w(alert abc), @shell.complete_property("a")
+  end
+
+  def test_run
+    q = Queue.new
+    @broker.subscribe("commands") do |msg|
+      q.push msg
+    end
+    assert q.empty?
+    
+    @input_writer.puts "window"
+    msg = q.pop
+    assert_equal "window", msg.body
+    id = msg.attributes["id"]
+    
+    @broker.send("events", JSCommander::Message.new("foobar", :type => "value",
+                                                    "in-reply-to" => id))
+    assert_equal "foobar\n", @output_reader.readline
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: jscmd
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2007-05-08 00:00:00 +09:00
+  version: 0.1.0
+date: 2007-05-13 00:00:00 +09:00
 summary: JavaScript console for any browser
 require_paths: 
 - lib
@@ -37,17 +37,26 @@ files:
 - Rakefile
 - bin/jscmd
 - lib/jscmd.rb
-- lib/jscmd/version.rb
-- lib/jscmd/jscommander.rb
 - lib/jscmd/asynchttpproxy.rb
+- lib/jscmd/inprocessbroker.rb
+- lib/jscmd/message.rb
+- lib/jscmd/pipebroker.rb
+- lib/jscmd/proxyserver.rb
+- lib/jscmd/shell.rb
+- lib/jscmd/stompproxy.rb
+- lib/jscmd/urlforwarder.rb
+- lib/jscmd/version.rb
 - lib/jscmd/agent.js
 - scripts/txt2html
 - setup.rb
 - test/test_helper.rb
-- test/test_jscmd.rb
+- test/test_proxyserver.rb
+- test/test_shell.rb
+- examples/get_title.pl
 test_files: 
 - test/test_helper.rb
-- test/test_jscmd.rb
+- test/test_proxyserver.rb
+- test/test_shell.rb
 rdoc_options: []
 
 extra_rdoc_files: []
@@ -58,5 +67,22 @@ extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: stomp
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: stompserver
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.7
+    version: 

data/lib/jscmd/jscommander.rb

@@ -1,339 +0,0 @@
-#
-# jscommander.rb: Remote JavaScript Console
-#
-# Copyright 2007 Shinya Kasatani
-#
-
-require 'uri'
-require 'thread'
-require 'webrick'
-require 'zlib'
-
-module JSCommander
-  SCRIPT_DIR = "/_remote_js_proxy/"
-  
-  class PipeQueue
-    attr_reader :reader, :writer
-    
-    def initialize
-      @reader, @writer = IO.pipe
-    end
-    
-    def push(obj)
-      data = Marshal.dump(obj)
-      @writer.write([data.size].pack("N") + data)
-    end
-
-    def pop
-      size = @reader.read(4).unpack("N")[0]
-      Marshal.load(@reader.read(size))
-    end
-  end
-
-  # types are: V: value, E: error, A: active message from proxy
-  Message = Struct.new(:value, :type, :clients)
-  
-  class Broker
-    attr_reader :cmd_queue, :msg_queue
-
-    def initialize(opts = {})
-      @cmd_queue = PipeQueue.new
-      @msg_queue = PipeQueue.new
-      @proxy = ProxyServer.new(self, opts)
-      @shell = Shell.new(self)
-    end
-    
-    def start
-      @proxy_pid = fork do
-        begin
-          Signal.trap('INT') {}
-          Signal.trap('TERM') { @proxy.shutdown }
-          IO.for_fd(0).close
-          @proxy.start
-        rescue Exception => e
-          p e
-        end
-      end
-      Signal.trap("TERM") { shutdown }
-      @shell.run # @shell.run should block
-    end
-
-    def shutdown
-      $stderr.puts "shutdown"
-      Process.kill "TERM", @proxy_pid
-      Process.waitall
-      exit(0)
-    end
-  end
-
-  class Shell
-    class SimpleConsole
-      def show_banner
-      end
-
-      def readline
-        line = $stdin.readline
-        line.chomp! if line
-        line
-      end
-      
-      def close
-      end
-    end
-    
-    class ReadlineConsole
-      HISTORY_PATH = "~/.jscmd_history"
-      
-      def history_path
-        File.expand_path(HISTORY_PATH)
-      end
-
-      def initialize(shell)
-        @shell = shell
-        require 'readline'
-        if File.exist?(history_path)
-          hist = File.readlines(history_path).map{|line| line.chomp}
-          Readline::HISTORY.push(*hist)
-        end
-        Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+-*/%"
-        Readline.completion_append_character = nil
-        Readline.completion_proc = proc do |word|
-          if word =~ /\.$/
-            @shell.object_props($`).map{|name| word + name}
-          elsif word =~ /\.([^.]+)$/
-            prefix = $1
-            parent = $`
-            props = @shell.object_props(parent)
-            props.select{|name|name[0...(prefix.size)] == prefix}.map{|name| "#{parent}.#{name}"}
-          else
-            props = @shell.object_props("this")
-            prefix = word
-            props.select{|name|name[0...(prefix.size)] == prefix}
-          end
-        end
-      end
-      
-      def show_banner
-        puts "Press Ctrl+D to exit."
-      end
-      
-      def close
-        open(history_path, "ab") do |f|
-          Readline::HISTORY.each{|line| f.puts(line)}
-        end
-      end
-
-      def readline
-        line = Readline.readline("#{@shell.clients}> ", true)
-        Readline::HISTORY.pop if /^\s*$/ =~ line
-        line
-      end
-    end
-
-    def console
-      @console ||= $stdin.tty? ? ReadlineConsole.new(self) : SimpleConsole.new
-    end
-
-    attr_reader :clients
-    
-    def initialize(broker)
-      @broker = broker
-      @clients = nil
-      @msg_lock = Mutex.new
-    end
-
-    def send_script(line, &handler)
-      @msg_lock.synchronize do
-        @broker.cmd_queue.push(line)
-        yield read_msg
-      end
-    end
-
-    def read_msg
-      msg = @broker.msg_queue.pop
-      # p msg
-      @clients = msg.clients
-      msg
-    end
-
-    def object_props(object)
-      send_script("P" + object) do |r|
-        if r.type == "V" && r.value
-          r.value.split(/,/)
-        else
-          []
-        end
-      end
-    end
-
-    def run
-      # read and print messages in background
-      Thread.start do
-        while IO.select([@broker.msg_queue.reader], nil, nil, nil)
-          @msg_lock.synchronize do
-            if IO.select([@broker.msg_queue.reader], nil, nil, 0)
-              msg = read_msg
-              puts msg.value || ""
-              Process.kill "INT", $$  # interrupt readline
-            end
-          end
-        end
-      end
-
-      console.show_banner
-      
-      begin
-        loop do
-          break unless line = console.readline
-          send_script("E" + line) do |msg|
-            puts msg.value if msg.value
-          end
-        end
-      rescue Interrupt
-        retry
-      rescue SystemExit
-        return
-      rescue Exception => e
-        $stderr.puts "#{e.inspect} at:\n#{e.backtrace.join("\n")}"
-      ensure
-        begin
-          console.close
-        rescue Exception => e
-          $stderr.puts "failed to close console: #{e.inspect}"
-        end
-      end
-      @broker.shutdown
-    end
-  end
-
-  class ProxyServer < WEBrick::AsyncHTTPProxyServer
-    def initialize(broker, args = {})
-      @broker = broker
-      @cmd_queue = PipeQueue.new
-      @clients = []
-      super({:ProxyContentHandler => method(:handle_content).to_proc}.merge(args))
-    end
-
-    def start
-      Thread.start do
-        sleep 1
-        begin
-          poll_cmd_queue
-        rescue Exception => e
-          p e
-        end
-      end
-      super
-    end
-
-    def service(req, res)
-      if req.path == "#{SCRIPT_DIR}agent.js"
-        res.content_type = "application/x-javascript"
-        res.body = File.read(File.join(File.dirname(__FILE__), "agent.js"))
-      elsif req.path == "#{SCRIPT_DIR}poll"
-        serve_script(req, res)
-      else
-        if req.header["accept-encoding"] && !req.header["accept-encoding"].empty?
-          if req.header["accept-encoding"].first.split(/,/).include?("gzip")
-            req.header["accept-encoding"] = ["gzip"]
-          else
-            req.header.delete "accept-encoding"
-          end
-        end
-        super
-      end
-    end
-    
-    def format_clients
-      @clients.map{|c|"[#{URI.parse(c.header["referer"].to_s).host}]"}.join(",")
-    end
-
-    def poll_cmd_queue
-      while @status == :Running
-        cmd = @broker.cmd_queue.pop
-        cmd_line = cmd[1...(cmd.size)]
-        if cmd_line.strip.empty?
-          @broker.msg_queue.push(Message.new(nil, "V", format_clients))
-        else
-          @cmd_queue.push(cmd)
-        end
-      end
-    end
-
-    def serve_script(req, res)
-      # puts "serve:#{req.body}"
-      @clients << req
-      if req.body && req.body =~ /^(\+?)([VE])/
-        more = $1 == '+'
-        type = $2
-        # V: value
-        # E: error
-        @broker.msg_queue.push Message.new(URI.decode($'), type, format_clients)
-        if more
-          res.content_type = "text/plain"
-          res.body = ''
-          return
-        end
-      else
-        # empty message - maybe a new client connected?
-        @broker.msg_queue.push Message.new(nil, "A", format_clients)
-      end
-      while @status == :Running
-        req_socket = req.instance_eval{@socket}
-        sockets = [req_socket, @cmd_queue.reader]
-        if @clients.first != req
-          # don't poll cmd_queue if this is request is not the first one
-          sockets.pop
-        end
-        r = IO.select(sockets, nil, nil, 1)
-        if r
-          if r[0].include?(@cmd_queue.reader)
-            line = @cmd_queue.pop
-            res.content_type = "text/plain"
-            res.body = line
-            return
-          elsif r[0].include?(req_socket)
-            @clients.delete(req); req = nil
-            @broker.msg_queue.push(Message.new("aborted", "A", format_clients))
-            raise WEBrick::HTTPStatus::EOFError
-          end
-        end
-      end
-      # server is shutting down
-      raise WEBrick::HTTPStatus::EOFError
-    ensure
-      @clients.delete(req) if req
-    end
-
-    def handle_content(req, res)
-      # $stderr.puts "handle_content:type=#{res.content_type}, status=#{res.status}, encoding=#{res.header["content-encoding"]}"
-      if res.content_type =~ %r{^text/html} && res.status == 200
-        res.flush_body
-        # we cannot always trust content_type, so check if the content looks like html
-        body = res.body
-        if res.header["content-encoding"] == "gzip"
-          body = Zlib::GzipReader.new(StringIO.new(body)).read
-        end
-        if body =~ /^\s*</
-          body = body.dup
-          # puts "injecting javascript"
-          script_tag = '<script type="text/javascript" src="/_remote_js_proxy/agent.js"></script>'
-          unless body.sub!(%r{<head( .*?)?>}i){|s|s+script_tag}
-            body = script_tag + body
-          end
-          if res.header["content-encoding"] == "gzip"
-            io = StringIO.new
-            writer = Zlib::GzipWriter.new(io)
-            writer.write(body)
-            writer.close
-            res.body = io.string
-          else
-            res.body = body
-          end
-          res.content_length = res.body.size if res.content_length
-        end
-      end
-    end
-  end
-end
-