web-console 2.0.0 → 2.1.0

data/lib/web_console/integration/rubinius.rb

@@ -0,0 +1,66 @@
+module WebConsole
+  module Rubinius
+    # Filters internal Rubinius locations.
+    #
+    # There are a couple of reasons why we wanna filter out the locations.
+    #
+    # * ::Kernel.raise, is implemented in Ruby for Rubinius. We don't wanna
+    #   have the frame for it to align with the CRuby and JRuby implementations.
+    #
+    # * For internal methods location variables can be nil. We can't create a
+    #   bindings for them.
+    #
+    # * Bindings from the current file are considered internal and ignored.
+    #
+    # We do that all that so we can align the bindings with the backtraces
+    # entries.
+    class InternalLocationFilter
+      def initialize(locations)
+        @locations = locations
+      end
+
+      def filter
+        @locations.reject do |location|
+          location.file.start_with?('kernel/delta/kernel.rb') ||
+            location.file == __FILE__ ||
+            location.variables.nil?
+        end
+      end
+    end
+
+    # Gets the current bindings for all available Ruby frames.
+    #
+    # Filters the internal Rubinius and WebConsole frames.
+    def self.current_bindings
+      locations = ::Rubinius::VM.backtrace(1, true)
+
+      InternalLocationFilter.new(locations).filter.map do |location|
+        Binding.setup(
+          location.variables,
+          location.variables.method,
+          location.constant_scope,
+          location.variables.self,
+          location
+        )
+      end
+    end
+  end
+end
+
+::Exception.class_eval do
+  def bindings
+    @bindings || []
+  end
+end
+
+::Rubinius.singleton_class.class_eval do
+  def raise_exception_with_current_bindings(exc)
+    if exc.bindings.empty?
+      exc.instance_variable_set(:@bindings, WebConsole::Rubinius.current_bindings)
+    end
+
+    raise_exception_without_current_bindings(exc)
+  end
+
+  alias_method_chain :raise_exception, :current_bindings
+end

data/lib/web_console/middleware.rb

@@ -0,0 +1,117 @@
+require 'active_support/core_ext/string/strip'
+
+module WebConsole
+  class Middleware
+    TEMPLATES_PATH = File.expand_path('../templates', __FILE__)
+
+    DEFAULT_OPTIONS = {
+      update_re: %r{/repl_sessions/(?<id>.+?)\z},
+      binding_change_re: %r{/repl_sessions/(?<id>.+?)/trace\z}
+    }
+
+    UNAVAILABLE_SESSION_MESSAGE = <<-END.strip_heredoc
+      Session %{id} is is no longer available in memory.
+
+      If you happen to run on a multi-process server (like Unicorn) the process
+      this request hit doesn't store %{id} in memory.
+    END
+
+    cattr_accessor :whiny_requests
+    @@whiny_requests = true
+
+    def initialize(app, options = {})
+      @app     = app
+      @options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def call(env)
+      request = create_regular_or_whiny_request(env)
+      return @app.call(env) unless request.from_whitelited_ip?
+
+      if id = id_for_repl_session_update(request)
+        return update_repl_session(id, request.params)
+      elsif id = id_for_repl_session_stack_frame_change(request)
+        return change_stack_trace(id, request.params)
+      end
+
+      status, headers, body = @app.call(env)
+
+      if exception = env['web_console.exception']
+        session = Session.from_exception(exception)
+      elsif binding = env['web_console.binding']
+        session = Session.from_binding(binding)
+      end
+
+      if session && request.acceptable_content_type?
+        response = Rack::Response.new(body, status, headers)
+        template = Template.new(env, session)
+
+        response.write(template.render('index'))
+        response.finish
+      else
+        [ status, headers, body ]
+      end
+    end
+
+    private
+
+      def create_regular_or_whiny_request(env)
+        request = Request.new(env)
+        whiny_requests ? WhinyRequest.new(request) : request
+      end
+
+      def update_re
+        @options[:update_re]
+      end
+
+      def binding_change_re
+        @options[:binding_change_re]
+      end
+
+      def id_for_repl_session_update(request)
+        if request.xhr? && request.put?
+          update_re.match(request.path_info) { |m| m[:id] }
+        end
+      end
+
+      def id_for_repl_session_stack_frame_change(request)
+        if request.xhr? && request.post?
+          binding_change_re.match(request.path_info) { |m| m[:id] }
+        end
+      end
+
+      def update_repl_session(id, params)
+        unless session = Session.find(id)
+          return respond_with_unavailable_session(id)
+        end
+
+        status  = 200
+        headers = { 'Content-Type' => 'application/json; charset = utf-8' }
+        body    = { output: session.eval(params[:input]) }.to_json
+
+        Rack::Response.new(body, status, headers).finish
+      end
+
+      def change_stack_trace(id, params)
+        unless session = Session.find(id)
+          return respond_with_unavailable_session(id)
+        end
+
+        session.switch_binding_to(params[:frame_id])
+
+        status  = 200
+        headers = { 'Content-Type' => 'application/json; charset = utf-8' }
+        body    = { ok: true }.to_json
+
+        Rack::Response.new(body, status, headers).finish
+      end
+
+      def respond_with_unavailable_session(id)
+        status = 404
+        headers = { 'Content-Type' => 'application/json; charset = utf-8' }
+        body    = { output: format(UNAVAILABLE_SESSION_MESSAGE, id: id)}.to_json
+
+        Rack::Response.new(body, status, headers).finish
+      end
+  end
+end

