rack-flags 0.1.2

data/lib/rack-flags/admin_app.rb

@@ -0,0 +1,120 @@
+require 'erb'
+
+module RackFlags
+  class FullFlagPresenter
+
+    def initialize(full_flag)
+      @full_flag = full_flag
+    end
+
+    def default
+      @full_flag.default ? 'On' : 'Off'
+    end
+
+    def name
+      @full_flag.name
+    end
+
+    def description
+      @full_flag.description
+    end
+
+    def checked_attribute_for(state)
+      state == selected_state ? 'checked' : ''
+    end
+
+    private
+
+      def selected_state
+        case @full_flag.override
+        when nil then :default
+        when true then :on
+        else :off
+        end
+      end
+
+  end
+
+  class AdminApp
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if request.path_info.chomp("/").empty?
+        handle_root(request)
+      else
+        handle_non_root(request)
+      end
+    end
+
+    private
+
+      def handle_root(request)
+        case 
+        when request.get? then handle_root_get(request)
+        when request.post? then handle_root_post(request)
+        else
+          not_allowed
+        end
+      end
+
+      def handle_root_get(request)
+        reader = RackFlags.for_env(request.env)
+
+        template = ERB.new(resource('index.html.erb'))
+
+
+        flag_presenters = reader.full_flags.map{ |flag| FullFlagPresenter.new(flag) }
+        view_model = OpenStruct.new( 
+          :css_href => "#{request.path}/style.css",
+          :flags => flag_presenters
+        )
+
+        [
+          200, 
+          {'Content-Type'=>'text/html'}, 
+          [template.result( view_model.instance_eval{ binding } )]
+        ]
+      end
+
+      def handle_root_post(request)
+        overrides = request.POST.inject({}) do |overrides, (flag_name, form_param_flag_state)|
+          overrides[flag_name.downcase.to_sym] = flag_value_for(form_param_flag_state)
+          overrides
+        end
+
+        cookie = CookieCodec.new.generate_cookie_from(overrides)
+
+        response = Rack::Response.new
+        response.redirect(request.script_name, 303)
+        response.set_cookie(CookieCodec::COOKIE_KEY, cookie)
+
+        response.finish
+      end
+
+      def handle_non_root(request)
+        Rack::File.new( RackFlags.path_for_resource('admin_app') ).call(request.env)
+      end
+
+      def not_allowed
+        [405, {}, ['405 - METHOD NOT ALLOWED']]
+      end
+
+      def flag_value_for(form_param_flag_state)
+        flag_states = {
+            on: true,
+            off: false,
+            default: nil
+        }
+        flag_states[form_param_flag_state.to_sym]
+      end
+
+      def resource_root
+        RackFlags.path_for_resource('admin_app')
+      end
+
+      def resource(filename)
+        File.read(RackFlags.path_for_resource(File.join('admin_app',filename)))
+      end
+
+  end
+end

data/lib/rack-flags/config.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module RackFlags
+
+  class Config
+    attr_reader :flags
+    
+    def self.load( yaml_path )
+      flags = YAML.load( File.read( yaml_path ) )
+      new( flags )
+    end
+
+    def initialize(flag_config)
+      flag_config ||= {}
+
+      @flags = flag_config.map do |flag_name, flag_details| 
+        base_flag_from_config_entry(flag_name,flag_details)
+      end
+    end
+
+    private
+
+    def base_flag_from_config_entry( name, details )
+      symbolized_details = symbolize_keys( details )
+      BaseFlag.new( 
+                   name.to_sym,
+                   symbolized_details.fetch( :description ,""),
+                   symbolized_details.fetch( :default ,false)
+                  )
+    end
+
+    def symbolize_keys(hash)
+      hash.inject({}) do |symbolized_hash, (key, value)|
+        symbolized_hash[key.to_sym] = value
+        symbolized_hash
+      end
+    end
+    
+  end
+
+end

data/lib/rack-flags/cookie_codec.rb

