RubyGems - terminus - Versions diffs - 0.1.0 → 0.2.0 - Mend

terminus 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

data/README.rdoc +71 -20
data/bin/terminus +21 -9
data/lib/capybara/driver/terminus.rb +47 -0
data/lib/public/loader.js +1 -0
data/lib/public/style.css +7 -2
data/lib/public/syn.js +2355 -0
data/lib/public/terminus.js +294 -1
data/lib/terminus.rb +50 -6
data/lib/terminus/application.rb +9 -4
data/lib/terminus/browser.rb +140 -0
data/lib/terminus/controller.rb +78 -0
data/lib/terminus/node.rb +68 -0
data/lib/terminus/server.rb +1 -6
data/lib/terminus/timeouts.rb +27 -0
data/lib/views/bookmarklet.erb +14 -4
data/lib/views/index.erb +11 -8
data/spec/spec_helper.rb +22 -0
data/spec/terminus_driver_spec.rb +20 -0
data/spec/terminus_session_spec.rb +32 -0
metadata +105 -42
data/lib/public/js.packages.js +0 -1

data/lib/public/terminus.js CHANGED

@@ -1,15 +1,308 @@
 Terminus = {
+  isIE: /\bMSIE\b/.test(navigator.userAgent),
   connect: function(endpoint) {
     if (this._client) return;
-    this._client = new Faye.Client(endpoint);
+    this._pageId = Faye.random();
+    this._id = window.name = window.name || Faye.random();
+    this.Registry.initialize();
+    this.Worker.initialize();
+    var client = this._client = new Faye.Client(endpoint);
     this._client.subscribe('/terminus/commands', function(message) {
       this.execute(message.command);
     }, this);
+    this._client.subscribe('/terminus/clients/' + this._id, function(message) {
+      var command = message.command,
+          method  = command.shift(),
+          driver  = this.Driver,
+          worker  = this.Worker,
+          self    = this;
+      command.push(function(result) {
+        self.postResult(message.commandId, result);
+      });
+      worker.monitor = true;
+      driver[method].apply(driver, command);
+      worker.monitor = false;
+    }, this);
+    var self = this;
+    setTimeout(function() { self.ping() }, 100);
+  },
+  browserDetails: function() {
+    return {
+      id:   this._id,
+      page: this._pageId,
+      ua:   navigator.userAgent,
+      url:  window.location.href
+    };
+  },
+  ping: function() {
+    this._client.publish('/terminus/ping', this.browserDetails());
+    var self = this;
+    setTimeout(function() { self.ping() }, 3000);
+  },
+  postResult: function(commandId, result) {
+    if (!commandId) return;
+    this._client.publish('/terminus/results', {
+      id:         this._id,
+      commandId:  commandId,
+      result:     result
+    });
   },
   execute: function(command) {
     eval(command);
+  },
+  Driver: {
+    _node: function(id) {
+      return Terminus.Registry.get(id);
+    },
+    attribute: function(nodeId, name, callback) {
+      var node = this._node(nodeId);
+      if (name === 'checked' || name === 'selected')
+        return callback(!!node[name]);
+      if (Terminus.isIE)
+        return callback(node.getAttributeNode(name).nodeValue);
+      callback(node.getAttribute(name));
+    },
+    body: function(callback) {
+      var html = document.getElementsByTagName('html')[0];
+      callback(html.outerHTML ||
+               '<html>\n' + html.innerHTML + '\n</html>\n');
+    },
+    source: function(callback) {
+      callback(Terminus.originalSource);
+    },
+    reset: function(callback) {
+      var cookies = document.cookie.split(';'), name;
+      var expiry = new Date();
+      expiry.setTime(expiry.getTime() - 24*60*60*1000);
+      for (var i = 0, n = cookies.length; i < n; i++) {
+        name = cookies[i].split('=')[0];
+        document.cookie = name + '=; expires=' + expiry.toGMTString() + '; path=/';
+      }
+      callback();
+    },
+    click: function(nodeId, callback) {
+      var element = this._node(nodeId);
+      Syn.trigger('click', {}, element);
+      Terminus.Worker.callback(callback);
+    },
+    drag: function(options, callback) {
+      var draggable = this._node(options.from),
+          droppable = this._node(options.to);
+      Syn.drag({to: droppable}, draggable, callback);
+    },
+    evaluate: function(expression, callback) {
+      callback(eval(expression));
+    },
+    execute: function(expression, callback) {
+      eval(expression);
+      callback();
+    },
+    find: function(xpath, nodeId, callback) {
+      var root = this._node(nodeId) || document;
+      var result = document.evaluate(xpath, root, null, XPathResult.ANY_TYPE, null),
+          list   = [],
+          element;
+      while (element = result.iterateNext())
+        list.push(Terminus.Registry.put(element));
+      return callback(list);
+    },
+    is_visible: function(nodeId, callback) {
+      var node = this._node(nodeId);
+      while (node.tagName.toLowerCase() !== 'body') {
+        if (node.style.display === 'none' || node.type === 'hidden')
+          return callback(false);
+        node = node.parentNode;
+      }
+      callback(true);
+    },
+    select: function(nodeId, callback) {
+      var option = this._node(nodeId);
+      option.selected = true;
+      Syn.trigger('change', {}, option.parentNode);
+      callback(true);
+    },
+    set: function(nodeId, value, callback) {
+      var field = this._node(nodeId);
+      if (field.type === 'file') return callback('not_allowed');
+      Syn.trigger('focus', {}, field);
+      Syn.trigger('click', {}, field);
+      switch (typeof value) {
+        case 'string':  field.value = value;    break;
+        case 'boolean': field.checked = value;  break;
+      }
+      callback();
+    },
+    tag_name: function(nodeId, callback) {
+      callback(this._node(nodeId).tagName.toLowerCase());
+    },
+    text: function(nodeId, callback) {
+      var node = this._node(nodeId),
+          text = node.textContent || node.innerText || '';
+      text = text.replace(/^\s*|\s*$/g, '');
+      callback(text);
+    },
+    trigger: function(nodeId, eventType, callback) {
+      var node = this._node(nodeId);
+      Syn.trigger(eventType, {}, node);
+      callback();
+    },
+    unselect: function(nodeId, callback) {
+      var option = this._node(nodeId);
+      if (!option.parentNode.multiple) return callback(false);
+      option.selected = false;
+      Syn.trigger('change', {}, option.parentNode);
+      callback(true);
+    },
+    value: function(nodeId, callback) {
+      var node = this._node(nodeId);
+      if (node.tagName.toLowerCase() !== 'select' || !node.multiple)
+        return callback(node.value);
+      var options = node.children,
+          values  = [];
+      for (var i = 0, n = options.length; i < n; i++) {
+        if (options[i].selected) values.push(options[i].value);
+      }
+      callback(values);
+    },
+    visit: function(url, callback) {
+      window.location.href = url;
+      callback();
+    }
+  },
+  Registry: {
+    initialize: function() {
+      this._namespace = new Faye.Namespace();
+      this._elements  = {};
+    },
+    get: function(id) {
+      return this._elements[id];
+    },
+    put: function(element) {
+      var id = this._namespace.generate();
+      this._elements[id] = element;
+      return id;
+    }
+  },
+  Worker: {
+    initialize: function() {
+      this._callbacks = [];
+      this._pending   = 0;
+      this._wrapTimeouts();
+    },
+    callback: function(callback, scope) {
+      if (this._pending === 0) return callback.call(scope);
+      else this._callbacks.push([callback, scope]);
+    },
+    suspend: function() {
+      this._pending += 1;
+    },
+    resume: function() {
+      if (this._pending === 0) return;
+      this._pending -= 1;
+      if (this._pending !== 0) return;
+      var callback;
+      for (var i = 0, n = this._callbacks.length; i < n; i++) {
+        callback = this._callbacks[i];
+        callback[0].call(callback[1]);
+      }
+      this._callbacks = [];
+    },
+    _wrapTimeouts: function() {
+      var timeout  = window.setTimeout,
+          clear    = window.clearTimeout,
+          timeouts = {},
+          self     = this;
+      var finish = function(id) {
+        if (!timeouts.hasOwnProperty(id)) return;
+        delete timeouts[id];
+        self.resume();
+      };
+      window.setTimeout = function(callback, delay) {
+        var id = timeout(function() {
+          try {
+            switch (typeof callback) {
+              case 'function':  callback();     break;
+              case 'string':    eval(callback); break;
+            }
+          } catch (e) {
+            throw e;
+          } finally {
+            finish(id);
+          }
+        }, delay);
+        if (self.monitor) {
+          timeouts[id] = true;
+          self.suspend();
+        }
+        return id;
+      };
+      window.clearTimeout = function(id) {
+        finish(id);
+        return clear(id);
+      };
+    }
   }
 };