data/lib/web_console/railtie.rb

@@ -0,0 +1,61 @@
+require 'rails/railtie'
+
+module WebConsole
+  class Railtie < ::Rails::Railtie
+    config.web_console = ActiveSupport::OrderedOptions.new
+    config.web_console.whitelisted_ips = %w( 127.0.0.1 ::1 )
+
+    initializer 'web_console.initialize' do
+      ActionDispatch::DebugExceptions.class_eval do
+        def render_exception_with_web_console(env, exception)
+          render_exception_without_web_console(env, exception).tap do
+            wrapper = ActionDispatch::ExceptionWrapper.new(env, exception)
+
+            # Get the original exception if ExceptionWrapper decides to follow it.
+            env['web_console.exception'] = wrapper.exception
+          end
+        end
+
+        alias_method_chain :render_exception, :web_console
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Base.send(:include, Helper)
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.send(:include, Helper)
+      end
+    end
+
+    initializer 'web_console.insert_middleware' do |app|
+      app.middleware.insert_before ActionDispatch::DebugExceptions, Middleware
+    end
+
+    initializer 'web_console.templates_path' do
+      if template_paths = config.web_console.template_paths
+        Template.template_paths.unshift(*Array(template_paths))
+      end
+    end
+
+    initializer 'web_console.whitelisted_ips' do
+      if whitelisted_ips = config.web_console.whitelisted_ips
+        Request.whitelisted_ips = Whitelist.new(whitelisted_ips)
+      end
+    end
+
+    initializer 'web_console.whiny_requests' do
+      if config.web_console.key?(:whiny_requests)
+        Middleware.whiny_requests = config.web_console.whiny_requests
+      end
+    end
+
+    # Leave this undocumented so we treat such content type misses as bugs,
+    # while still being able to help the affected users in the meantime.
+    initializer 'web_console.acceptable_content_types' do
+      if acceptable_content_types = config.web_console.acceptable_content_types
+        Request.acceptable_content_types.concat(Array(acceptable_content_types))
+      end
+    end
+  end
+end

data/lib/web_console/request.rb

@@ -0,0 +1,30 @@
+module WebConsole
+  # Web Console tailored request object.
+  class Request < ActionDispatch::Request
+    # While most of the servers will return blank content type if none given,
+    # Puma will return text/plain.
+    cattr_accessor :acceptable_content_types
+    @@acceptable_content_types = [Mime::HTML, Mime::TEXT]
+
+    # Configurable set of whitelisted networks.
+    cattr_accessor :whitelisted_ips
+    @@whitelisted_ips = Whitelist.new
+
+    # Returns whether a request came from a whitelisted IP.
+    #
+    # For a request to hit Web Console features, it needs to come from a white
+    # listed IP.
+    def from_whitelited_ip?
+      whitelisted_ips.include?(remote_ip)
+    end
+
+    # Returns whether the request is from an acceptable content type.
+    #
+    # We can render a console for HTML and TEXT by default. If a client didn't
+    # specified any content type and the server returned it as blank, we'll
+    # render it as well.
+    def acceptable_content_type?
+      content_type.blank? || content_type.in?(acceptable_content_types)
+    end
+  end
+end