@@ -0,0 +1,66 @@
+module RackFlags
+
+  class CookieCodec
+    COOKIE_KEY='rack-flags'
+
+    class Parser
+      attr_reader :overrides
+
+      def self.parse(cookie_value)
+        parser = new 
+        parser.parse(cookie_value)
+        parser.overrides
+      end
+
+      def initialize()
+        @overrides = {}
+      end
+
+      def parse(raw_overrides)
+        return if raw_overrides.nil?
+
+        raw_overrides.split(' ').each do |override|
+          parse_override(override)
+        end
+      end
+
+      private
+
+      BANG_DETECTOR = Regexp.compile(/^!(.+)/)
+
+      def parse_override(override)
+        if override_without_bang = override[BANG_DETECTOR,1]
+          add_override(override_without_bang,false)
+        else
+          add_override(override,true)
+        end
+      end
+
+      def add_override( name, value )
+        @overrides[name.to_sym] = value
+      end
+    end
+
+    def overrides_from_env(env)
+      req = Rack::Request.new(env)
+      raw_overrides = req.cookies[COOKIE_KEY]
+      Parser.parse( raw_overrides )
+    end
+
+    def generate_cookie_from(overrides)
+      cookie_values = overrides.map {|flag_name, flag_value| cookie_value_for(flag_name, flag_value) }
+      cookie_values.compact.join(' ')
+    end
+
+    private
+
+      def cookie_value_for(flag_name, flag_value)
+        case flag_value
+        when true then flag_name
+        when false then "!#{flag_name}"
+        else nil
+        end
+      end
+  end
+
+end

data/lib/rack-flags/rack_middleware.rb

@@ -0,0 +1,19 @@
+module RackFlags
+  class RackMiddleware
+    ENV_KEY = 'x-rack-flags.flag-reader'
+
+    def initialize( app, args )
+      @app = app
+      yaml_path = args.fetch( :yaml_path ){ raise ArgumentError.new( 'yaml_path must be provided' ) }
+      @config = Config.load( yaml_path )
+    end
+
+    def call( env )
+      overrides = CookieCodec.new.overrides_from_env( env )
+      reader = Reader.new( @config.flags, overrides )
+      env[ENV_KEY] = reader
+
+      @app.call(env)
+    end
+  end
+end

data/lib/rack-flags/reader.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+module RackFlags
+
+  BaseFlag = Struct.new(:name,:description,:default)
+
+  FullFlag = Struct.new(:base_flag, :override) do
+    extend Forwardable
+
+    def_delegators :base_flag, :name, :description, :default
+  end
+
+  class Reader
+    def self.blank_reader
+      new( [], {} )
+    end
+
+    def initialize( base_flags, overrides )
+      @base_flags = load_base_flags( base_flags )
+      @overrides = overrides
+    end
+
+    def base_flags
+      @base_flags.values.inject({}) { |h,flag| h[flag.name] = flag.default; h }
+    end
+
+    def full_flags
+      @base_flags.values.map do |base_flag|
+        FullFlag.new(base_flag, @overrides[base_flag.name.to_sym])
+      end
+    end
+
+    def on?(flag_name)
+      flag_name = flag_name.to_sym
+
+      return false unless base_flag_exists?( flag_name )
+
+      @overrides.fetch(flag_name) do
+        # fall back to defaults
+        fetch_base_flag(flag_name).default
+      end
+    end
+
+    private
+
+    def load_base_flags( flags )
+      Hash[ *flags.map{ |f| [f.name.to_sym, f] }.flatten ]
+    end
+
+    def base_flag_exists?( flag_name )
+      @base_flags.has_key?( flag_name )
+    end
+
+    def fetch_base_flag( flag_name )
+      @base_flags.fetch( flag_name ) do
+        BaseFlag.new( nil, nil, false ) # if we couldn't find a flag return a Null flag
+      end
+    end
+  end
+
+end

data/lib/rack-flags/version.rb

@@ -0,0 +1,3 @@
+module RackFlags
+  VERSION = "0.1.2"
+end

data/lib/rack-flags.rb

@@ -0,0 +1,15 @@
+require 'rack-flags/reader'
+require 'rack-flags/cookie_codec'
+require 'rack-flags/config'
+require 'rack-flags/rack_middleware'
+require 'rack-flags/admin_app'
+
+module RackFlags
+  def self.for_env(env)
+    env[RackMiddleware::ENV_KEY] || Reader.blank_reader
+  end
+
+  def self.path_for_resource(subpath)
+    File.expand_path( File.join( "../../resources", subpath ), __FILE__ )
+  end
+end

