web-console-compat 3.5.1

data/lib/web_console/locales/en.yml

@@ -0,0 +1,15 @@
+en:
+  errors:
+    unavailable_session: |
+      Session %{id} is no longer available in memory.
+
+      If you happen to run on a multi-process server (like Unicorn or Puma) the process
+      this request hit doesn't store %{id} in memory. Consider turning the number of
+      processes/workers to one (1) or using a different server in development.
+
+    unacceptable_request: |
+      A supported version is expected in the Accept header.
+
+    connection_refused: |
+      Oops! Failed to connect to the Web Console middleware.
+      Please make sure a rails development server is running.

data/lib/web_console/middleware.rb

@@ -0,0 +1,140 @@
+require 'active_support/core_ext/string/strip'
+
+module WebConsole
+  class Middleware
+    TEMPLATES_PATH = File.expand_path('../templates', __FILE__)
+
+    cattr_accessor :mount_point
+    @@mount_point = '/__web_console'
+
+    cattr_accessor :whiny_requests
+    @@whiny_requests = true
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      app_exception = catch :app_exception do
+        request = create_regular_or_whiny_request(env)
+        return call_app(env) unless request.from_whitelisted_ip?
+
+        if id = id_for_repl_session_update(request)
+          return update_repl_session(id, request)
+        elsif id = id_for_repl_session_stack_frame_change(request)
+          return change_stack_trace(id, request)
+        end
+
+        status, headers, body = call_app(env)
+
+        if session = Session.from(Thread.current) and acceptable_content_type?(headers)
+          response = Response.new(body, status, headers)
+          template = Template.new(env, session)
+
+          response.headers["X-Web-Console-Session-Id"] = session.id
+          response.headers["X-Web-Console-Mount-Point"] = mount_point
+          response.write(template.render('index'))
+          response.finish
+        else
+          [ status, headers, body ]
+        end
+      end
+    rescue => e
+      WebConsole.logger.error("\n#{e.class}: #{e}\n\tfrom #{e.backtrace.join("\n\tfrom ")}")
+      raise e
+    ensure
+      # Clean up the fiber locals after the session creation. Object#console
+      # uses those to communicate the current binding or exception to the middleware.
+      Thread.current[:__web_console_exception] = nil
+      Thread.current[:__web_console_binding] = nil
+
+      raise app_exception if Exception === app_exception
+    end
+
+    private
+
+      def acceptable_content_type?(headers)
+        Mime::Type.parse(headers['Content-Type'].to_s).first == Mime[:html]
+      end
+
+      def json_response(opts = {})
+        status  = opts.fetch(:status, 200)
+        headers = { 'Content-Type' => 'application/json; charset = utf-8' }
+        body    = yield.to_json
+
+        Rack::Response.new(body, status, headers).finish
+      end
+
+      def json_response_with_session(id, request, opts = {})
+        return respond_with_unacceptable_request unless request.acceptable?
+        return respond_with_unavailable_session(id) unless session = Session.find(id)
+
+        json_response(opts) { yield session }
+      end
+
+      def create_regular_or_whiny_request(env)
+        request = Request.new(env)
+        whiny_requests ? WhinyRequest.new(request) : request
+      end
+
+      def repl_sessions_re
+        @_repl_sessions_re ||= %r{#{mount_point}/repl_sessions/(?<id>[^/]+)}
+      end
+
+      def update_re
+        @_update_re ||= %r{#{repl_sessions_re}\z}
+      end
+
+      def binding_change_re
+        @_binding_change_re ||= %r{#{repl_sessions_re}/trace\z}
+      end
+
+      def id_for_repl_session_update(request)
+        if request.xhr? && request.put?
+          update_re.match(request.path) { |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) { |m| m[:id] }
+        end
+      end
+
+      def update_repl_session(id, request)
+        json_response_with_session(id, request) do |session|
+          if input = request.params[:input]
+            { output: session.eval(input) }
+          elsif input = request.params[:context]
+            { context: session.context(input) }
+          end
+        end
+      end
+
+      def change_stack_trace(id, request)
+        json_response_with_session(id, request) do |session|
+          session.switch_binding_to(request.params[:frame_id])
+
+          { ok: true }
+        end
+      end
+
+      def respond_with_unavailable_session(id)
+        json_response(status: 404) do
+          { output: format(I18n.t('errors.unavailable_session'), id: id)}
+        end
+      end
+
+      def respond_with_unacceptable_request
+        json_response(status: 406) do
+          { output: I18n.t('errors.unacceptable_request') }
+        end
+      end
+
+      def call_app(env)
+        @app.call(env)
+      rescue => e
+        throw :app_exception, e
+      end
+  end
+end

data/lib/web_console/railtie.rb

@@ -0,0 +1,71 @@
+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
+      require 'web_console/integration'
+      require 'web_console/extensions'
+
+      if logger = ::Rails.logger
+        WebConsole.logger = logger
+      end
+    end
+
+    initializer 'web_console.development_only' do
+      unless (config.web_console.development_only == false) || Rails.env.development?
+        abort <<-END.strip_heredoc
+          Web Console is activated in the #{Rails.env} environment. This is
+          usually a mistake. To ensure it's only activated in development
+          mode, move it to the development group of your Gemfile:
+
+              gem 'web-console', group: :development
+
+          If you still want to run it in the #{Rails.env} environment (and know
+          what you are doing), put this in your Rails application
+          configuration:
+
+              config.web_console.development_only = false
+        END
+      end
+    end
+
+    initializer 'web_console.insert_middleware' do |app|
+      app.middleware.insert_before ActionDispatch::DebugExceptions, Middleware
+    end
+
+    initializer 'web_console.mount_point' do
+      if mount_point = config.web_console.mount_point
+        Middleware.mount_point = mount_point.chomp('/')
+      end
+
+      if root = Rails.application.config.relative_url_root
+        Middleware.mount_point = File.join(root, Middleware.mount_point)
+      end
+    end
+
+    initializer 'web_console.template_paths' 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
+
+    initializer 'i18n.load_path' do
+      config.i18n.load_path.concat(Dir[File.expand_path('../locales/*.yml', __FILE__)])
+    end
+  end
+end

data/lib/web_console/request.rb

@@ -0,0 +1,50 @@
+module WebConsole
+  # Web Console tailored request object.
+  class Request < ActionDispatch::Request
+    # Configurable set of whitelisted networks.
+    cattr_accessor :whitelisted_ips
+    @@whitelisted_ips = Whitelist.new
+
+    # Define a vendor MIME type. We can call it using Mime[:web_console_v2].
+    Mime::Type.register 'application/vnd.web-console.v2', :web_console_v2
+
+    # 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_whitelisted_ip?
+      whitelisted_ips.include?(strict_remote_ip)
+    end
+
+    # Determines the remote IP using our much stricter whitelist.
+    def strict_remote_ip
+      GetSecureIp.new(self, whitelisted_ips).to_s
+    end
+
+    # Returns whether the request is acceptable.
+    def acceptable?
+      xhr? && accepts.any? { |mime| Mime[:web_console_v2] == mime }
+    end
+
+    private
+
+      class GetSecureIp < ActionDispatch::RemoteIp::GetIp
+        def initialize(req, proxies)
+          # After rails/rails@07b2ff0 ActionDispatch::RemoteIp::GetIp initializes
+          # with a ActionDispatch::Request object instead of plain Rack
+          # environment hash. Keep both @req and @env here, so we don't if/else
+          # on Rails versions.
+          @req      = req
+          @env      = req.env
+          @check_ip = true
+          @proxies  = proxies
+        end
+
+        def filter_proxies(ips)
+          ips.reject do |ip|
+            @proxies.include?(ip)
+          end
+        end
+      end
+  end
+end

data/lib/web_console/response.rb

@@ -0,0 +1,23 @@
+module WebConsole
+  # A response object that writes content before the closing </body> tag, if
+  # possible.
+  #
+  # The object quacks like Rack::Response.
+  class Response < Struct.new(:body, :status, :headers)
+    def write(content)
+      raw_body = Array(body).first.to_s
+
+      if position = raw_body.rindex('</body>')
+        raw_body.insert(position, content)
+      else
+        raw_body << content
+      end
+
+      self.body = raw_body
+    end
+
+    def finish
+      Rack::Response.new(body, status, headers).finish
+    end
+  end
+end

data/lib/web_console/session.rb

@@ -0,0 +1,76 @@
+module WebConsole
+  # A session lets you persist an +Evaluator+ instance in memory associated
+  # with multiple bindings.
+  #
+  # Each newly created session is persisted into memory and you can find it
+  # later by 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
+    cattr_reader :inmemory_storage
+    @@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 binding or exception in a storage.
+      #
+      # The storage is expected to respond to #[]. The binding is expected in
+      # :__web_console_binding and the exception in :__web_console_exception.
+      #
+      # Can return nil, if no binding or exception have been preserved in the
+      # storage.
+      def from(storage)
+        if exc = storage[:__web_console_exception]
+          new(ExceptionMapper.new(exc))
+        elsif binding = storage[:__web_console_binding]
+          new([binding])
+        end
+      end
+    end
+
+    # An unique identifier for every REPL.
+    attr_reader :id
+
+    def initialize(bindings)
+      @id = SecureRandom.hex(16)
+      @bindings = bindings
+      @evaluator = Evaluator.new(@current_binding = bindings.first)
+
+      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(@current_binding = @bindings[index.to_i])
+    end
+
+    # Returns context of the current binding
+    def context(objpath)
+      Context.new(@current_binding).extract(objpath)
+    end
+
+    private
+
+      def store_into_memory
+        inmemory_storage[id] = self
+      end
+  end
+end

data/lib/web_console/tasks/extensions.rake

@@ -0,0 +1,60 @@
+namespace :ext do
+  rootdir = Pathname('extensions')
+
+  desc 'Build Chrome Extension'
+  task chrome: 'chrome:build'
+
+  namespace :chrome do
+    dist   = Pathname('dist/crx')
+    extdir = rootdir.join(dist)
+    manifest_json = rootdir.join('chrome/manifest.json')
+
+    directory extdir
+
+    task build: [ extdir, 'lib:templates' ] do
+      cd rootdir do
+        cp_r [ 'img/', 'tmp/lib/' ], dist
+        `cd chrome && git ls-files`.split("\n").each do |src|
+          dest = dist.join(src)
+          mkdir_p dest.dirname
+          cp Pathname('chrome').join(src), dest
+        end
+      end
+    end
+
+    # Generate a .crx file.
+    task crx: [ :build, :npm ] do
+      out = "crx-web-console-#{JSON.parse(File.read(manifest_json))["version"]}.crx"
+      cd(extdir) { sh "node \"$(npm bin)/crx\" pack ./ -p ../crx-web-console.pem -o ../#{out}" }
+    end
+
+    # Generate a .zip file for Chrome Web Store.
+    task zip: [ :build ] do
+      version = JSON.parse(File.read(manifest_json))["version"]
+      cd(extdir) { sh "zip -r ../crx-web-console-#{version}.zip ./" }
+    end
+
+    desc 'Launch a browser with the chrome extension.'
+    task run: [ :build ] do
+      cd(rootdir) { sh "sh ./script/run_chrome.sh --load-extension=#{dist}" }
+    end
+  end
+
+  task :npm do
+    cd(rootdir) { sh "npm install --silent" }
+  end
+
+  namespace :lib do
+    templates = Pathname('lib/web_console/templates')
+    tmplib    = rootdir.join('tmp/lib/')
+    js_erb    = FileList.new(templates.join('**/*.js.erb'))
+    dirs      = js_erb.pathmap("%{^#{templates},#{tmplib}}d")
+
+    task templates: dirs + js_erb.pathmap("%{^#{templates},#{tmplib}}X")
+
+    dirs.each { |d| directory d }
+    rule '.js' => [ "%{^#{tmplib},#{templates}}X.js.erb" ] do |t|
+      File.write(t.name, WebConsole::Testing::ERBPrecompiler.new(t.source).build)
+    end
+  end
+end

data/lib/web_console/tasks/templates.rake

@@ -0,0 +1,54 @@
+namespace :templates do
+  desc 'Run tests for templates'
+  task test: [ :daemonize, :npm, :rackup, :wait, :mocha, :kill, :exit ]
+  task serve: [ :npm, :rackup ]
+
+  workdir = Pathname(EXPANDED_CWD).join('test/templates')
+  pid     = Pathname(Dir.tmpdir).join("web_console_test.pid")
+  runner  = URI.parse("http://#{ENV['IP'] || '127.0.0.1'}:#{ENV['PORT'] || 29292}/html/test_runner.html")
+  rackup  = "rackup --host #{runner.host} --port #{runner.port}"
+  result  = nil
+  browser = 'phantomjs'
+
+  def need_to_wait?(uri)
+    Net::HTTP.start(uri.host, uri.port) { |http| http.get(uri.path) }
+  rescue Errno::ECONNREFUSED
+    retry if yield
+  end
+
+  task :daemonize do
+    rackup += " -D --pid #{pid}"
+  end
+
+  task :npm => [ :phantomjs ] do
+    Dir.chdir(workdir) { system 'npm install --silent' }
+  end
+
+  task :phantomjs do
+    unless system("which #{browser} >/dev/null")
+      browser = './node_modules/.bin/phantomjs'
+      Dir.chdir(workdir) { system("test -f #{browser} || npm install --silent phantomjs-prebuilt") }
+    end
+  end
+
+  task :rackup do
+    Dir.chdir(workdir) { system rackup }
+  end
+
+  task :wait do
+    cnt = 0
+    need_to_wait?(runner) { sleep 1; cnt += 1; cnt < 5 }
+  end
+
+  task :mocha do
+    Dir.chdir(workdir) { result = system("#{browser} ./node_modules/mocha-phantomjs-core/mocha-phantomjs-core.js #{runner} dot") }
+  end
+
+  task :kill do
+    system "kill #{File.read pid}"
+  end
+
+  task :exit do
+    exit result
+  end
+end