rack-webconsole 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+pkg/*
+graph.png
+.yardoc/*
+doc/*
+coverage/*
+*.rbc

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.9.2@rack-webconsole

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rack-webconsole.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    rack-webconsole (0.0.1)
+      json
+      rack
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bluecloth (2.1.0)
+    json (1.5.3)
+    minitest (2.3.1)
+    mocha (0.9.12)
+    purdytest (1.0.0)
+      minitest (~> 2.2)
+    rack (1.3.1)
+    rake (0.9.2)
+    yard (0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bluecloth
+  minitest
+  mocha
+  purdytest
+  rack-webconsole!
+  rake
+  yard

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+desc "Run rack-webconsole specs"
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new(:docs) do |t|
+  t.files   = ['lib/**/*.rb']
+  t.options = ['-m', 'markdown', '--no-private', '-r', 'Readme.md', '--title', 'rack-webconsole documentation']
+end
+
+task :doc => [:docs]
+
+desc "Generate and open class diagram (needs Graphviz installed)"
+task :graph do |t|
+ `bundle exec yard graph -d --full --no-private | dot -Tpng -o graph.png && open graph.png`
+end
+
+task :default => [:test]

data/Readme.md

@@ -0,0 +1,87 @@
+#rack-webconsole
+
+Rack-webconsole is a Rack-based interactive console (à la Rails console) in
+your web application's frontend. That means you can interact with your
+application's backend from within the browser itself!
+
+To get a clearer idea, you can check out [this video](
+http://youtu.be/yKK5J01Dqts?hd=1) showing a live example :)
+
+Rack-webconsole is a Rack middleware designed to be unobtrusive. With Rails 3,
+for example, you only have to include the gem in your Gemfile and it already
+works. Without any configuration.
+
+Tested with MRI 1.9.2 and ruby-head (1.9.3).
+
+##Resources
+
+* [Example video](http://youtu.be/yKK5J01Dqts?hd=1)
+* [Documentation](http://rubydoc.info/github/codegram/rack-webconsole)
+
+##Install
+
+In your Gemfile:
+
+    gem 'rack-webconsole'
+
+
+##Usage with Rails 3
+
+If you are using Rails 3, you have no further steps to do. It works! To give
+it a try, fire up the Rails server and go to any page, press the ` ` ` key and
+the console will show :)
+
+##Usage with Sinatra/Padrino
+
+With Sinatra and Padrino you have to tell your application to use the
+middleware:
+
+    require 'sinatra'
+    require 'rack/webconsole'
+
+    class MySinatraApp < Sinatra::Application
+      use Rack::Webconsole
+      # . . .
+    end
+
+    class SamplePadrino < Padrino::Application
+      use Rack::Webconsole
+      # . . .
+    end
+
+NOTE: If you are using Bundler and initializing it from config.ru, you don't
+have to `require 'rack/webconsole'` manually, otherwise you have to.
+
+And it works! Fire up the server, go to any page and press the ` ` ` key.
+
+##Commands
+
+In the console you can issue whatever Ruby commands you want, except multiline commands. Local variables are kept, so you can get a more IRB-esque feeling.
+
+To reset all local variables, just issue the `reload!` command.
+
+##Under the hood
+
+Run the test suite by typing:
+
+    rake
+
+You can also build the documentation with the following command:
+
+    rake docs
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send us a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Codegram. See LICENSE for details.
+
+
+

data/lib/rack/webconsole/asset_helpers.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Rack
+  class Webconsole
+    # Helper module to encapsulate the asset loading logic used by the {Assets}
+    # middleware.
+    #
+    # For now, the strategy is reading the files from disk. In the future, we
+    # should come up with a somewhat more sophisticated strategy, although
+    # {Webconsole} is used only in development environments, where performance
+    # isn't usually a concern.
+    #
+    module AssetHelpers
+      # Loads the HTML from a file in `/public`.
+      #
+      # It contains a form and the needed divs to render the console.
+      #
+      # @return [String] the injectable HTML.
+      def html_code
+        asset 'webconsole.html'
+      end
+
+      # Loads the CSS from a file in `/public`.
+      #
+      # It contains the styles for the console.
+      #
+      # @return [String] the injectable CSS.
+      def css_code
+        '<style type="text/css">' <<
+          asset('webconsole.css') <<
+          '</style>'
+      end
+
+      # Loads the JavaScript from a file in `/public`.
+      #
+      # It contains the JavaScript logic of the webconsole.
+      #
+      # @return [String] the injectable JavaScript.
+      def js_code
+        '<script type="text/javascript">' <<
+          asset('webconsole.js') <<
+          '</script>'
+      end
+
+      private
+
+      def asset(file)
+        ::File.read(::File.join(::File.dirname(__FILE__), '..', '..', '..', 'public', file))
+      end
+    end
+  end
+end

data/lib/rack/webconsole/assets.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+module Rack
+  class Webconsole
+    # {Assets} is a Rack middleware responsible for injecting view code for the
+    # console to work properly.
+    #
+    # It intercepts HTTP requests, detects successful HTML responses and
+    # injects HTML, CSS and JavaScript code into those.
+    #
+    class Assets
+      include Webconsole::AssetHelpers
+
+      # Honor the Rack contract by saving the passed Rack application in an ivar.
+      #
+      # @param [Rack::Application] app the previous Rack application in the
+      #   middleware chain.
+      def initialize(app)
+        @app = app
+      end
+
+      # Checks for successful HTML responses and injects HTML, CSS and
+      # JavaScript code into them.
+      #
+      # @param [Hash] env a Rack request environment.
+      def call(env)
+        status, headers, response = @app.call(env)
+        return [status, headers, response] unless check_html?(headers, response) && status == 200
+
+        if response.respond_to?(:body)
+          response_body = response.body
+        else
+          response_body = response.first
+        end
+
+        # Inject the html, css and js code to the view
+        response_body.gsub!('</body>', "#{code}</body>")
+        headers['Content-Length'] = (response_body.length + 2).to_s
+
+        [status, headers, [response_body]]
+      end
+
+      # Returns a string with all the HTML, CSS and JavaScript code needed for
+      # the view.
+      #
+      # @return [String] the injectable code.
+      def code
+        html_code << css_code << js_code
+      end
+
+      private
+
+      def check_html?(headers, response)
+        body = response.respond_to?(:body) ? response.body : response.first
+        headers['Content-Type'] and
+          headers['Content-Type'].include? 'text/html' and
+          body =~ %r{<html.*</html>}m
+      end
+    end
+  end
+end

data/lib/rack/webconsole/railtie.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module Rack
+  class Webconsole
+    # Railtie loaded in Rails applications. Its purpose is to automatically use
+    # the middleware in development environment, so that Rails users only have
+    # to require 'rack-webconsole' in their Gemfile and nothing more than that.
+    #
+    class Railtie < Rails::Railtie
+      initializer 'rack-webconsole.add_middleware' do |app|
+        app.middleware.use Rack::Webconsole if Rails.env.development?
+      end
+    end
+  end
+end

data/lib/rack/webconsole/repl.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require 'json'
+module Rack
+  class Webconsole
+    # {Repl} is a Rack middleware acting as a Ruby evaluator application.
+    #
+    # In a nutshell, it evaluates a string in a {Sandbox} instance stored in an
+    # evil global variable. Then, to keep the state, it inspects the local
+    # variables and stores them in an instance variable for further retrieval.
+    #
+    class Repl
+      # Honor the Rack contract by saving the passed Rack application in an ivar.
+      #
+      # @param [Rack::Application] app the previous Rack application in the
+      #   middleware chain.
+      def initialize(app)
+        @app = app
+      end
+
+      # Evaluates a string as Ruby code and returns the evaluated result as
+      # JSON.
+      #
+      # It also stores the {Sandbox} state in a `$sandbox` global variable, with
+      # its local variables.
+      #
+      # @param [Hash] env the Rack request environment.
+      # @return [Array] a Rack response with status code 200, HTTP headers
+      #   and the evaluated Ruby result.
+      def call(env)
+        status, headers, response = @app.call(env)
+
+        req = Rack::Request.new(env)
+
+        params = req.params
+
+        result = begin
+          $sandbox ||= Sandbox.new
+
+          boilerplate = local_variables + [:ls]
+
+          result = $sandbox.instance_eval """
+            result = (#{params['query']})
+            ls = (local_variables - #{boilerplate})
+            @locals ||= {}
+            @locals.update(ls.inject({}) do |hash, value|
+              hash.update({value => eval(value.to_s)})
+            end)
+            result
+          """
+
+          result.inspect
+        rescue=>e
+          "Error: " + e.message
+        end
+        response_body = {:result => result}.to_json
+        headers = {}
+        headers['Content-Type'] = 'application/json'
+        headers['Content-Length'] = response_body.length.to_s
+        [200, headers, [response_body]]
+      end
+    end
+  end
+end

data/lib/rack/webconsole/sandbox.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Rack
+  class Webconsole
+    # A sandbox to evaluate Ruby in. It is responsible for retrieving local
+    # variables stored in `@locals`, and resetting the environment.
+    #
+    class Sandbox
+      # Catches all the undefined local variables and tries to retrieve them
+      # from `@locals`. If it doesn't find them, it falls back to the default
+      # method missing behavior.
+      def method_missing(method, *args, &block)
+        @locals ||= {}
+        @locals[method] || super(method, *args, &block)
+      end
+
+      # Makes the console use a fresh, new {Sandbox} with all local variables
+      # resetted.
+      #
+      # @return [String] 'ok' to make the user notice.
+      def reload!
+        $sandbox = Sandbox.new
+        'ok'
+      end
+    end
+  end
+end

data/lib/rack/webconsole/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+module Rack
+  class Webconsole
+    # rack-webconsole version number.
+    VERSION = "0.0.1"
+  end
+end

data/lib/rack/webconsole.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require 'rack/webconsole/repl'
+require 'rack/webconsole/asset_helpers'
+require 'rack/webconsole/assets'
+require 'rack/webconsole/sandbox'
+
+require 'rack/webconsole/railtie' if defined?(Rails)
+
+# Rack is a modular webserver interface written by Christian Neukirchen.
+#
+# Learn more at: https://github.com/rack/rack
+#
+module Rack
+  # {Rack::Webconsole} is a Rack middleware that provides an interactive
+  # console à la Rails console, but for any kind of Rack application (Rails,
+  # Sinatra, Padrino...), accessible from your web application's front-end.
+  #
+  # For every request, it normally passes control to the {Assets} middleware,
+  # which injects needed JavaScript, CSS and HTML code for the console to work
+  # properly.
+  #
+  # It also exposes a special route used by the {Repl}, a Ruby evaluator which
+  # is responsible of keeping state between requests, remembering local
+  # variables and giving a true IRB-esque experience.
+  #
+  class Webconsole
+    # Honor the Rack contract by saving the passed Rack application in an ivar.
+    #
+    # @param [Rack::Application] app the previous Rack application in the
+    #   middleware chain.
+    def initialize(app)
+      @app = app
+    end
+
+    # Decides where to send the request. In case the path is `/webconsole`
+    # (e.g. when calling the {Repl} endpoint), pass the request onto the
+    # {Repl}. Otherwise, pass it onto the {Assets} middleware, which will
+    # inject the needed assets for the Webconsole to work.
+    #
+    # @param [Hash] env a Rack request environment.
+    def call(env)
+      if env['PATH_INFO'] == '/webconsole'
+        Repl.new(@app).call(env)
+      else
+        Assets.new(@app).call(env)
+      end
+    end
+  end
+end

data/lib/rack-webconsole.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require 'rack'
+require 'rack/webconsole'

data/public/webconsole.css

@@ -0,0 +1,47 @@
+body {
+  margin:0;
+  padding:0;
+}
+#console {
+  opacity: 0.9;
+  z-index: 999;
+  background: #000;
+  color: #DDD;
+  font-family: monospace;
+  padding-left: 15px;
+  padding-top: 10px;
+  height: 25%;
+  position: fixed;
+  width: 100%;
+  bottom: 0px;
+  border-top: 3px solid #DEDEDE;
+  overflow: hidden;
+  padding-top: 10px;
+}
+#console form div, #console form span {
+  font-size: 14px;
+  background: #000;
+  border: 0px;
+  font-family: monospace;
+  color: #FFF;
+}
+#console form div.results{
+  position: absolute;
+  bottom: 40px;
+  margin-bottom: -10px;
+}
+#console form div.input{
+  width: 97%;
+  position: absolute;
+  bottom: 10px;
+}
+#console form div.input input{
+  margin-top: 0px;
+  margin-bottom: 0px;
+  width: 97%;
+  font-size: 14px;
+  background: #000;
+  border: 0px;
+  font-family: monospace;
+  color: #FFF;
+}