data/resources/admin_app/index.html.erb

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>rack-flags admin</title>
+    <link href="<%=css_href%>" rel="stylesheet" type="text/css">
+  </head>
+  <body>
+    <h1>rack-flags admin</h1>
+    <form method="post">
+      <%flags.each do |flag|%>
+        <section data-flag-name="<%=flag.name%>">
+          <h3><%=flag.name%></h3>
+          <p><%=flag.description%></p>
+          <div>
+            <label class="default">
+              Default (<%=flag.default%>)
+              <input type="radio" name="<%=flag.name%>" value="default" <%=flag.checked_attribute_for(:default)%>/>
+            </label>
+
+            <label class="on">
+              On
+              <input type="radio" name="<%=flag.name%>" value="on" <%=flag.checked_attribute_for(:on)%>/>
+            </label>
+
+            <label class="off">
+              Off
+              <input type="radio" name="<%=flag.name%>" value="off" <%=flag.checked_attribute_for(:off)%>/>
+            </label>
+          </div>
+        </section>
+      <%end%>
+      <input type="submit" value="Update Flags"/>
+    </form>
+  </body>
+</html>

data/resources/admin_app/style.css

@@ -0,0 +1,35 @@
+body {
+  font-family: Futura, "Trebuchet MS", Arial, sans-serif;
+}
+
+section {
+  margin: 20px 20px 40px 20px;
+  padding-bottom: 10px;
+  background-color: lightgray;
+}
+section>* {
+  padding-left: 8px;
+}
+
+section h3 {
+  background-color: gray;
+  color: white;
+  font-size: 16pt;
+  padding-top: 5px;
+  padding-bottom: 5px;
+  margin: 0;
+}
+
+section p {
+  margin-top: 0;
+  font-style: italic;
+}
+
+input[type="submit"] {
+  font-family: Futura, "Trebuchet MS", Arial, sans-serif;
+  padding: 10px;
+  margin-left: 20px;
+  font-size: 20px;
+  background-color: #eee;
+  border: 1px solid;
+}

data/spec/acceptance/administering_feature_flags_spec.rb

@@ -0,0 +1,93 @@
+require_relative 'spec_helper'
+
+describe 'displaying flags in admin app' do
+  include Capybara::DSL
+
+  let( :feature_flag_config ) do
+    {
+      on_by_default: {
+        'default' => true,
+        'description' => 'this flag on by default'
+      },
+      off_by_default: {
+        'default' => false,
+        'description' => 'this flag off by default'
+      }
+    }
+  end
+
+  before :each do
+    ff_config_file_contains feature_flag_config
+    Capybara.app = app
+  end
+
+  let( :app ) do
+    yaml_path = ff_config_file_path
+    Rack::Builder.new do
+      use RackFlags::RackMiddleware, yaml_path: yaml_path
+      run RackFlags::AdminApp.new
+    end
+  end
+
+  let(:on_flag_section){ page.find('section[data-flag-name="on_by_default"]') }
+  let(:off_flag_section){ page.find('section[data-flag-name="off_by_default"]') }
+  let(:update_button){ page.find('input[type="submit"]') }
+
+  it 'successfully GETs the admin page' do
+    visit '/'
+    status_code.should == 200
+  end
+
+  it 'renders the feature flag name, default and description' do
+    visit '/'
+
+    on_flag_section.should_not be_nil
+    on_flag_section.find('h3').text.should == 'on_by_default'
+    on_flag_section.find('p').text.should == 'this flag on by default'
+    on_flag_section.find('label.default').text.should include('Default (On)')
+
+    off_flag_section.should_not be_nil
+    off_flag_section.find('h3').text.should == 'off_by_default'
+    off_flag_section.find('p').text.should == 'this flag off by default'
+    off_flag_section.find('label.default').text.should include('Default (Off)')
+  end
+
+  it 'selects the default option if there are no cookies present' do
+    visit '/'
+
+    verify_flag_section( on_flag_section, :default )
+    verify_flag_section( off_flag_section, :default )
+  end
+
+  it 'allows switching off a flag defaulted to on' do
+    visit '/'
+    
+    on_flag_section.choose( 'Off' )
+    update_button.click
+
+    verify_flag_section( on_flag_section, :off )
+    verify_flag_section( off_flag_section, :default )
+  end
+
+  def verify_flag_section( section, expected_state )
+    case expected_state.to_sym
+    when :default
+      section.find('label.default input').should be_checked
+
+      section.find('label.on input').should_not be_checked
+      section.find('label.off input').should_not be_checked
+    when :on
+      section.find('label.on input').should be_checked
+
+      section.find('label.default input').should_not be_checked
+      section.find('label.off input').should_not be_checked
+    when :off
+      section.find('label.off input').should be_checked
+
+      section.find('label.default input').should_not be_checked
+      section.find('label.on input').should_not be_checked
+    else 
+      raise "unrecognized state '#{expected_state}'"
+    end
+  end
+end