data/lib/terminus.rb CHANGED

@@ -1,23 +1,67 @@
+require 'forwardable'
+require 'uri'
 require 'rubygems'
 require 'rack'
 require 'thin'
 require 'eventmachine'
 require 'faye'
+require 'capybara'
 require 'sinatra'
 require 'packr'
-%w[application server].each do |file|
-  require File.join(File.dirname(__FILE__), 'terminus', file)
+root = File.expand_path(File.dirname(__FILE__))
+%w[ application
+    server
+    timeouts
+    controller
+    browser
+    node
+].each do |file|
+  require File.join(root, 'terminus', file)
 end
+require root + '/capybara/driver/terminus'
 Thin::Logging.silent = true
 module Terminus
-  VERSION    = '0.1.0'
-  FAYE_MOUNT = '/messaging'
+  VERSION      = '0.2.0'
+  FAYE_MOUNT   = '/messaging'
+  DEFAULT_HOST = 'localhost'
+  DEFAULT_PORT = 7004
-  def self.create(options = {})
-    Server.new(options)
+  class << self
+    def create(options = {})
+      Server.new(options)
+    end
+    def driver_script(host = DEFAULT_HOST)
+      Application.driver_script(host)
+    end
+    def endpoint(host = DEFAULT_HOST)
+      "http://#{host}:#{DEFAULT_PORT}#{FAYE_MOUNT}"
+    end
+    def ensure_reactor_running
+      Thread.new { EM.run unless EM.reactor_running? }
+      while not EM.reactor_running?; end
+    end
+    extend Forwardable
+    def_delegators :controller, :browser,
+                                :browser=,
+                                :ensure_docked_browser,
+                                :ensure_browser,
+                                :return_to_dock
+  private
+    def controller
+      @controller ||= Controller.new
+    end
   end
 end

