rack-info 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Greenberg
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# Rack::Info
+
+`Rack::Info` is a Rack middleware that can be used to add information about your application or environment to requests. You can use it to expose data like the current version of the application or which host served the request.
+
+This information can be added as X-headers, output as HTML, or served from a dedicated endpoint.
+
+## Installation
+
+```
+gem install rack-info
+```
+
+## Usage
+
+For the simple case where you want to add the same values as headers to every request, provide `Rack::Info` with a hash of key/value pairs.
+
+Here's an example from `examples/basic_example.ru`:
+```
+require 'rack/info'
+require 'socket'
+
+use Rack::Head
+use Rack::Info, {:git => `git rev-parse HEAD`.strip, :host => Socket.gethostname}
+run lambda {|env| [200, {"Content-Type" => "text/plain"}, ["OK"]] }
+```
+
+After you start a server by running `rackup config/basic_example.ru`, you can see the headers are added to your request:
+
+```
+$ curl -I http://localhost:9292
+HTTP/1.1 200 OK
+X-Git: 3e534f6302eca4e8f94456efa09523b49b1c41c7
+X-Host: Ollantaytambo.local
+Transfer-Encoding: chunked
+Connection: close
+```
+
+For more complex cases, use a `Rack::Info::Config` object:
+
+```
+use(Rack::Info, Rack::Info::Config.new do |config|
+  # Set any desired options; see Configuration below
+  config.metadata = {:git => `git rev-parse HEAD`.strip, :host => Socket.gethostname}
+  config.is_enabled = lambda {|env| [true, false].sample }
+  config.path = "/version"
+end)
+```
+
+## Configuration
+
+Configuration is done via an instance of `Rack::Info::Config`. You can create a configuration by providing a block to the constructor, or by setting values directly on a new instance:
+
+```
+Rack::Info::Config.new do |config|
+  config.add_html = false
+end
+
+config = Rack::Info::Config.new
+config.add_html = false
+```
+
+The following options can be set on an config object:
+
+- `metadata`: a hash of key/value pairs that will be added as X-headers, HTML content, or exposed directly at a JSON endpoint, depending on the other configuration. (default: `{}`)
+- `is_enabled`: whether or not this middleware will add any metadata to the response. It can be a boolean value, or an object that responds to .call with a boolean value. The Rack request environment is provided to a callable object. This can be useful for adding data only to requests from a certain IP block, for example. (default: `true`)
+- `add_headers`: whether or not metadata will be added to this request as X-headers. It can be a boolean value, or an object that responds to .call with a boolean value. The Rack request environment _and_ current Rack response tuple are provided to a callable object. (default: `true`)
+- `add_html`: whether or not metadata will be added to this request as HTML. It can be a boolean value, or an object that responds to .call with a boolean value. The Rack request environment *and* current Rack response tuple are provided to a callable object. Note: content is only added to responses with a content-type header of text/html. (default: `true`)
+- `insert_html_after`: the HTML tag after which the HTML metadata will be added. (default: `</body>`)
+- `html_formatter`: object that converts metadata pairs to an HTML string. See `HTMLComment` and `HTMLMetaTag` for examples. (default: `HTMLComment`)
+- `path`: an endpoint at which metadata will be returned as a JSON string. Set to nil to disable. (default: `nil`)
+
+## Examples
+
+You can find examples of different configurations in `examples`.
+
+## Development
+
+To make changes to rack-metadata:
+
+1. Clone this repository
+2. `bundle install`
+3. Run tests with `rspec`

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO.txt