data/spec/acceptance/reading_feature_flags_spec.rb

@@ -0,0 +1,73 @@
+require_relative 'spec_helper'
+require_relative 'support/reader_app'
+
+describe 'reading feature flags in an app' do
+  include Rack::Test::Methods
+
+  let( :feature_flag_config ){ {} }
+  let( :feature_flag_cookie ){ "" }
+
+  before :each do
+    ff_config_file_contains feature_flag_config
+    set_feature_flags_cookie feature_flag_cookie
+  end
+
+  let( :app ) do
+    yaml_path = ff_config_file_path
+    Rack::Builder.new do
+      use RackFlags::RackMiddleware, yaml_path: yaml_path
+      run ReaderApp
+    end
+  end
+
+  context 'no base flags, no overrides' do
+    it 'should interpret both foo and bar as off by default' do
+      get '/'
+      last_response.body.should == 'foo is off; bar is off'
+    end
+  end
+
+  context 'foo defined as a base flag, defaulted to true' do
+    let( :feature_flag_config ) do
+      {
+        foo: { default: true }
+      }
+    end
+
+    it 'should interpret foo as on and bar as off' do
+      get '/'
+      last_response.body.should == 'foo is on; bar is off'
+    end
+  end
+
+  context 'foo defaults to false, bar defaults to true' do
+    let( :feature_flag_config ) do
+      {
+        foo: { default: false },
+        bar: { default: true }
+      }
+    end
+
+    it 'should interpret foo as off and bar as on' do
+      get '/'
+      last_response.body.should == 'foo is off; bar is on'
+    end
+  end
+
+  context 'foo and bar both default to true, bar is overridden to false' do
+    let( :feature_flag_config ) do
+      {
+        foo: { default: true },
+        bar:  { default: true }
+      }
+    end
+
+    let( :feature_flag_cookie){ "!bar" }
+
+    it 'should interpret foo as on and bar as off' do
+      get '/'
+      last_response.body.should == 'foo is on; bar is off'
+    end
+  end
+
+end

data/spec/acceptance/spec_helper.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+require 'rack/test'
+require 'capybara/rspec'
+
+module ConfigFileHelper
+
+  def ff_config_file_path
+    ff_yaml_file.path
+  end
+
+  def ff_config_file_contains(config)
+    ff_yaml_file.write( config.to_yaml )
+    ff_yaml_file.flush
+  end
+
+  def teardown_ff_config_file_if_exists
+    @_ff_yaml_file.unlink if @_ff_yaml_file
+  end
+
+  def ff_yaml_file
+    @_ff_yaml_file ||= Tempfile.new('rack-flags acceptance test example config file')
+  end
+end
+
+module CookieHelper
+  def set_feature_flags_cookie ff_cookie
+    raw_cookie = "#{RackFlags::CookieCodec::COOKIE_KEY}=#{Rack::Utils.escape(ff_cookie)}"
+    set_cookie(raw_cookie)
+  end
+end
+
+RSpec.configure do |config|
+  include ConfigFileHelper
+  include CookieHelper
+
+  config.after :each do
+    teardown_ff_config_file_if_exists
+  end
+end

data/spec/acceptance/support/reader_app.rb