data/lib/web_console/session.rb

@@ -0,0 +1,65 @@
+module WebConsole
+  # A session lets you persist wrap an +Evaluator+ instance in memory
+  # associated with multiple bindings.
+  #
+  # Each newly created session is persisted into memory and you can find it
+  # later its +id+.
+  #
+  # A session may be associated with multiple bindings. This is used by the
+  # error pages only, as currently, this is the only client that needs to do
+  # that.
+  class Session
+    INMEMORY_STORAGE = {}
+
+    class << self
+      # Finds a persisted session in memory by its id.
+      #
+      # Returns a persisted session if found in memory.
+      # Raises NotFound error unless found in memory.
+      def find(id)
+        INMEMORY_STORAGE[id]
+      end
+
+      # Create a Session from an exception.
+      def from_exception(exc)
+        new(exc.bindings)
+      end
+
+      # Create a Session from a single binding.
+      def from_binding(binding)
+        new(binding)
+      end
+    end
+
+    # An unique identifier for every REPL.
+    attr_reader :id
+
+    def initialize(bindings)
+      @id = SecureRandom.hex(16)
+      @bindings = Array(bindings)
+      @evaluator = Evaluator.new(@bindings[0])
+
+      store_into_memory
+    end
+
+    # Evaluate +input+ on the current Evaluator associated binding.
+    #
+    # Returns a string of the Evaluator output.
+    def eval(input)
+      @evaluator.eval(input)
+    end
+
+    # Switches the current binding to the one at specified +index+.
+    #
+    # Returns nothing.
+    def switch_binding_to(index)
+      @evaluator = Evaluator.new(@bindings[index.to_i])
+    end
+
+    private
+
+      def store_into_memory
+        INMEMORY_STORAGE[id] = self
+      end
+  end
+end

data/lib/web_console/template.rb

@@ -0,0 +1,49 @@
+module WebConsole
+  # A facade that handles template rendering and composition.
+  #
+  # It introduces template helpers to ease the inclusion of scripts only on
+  # Rails error pages.
+  class Template
+    class Context < ActionView::Base
+      # Execute a block only on error pages.
+      #
+      # The error pages are special, because they are the only pages that
+      # currently require multiple bindings. We get those from exceptions.
+      def only_on_error_page(*args)
+        yield if @env['web_console.exception'].present?
+      end
+
+      # Render JavaScript inside a script tag and a closure.
+      #
+      # This one lets write JavaScript that will automatically get wrapped in a
+      # script tag and enclosed in a closure, so you don't have to worry for
+      # leaking globals, unless you explicitly want to.
+      def render_javascript(template)
+        render(template: template, layout: 'layouts/javascript')
+      end
+
+      # Render inlined string to be used inside of JavaScript code.
+      #
+      # The inlined string is returned as an actual JavaScript string. You
+      # don't need to wrap the result yourself.
+      def render_inlined_string(template)
+        render(template: template, layout: 'layouts/inlined_string')
+      end
+    end
+
+    # Lets you customize the default templates folder location.
+    cattr_accessor :template_paths
+    @@template_paths = [ File.expand_path('../templates', __FILE__) ]
+
+    def initialize(env, session)
+      @env = env
+      @session = session
+    end
+
+    # Render a template (inferred from +template_paths+) as a plain string.
+    def render(template)
+      context = Context.new(template_paths, instance_values)
+      context.render(template: template, layout: false)
+    end
+  end
+end

data/lib/web_console/templates/_inner_console_markup.html

@@ -0,0 +1,3 @@
+<div id='resizer'></div>
+<div class='console-inner'></div>
+<input id='clipboard' type='text'>

data/lib/web_console/templates/_markup.html