data/public/webconsole.html

@@ -0,0 +1,12 @@
+<script type="text/javascript" src="http://code.jquery.com/jquery-1.6.2.min.js"></script>
+<div id="console">
+  <form accept-charset="UTF-8" action="/webconsole" method="post">
+    <input name="utf8" type="hidden" value="✓"/>
+    <div class="results">
+    </div>
+    <div class="input">
+      <span>>></span>
+      <input id="query" name="query" type="text" />
+    </div>
+  </form>
+</div>

data/public/webconsole.js

@@ -0,0 +1,45 @@
+$(document).ready(function() {
+  $("#console").hide();
+  $(this).keypress(function(event) {
+    if (event.which == 96) {
+      $("#console").slideToggle('fast', function() {
+        if ($(this).is(':visible')) {
+          $("#console form input").focus();
+        } else {
+          $("#console form input").blur();
+        }
+      });
+      event.preventDefault();
+    }
+  });
+});
+$('#console form').submit(function(e){
+    e.preventDefault();
+});
+String.prototype.escapeHTML = function () {
+    return(
+        this.replace(/&/g,'&').
+            replace(/>/g,'>').
+            replace(/</g,'&lt;').
+            replace(/"/g,'&quot;')
+    );
+};
+
+$("#console form input").keyup(function(event) {
+  if(event.which == 13) {
+    /*$.post('/webconsole', $("#console form").serialize());*/
+    var query = $("#query").val();
+    $.ajax({
+      url: '/webconsole',
+      type: 'POST',
+      dataType: 'json',
+      data: ({query: query}),
+      success: function (data) {
+        var q = "<div>>> " + query.escapeHTML() + "</div>";
+        var r = "<div>=> " + data.result.escapeHTML() + "</div>";
+        $("#console .results").append(q + r);
+        $("#query").val('');
+      }
+    });
+  }
+});

data/rack-webconsole.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack/webconsole/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rack-webconsole"
+  s.version     = Rack::Webconsole::VERSION
+  s.authors     = ["Josep M. Bach", "Josep Jaume Rey", "Oriol Gual"]
+  s.email       = ["info@codegram.com"]
+  s.homepage    = "http://github.com/codegram/rack-webconsole"
+  s.summary     = %q{Rack-based console inside your web applications}
+  s.description = %q{Rack-based console inside your web applications}
+
+  s.rubyforge_project = "rack-webconsole"
+
+  s.add_runtime_dependency 'rack'
+  s.add_runtime_dependency 'json'
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'purdytest'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'bluecloth'
+  s.add_development_dependency 'rake'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/rack/webconsole/asset_helpers_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class AssetClass
+  include Rack::Webconsole::AssetHelpers
+end
+
+module Rack
+  describe Webconsole::AssetHelpers do
+
+    describe '#html_code' do
+      it 'loads the html code' do
+        asset_class = AssetClass.new
+        html = asset_class.html_code
+
+        html.must_match /console/
+        html.must_match /results/
+        html.must_match /form/
+      end
+    end
+
+    describe '#css_code' do
+      it 'loads the css code' do
+        asset_class = AssetClass.new
+        css = asset_class.css_code
+
+        css.must_match /<style/
+        css.must_match /text\/css/
+        css.must_match /#console/
+      end
+    end
+
+    describe '#js_code' do
+      it 'loads the js code' do
+        asset_class = AssetClass.new
+        js = asset_class.js_code
+
+        js.must_match /\$\("#console"\)/
+        js.must_match /escapeHTML/
+      end
+    end
+
+  end
+end

data/spec/rack/webconsole/assets_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Rack
+  describe Webconsole::Assets do
+
+    it 'initializes with an app' do
+      @app = stub
+      @assets = Webconsole::Assets.new(@app)
+
+      @assets.instance_variable_get(:@app).must_equal @app
+    end
+
+    describe "#call" do
+
+      describe 'when the call is not appropriate to inject the view code' do
+        # Different invalid cases
+        [
+          [200, {'Content-Type' => 'text/html'}, ['Whatever']],
+          [200, {'Content-Type' => 'text/plain'}, ['Hello World']],
+          [404, {'Content-Type' => 'text/html'}, ['Hello World']],
+          [404, {'Content-Type' => 'text/html'}, ['Hello, World']],
+
+        ].each do |invalid_response|
+          it 'passes the call untouched' do
+            @app = lambda { |env| invalid_response }
+
+            assets = Webconsole::Assets.new(@app)
+            assets.expects(:inject_code).never
+
+            assets.call({}).last.first.must_equal invalid_response.last.first
+          end
+        end
+      end
+
+      describe 'otherwise' do
+
+        it 'injects the view code before the body ending' do
+
+          valid_html = "<!DOCTYPE html>\n<html>\n<head>\n  <title>Testapp</title>\n  <link href=\"/assets/application.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />\n  <script src=\"/assets/application.js\" type=\"text/javascript\"></script>\n  <meta content=\"authenticity_token\" name=\"csrf-param\" />\n<meta content=\"26Ls63zdKBiCXoqU5CuG6KqVbeMYydRqOuovP+DXx8g=\" name=\"csrf-token\" />\n</head>\n<body>\n\n<h1> Hello bitches </h1>\n\n<p> Lorem ipsum dolor sit amet. </p>\n\n\n</body>\n</html>\n"
+
+          html = [valid_html]
+
+          @app = lambda { |env| [200, {'Content-Type' => 'text/html'}, html] }
+
+          assets = Webconsole::Assets.new(@app)
+          response = assets.call({}).last.first
+
+          response.must_match /input name/m # html
+          response.must_match /text\/css/m # css
+          response.must_match /escapeHTML/m # js
+        end
+
+        it "works with Rails' particular conception of what a response is" do
+
+          valid_html = "<!DOCTYPE html>\n<html>\n<head>\n  <title>Testapp</title>\n  <link href=\"/assets/application.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />\n  <script src=\"/assets/application.js\" type=\"text/javascript\"></script>\n  <meta content=\"authenticity_token\" name=\"csrf-param\" />\n<meta content=\"26Ls63zdKBiCXoqU5CuG6KqVbeMYydRqOuovP+DXx8g=\" name=\"csrf-token\" />\n</head>\n<body>\n\n<h1> Hello bitches </h1>\n\n<p> Lorem ipsum dolor sit amet. </p>\n\n\n</body>\n</html>\n"
+
+          @app = lambda { |env| [200, {'Content-Type' => 'text/html'}, OpenStruct.new({:body => valid_html})] }
+
+          assets = Webconsole::Assets.new(@app)
+
+          response = assets.call({}).last.first
+
+          response.must_match /input name/m # html
+          response.must_match /text\/css/m # css
+          response.must_match /escapeHTML/m # js
+        end
+
+      end
+    end
+
+  end
+end

data/spec/rack/webconsole/repl_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Rack
+  describe Webconsole::Repl do
+
+    it 'initializes with an app' do
+      @app = stub
+      @repl = Webconsole::Repl.new(@app)
+
+      @repl.instance_variable_get(:@app).must_equal @app
+    end
+
+    describe "#call" do
+      it 'evaluates the :query param in a sandbox and returns the result' do
+        @app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['hello world']] }
+        env = {}
+        request = OpenStruct.new(:params => {'query' => 'a = 4; a * 2'})
+        Rack::Request.stubs(:new).returns request
+
+        @repl = Webconsole::Repl.new(@app)
+
+        response = @repl.call(env).last.first
+
+        JSON.parse(response)['result'].must_equal "8"
+      end
+
+      it 'maintains local state in subsequent calls thanks to an evil global variable' do
+        @app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['hello world']] }
+        env = {}
+        request = OpenStruct.new(:params => {'query' => 'a = 4'})
+        Rack::Request.stubs(:new).returns request
+        @repl = Webconsole::Repl.new(@app)
+
+        @repl.call(env) # call 1 sets a to 4
+
+        request = OpenStruct.new(:params => {'query' => 'a * 8'})
+        Rack::Request.stubs(:new).returns request
+
+        response = @repl.call(env).last.first # call 2 retrieves a and multiplies it by 8
+
+        JSON.parse(response)['result'].must_equal "32"
+        $sandbox.instance_variable_get(:@locals)[:a].must_equal 4
+      end
+
+      it "returns any found errors prepended with 'Error:'" do
+        @app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['hello world']] }
+        env = {}
+        request = OpenStruct.new(:params => {'query' => 'unknown_method'})
+        Rack::Request.stubs(:new).returns request
+        @repl = Webconsole::Repl.new(@app)
+
+        response = @repl.call(env).last.first
+
+        JSON.parse(response)['result'].must_match /Error:/
+      end
+    end
+
+  end
+end