@@ -0,0 +1,24 @@
+require 'sinatra'
+class ReaderApp < Sinatra::Base
+  enable :raise_errors
+  disable :show_exceptions 
+
+  get "/" do
+    flags = RackFlags.for_env(env)
+
+    output = []
+    if flags.on?( :foo )
+      output << "foo is on"
+    else
+      output << "foo is off"
+    end
+
+    if flags.on?( :bar )
+      output << "bar is on"
+    else
+      output << "bar is off"
+    end
+
+    output.join("; ")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rr'
+require 'pry'
+require 'rack'
+
+require_relative '../lib/rack-flags'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  # or if that doesn't work due to a version incompatibility
+  # config.mock_with RR::Adapters::Rspec
+end

data/spec/unit/admin_app_spec.rb

@@ -0,0 +1,143 @@
+require_relative 'spec_helper'
+
+module RackFlags
+
+  describe AdminApp do
+    describe '#call' do
+      let(:fake_env) { {} }
+      let(:admin_app) { AdminApp.new }
+
+      context 'when the request is a get' do
+        let(:fake_env) { {'REQUEST_METHOD' => 'GET'} }
+
+        it 'returns a successful HTML response' do
+          status, headers, body = admin_app.call(fake_env)
+
+          expect(status).to eq(200)
+          expect(headers).to include({'Content-Type' => 'text/html'})
+          expect(body).to_not be_empty
+        end
+
+      end
+
+      context 'when the request is a post' do
+        let(:fake_env) { {'REQUEST_METHOD' => 'POST', 'SCRIPT_NAME' => 'admin-app' } }
+
+        before do
+          any_instance_of(Rack::Request) do |rack_request|
+            stub(rack_request).POST { {} }
+          end
+        end
+
+        it 'returns a 303 redirect response' do
+          status, headers , body = admin_app.call(fake_env)
+
+          expect(status).to eq(303)
+          expect(headers).to include({'Location' => 'admin-app'})
+          expect(body).to be_empty
+        end
+
+        it 'sets the cookie using the post params' do
+          any_instance_of(Rack::Request) do |rack_request|
+            stub(rack_request).POST { {flag_1: 'on', flag_2: 'off', flag_3: 'default'} }
+          end
+
+          stub.proxy(CookieCodec).new do |cookie_codec|
+            mock(cookie_codec).generate_cookie_from({flag_1: true, flag_2: false, flag_3: nil}) { 'flag_1 !flag2' }
+          end
+
+          any_instance_of(Rack::Response) do |rack_response|
+            mock(rack_response).set_cookie(CookieCodec::COOKIE_KEY, 'flag_1 !flag2')
+          end
+
+          admin_app.call(fake_env)
+        end
+
+        it 'returns the finished response' do
+          stub.proxy(Rack::Response).new do |rack_response|
+            mock(rack_response).finish { 'finished rack response' }
+          end
+
+          response = admin_app.call(fake_env)
+
+          expect(response).to eq('finished rack response')
+        end
+
+      end
+
+      context 'when the request is something else' do
+        let(:fake_env) { {'REQUEST_METHOD' => 'OTHER'} }
+
+        it 'returns a 405 method not allowed response' do
+          status, headers , body = admin_app.call(fake_env)
+
+          expect(status).to eq(405)
+          expect(headers).to be_empty
+          expect(body).to eq('405 - METHOD NOT ALLOWED')
+        end
+      end
+
+    end
+
+  end
+
+  describe FullFlagPresenter do
+    describe '#default' do
+      let(:full_flag) { FullFlag.new(base_flag, nil) }
+
+      subject(:full_flag_presenter) { FullFlagPresenter.new(full_flag) }
+
+      context 'when the default is true' do
+        let(:base_flag) { BaseFlag.new('name', 'description', true) }
+
+        its(:default) { should == 'On' }
+      end
+
+      context 'when the default is false' do
+        let(:base_flag) { BaseFlag.new('name', 'description', false) }
+
+        its(:default) { should == 'Off' }
+      end
+    end
+
+    describe '#checked_attributes_for' do
+      let(:full_flag) { FullFlag.new(mock(BaseFlag), override) }
+
+      subject(:full_flag_presenter) { FullFlagPresenter.new(full_flag) }
+
+      context 'when the default value is not overridden' do
+        let(:final_value) { nil }
+        let(:override) { nil }
+
+        specify 'only its default checked state is "checked"' do
+          expect(subject.checked_attribute_for(:default)).to eq('checked')
+          expect(subject.checked_attribute_for(:on)).to eq('')
+          expect(subject.checked_attribute_for(:off)).to eq('')
+        end
+      end
+
+      context 'when the default value is overridden to true' do
+        let(:final_value) { nil }
+        let(:override) { true }
+
+        specify 'only its on checked state is "checked"' do
+          expect(subject.checked_attribute_for(:default)).to eq('')
+          expect(subject.checked_attribute_for(:on)).to eq('checked')
+          expect(subject.checked_attribute_for(:off)).to eq('')
+        end
+      end
+
+      context 'when the default value is overridden to false' do
+        let(:final_value) { nil }
+        let(:override) { false }
+
+        specify 'only its off checked state is "checked"' do
+          expect(subject.checked_attribute_for(:default)).to eq('')
+          expect(subject.checked_attribute_for(:on)).to eq('')
+          expect(subject.checked_attribute_for(:off)).to eq('checked')
+        end
+      end
+    end
+  end
+
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,65 @@
+require_relative 'spec_helper'
+
+module RackFlags
+ 
+  describe Config do
+    let( :config_file ) { Tempfile.new('rack-flags-config-unit-test') }
+    let( :yaml ) { raise NotImplementedError }
+
+
+    before :each do
+      config_file.write( yaml )
+      config_file.flush
+    end
+
+    let(:config){ Config.load( config_file.path ) }
+
+    after :each do
+      config_file.unlink
+    end
+
+    context 'regular yaml' do
+      let(:yaml) do
+        <<-EOS
+        foo: 
+          description: the description
+          default: true
+        bar:
+          description: another description
+          default: false
+        EOS
+      end
+
+      it 'loads a set of BaseFlags' do
+        config.should have(2).flags
+        config.flags.map(&:name) .should =~ [:foo,:bar]
+        config.flags.map(&:description).should =~ ["the description","another description"]
+        config.flags.map(&:default).should =~ [true,false]
+      end
+    end
+
+    context 'empty file' do
+      let(:yaml){ "" }
+      it 'loads as an empty config' do
+        config.should have(0).flags
+      end
+    end
+
+    context 'symbolized yaml' do
+      let :yaml do
+        <<-EOS
+          :foo: 
+            :default: true
+            :description: a description
+        EOS
+      end
+
+      subject(:flag){ config.flags.first } 
+
+      it { should_not be_nil }
+      its(:default) { should be_true }
+      its(:description) { should == "a description" }
+    end
+  end
+
+end

