web-console 0.1.0

data/lib/web_console.rb

@@ -0,0 +1,7 @@
+require 'active_support/lazy_load_hooks'
+require 'web_console/engine'
+require 'web_console/repl'
+
+module WebConsole
+  ActiveSupport.run_load_hooks(:web_console, self)
+end

data/lib/web_console/engine.rb

@@ -0,0 +1,38 @@
+require 'ipaddr'
+require 'rails/engine'
+require 'jquery-rails'
+
+module WebConsole
+  class Engine < ::Rails::Engine
+    isolate_namespace WebConsole
+
+    config.web_console = ActiveSupport::OrderedOptions.new
+    config.web_console.default_mount_path = '/console'
+    config.web_console.whitelisted_ips = '127.0.0.1'
+
+    initializer 'web_console.add_default_route' do |app|
+      # While we don't need the route in the test environment, we define it
+      # there as well, so we can easily test it.
+      if Rails.env.development? || Rails.env.test?
+        app.routes.append do
+          mount WebConsole::Engine => app.config.web_console.default_mount_path
+        end
+      end
+    end
+
+    initializer 'web_console.process_whitelisted_ips' do
+      # Ensure that it is an array of IPAddr instances and it is defaulted to
+      # 127.0.0.1 if not precent. Only unique entries are left in the end.
+      config.web_console.whitelisted_ips = Array(config.web_console.whitelisted_ips)
+      config.web_console.whitelisted_ips.map! do |ip|
+        ip.is_a?(IPAddr) ? ip : IPAddr.new(ip.presence || '127.0.0.1')
+      end.uniq!
+
+      # IPAddr instances can cover whole networks, so simplify the #include?
+      # check for the most common case.
+      def (config.web_console.whitelisted_ips).include?(ip)
+        ip.is_a?(IPAddr) ? super : any? { |net| net.include?(ip.to_s) }
+      end
+    end
+  end
+end

data/lib/web_console/fiber.rb