data/spec/rack/webconsole/sandbox_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Rack
+  describe Webconsole::Sandbox do
+
+    describe "#method_missing" do
+      describe 'when the method exists in @locals' do
+        it 'retrieves it' do
+          @sandbox = Webconsole::Sandbox.new
+          @sandbox.instance_variable_set(:@locals, {:a => 123})
+
+          @sandbox.a.must_equal 123
+        end
+      end
+      describe 'otherwise' do
+        it 'raises a NoMethodError' do
+          @sandbox = Webconsole::Sandbox.new
+
+          lambda {
+            @sandbox.a
+          }.must_raise NoMethodError
+        end
+      end
+    end
+
+    describe "#reload!" do
+      it 'assigns a new, fresh Sandbox to the global variable' do
+        old_sandbox = $sandbox = Webconsole::Sandbox.new
+
+        $sandbox.reload!
+
+        $sandbox.wont_equal old_sandbox
+      end
+      it 'returns a feedback string' do
+        Webconsole::Sandbox.new.reload!.must_equal 'ok'
+      end
+    end
+
+  end
+end

data/spec/rack/webconsole_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Rack
+  describe Webconsole do
+
+    it 'initializes with an app' do
+      @app = stub
+      @webconsole = Webconsole.new(@app)
+
+      @webconsole.instance_variable_get(:@app).must_equal @app
+    end
+
+    describe "#call" do
+      it 'delegates the call to the Repl middleware when the path is /webconsole' do
+        @app = stub
+        @webconsole = Webconsole.new(@app)
+        @env = {'PATH_INFO' => '/webconsole'}
+
+        repl = stub
+        Webconsole::Repl.expects(:new).with(@app).returns repl
+        repl.expects(:call).with @env
+
+        @webconsole.call(@env)
+      end
+
+      it 'passes the call to the Assets middleware otherwise' do
+        @app = stub
+        @webconsole = Webconsole.new(@app)
+        @env = {'PATH_INFO' => '/whatever'}
+
+        assets = stub
+        Webconsole::Assets.expects(:new).with(@app).returns assets
+        assets.expects(:call).with @env
+
+        @webconsole.call(@env)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'purdytest'
+require 'mocha'
+
+require 'rack-webconsole'
+

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification 
+name: rack-webconsole
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Josep M. Bach
+- Josep Jaume Rey
+- Oriol Gual
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: purdytest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bluecloth
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: Rack-based console inside your web applications
+email: 
+- info@codegram.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- lib/rack-webconsole.rb
+- lib/rack/webconsole.rb
+- lib/rack/webconsole/asset_helpers.rb
+- lib/rack/webconsole/assets.rb
+- lib/rack/webconsole/railtie.rb
+- lib/rack/webconsole/repl.rb
+- lib/rack/webconsole/sandbox.rb
+- lib/rack/webconsole/version.rb
+- public/webconsole.css
+- public/webconsole.html
+- public/webconsole.js
+- rack-webconsole.gemspec
+- spec/rack/webconsole/asset_helpers_spec.rb
+- spec/rack/webconsole/assets_spec.rb
+- spec/rack/webconsole/repl_spec.rb
+- spec/rack/webconsole/sandbox_spec.rb
+- spec/rack/webconsole_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/codegram/rack-webconsole
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: rack-webconsole
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: Rack-based console inside your web applications
+test_files: 
+- spec/rack/webconsole/asset_helpers_spec.rb
+- spec/rack/webconsole/assets_spec.rb
+- spec/rack/webconsole/repl_spec.rb
+- spec/rack/webconsole/sandbox_spec.rb
+- spec/rack/webconsole_spec.rb
+- spec/spec_helper.rb