data/spec/unit/cookie_codec_spec.rb

@@ -0,0 +1,63 @@
+require_relative 'spec_helper'
+
+module RackFlags
+ 
+  describe CookieCodec do
+    let(:cookie_codec){ CookieCodec.new }
+
+    describe '#overrides_from_env' do
+      subject(:overrides){ cookie_codec.overrides_from_env(env) }
+      let(:env){ {'HTTP_COOKIE'=>cookie_header } }
+      let(:cookie_header){ "#{CookieCodec::COOKIE_KEY}=#{Rack::Utils.escape(ff_cookie)};foo=bar" }
+
+      context 'no cookie' do
+        let(:env){ {} }
+        it{ should == {} }
+      end
+
+      context 'empty cookie' do
+        let(:ff_cookie){ '' }
+        it{ should == {} }
+      end
+
+      context 'simple cookie' do
+        let(:ff_cookie){ 'foo bar' }
+        it{ should == {foo: true, bar: true} }
+      end
+
+      context 'cookie with positives and negatives' do
+        let(:ff_cookie){ 'yes !no yes-sir !na-huh' }
+        it{ should == {
+          :yes => true, 
+          :'yes-sir' => true,
+          :no => false,
+          :'na-huh' => false
+        } }
+      end
+    end
+
+    describe '#generate_cookie_from' do
+      it 'returns a simple cookie' do
+        admin_app_overrides = {flag_1: true}
+        cookie = cookie_codec.generate_cookie_from(admin_app_overrides)
+
+        expect(cookie).to eq('flag_1')
+      end
+
+      it 'returns a cookie with positive and negative values' do
+        admin_app_overrides = {flag_1: true, flag_2: false}
+        cookie = cookie_codec.generate_cookie_from(admin_app_overrides)
+
+        expect(cookie).to eq('flag_1 !flag_2')
+      end
+
+      it 'returns a cookie with default values' do
+        admin_app_overrides = {flag_1: true, flag_2: false, flag_3: nil}
+        cookie = cookie_codec.generate_cookie_from(admin_app_overrides)
+
+        expect(cookie).to eq('flag_1 !flag_2')
+      end
+    end
+
+  end
+end