@@ -0,0 +1,4 @@
+<div id="console"
+  data-remote-path='<%= "console/repl_sessions/#{@session.id}" %>'
+  data-initial-prompt='>> '>
+</div>

data/lib/web_console/templates/_prompt_box_markup.html

@@ -0,0 +1,2 @@
+<span class='console-prompt-label'></span>
+<pre class='console-prompt-display'></pre>

data/lib/web_console/templates/console.js

@@ -0,0 +1,373 @@
+// DOM helpers
+function hasClass(el, className) {
+  var regex = new RegExp('(?:^|\\s)' + className + '(?!\\S)', 'g');
+  return el.className.match(regex);
+}
+
+function addClass(el, className) {
+  el.className += " " + className;
+}
+
+function removeClass(el, className) {
+  var regex = new RegExp('(?:^|\\s)' + className + '(?!\\S)', 'g');
+  el.className = el.className.replace(regex, '');
+}
+
+function removeAllChildren(el) {
+  while (el.firstChild) {
+    el.removeChild(el.firstChild);
+  }
+}
+
+function escapeHTML(html) {
+  return html
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#x27;')
+    .replace(/`/g, '&#x60;');
+}
+
+// Add CSS styles dynamically. This probably doesnt work for IE <8.
+var style = document.createElement('style');
+style.type = 'text/css';
+style.innerHTML = <%= render_inlined_string 'style.css' %>;
+document.getElementsByTagName('head')[0].appendChild(style);
+
+/**
+ * Constructor for command storage.
+ * It uses localStorage if available. Otherwise fallback to normal JS array.
+ */
+function CommandStorage() {
+  this.previousCommands = [];
+  var previousCommandOffset = 0;
+  var hasLocalStorage = typeof window.localStorage !== 'undefined';
+  var STORAGE_KEY = "web_console_previous_commands";
+  var MAX_STORAGE = 100;
+
+  if (hasLocalStorage) {
+    this.previousCommands = JSON.parse(localStorage.getItem(STORAGE_KEY)) || [];
+    previousCommandOffset = this.previousCommands.length;
+  }
+
+  this.addCommand = function(command) {
+    previousCommandOffset = this.previousCommands.push(command);
+
+    if (previousCommandOffset > MAX_STORAGE) {
+      this.previousCommands.splice(0, 1);
+      previousCommandOffset = MAX_STORAGE;
+    }
+
+    if (hasLocalStorage) {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.previousCommands));
+    }
+  };
+
+  this.navigate = function(offset) {
+    previousCommandOffset += offset;
+
+    if (previousCommandOffset < 0) {
+      previousCommandOffset = -1;
+      return null;
+    }
+
+    if (previousCommandOffset >= this.previousCommands.length) {
+      previousCommandOffset = this.previousCommands.length;
+      return null;
+    }
+
+    return this.previousCommands[previousCommandOffset];
+  }
+}
+
+// HTML strings for dynamic elements.
+var consoleInnerHtml = <%= render_inlined_string '_inner_console_markup.html' %>;
+var promptBoxHtml = <%= render_inlined_string '_prompt_box_markup.html' %>;
+
+// REPLConsole Constructor
+function REPLConsole(config) {
+  this.commandStorage = new CommandStorage();
+  this.prompt = config && config.promptLabel ? config.promptLabel : ' >>';
+  this.commandHandle = config && config.commandHandle ? config.commandHandle : function() { return this; }
+}
+
+
+REPLConsole.prototype.install = function(container) {
+  var _this = this;
+
+  document.onkeydown = function(ev) {
+    if (_this.focused) { _this.onKeyDown(ev); }
+  };
+
+  document.onkeypress = function(ev) {
+    if (_this.focused) { _this.onKeyPress(ev); }
+  };
+
+  document.addEventListener('mousedown', function(ev) {
+    var el = ev.target || ev.srcElement;
+
+    if (el) {
+      do {
+        if (el === container) {
+          _this.focus();
+          return;
+        }
+      } while (el = el.parentNode);
+
+      _this.blur();
+    }
+  });
+
+  // Render the console.
+  container.innerHTML = consoleInnerHtml;
+
+  // Make the console resizable.
+  document.getElementById('resizer').addEventListener('mousedown', function(ev) {
+    var startY                   = ev.clientY;
+    var startHeight              = parseInt(document.defaultView.getComputedStyle(container).height, 10);
+    var consoleInner             = document.getElementsByClassName('console-inner')[0];
+    var innerScrollTopStart      = consoleInner.scrollTop;
+    var innerClientHeightStart   = consoleInner.clientHeight;
+
+    var doDrag = function(e) {
+      container.style.height = (startHeight + startY - e.clientY) + 'px';
+      consoleInner.scrollTop = innerScrollTopStart + (innerClientHeightStart - consoleInner.clientHeight);
+    };
+
+    var stopDrag = function(e) {
+      document.documentElement.removeEventListener('mousemove', doDrag, false);
+      document.documentElement.removeEventListener('mouseup', stopDrag, false);
+    };
+
+    document.documentElement.addEventListener('mousemove', doDrag, false);
+    document.documentElement.addEventListener('mouseup', stopDrag, false);
+  });
+
+  // Initialize
+  this.inner = container.getElementsByClassName('console-inner')[0];
+  this.clipboard = document.getElementById('clipboard');
+  this.newPromptBox();
+};
+
+REPLConsole.prototype.focus = function() {
+  if (! this.focused) {
+    this.focused = true;
+    if (! hasClass(this.inner, "console-focus")) {
+      addClass(this.inner, "console-focus");
+    }
+    this.scrollToBottom();
+  }
+};
+
+REPLConsole.prototype.blur = function() {
+  this.focused = false;
+  removeClass(this.inner, "console-focus");
+};
+
+/**
+ * Add a new empty prompt box to the console.
+ */
+REPLConsole.prototype.newPromptBox = function() {
+  // Remove the caret from previous prompt display if any.
+  if (this.promptDisplay) {
+    this.removeCaretFromPrompt();
+  }
+
+  var promptBox = document.createElement('div');
+  promptBox.className = "console-prompt-box";
+  promptBox.innerHTML = promptBoxHtml;
+  this.promptLabel = promptBox.getElementsByClassName('console-prompt-label')[0];
+  this.promptDisplay = promptBox.getElementsByClassName('console-prompt-display')[0];
+  // Render the prompt box
+  this.setInput("");
+  this.promptLabel.innerHTML = this.prompt;
+  this.inner.appendChild(promptBox);
+  this.scrollToBottom();
+};
+
+/**
+ * Remove the caret from the prompt box,
+ * mainly before adding a new prompt box.
+ * For simplicity, just re-render the prompt box
+ * with caret position -1.
+ */
+REPLConsole.prototype.removeCaretFromPrompt = function() {
+  this.setInput(this._input, -1);
+};
+
+REPLConsole.prototype.setInput = function(input, caretPos) {
+  this._caretPos = caretPos === undefined ? input.length : caretPos;
+  this._input = input;
+  this.renderInput();
+};
+
+/**
+ * Add some text to the existing input.
+ */
+REPLConsole.prototype.addToInput = function(val, caretPos) {
+  caretPos = caretPos || this._caretPos;
+  var before = this._input.substring(0, caretPos);
+  var after = this._input.substring(caretPos, this._input.length);
+  var newInput =  before + val + after;
+  this.setInput(newInput, caretPos + val.length);
+};
+
+/**
+ * Render the input prompt. This is called whenever
+ * the user input changes, sometimes not very efficient.
+ */
+REPLConsole.prototype.renderInput = function() {
+  // Clear the current input.
+  removeAllChildren(this.promptDisplay);
+
+  var promptCursor = document.createElement('span');
+  promptCursor.className = "console-cursor";
+  var before, current, after;
+
+  if (this._caretPos < 0) {
+    before = this._input;
+    current = after = "";
+  } else if (this._caretPos === this._input.length) {
+    before = this._input;
+    current = "\u00A0";
+    after = "";
+  } else {
+    before = this._input.substring(0, this._caretPos);
+    current = this._input.charAt(this._caretPos);
+    after = this._input.substring(this._caretPos + 1, this._input.length);
+  }
+
+  this.promptDisplay.appendChild(document.createTextNode(before));
+  promptCursor.appendChild(document.createTextNode(current));
+  this.promptDisplay.appendChild(promptCursor);
+  this.promptDisplay.appendChild(document.createTextNode(after));
+};
+
+REPLConsole.prototype.writeOutput = function(output) {
+  var consoleMessage = document.createElement('pre');
+  consoleMessage.className = "console-message";
+  consoleMessage.innerHTML = escapeHTML(output);
+  this.inner.appendChild(consoleMessage);
+  this.newPromptBox();
+};
+
+REPLConsole.prototype.onEnterKey = function() {
+  var input = this._input;
+
+  if(input != "" && input !== undefined) {
+    this.commandStorage.addCommand(input);
+  }
+
+  this.commandHandle(input);
+};
+
+REPLConsole.prototype.onNavigateHistory = function(offset) {
+  var command = this.commandStorage.navigate(offset) || "";
+  this.setInput(command);
+};
+
+/**
+ * Handle control keys like up, down, left, right.
+ */
+REPLConsole.prototype.onKeyDown = function(ev) {
+  switch (ev.keyCode) {
+    case 13:
+      // Enter key
+      this.onEnterKey();
+      ev.preventDefault();
+      break;
+    case 80:
+      // Ctrl-P
+      if (! ev.ctrlKey) break;
+    case 38:
+      // Up arrow
+      this.onNavigateHistory(-1);
+      ev.preventDefault();
+      break;
+    case 78:
+      // Ctrl-N
+      if (! ev.ctrlKey) break;
+    case 40:
+      // Down arrow
+      this.onNavigateHistory(1);
+      ev.preventDefault();
+      break;
+    case 37:
+      // Left arrow
+      var caretPos = this._caretPos > 0 ? this._caretPos - 1 : this._caretPos;
+      this.setInput(this._input, caretPos);
+      ev.preventDefault();
+      break;
+    case 39:
+      // Right arrow
+      var length = this._input.length;
+      var caretPos = this._caretPos < length ? this._caretPos + 1 : this._caretPos;
+      this.setInput(this._input, caretPos);
+      ev.preventDefault();
+      break;
+    case 8:
+      // Delete
+      this.deleteAtCurrent();
+      ev.preventDefault();
+      break;
+    default:
+      break;
+  }
+
+  if (ev.ctrlKey || ev.metaKey) {
+    // Set focus to our clipboard in case they hit the "v" key
+    this.clipboard.focus();
+    if (ev.keyCode == 86) {
+      // Pasting to clipboard doesn't happen immediately,
+      // so we have to wait for a while to get the pasted text.
+      var _this = this;
+      setTimeout(function() {
+        _this.addToInput(_this.clipboard.value);
+        _this.clipboard.value = "";
+        _this.clipboard.blur();
+      }, 10);
+    }
+  }
+
+  ev.stopPropagation();
+};
+
+/**
+ * Handle input key press.
+ */
+REPLConsole.prototype.onKeyPress = function(ev) {
+  // Only write to the console if it's a single key press.
+  if (ev.ctrlKey || ev.metaKey) { return; }
+  var keyCode = ev.keyCode || ev.which;
+  this.insertAtCurrent(String.fromCharCode(keyCode));
+  ev.stopPropagation();
+  ev.preventDefault();
+};
+
+/**
+ * Delete a character at the current position.
+ */
+REPLConsole.prototype.deleteAtCurrent = function() {
+  if (this._caretPos > 0) {
+    var caretPos = this._caretPos - 1;
+    var before = this._input.substring(0, caretPos);
+    var after = this._input.substring(this._caretPos, this._input.length);
+    this.setInput(before + after, caretPos);
+  }
+};
+
+/**
+ * Insert a character at the current position.
+ */
+REPLConsole.prototype.insertAtCurrent = function(char) {
+  var before = this._input.substring(0, this._caretPos);
+  var after = this._input.substring(this._caretPos, this._input.length);
+  this.setInput(before + char + after, this._caretPos + 1);
+};
+
+REPLConsole.prototype.scrollToBottom = function() {
+  this.inner.scrollTop = this.inner.scrollHeight;
+};
+
+window.REPLConsole = REPLConsole;