@@ -0,0 +1,48 @@
+module WebConsole
+  # Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
+  # (c) 2008 Aman Gupta (tmm1)
+  #
+  # For the purposes of our REPL adapters there is a need for fiber invocation
+  # across threads. The native implementation does not support that.
+  class FiberError < StandardError; end
+
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new { @yield.push [ *yield(*@resume.pop) ] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :thread
+
+    def resume(*args)
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def yield(*args)
+      @yield.push(args)
+      result = @resume.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def self.yield(*args)
+      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
+      fiber.yield(*args)
+    end
+
+    def self.current
+      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+end

data/lib/web_console/repl.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext/string/inflections'
+
+module WebConsole
+  module REPL
+    extend self
+
+    # Registry of REPL implementations mapped to their correspondent adapter
+    # classes.
+    #
+    # Don't manually alter the registry. Use WebConsole::REPL.register_adapter
+    # for adding entries.
+    def adapters
+      @adapters ||= {}
+    end
+
+    # Register an adapter into the adapters registry.
+    #
+    # Registration maps and adapter class to an existing REPL implementation,
+    # that we call an adaptee constant. If the adaptee constant is not given,
+    # it is automatically derived from the adapter class name.
+    #
+    # For example, adapter named +WebConsole::REPL::IRB+ will derive the
+    # adaptee constant to +::IRB+.
+    #
+    # If a block is given, it would be evaluated right after the adapter
+    # registration.
+    def register_adapter(adapter_class, adaptee_constant = nil, options = {})
+      if adaptee_constant.is_a?(Hash)
+        options          = adaptee_constant
+        adaptee_constant = nil
+      end
+      adaptee_constant   = adapter_class if options[:standalone]
+      adaptee_constant ||= derive_adaptee_constant_from(adapter_class)
+      adapters[adaptee_constant] = adapter_class
+      yield if block_given?
+    end
+
+    # Get the default adapter for the given application.
+    #
+    # By default the application will be Rails.application and the adapter
+    # will be chosen from Rails.application.config.console.
+    #
+    # If no suitible adapter is found for the configured Rails console, a dummy
+    # adapter will be used. You can evaluate code in it, but it won't support
+    # any advanced features, like multiline code evaluation.
+    def default(app = Rails.application)
+      adapters[app.config.console || ::IRB] || adapters[Dummy]
+    end
+
+    private
+      def derive_adaptee_constant_from(cls, suffix = 'REPL')
+        "::#{cls.name.split('::').last.gsub(/#{suffix}$/i, '')}".constantize
+      end
+  end
+end
+
+# Require the builtin adapters.
+require 'web_console/repl/irb'
+require 'web_console/repl/dummy'

data/lib/web_console/repl/dummy.rb

@@ -0,0 +1,38 @@
+require 'web_console/stream'
+
+module WebConsole
+  module REPL
+    # == Dummy\ Adapter
+    #
+    # Dummy adapter that is used as a fallback for REPL with no adapters.
+    #
+    # It provides only the most basic code evaluation with no multiline code
+    # support.
+    class Dummy
+      def initialize(binding = TOPLEVEL_BINDING)
+        @binding = binding
+      end
+
+      def prompt
+        '>> '
+      end
+
+      def send_input(input)
+        eval_result = nil
+        streams_output = Stream.threadsafe_capture! do
+          eval_result = @binding.eval(input).inspect
+        end
+        "#{streams_output}=> #{eval_result}\n"
+      rescue Exception => exc
+        exc.backtrace.join("\n")
+      end
+    end
+
+    register_adapter Dummy, standalone: true do
+      require 'rails/console/app'
+      require 'rails/console/helpers'
+
+      TOPLEVEL_BINDING.eval('self').send(:include, Rails::ConsoleMethods)
+    end
+  end
+end

data/lib/web_console/repl/irb.rb

@@ -0,0 +1,61 @@
+require 'irb'
+require 'web_console/fiber'
+require 'web_console/stream'
+
+module WebConsole
+  module REPL
+    # == IRB\ Adapter
+    #
+    # Adapter for the IRB REPL, which is the default Ruby on Rails console.
+    class IRB
+      # For some reason™ we have to be ::IRB::StdioInputMethod subclass to get
+      # #prompt populated.
+      #
+      # Not a pretty OOP, but for now, we just have to deal with it.
+      class FiberInputMethod < ::IRB::StdioInputMethod
+        def initialize; end
+
+        def gets
+          @previous = Fiber.yield
+        end
+
+        def encoding
+          (@previous || '').encoding
+        end
+      end
+
+      def initialize(binding = TOPLEVEL_BINDING)
+        initialize_irb_session!
+        @input = FiberInputMethod.new
+        @irb   = ::IRB::Irb.new(::IRB::WorkSpace.new(binding), @input)
+        @fiber = Fiber.new { @irb.eval_input }.tap(&:resume)
+        finalize_irb_session!
+      end
+
+      def prompt
+        @input.prompt
+      end
+
+      def send_input(input)
+        Stream.threadsafe_capture! { @fiber.resume("#{input}\n") }
+      end
+
+      private
+        def initialize_irb_session!(ap_path = nil)
+          ::IRB.init_config(ap_path)
+        end
+
+        def finalize_irb_session!
+          ::IRB.conf[:MAIN_CONTEXT] = @irb.context
+        end
+    end
+
+    register_adapter IRB do
+      require 'rails/console/app'
+      require 'rails/console/helpers'
+
+      # Include all of the rails console helpers in the IRB session.
+      ::IRB::ExtendCommandBundle.send :include, Rails::ConsoleMethods
+    end
+  end
+end

data/lib/web_console/stream.rb

@@ -0,0 +1,27 @@
+module WebConsole
+  module Stream
+    extend Mutex_m
+
+    def self.threadsafe_capture!(*streams)
+      streams = [$stdout, $stderr] if streams.empty?
+      synchronize do
+        begin
+          streams_copy = streams.collect(&:dup)
+          replacement  = Tempfile.new(name)
+          streams.each do |stream|
+            stream.reopen(replacement)
+            stream.sync = true
+          end
+          yield
+          streams.each(&:rewind)
+          replacement.read
+        ensure
+          replacement.unlink
+          streams.each_with_index do |stream, i|
+            stream.reopen(streams_copy[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/web_console/version.rb

@@ -0,0 +1,3 @@
+module WebConsole
+  VERSION = '0.1.0'
+end

data/test/controllers/web_console/console_sessions_controller_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module WebConsole
+  class ConsoleSessionsControllerTest < ActionController::TestCase
+    setup do
+      # Where does .stubs lives?
+      def @request.remote_ip; '127.0.0.1' end
+    end
+
+    test 'index is successful' do
+      get :index, use_route: 'web_console'
+      assert_response :success
+    end
+
+    test 'index creates new console session' do
+      assert_difference 'ConsoleSession::INMEMORY_STORAGE.size' do
+        get :index, use_route: 'web_console'
+      end
+    end
+
+    test 'update updates new console session' do
+      get :index, use_route: 'web_console'
+      assert_not_nil console_session = assigns(:console_session)
+
+      put :update, id: console_session.id, input: 42, use_route: 'web_console'
+      assert_match %r{42}, console_session.output
+    end
+
+    test 'update failes when session is no longer available' do
+      get :index, use_route: 'web_console'
+      assert_not_nil console_session = assigns(:console_session)
+
+      ConsoleSession::INMEMORY_STORAGE.delete(console_session.id)
+      put :update, id: console_session.id, input: 42, use_route: 'web_console'
+      assert_response :gone
+    end
+
+    test 'blocks requests from non-whitelisted ips' do
+      def @request.remote_ip; '128.0.0.1' end
+      get :index, use_route: 'web_console'
+      assert_response :unauthorized
+    end
+
+    test 'index generated path' do
+      assert_generates mount_path, {
+        use_route: 'web_console',
+        controller: 'console_sessions'
+      }, {}, {controller: 'console_sessions'}
+    end
+
+    private
+
+      def mount_path
+        WebConsole::Engine.config.web_console.default_mount_path
+      end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application", media: "all", "data-turbolinks-track" => true %>
+  <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')