data/spec/unit/middleware_spec.rb

@@ -0,0 +1,87 @@
+require_relative 'spec_helper'
+
+module RackFlags
+
+  describe RackMiddleware do
+
+    def mock_out_config_loading
+      stub(Config).load(anything){ OpenStruct.new( flags: {} ) }
+    end
+
+    it 'raise an exception if no yaml path is provided' do
+      lambda{
+        RackMiddleware.new( :fake_app, {} )
+      }.should raise_error( ArgumentError, 'yaml_path must be provided' )
+    end
+
+    it 'loads the config from the specified yaml file' do
+      mock(Config).load('some/config/path')
+      RackMiddleware.new( :fake_app, yaml_path: 'some/config/path' )
+    end
+
+    describe '#call' do
+
+      def create_middleware( fake_app = false)
+        fake_app ||= Proc.new {}
+
+        RackMiddleware.new( fake_app, yaml_path: 'blah' )
+      end
+
+      it 'creates a Reader using the config flags when called' do
+        stub(Config).load(anything){ OpenStruct.new( flags: 'fake flags from config' ) }
+        mock(Reader).new( 'fake flags from config', anything )
+
+        middleware = create_middleware()
+        middleware.call( {} )
+      end
+
+      it 'adds the reader to the env' do
+        mock_out_config_loading
+
+        mock(Reader).new(anything,anything){ 'fake derived flags' }
+
+        middleware = create_middleware()
+        fake_env = {}
+        middleware.call( fake_env )
+        fake_env[RackMiddleware::ENV_KEY].should == 'fake derived flags'
+      end
+
+      it 'reads overrides from cookies' do
+        mock_out_config_loading
+
+        fake_env = { fake: 'env' }
+
+
+        fake_cookie_codec = mock( Object.new )
+        mock(CookieCodec).new{ fake_cookie_codec }
+
+        fake_cookie_codec.overrides_from_env( fake_env )
+
+        create_middleware().call( fake_env )
+      end
+
+      it 'passes the overrides into the reader' do
+        mock_out_config_loading
+
+        mock(CookieCodec).new{ stub!.overrides_from_env{'fake overrides'} }
+        mock(Reader).new( anything, 'fake overrides' )
+
+        create_middleware().call( {} )
+      end
+
+      it 'passes through to downstream app' do
+        mock_out_config_loading
+
+        fake_app ||= Proc.new do
+          "downstream app response"
+        end
+
+        middleware = create_middleware( fake_app )
+        middleware_response = middleware.call( {} )
+
+        middleware_response.should == "downstream app response"
+      end
+    end
+  end
+
+end

data/spec/unit/rack_flags_module_methods_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+
+module RackFlags
+  describe '.for_env' do
+    it 'should return the flags which the middleware stuffed in the env' do
+      fake_env = {RackMiddleware::ENV_KEY => 'fake flags from env'}
+      RackFlags.for_env(fake_env).should == 'fake flags from env'
+    end
+
+    it 'returns a generic empty reader if none is in the env' do
+      fake_env = {}
+      reader = RackFlags.for_env(fake_env)
+      reader.should_not be_nil
+      reader.should respond_to(:on?)
+    end
+  end
+end
+

data/spec/unit/reader_spec.rb