@@ -0,0 +1,4 @@
+- Ensure that HTTP headers are properly sanitized (see http://tools.ietf.org/html/rfc2616#section-4.2, http://tools.ietf.org/html/rfc2616#section-6.2, http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html)
+- Allow metadata to have dynamic values when values are callable
+- Cache HTML content and header content when metadata values are not dynamic
+- Have the config validate itself, and raise an exception in ::Metadata if config is invalid

data/examples/basic_example.ru

@@ -0,0 +1,7 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'rack/info'
+require 'socket'
+
+use Rack::Head
+use Rack::Info, {:git => `git rev-parse HEAD`.strip, :host => Socket.gethostname}
+run lambda {|env| [200, {"Content-Type" => "text/plain"}, ["OK"]] }

data/examples/html_comment_example.ru

@@ -0,0 +1,10 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'rack/info'
+require 'socket'
+
+HTML = "<html><head><title>My Website</title></head><body>My content</body></html>".freeze
+
+use(Rack::Info, Rack::Info::Config.new do |config|
+  config.data = {:git => `git rev-parse HEAD`.strip, :host => Socket.gethostname}
+end)
+run lambda {|env| [200, {"Content-Type" => "text/html"}, [HTML]] }

data/examples/html_meta_tag_example.ru

@@ -0,0 +1,12 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'rack/info'
+require 'socket'
+
+HTML = "<html><head><title>My Website</title></head><body>My content</body></html>".freeze
+
+use(Rack::Info, Rack::Info::Config.new do |config|
+  config.data = {:git => `git rev-parse HEAD`.strip, :host => Socket.gethostname}
+  config.insert_html_after = '<head>'
+  config.html_formatter = Rack::Info::HTMLMetaTag
+end)
+run lambda {|env| [200, {"Content-Type" => "text/html"}, [HTML]] }

data/examples/path_example.ru

@@ -0,0 +1,9 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'rack/info'
+require 'socket'
+
+use(Rack::Info, Rack::Info::Config.new do |config|
+  config.data = {:git => `git rev-parse HEAD`, :host => Socket.gethostname}
+  config.path = "/server_info"
+end)
+run lambda {|env| [200, {}, ["OK"]] }

data/lib/rack-info.rb

@@ -0,0 +1 @@
+require 'rack/info'

data/lib/rack/info.rb

@@ -0,0 +1,67 @@
+require "multi_json"
+
+require "rack/info/version"
+require "rack/info/config"
+require "rack/info/html_formatter"
+require "rack/info/html_comment"
+require "rack/info/html_meta_tag"
+
+module Rack
+  class Info
+    CONTENT_TYPE_HEADER = 'Content-Type'
+    HTML_CONTENT_TYPE = 'text/html'
+
+    def self.header_name(str)
+      "X-" + str.to_s.split(/[-_ ]/).map(&:capitalize).join("-")
+    end
+
+    def self.header_value(obj)
+      obj.to_s
+    end
+
+    attr_reader :app, :config, :metadata
+
+    def initialize(app, hsh_or_config = {})
+      @app = app
+      @config = Config.from(hsh_or_config)
+      @data_headers = to_headers(@config.data)
+    end
+
+    def call(env)
+      return app.call(env) unless config.enabled?(env)
+      return json_rsp if config.path == env["PATH_INFO"]
+
+      status, headers, body = @app.call(env)
+      headers.merge!(@data_headers) if config.add_headers?(env, [status, headers, body])
+      if html?(headers) && config.add_html?(env, [status, headers, body])
+        body = add_html(body)
+      end
+
+      [status, headers, body]
+    end
+
+    private
+
+    def to_headers(hsh)
+      Hash[@config.data.map do |k, v|
+        [self.class.header_name(k), self.class.header_value(v)]
+      end]
+    end
+
+    def json_rsp
+      [200, {"Content-Type" => "application/json"}, [MultiJson.dump(config.data)]]
+    end
+
+    def html?(headers)
+      headers[CONTENT_TYPE_HEADER] &&
+      headers[CONTENT_TYPE_HEADER].start_with?(HTML_CONTENT_TYPE)
+    end
+
+    def add_html(body)
+      content = ""
+      body.each {|ea| content << ea}
+      new_html_content = config.html_formatter.format(config.data)
+      [ content.sub(config.insert_html_after) {|match| match + new_html_content } ]
+    end
+  end
+end

data/lib/rack/info/config.rb

@@ -0,0 +1,57 @@
+class Rack::Info
+  class Config
+    # You can create a configuration by providing a block to the constructor,
+    # or by setting values directly on a new instance:
+    #
+    # Rack::Info::Config.new do |config|
+    #   config.add_html = false
+    # end
+    #
+    # config = Rack::Info::Config.new
+    # config.add_html = false
+    #
+    # Configuration options (see README for explanation of options)
+    #   - data
+    #   - is_enabled
+    #   - add_headers
+    #   - add_html
+    #   - html_formatter
+    #   - insert_html_after
+    #   - path
+    attr_accessor :data, :is_enabled, :add_headers, :add_html,
+      :html_formatter, :insert_html_after, :path
+
+    def self.from(obj)
+      obj.is_a?(self) ? obj : self.new {|cnf| cnf.data = obj }
+    end
+
+    def initialize
+      set_defaults
+      yield self if block_given?
+    end
+
+    def enabled?(env)
+      is_enabled.respond_to?(:call) ? is_enabled.call(env) : is_enabled
+    end
+
+    def add_headers?(env, rsp)
+      add_headers.respond_to?(:call) ? add_headers.call(env, rsp) : add_headers
+    end
+
+    def add_html?(env, rsp)
+      add_html.respond_to?(:call) ? add_html.call(env, rsp) : add_html
+    end
+
+    private
+
+    def set_defaults
+      self.data = {}
+      self.is_enabled = true
+      self.add_headers = true
+      self.add_html = true
+      self.html_formatter = HTMLComment
+      self.insert_html_after = '</body>'
+      self.path = nil
+    end
+  end
+end

data/lib/rack/info/html_comment.rb

@@ -0,0 +1,26 @@
+class Rack::Info
+  # See http://www.w3.org/TR/html-markup/spec.html#comments and
+  # http://www.w3.org/TR/html5/syntax.html#comments for restrictions on
+  # HTML comments.
+  class HTMLComment < HTMLFormatter
+    START_COMMENT = "<!--"
+    END_COMMENT = "-->"
+    INVALID_COMMENT_CONTENT = "--"
+
+    def self.format(hsh)
+      START_COMMENT + "\n" + sanitize(format_pairs(hsh)) + "\n" + END_COMMENT
+    end
+
+    def self.sanitize(str)
+      str.gsub(INVALID_COMMENT_CONTENT, '')
+    end
+
+    def self.format_pairs(hsh)
+      hsh.map {|k,v| format_pair(k, v) }.sort_by {|k, v| k }.join("\n")
+    end
+
+    def self.format_pair(key, value)
+      "#{key}: #{value}"
+    end
+  end
+end

data/lib/rack/info/html_formatter.rb

@@ -0,0 +1,7 @@
+class Rack::Info
+  class HTMLFormatter
+    def self.format(hsh)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/rack/info/html_meta_tag.rb

@@ -0,0 +1,17 @@
+class Rack::Info
+  class HTMLMetaTag < HTMLFormatter
+    def self.format(hsh)
+      "\n" + hsh.map {|k, v| format_item(k, v) }.join("\n") + "\n"
+    end
+
+    def self.format_item(key, value)
+      %|<meta name="#{h(key)}" content="#{h(value)}">|
+    end
+
+    private
+
+    def self.h(str)
+      Rack::Utils.escape_html(str)
+    end
+  end
+end

data/lib/rack/info/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Info
+    VERSION = "0.0.1"
+  end
+end

data/rack-info.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/info/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-info"
+  spec.version       = Rack::Info::VERSION
+  spec.authors       = ["Ryan Greenberg"]
+  spec.email         = ["ryangreenberg@gmail.com"]
+  spec.summary       = "Rack middleware to add information to request headers or body"
+  spec.description   = spec.summary
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'multi_json', '~> 1.0'
+  spec.add_dependency 'rack'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+end

data/spec/config_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Rack::Info::Config do
+  it "passes itself to a constructor block" do
+    expect do |blk|
+      Rack::Info::Config.new(&blk)
+    end.to yield_with_args(Rack::Info::Config)
+  end
+
+  describe ".from" do
+    it "returns Config objects unchanged" do
+      config = Rack::Info::Config.new
+      Rack::Info::Config.from(config).should == config
+    end
+
+    it "creates a new Config object from a hash" do
+      hsh = {:key => :value}
+      new_config = Rack::Info::Config.from(hsh)
+      new_config.data.should == hsh
+    end
+  end
+
+  describe "add_headers?" do
+    before :each do
+      @rack_env = {}
+      @rack_rsp = [200, {}, [""]]
+    end
+
+    it "is true when add_headers is set to true" do
+      config = Rack::Info::Config.new
+      config.add_headers = true
+      config.should be_add_headers(@rack_env, @rack_rsp)
+    end
+
+    it "is false when add_headers is set to false" do
+      config = Rack::Info::Config.new
+      config.add_headers = false
+      config.should_not be_add_headers(@rack_env, @rack_rsp)
+    end
+
+    context "when add_headers is callable" do
+      it "calls add_headers" do
+        config = Rack::Info::Config.new
+        lambda_was_called = false
+        config.add_headers = lambda {|*args| lambda_was_called = true }
+        config.add_headers?(@rack_env, @rack_rsp)
+        lambda_was_called.should be_true
+      end
+
+      it "provides the rack_env and response" do
+        config = Rack::Info::Config.new
+        yielded_args = []
+        config.add_headers = lambda {|*args| yielded_args = args }
+        config.add_headers?(@rack_env, @rack_rsp)
+        yielded_args.should == [@rack_env, @rack_rsp]
+      end
+    end
+  end
+end

data/spec/html_comment_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Rack::Info::HTMLComment do
+  describe ".format" do
+    before :each do
+      @hsh = {:some_key => :some_value}
+    end
+
+    it "returns a string that starts with <!--" do
+      Rack::Info::HTMLComment.format(@hsh).should be_start_with("<!--")
+    end
+
+    it "returns a string that ends with -->" do
+      Rack::Info::HTMLComment.format(@hsh).should be_end_with("-->")
+    end
+
+    it "returns a string that includes the formatted values" do
+      comment = Rack::Info::HTMLComment.format(@hsh)
+      comment.should include(Rack::Info::HTMLComment.format_pairs(@hsh))
+    end
+
+    it "removes the string -- to avoid closing the comment early" do
+      @hsh["value_including_html"] = "attempt to close comment early -->"
+      comment = Rack::Info::HTMLComment.format(@hsh)
+      comment.should include("attempt to close comment early >")
+    end
+  end
+
+  describe ".format_pairs" do
+    it "separates individual pairs with a newline" do
+      hsh = {:a => 1, :b => 2}
+      output = Rack::Info::HTMLComment.format_pairs(hsh)
+      output.should include("\n")
+    end
+
+    it "sorts pairs alphabetically by key name" do
+      hsh = {:c => 3, :b => 2, :a => 1}
+      alphabetical_order = [[:a, 1], [:b, 2], [:c, 3]]
+      expected_order = alphabetical_order.map do |ea|
+        Rack::Info::HTMLComment.format_pair(*ea)
+      end
+      output = Rack::Info::HTMLComment.format_pairs(hsh)
+      output.split("\n").should == expected_order
+    end
+  end
+
+  describe ".format_pair" do
+    it "separates the key and value with a colon" do
+      output = Rack::Info::HTMLComment.format_pair("some_key", "some_value")
+      output.should == "some_key: some_value"
+    end
+
+    it "converts key and value to strings" do
+      output = Rack::Info::HTMLComment.format_pair(:some_key, :some_value)
+      output.should == "some_key: some_value"
+    end
+  end
+end

data/spec/html_meta_tag_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Rack::Info::HTMLMetaTag do
+  describe ".format_item" do
+    it "returns a <meta> tag string" do
+      tag = Rack::Info::HTMLMetaTag.format_item("color", "red")
+      tag.should be_start_with("<meta")
+      tag.should be_end_with(">")
+    end
+
+    it "converts the key into a name attribute" do
+      tag = Rack::Info::HTMLMetaTag.format_item("color", "red")
+      tag.should include('name="color"')
+    end
+
+    it "converts the value into a content attribute" do
+      tag = Rack::Info::HTMLMetaTag.format_item("color", "red")
+      tag.should include('content="red"')
+    end
+
+    it "escapes HTML entities in the key and value" do
+      tag = Rack::Info::HTMLMetaTag.format_item(%|"it's & its"|, "my <item>")
+      tag.should include('&quot;it&#x27;s &amp; its&quot;')
+      tag.should include('my &lt;item&gt;')
+    end
+  end
+end

data/spec/info_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Rack::Info do
+  def base_data
+    {:some_key => :some_value}
+  end
+
+  def base_config(hsh = base_data)
+    Rack::Info::Config.from(hsh)
+  end
+
+  describe ".header_name" do
+    it "prepends X-" do
+      Rack::Info.header_name("Dog").should == "X-Dog"
+    end
+
+    it "capitalizes words" do
+      Rack::Info.header_name("cat").should == "X-Cat"
+    end
+
+    it "converts symbols to strings" do
+      Rack::Info.header_name(:giraffe).should == "X-Giraffe"
+    end
+
+    it "converts spaces to dashes" do
+      Rack::Info.header_name("mountain lion").should == "X-Mountain-Lion"
+    end
+
+    it "converts underscores to dashes" do
+      Rack::Info.header_name("mountain_lion").should == "X-Mountain-Lion"
+    end
+  end
+
+  describe ".header_value" do
+    it "converts to a string" do
+      actual_values = [1, true, :true, nil]
+      expected_values = ["1", "true", "true", ""]
+      actual_values.zip(expected_values).each do |actual, expected|
+        Rack::Info.header_value(actual).should == expected
+      end
+    end
+  end
+
+  describe "#call" do
+    it "can be constructed with a hash instead of a config object" do
+      hsh = {:color => "Red", :virtue => "Beauty"}
+      app = rack_app(OK_APP, Rack::Info, hsh)
+      rsp = app.call(rack_env)
+      rsp.headers.should include({"X-Color" => "Red"}, {"X-Virtue" => "Beauty"})
+    end
+
+    context "when config.enabled? returns false" do
+      before :each do
+        @config = base_config
+        @config.stub(:enabled?).and_return(false)
+      end
+
+      it "does not add headers" do
+        env = rack_env
+        @config.stub(:add_headers?).and_return(true)
+        app = rack_app(OK_APP, Rack::Info, @config)
+        rsp = app.call(env)
+        rsp.headers.should == unchanged_rsp(OK_APP, env).headers
+      end
+
+      it "calls the underlying app even if config.path is requested" do
+        env = rack_env
+        @config.path = env["PATH_INFO"]
+        app = rack_app(NOT_FOUND_APP, Rack::Info, @config)
+        rsp = app.call(env)
+        rsp.headers.should == unchanged_rsp(NOT_FOUND_APP, env).headers
+      end
+
+      it "does not modify HTML" do
+        env = rack_env
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(env)
+        rsp.body.should == unchanged_rsp(HTML_APP, env).body
+      end
+    end
+
+    context "when config.add_headers? returns true" do
+      it "adds the data as response headers" do
+        config = Rack::Info::Config.new do |config|
+          config.data = {:color => "Blue", :virtue => "Justice"}
+        end
+        config.stub(:add_headers?).and_return(true)
+        app = rack_app(OK_APP, Rack::Info, config)
+        rsp = app.call(rack_env)
+        rsp.headers.should include({"X-Color" => "Blue"}, {"X-Virtue" => "Justice"})
+      end
+    end
+
+    context "when config.add_headers? returns false" do
+      it "does not modify the response headers" do
+        env = rack_env
+        config = base_config
+        config.stub(:add_headers?).and_return(false)
+        app = rack_app(OK_APP, Rack::Info, config)
+        rsp = app.call(env)
+        rsp.headers.should == unchanged_rsp(OK_APP, env).headers
+      end
+    end
+
+    context "when config.add_html? returns true" do
+      before :each do
+        @config = base_config
+        @config.stub(:add_html?).and_return(true)
+        @config.html_formatter = Rack::Info::HTMLComment
+        @env = rack_env
+      end
+
+      it "adds an HTML fragment when the response Content-Type is text/html" do
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.headers["Content-Type"].should == "text/html"
+        rsp.body.should include Rack::Info::HTMLComment.format(@config.data)
+      end
+
+      it "adds an HTML fragment when the response Content-Type is 'text/html; charset=utf-8'" do
+        charset_app = lambda do |env|
+          HTML_APP.call(env).tap {|s, h, b| h.merge!('Content-Type' => 'text/html; charset=utf-8') }
+        end
+        app = rack_app(charset_app, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should include Rack::Info::HTMLComment.format(@config.data)
+      end
+
+      it "puts the HTML fragment after config.insert_html_after" do
+        @config.insert_html_after = "<html>"
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should include("<html>" + Rack::Info::HTMLComment.format(@config.data))
+      end
+
+      it "puts the HTML fragment after config.insert_html_after as a regex" do
+        @config.insert_html_after = /<head.*?>/
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should include("<head>" + Rack::Info::HTMLComment.format(@config.data))
+      end
+
+      it "uses the HTML fragment provided by config.html_formatter" do
+        formatter = double("formatter")
+        allow(formatter).to receive(:format).and_return("<strong>content</strong>")
+        @config.html_formatter = formatter
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should include("<strong>content</strong>")
+      end
+
+      it "provides config.data when calling config.html_formatter" do
+        formatter = double("formatter", :format => "")
+        @config.html_formatter = formatter
+        app = rack_app(HTML_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        expect(formatter).to have_received(:format).with(@config.data)
+      end
+
+      it "does not error if Content-Type is not provided" do
+        malformed_app = lambda {|env| [200, {}, ["OK"]] }
+        app = rack_app(malformed_app, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should == unchanged_rsp(malformed_app, @env).body
+      end
+
+      it "does not modify the response body when Content-Type is not text/html" do
+        app = rack_app(OK_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.headers["Content-Type"].should_not == "text/html"
+        rsp.body.should == unchanged_rsp(OK_APP, @env).body
+      end
+    end
+
+    context "when config.path matches the request path" do
+      before :each do
+        @config = base_config
+        @config.path = "/version"
+        @env = rack_env(@config.path)
+      end
+
+      it "does not call the underlying app" do
+        uncalled_app = lambda {|env| raise RuntimeError, "Underlying app should not be called" }
+        app = rack_app(uncalled_app, Rack::Info, @config)
+        lambda { app.call(@env) }.should_not raise_error
+      end
+
+      it "returns HTTP 200" do
+        app = rack_app(NOT_FOUND_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.status.should == 200
+      end
+
+      it "sets the Content-Type to application/json" do
+        app = rack_app(NOT_FOUND_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.headers["Content-Type"].should == "application/json"
+      end
+
+      it "returns config.data as a JSON string" do
+        app = rack_app(NOT_FOUND_APP, Rack::Info, @config)
+        rsp = app.call(@env)
+        rsp.body.should == '{"some_key":"some_value"}'
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+$:.unshift('../lib')
+require 'rack/info'
+
+require 'rack'
+require 'rack/builder'
+
+require 'rspec'
+require 'rspec/autorun'
+
+HTML =<<MARKUP
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>The Internet</html>
+  </head>
+  <body>
+    <h1>The Internet</h1>
+    <p>Welcome</p>
+  </body>
+</html>
+MARKUP
+
+# Simple Rack apps for testing
+OK_APP = lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+NOT_FOUND_APP = lambda {|env| [400, {'Content-Type' => 'text/plain'}, ['Not found']] }
+HTML_APP = lambda {|env| [200, {'Content-Type' => 'text/html'}, [HTML]] }
+
+module RackSpecHelpers
+  def rack_env(path="/")
+    Rack::MockRequest.env_for(path)
+  end
+
+  # Construct a middleware chain with +underlying_app+ at the bottom,
+  # Rack::Lint on either side of +middleware+, and +middleware_args+
+  # provided when constructing +middleware+.
+  #
+  # For more convenient assertions, the response is automatically
+  # wrapped as a Rack::MockResponse instead of a [status, header, body]
+  # tuple.
+  def rack_app(underlying_app, middleware, *middleware_args)
+    app = Rack::Builder.new do
+      use Rack::Lint
+      use middleware, *middleware_args
+      use Rack::Lint
+      run underlying_app
+    end.to_app
+
+    lambda do |env|
+      Rack::MockResponse.new(*app.call(env))
+    end
+  end
+
+  def unchanged_rsp(app, env)
+    Rack::MockResponse.new(*app.call(env))
+  end
+end
+
+RSpec.configure do |config|
+  config.include RackSpecHelpers
+end

data/spec/test_examples.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby -wKU
+
+# Ensure that all of the examples start properly and respond to a request
+# successfully
+#
+# This set of tests relies on certain Unix commands that will not be available
+# on Windows.
+
+require 'fileutils'
+require 'net/http'
+require 'tmpdir'
+
+def wait_for_port(port, timeout_secs)
+  timeout_secs.times do
+    success = system("lsof -i:#{port} >/dev/null")
+    return if success
+    sleep 1
+  end
+  abort("Port #{port} was not in use after waiting for #{timeout_secs} seconds")
+end
+
+def with_server(rackup_config)
+  pid_file = "#{Dir.tmpdir}/example.pid"
+  port = 9292
+  print "Starting server using #{rackup_config}..."
+  success = system("rackup --daemonize --pid #{pid_file} #{rackup_config}")
+  abort("Unable to start server using #{example}") unless success
+  wait_for_port(port, 10)
+  puts "OK"
+
+  yield URI.parse("http://localhost:#{port}") if block_given?
+ensure
+  pid = File.read(pid_file)
+  puts "Stopping pid #{pid}"
+  system("kill -9 #{pid}")
+end
+
+def main
+  examples = Dir["./examples/*.ru"]
+  examples.each do |example|
+    with_server(example) do |uri|
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.request_get("/") do |rsp|
+        puts ""
+        puts "GET #{uri}/ => HTTP #{rsp.code}"
+        rsp.each_header {|header| puts "#{header}: #{rsp[header]}" }
+        puts rsp.body
+        puts ""
+        abort("Received non-HTTP 200 response from #{uri}") unless rsp.code == "200"
+      end
+    end
+  end
+end
+
+main

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: rack-info
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Greenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: Rack middleware to add information to request headers or body
+email:
+- ryangreenberg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.txt
+- examples/basic_example.ru
+- examples/html_comment_example.ru
+- examples/html_meta_tag_example.ru
+- examples/path_example.ru
+- lib/rack-info.rb
+- lib/rack/info.rb
+- lib/rack/info/config.rb
+- lib/rack/info/html_comment.rb
+- lib/rack/info/html_formatter.rb
+- lib/rack/info/html_meta_tag.rb
+- lib/rack/info/version.rb
+- rack-info.gemspec
+- spec/config_spec.rb
+- spec/html_comment_spec.rb
+- spec/html_meta_tag_spec.rb
+- spec/info_spec.rb
+- spec/spec_helper.rb
+- spec/test_examples.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4600296762285921712
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4600296762285921712
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Rack middleware to add information to request headers or body
+test_files:
+- spec/config_spec.rb
+- spec/html_comment_spec.rb
+- spec/html_meta_tag_spec.rb
+- spec/info_spec.rb
+- spec/spec_helper.rb
+- spec/test_examples.rb