data/lib/terminus/application.rb CHANGED

@@ -7,17 +7,22 @@ module Terminus
     set :public, ROOT + '/public'
     set :views,  ROOT + '/views'
+    def self.driver_script(host)
+      %Q{<script type="text/javascript" src="http://#{host}:#{DEFAULT_PORT}/controller.js"></script>}
+    end
     helpers do
-      def host
-        "http://#{ env['HTTP_HOST'] }"
-      end
       def bookmarklet
         Packr.pack(erb(:bookmarklet), :shrink_vars => true)
       end
+      def host
+        "http://#{ env['HTTP_HOST'] }"
+      end
     end
     get('/') { erb :index }
+    get('/controller.js') { bookmarklet }
   end
 end

data/lib/terminus/browser.rb ADDED

@@ -0,0 +1,140 @@
+module Terminus
+  class Browser
+    include Timeouts
+    LOCALHOST   = /localhost|0\.0\.0\.0|127\.0\.0\.1/
+    RETRY_LIMIT = 3
+    def initialize(controller)
+      @controller     = controller
+      @attributes     = {}
+      @docked         = false
+      @namespace      = Faye::Namespace.new
+      @ping_callbacks = []
+      @results        = {}
+      add_timeout(:dead, Timeouts::TIMEOUT) { drop_dead! }
+    end
+    def ask(command, retries = RETRY_LIMIT)
+      id = tell(command)
+      result_hash = wait_with_timeout(:result) { result(id) }
+      result_hash[:value]
+    rescue Timeouts::TimeoutError => e
+      raise e if retries.zero?
+      ask(command, retries - 1)
+    end
+    def body
+      ask([:body])
+    end
+    def source
+      ask([:source])
+    end
+    def current_path
+      return nil unless url = @attributes['url']
+      URI.parse(url).path
+    end
+    def current_url
+      @attributes['url']
+    end
+    def docked?
+      @docked
+    end
+    def evaluate_script(expression)
+      ask([:evaluate, expression])
+    end
+    def execute_script(expression)
+      tell([:execute, expression])
+      nil
+    end
+    def find(xpath)
+      ask([:find, xpath, false]).map { |id| Node.new(self, id) }
+    end
+    def id
+      @attributes['id']
+    end
+    alias :name :id
+    def page_id
+      @attributes['page']
+    end
+    def ping!(message)
+      remove_timeout(:dead)
+      add_timeout(:dead, Timeouts::TIMEOUT) { drop_dead! }
+      @attributes = @attributes.merge(message)
+      detect_dock_host
+      @ping = true
+    end
+    def reset!
+      ask([:reset])
+    end
+    def result!(message)
+      @results[message['commandId']] = message['result']
+    end
+    def result(id)
+      return nil unless @results.has_key?(id)
+      {:value => @results.delete(id)}
+    end
+    def return_to_dock
+      visit "http://#{@controller.dock_host}:#{DEFAULT_PORT}/"
+    end
+    def tell(command)
+      id = @namespace.generate
+      messenger.publish(channel, 'command' => command, 'commandId' => id)
+      id
+    end
+    def visit(url, retries = RETRY_LIMIT)
+      url = url.gsub(LOCALHOST, @controller.dock_host)
+      tell([:visit, url])
+      wait_for_ping
+    rescue Timeouts::TimeoutError => e
+      raise e if retries.zero?
+      visit(url, retries - 1)
+    end
+    def wait_for_ping
+      @ping = false
+      wait_with_timeout(:ping) { @ping or @dead }
+    end
+  private
+    def channel
+      "/terminus/clients/#{id}"
+    end
+    def detect_dock_host
+      uri = URI.parse(@attributes['url'])
+      return unless uri.port == DEFAULT_PORT
+      @docked = true
+      @controller.dock_host = uri.host
+    end
+    def drop_dead!
+      @dead = true
+      @controller.drop_browser(self)
+    end
+    def messenger
+      @controller.messenger
+    end
+  end
+end