@@ -0,0 +1,100 @@
+require_relative 'spec_helper'
+
+module RackFlags
+
+  describe Reader do
+    def derived_flags_final_values(derived_flags)
+      derived_flags.map { |flag| flag.final_value }
+    end
+
+    def full_flags_overrides(derived_flags)
+      derived_flags.map { |flag| flag.override }
+    end
+
+    let( :base_flags ) do
+      [
+        BaseFlag.new( :usually_on, 'a flag', true ),
+        BaseFlag.new( :usually_off, 'another flag', false )
+      ]
+    end
+    let( :overrides ){ {} }
+
+    subject( :reader ){ Reader.new( base_flags, overrides ) }
+
+    shared_examples 'full flags that mimic the base flags' do
+      it 'has a name, description, and default for each base flag' do
+        full_flags = subject.full_flags
+
+        expect(full_flags.length).to eq(base_flags.length)
+
+        expect(full_flags[0].name).to eq(:usually_on)
+        expect(full_flags[0].description).to eq('a flag')
+        expect(full_flags[0].default).to be_true
+
+        expect(full_flags[1].name).to eq(:usually_off)
+        expect(full_flags[1].description).to eq('another flag')
+        expect(full_flags[1].default).to be_false
+      end
+
+    end
+
+    context 'no overrides' do
+      let( :overrides ){ {} }
+
+      its(:base_flags){ should == {usually_on: true, usually_off: false} }
+
+      specify 'on? is true for a flag which is on by default' do
+        subject.on?( :usually_on ).should be_true
+      end
+
+      specify 'on? is false for a flag which is off by default' do
+        subject.on?( :usually_off ).should be_false
+      end
+
+      specify 'on? is false for unknown flags' do
+        subject.on?( :unknown_flag ).should be_false
+      end
+
+      it_behaves_like 'full flags that mimic the base flags'
+
+      it 'has derived flags with nil override values' do
+        overrides = full_flags_overrides(subject.full_flags)
+
+        expect(overrides).to eq([nil, nil])
+      end
+    end
+
+    context 'overridden to false' do
+      let( :overrides ){ {usually_on: false} }
+
+      specify 'on? is false' do
+        subject.on?( :usually_on ).should be_false
+      end
+
+      it_behaves_like 'full flags that mimic the base flags'
+
+      it 'has full flags with one override value' do
+        overrides = full_flags_overrides(subject.full_flags)
+
+        expect(overrides).to eq([false, nil])
+      end
+    end
+
+    context 'overridding a flag which has no base' do
+      let( :overrides ){ {no_base: true} }
+
+      specify 'on? is false' do
+        subject.on?( :no_base ).should be_false
+      end
+
+      it_behaves_like 'full flags that mimic the base flags'
+
+      it 'has full flags with no override values' do
+        overrides = full_flags_overrides(subject.full_flags)
+
+        expect(overrides).to eq([nil, nil])
+      end
+    end
+  end
+
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: rack-flags
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Pete Hodgson
+- Ryan Oglesby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  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-core
+  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-expectations
+  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: rr
+  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: capybara
+  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'
+description: This is a simple lightweight way to expose work-in-progress functionality
+  to developers, testers or other internal users.
+email:
+- git@thepete.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack-flags.rb
+- lib/rack-flags/admin_app.rb
+- lib/rack-flags/config.rb
+- lib/rack-flags/cookie_codec.rb
+- lib/rack-flags/rack_middleware.rb
+- lib/rack-flags/reader.rb
+- lib/rack-flags/version.rb
+- resources/admin_app/index.html.erb
+- resources/admin_app/style.css
+- spec/acceptance/administering_feature_flags_spec.rb
+- spec/acceptance/reading_feature_flags_spec.rb
+- spec/acceptance/spec_helper.rb
+- spec/acceptance/support/reader_app.rb
+- spec/spec_helper.rb
+- spec/unit/admin_app_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/cookie_codec_spec.rb
+- spec/unit/middleware_spec.rb
+- spec/unit/rack_flags_module_methods_spec.rb
+- spec/unit/reader_spec.rb
+- spec/unit/spec_helper.rb
+homepage: https://github.com/moredip/rack-flags
+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'
+      segments:
+      - 0
+      hash: -2280499656748688466
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2280499656748688466
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple cookie-based feature flags using Rack.
+test_files:
+- spec/acceptance/administering_feature_flags_spec.rb
+- spec/acceptance/reading_feature_flags_spec.rb
+- spec/acceptance/spec_helper.rb
+- spec/acceptance/support/reader_app.rb
+- spec/spec_helper.rb
+- spec/unit/admin_app_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/cookie_codec_spec.rb
+- spec/unit/middleware_spec.rb
+- spec/unit/rack_flags_module_methods_spec.rb
+- spec/unit/reader_spec.rb
+- spec/unit/spec_helper.rb