fickle 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+test_project
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/README.md

@@ -0,0 +1,132 @@
+fickle
+======
+*Don't make up your mind.*
+
+Fickle is a feature engine for Rails 3. It is currently under heavy development and
+is not stable in any sense of the word. Especially not the emotional sense.
+
+Unlike other solutions, fickle lets you manage your features without __opening a file__,
+__committing to a repository__, __performing a deploy__, or __breaking out ssh__. Just
+point a browser at your application and bend it to your will!
+
+Not only that, but fickle allows you to override your global features by mixing feature-set
+functionality into __any model in your application__. If you want to restrict some experimental
+features to a group of beta testers, it's easy to implement. If you want to enable every
+feature when you're logged in as, say, "guinea_pig," you got it. 
+
+Quickstart
+----------
+
+1.  Add fickle to your Gemfile
+  
+        gem 'fickle'
+    
+2.  Run the generator
+
+      > ./script/rails generate fickle:install
+    
+3.  Add feature switches
+    
+        <%- if feature_enabled? :my_totally_sweet_feature %>
+          <!--
+            My totally sweet code
+          -->
+        <%- else %>
+          <!--
+            My slightly less sweet code
+          -->
+        <%- end %>
+
+
+4.  Administer!
+
+    ![Fickle Administrative Panel](http://i.imgur.com/2yL86.png "http://localhost:3000/features")
+    
+Web Interface
+-------------
+
+Fickle includes a web interface for managing your features. You can globally turn features on and off,
+and you can manage them on a model-by-model basis. You can even hardstop a feature if it starts causing
+you trouble.
+
+The `fickle:install` generator adds this line to your `config/routes.rb` file:
+
+    fickle_admin 'features'
+    
+You can change this line for more advanced control, or you can remove it altogether if you don't want
+to use the web interface.
+
+The following options are currently supported:
+
+    path         - the first argument, where the fickle admin panel should live.
+    :restrict_on - symbol which refers to a method in ApplicationController for
+                   access restriction (ex. :current_user). If provided, fickle
+                   will return a 404 unless the result of this method call returns
+                   true for "can_administer_fickle?"
+    :controller  - The controller to use. If you would like to override fickle's
+                   behavior, you can subclass "Fickle::FeaturesController" with
+                   your own controller and provide the name here.
+
+
+Advanced Features
+-----------------
+
+Let's say you want to limit features on a per-user basis.
+
+### app/models/user.rb
+
+    class User < ActiveRecord::Base
+      
+      has_feature_set
+      
+    end
+    
+### app/controllers/experimental_controller.rb
+
+    class ExperimentalController
+    
+      before_filter :authenticate
+      
+      def secret_feature
+        status 404 and return unless current_user.has_feature? :my_secret_new_feature
+        # Do secret stuff
+      end
+    
+    end
+
+You can also access this method in the views. Cause, you know, it's on the model.
+
+Tips/tricks
+-----------
+
+
+Want a user who gets all the goodies? It's ruby!
+
+### app/models/user.rb
+
+    def has_feature?(feature)
+      admin? || super
+    end
+
+Oh, snap that was easy.
+
+
+    Copyright (c) 2011 chrisrhoden && lazerclub industries
+
+    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/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/app/controllers/fickle/application_controller.rb

@@ -0,0 +1,22 @@
+module Fickle
+  class ApplicationController < ActionController::Base
+    layout 'fickle'
+    before_filter :get_models, :get_features, :get_backend, :get_overrides
+    
+    def get_models
+      @models = Fickle::Config.backend.models
+    end
+    
+    def get_features
+      @features = Fickle::Config.backend.feature_set('global')
+    end
+    
+    def get_backend
+      @backend = Fickle::Config.backend
+    end
+    
+    def get_overrides
+      @overrides = Fickle::Config.backend.feature_set('master')
+    end
+  end
+end

data/app/controllers/fickle/features_controller.rb

@@ -0,0 +1,37 @@
+module Fickle
+  class FeaturesController < ApplicationController
+    
+            
+    def index
+      
+    end
+    
+    def update
+      if params[:enabled] == 'true'
+        @backend.global_enable(params[:id])
+      elsif params[:enabled] == 'false'
+        @backend.global_disable(params[:id])
+      elsif params[:hard_stop] == 'true'
+        @backend.override_disable(params[:id])
+      elsif params[:hard_stop] == 'false'
+        @backend.remove_override(params[:id])
+      end
+      
+      respond_to do |format|
+        format.js { render :js => 'true'}
+      end
+    end
+    
+    def create
+      
+    end
+    
+    def edit
+      
+    end
+    
+    def show
+      
+    end
+  end
+end

data/app/controllers/fickle/model_features_controller.rb

@@ -0,0 +1,34 @@
+module Fickle
+  class ModelFeaturesController < ApplicationController    
+    before_filter :find_model
+    
+    def index
+      @features = @backend.model_feature_sets[@model]
+    end
+    
+    def show; end
+    
+    def update
+      @feature_set = @backend.feature_set(params[:id], @model)
+      
+      if params[:enabled] == 'true'
+        @feature_set.enable_feature(params[:feature])
+      elsif params[:enabled] == 'false'
+        @feature_set.enable_feature(params[:feature])
+      end
+      
+      respond_to do |format|
+        format.js { render :js => 'true'}
+      end
+    end
+    
+    
+    private
+    def find_model
+      @model = (Fickle::Config.backend.models & [params[:model]]).first
+      unless @model
+        render :text => 'Not Found', :status => 404
+      end
+    end
+  end
+end

data/app/views/fickle/features/index.html.erb

@@ -0,0 +1,9 @@
+<ul id="features">
+<%- @features.each do |name, enabled| %>
+  <li>
+    <span class="feature_name"><%= name.to_s.humanize %></span>
+    <input type='checkbox' class='hardstop' name='<%= name %>'<%= ' checked' if @overrides.enabled?(name) == false %>/>
+    <input type='checkbox' class='feature' name='<%= name %>'<%= ' checked' if enabled %>/>
+  </li>
+<%- end %>
+</ul>

data/app/views/fickle/model_features/index.html.erb

@@ -0,0 +1,5 @@
+<ul id="features">
+<%- @features.each do |feature| %>
+  <li><span class="feature_name"><%= feature[0].to_s.humanize %></span><input type='checkbox' name='features[<%= feature[0] %>]'<%= ' checked' if feature[1] %>/></li>
+<%- end %>
+</ul>

data/app/views/layouts/fickle.html.erb

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Fickle!</title>
+    <%= stylesheet_link_tag 'fickle/fickle' %>
+  </head>
+  <body>
+    <h1>Fickle</h1>
+    <ul id="tabs">
+      <li><%= link_to 'Features', fickle_features_path %>
+    <%# @models.each do |model| 
+      <li><%= link_to model.to_s.pluralize, fickle_model_features_path(model) </li>
+     end %>
+    </ul>
+    <div id="main">
+      <%= yield %>
+    </div>
+    <%= javascript_include_tag 'http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js' %>
+    <%= javascript_include_tag 'fickle' %>
+  </body>
+</html>

data/fickle.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fickle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fickle"
+  s.version     = Fickle::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["chrisrhoden"]
+  s.email       = ["chris@lazerclub.co"]
+  s.homepage    = ""
+  s.summary     = %q{The feature library for rails that can't make up its mind}
+  s.description = %q{Fickle lets you turn features on and off at will in your rails app using a web interface.
+                     It also lets you manage features on a model-by-model basis (maybe users?)}.gsub('                     ','')
+
+  s.rubyforge_project = "fickle"
+  
+  s.add_development_dependency 'rspec', '~> 2.4.0'
+  s.add_development_dependency 'rails', '~> 3.0.0'
+
+  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/lib/fickle.rb

@@ -0,0 +1,39 @@
+module Fickle
+  
+  MODELS = []
+  
+  def self.setup!
+    Class.send :include, Fickle::ClassMethods unless Class.respond_to? :has_featureset
+    begin
+      ApplicationHelper
+    rescue Exception; nil
+    else
+      ApplicationHelper.send :include, Fickle::ViewHelpers
+    end
+    begin
+      ActionDispatch::Routing::Mapper
+    rescue Exception; nil
+    else
+      ActionDispatch::Routing::Mapper.send :include, Fickle::Routes
+    end
+  end
+  
+  def self.config
+    yield Fickle::Config if block_given?
+  end
+  
+  autoload :FeatureSet, 'fickle/feature_set'
+  autoload :ClassMethods, 'fickle/class_methods'
+  autoload :Railtie, 'fickle/railtie'
+  autoload :VERSION, 'fickle/version'
+  autoload :ViewHelpers, 'fickle/view_helpers'
+  autoload :ModelExtensions, 'fickle/model_extensions'
+  autoload :Routes, 'fickle/routes'
+  autoload :Config, 'fickle/config'
+  autoload :Backends, 'fickle/backends'
+  autoload :AbstractFeatureSet, 'fickle/abstract_feature_set'
+  autoload :AbstractBackend, 'fickle/abstract_backend'
+  
+  require 'fickle/railtie' if defined? Rails
+  
+end

data/lib/fickle/abstract_backend.rb

@@ -0,0 +1,59 @@
+module Fickle
+  class AbstractBackend
+    
+    def initialize(options)
+      @_klass = options[:feature_set_class]
+      add_feature_set('global', new_feature_set('global', :set_default => true))
+      add_feature_set('master', new_feature_set('master'))
+    end
+    
+    def new_feature_set(feature_set_key, options={})
+      options.merge!(:key => feature_set_key)
+      if !['master', 'global'].include?(feature_set_key)
+        options[:override] = feature_set('master')
+        options[:fallthrough] = feature_set('global')
+      end
+      @_klass.new(options)
+    end
+    
+    def global_enable(feature)
+      feature_set('global').enable_feature(feature)
+    end
+    
+    def global_disable(feature)
+      feature_set('global').disable_feature(feature)
+    end
+    
+    def remove_global(feature)
+      feature_set('global').remove_feature(feature)
+    end
+    
+    def override_enable(feature)
+      feature_set('master').enable_feature(feature)
+    end
+    
+    def override_disable(feature)
+      feature_set('master').disable_feature(feature)
+    end
+    
+    def remove_override(feature)
+      feature_set('master').remove_feature(feature)
+    end
+    
+    def feature_set(key, model=nil)
+      if model
+        feature_set = get_feature_set("#{model}-#{key}")
+        add_model_feature_set("#{model}-#{key}", model)
+      else
+        feature_set = get_feature_set(key)
+      end
+      return feature_set
+    end
+    
+    def inspect
+      "#<Fickle::Backend overrides:#{feature_set('master').inspect} fallthroughs:#{feature_set('global').inspect}>"
+    end
+    
+    alias_method :to_s, :inspect
+  end
+end

data/lib/fickle/abstract_feature_set.rb

@@ -0,0 +1,52 @@
+module Fickle
+  class AbstractFeatureSet
+    
+    include Enumerable
+    
+    def initialize(options = {}) 
+      @_override = options[:override]
+      @_fallthrough = options[:fallthrough]
+      @_set_default = options[:set_default]
+      @_name = options[:key]
+    end
+    
+    def enabled?(feature)
+      return overridden(feature) if overridden?(feature)
+      return feature_enabled?(feature) if feature_defined?(feature)
+      return fallthrough(feature)
+    end
+    
+    def inspect
+      "#<Fickle::FeatureSet #@_name#{map{|key, value| " #{key}:#{value}"}.join}>"
+    end
+    
+    alias_method :to_s, :inspect
+    
+    private
+    
+    def overridden?(feature)
+      return false unless @_override
+      if !@_override.feature_enabled?(feature).nil?
+        return true
+      end
+      return false
+    end
+    
+    def overridden(feature)
+      @_override.feature_enabled?(feature)
+    end
+    
+    def feature_defined?(feature)
+      !feature_enabled?(feature).nil?
+    end
+    
+    def fallthrough(feature)  
+      return @_fallthrough.enabled?(feature) if @_fallthrough
+      if @_set_default
+        Fickle::Config.default_state ? enable_feature(feature) : disable_feature(feature)
+        return feature_enabled?(feature)
+      end
+    end
+    
+  end
+end

data/lib/fickle/backends.rb

@@ -0,0 +1,5 @@
+module Fickle
+  module Backends
+    autoload :Memory, 'fickle/backends/memory'
+  end
+end

data/lib/fickle/backends/memory.rb

@@ -0,0 +1,42 @@
+module Fickle
+  module Backends
+    class Memory < Fickle::AbstractBackend
+      
+      autoload :FeatureSet, 'fickle/backends/memory/feature_set'
+      
+      def initialize(options={})
+        @models = []
+        @model_feature_sets = {}
+        @sets = {}
+        super(options.merge(:feature_set_class => Fickle::Backends::Memory::FeatureSet))
+      end
+      
+      def get_feature_set(feature_set_key)
+        @sets[feature_set_key] ||= new_feature_set(feature_set_key)
+      end
+      
+      def add_model_feature_set(feature_set_key, model)
+        @model_feature_sets[model] ||= []
+        @model_feature_sets[model] = (@model_feature_sets[model] | [feature_set_key])
+      end
+      
+      def add_model(model)
+        @models = (@models | [model])
+      end
+      
+      def remove_model(model)
+        @models = (@models - [model])
+      end
+      
+      attr_reader :models, :model_feature_sets
+      
+      def add_feature_set(feature_set_key, feature_set)
+        @sets[feature_set_key] = feature_set
+      end
+      
+      def feature_sets
+        @sets
+      end
+    end
+  end
+end

data/lib/fickle/backends/memory/feature_set.rb

@@ -0,0 +1,39 @@
+module Fickle
+  module Backends
+    class Memory
+      class FeatureSet < Fickle::AbstractFeatureSet
+        
+        def initialize(options={})
+          super
+          @features = {}
+        end
+        
+        def feature_enabled?(feature)
+          features[feature.to_s]
+        end
+        
+        def enable_feature(feature)
+          features[feature.to_s] = true
+        end
+        
+        def disable_feature(feature)
+          features[feature.to_s] = false
+        end
+        
+        def remove_feature(feature)
+          features.delete(feature.to_s)
+        end
+        
+        def each
+          features.each do |feature, enabled|
+            yield feature, enabled
+          end
+        end
+        
+        private
+        attr_reader :features
+        
+      end
+    end
+  end
+end

data/lib/fickle/class_methods.rb

@@ -0,0 +1,14 @@
+module Fickle
+  module ClassMethods
+    
+    def has_feature_set
+      Fickle::Config.backend.add_model(name)
+      include Fickle::ModelExtensions
+    end
+    
+    alias_method :is_subjugated, :has_feature_set
+    
+  end
+end
+    
+    

data/lib/fickle/config.rb

@@ -0,0 +1,29 @@
+module Fickle
+  module Config
+    
+    # Please ignore the mess. Memoizing on a ModuleAccessor without ActiveSupport
+    def self.default_state
+      @default_state ||= false
+      def self.default_state
+        @default_state
+      end
+      @default_state
+    end
+    
+    def self.backend=(backend)
+      @backend = backend
+    end
+    
+    def self.backend
+      @backend ||= Fickle::Backends::Memory.new
+      def self.backend
+        @backend
+      end
+      @backend
+    end
+    
+    def self.default_state=(default_state)
+      @default_state = default_state
+    end
+  end
+end

data/lib/fickle/controllers.rb

@@ -0,0 +1,5 @@
+module Fickle
+  module Controllers
+    autoload :FeaturesController, 'fickle/controllers/features_controller'
+  end
+end

data/lib/fickle/model_extensions.rb

@@ -0,0 +1,28 @@
+module Fickle 
+  module ModelExtensions
+    def has_feature?(feature)
+      feature_set.enabled?(feature)
+    end
+    
+    def add_feature(feature)
+      feature_set.enable_feature(feature)
+    end
+    
+    def remove_feature(feature)
+      feature_set.disable_feature(feature)
+    end
+    
+    def feature_set
+      @feature_set = Fickle::Config.backend.feature_set(fickle_id, self.class.name)
+    end
+    
+    def fickle_id
+      return @fickle_id if @fickle_id
+      @fickle_id = case self
+      when (defined? ActiveRecord and ActiveRecord::Base) then id
+      when (defined? Mongoid and Mongoid::Document) then id
+      else hash
+      end
+    end
+  end
+end

data/lib/fickle/railtie.rb

@@ -0,0 +1,8 @@
+module Fickle
+  class Railtie < Rails::Engine
+    
+    config.to_prepare do
+      Fickle.setup!
+    end
+  end
+end

data/lib/fickle/routes.rb

@@ -0,0 +1,12 @@
+module Fickle
+  module Routes
+    def fickle_admin(path, options = {})
+      options = {:controller => 'Fickle::Features', :model_controller => 'Fickle::ModelFeatures'}.merge(options)      
+      
+      namespace 'fickle', :module => nil, :path => path do
+        resources :model_features, :path => 'models/:model', :controller => options.delete(:model_controller)
+        resources :features, options.merge(:path => '')
+      end
+    end
+  end
+end

data/lib/fickle/version.rb

@@ -0,0 +1,3 @@
+module Fickle
+  VERSION = "0.0.1"
+end

data/lib/fickle/view_helpers.rb

@@ -0,0 +1,7 @@
+module Fickle
+  module ViewHelpers
+    def feature_enabled?(feature)
+      Fickle::Config.backend.feature_set('views').enabled?(feature)
+    end
+  end
+end

data/lib/generators/fickle/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate fickle:install
+
+    This will create:
+        what/will/it/create

data/lib/generators/fickle/install/install_generator.rb

@@ -0,0 +1,22 @@
+module Fickle
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    
+    class_option :route, :type => :boolean, :default => true, :desc => "Add route for the Fickle web interface"
+    class_option :default_enabled, :type => :boolean, :default => false, :desc => "Default all features to be enabled"
+    
+    def generate_route
+      route("fickle_admin 'features'") if options.route
+    end
+    
+    def generate_config_file
+      template "fickle.rb.erb", "config/initializers/fickle.rb"
+    end
+    
+    def generate_public_files
+      copy_file 'fickle.css', 'public/stylesheets/fickle/fickle.css'
+      copy_file 'fickle.js', 'public/javascripts/fickle.js'
+    end
+      
+  end
+end

data/lib/generators/fickle/install/templates/fickle.css

@@ -0,0 +1,112 @@
+body, html {
+    font-family: "Helvetica Neue", "Arial", "Sans-Serif";
+    font-weight: 100;
+    letter-spacing: 0.1em;
+}
+
+h1 {
+    width: 500px;
+    margin: 0 auto;
+    position: relative;
+    top: 1.0em;
+    font-weight: 100;
+    letter-spacing:0.2em;
+    position: relative;
+    z-index: 0;
+}
+
+#main {
+    width: 535px;
+    margin: 0 auto;
+    background: #347af4;
+    padding: 1px 0;
+    border-radius: 15px;
+}
+
+#features {
+    width: 500px;
+    background: #333;
+    color: #fff;
+    list-style-type: none;
+    padding:35px 10px;
+    font-size: 2.0em;
+    border-radius: 10px;
+    margin: 7px auto;
+    text-shadow: 0 -1px 0 #000;
+}
+
+#tabs {
+    width: 515px;
+    margin: 0 auto;
+    list-style-type: none;
+    padding: 0;
+    text-align:right;
+    font-weight: 100;
+    position: relative;
+    z-index: 5;
+}
+
+#tabs li {
+    display: inline-block;
+    padding: 5px 10px;
+    margin: 0 5px;
+    border-top-left-radius: 10px;
+    border-top-right-radius: 10px;
+    background: #347af4;
+    color: #fff;
+    text-shadow: 0 -1px 0 #333;
+}
+
+#tabs li a {
+    font-weight: 400;
+    color: #FFF;
+    text-decoration: none;
+}
+
+.toggle {
+    width: 150px;
+    color: #FFF;
+    text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.7);
+    position: relative;
+    height: 36px;
+    margin: 0 30px 0 0;
+    border-radius: 5px;
+    float: right;
+    font-weight: 400;
+}
+
+.toggle .on, .toggle .off {
+    display:inline-block;
+    width: 75px;
+    margin: 0;
+    text-align: center;
+    height: 36px;
+    -webkit-box-shadow: 0 1px 0 rgba(255,255,255,0.4), inset 0 2px 3px rgba(0,0,0,0.6);
+    
+}
+.toggle .on {
+    border-top-right-radius: 5px;
+    border-bottom-right-radius: 5px;
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0, #347af4), color-stop(0.5, #3680f8), color-stop(0.501, #5091f3), color-stop(1, #75acfc));
+}
+
+.toggle .off {
+    border-top-left-radius: 5px;
+    border-bottom-left-radius: 5px;
+    color: #333;
+    text-shadow: 0 1px 0 #fff;
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0, #999), color-stop(0.5, #AAA), color-stop(0.501, #bbb), color-stop(1, #ddd));
+}
+
+.toggle .slider {
+    cursor:pointer;
+    width: 78px;
+    height: 33px;
+    top:1px;
+    left:1px;
+    border-top: 1px solid #bbb;
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0, #666), color-stop(0.5, #777), color-stop(1, #555));
+    -webkit-box-shadow: 0 0 1px 1px #222;
+    position: absolute;
+    border-radius: 5px;
+}

data/lib/generators/fickle/install/templates/fickle.rb.erb

@@ -0,0 +1,4 @@
+Fickle.config do |config|
+  config.default_state = <%= options.default_enabled? %>
+  config.backend = Fickle::Backends::Memory.new
+end

data/spec/class_methods_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Fickle::ClassMethods do
+  
+  describe '#has_featureset' do
+    
+    before :all do
+      Fickle.setup!
+      class MagicClass 
+        has_featureset
+      end
+    end
+    
+    it 'should add the class to the models pile' do    
+      Fickle::MODELS.should include MagicClass
+    end
+    
+    it 'should mix in the feature-specific methods' do
+      MagicClass.new.should respond_to :has_feature?
+    end
+  end
+end

data/spec/feature_set_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Fickle::FeatureSet do
+  it 'should allow the enabling of features' do
+    subject.enable_feature(:kill)
+    subject.enabled?(:kill).should be true
+  end
+  
+  it 'should allow the disabling of features' do
+    subject.disable_feature(:kill)
+    subject.enabled?(:kill).should be false
+  end
+  
+  it 'should default to false' do
+    subject.enabled?(:jabberwocky).should be false
+  end
+  
+  context 'persistence' do
+    before :each do
+      @feature_set_one = Fickle::FeatureSet.for('kings')
+      @feature_set_two = Fickle::FeatureSet.for('kings')
+    end
+    
+    it 'should work' do
+      @feature_set_one.enable_feature(:drawing)
+      @feature_set_two.enabled?(:drawing).should be true
+    end
+  end
+    
+end

data/spec/fickle_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Fickle do
+  it { should respond_to :setup! }
+  
+  context 'in a rails app' do
+    before :all do
+      ApplicationHelper = Class.new
+      Fickle.setup!
+    end
+    
+    it 'should include the view helpers in ApplicationHelper' do
+      ApplicationHelper.new.should respond_to :feature_enabled?
+    end
+    
+    it 'should extend class to include the has_featureset method' do
+      class TestClass; end
+      TestClass.should respond_to :has_featureset
+    end
+  end
+end

data/spec/model_extensions_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+Fickle.setup!
+
+class Genius
+  has_featureset
+end
+
+describe Genius do
+  it { should respond_to :has_feature? }
+  
+  it 'should allow features to be enabled' do
+    subject.add_feature :thrill
+    subject.has_feature?(:thrill).should be true
+  end
+  
+  it 'should allow features to be disabled' do
+    subject.remove_feature :chill
+    subject.has_feature?(:chill).should be false
+  end
+  
+  it 'should default to false for new features' do
+    subject.has_feature?(:evil).should be false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'test_project/config/application'

data/spec/view_helpers_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Fickle::ViewHelpers do
+  
+  class TestClass
+    include Fickle::ViewHelpers
+  end
+  
+  subject do
+    TestClass.new
+  end
+  
+  it { should respond_to :feature_enabled? }
+  
+  describe '#feature_enabled?' do
+    
+    before :each do
+      @feature_set = Fickle::FeatureSet.for('global')
+    end
+    
+    it 'should create features that have not been tested before and default to false' do
+      subject.feature_enabled?(:feature).should be false
+    end
+    it 'should return false when a feature is not enabled' do
+      @feature_set.disable_feature(:kill_robots)
+      subject.feature_enabled?(:kill_robots).should be false
+    end
+    it 'should return true when a feature is enabled' do
+      @feature_set.enable_feature(:kill_robots)
+      subject.feature_enabled?(:kill_robots).should be true
+    end
+  end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: fickle
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- chrisrhoden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-20 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id002
+description: |-
+  Fickle lets you turn features on and off at will in your rails app using a web interface.
+  It also lets you manage features on a model-by-model basis (maybe users?)
+email: 
+- chris@lazerclub.co
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- app/controllers/fickle/application_controller.rb
+- app/controllers/fickle/features_controller.rb
+- app/controllers/fickle/model_features_controller.rb
+- app/views/fickle/features/index.html.erb
+- app/views/fickle/model_features/index.html.erb
+- app/views/layouts/fickle.html.erb
+- fickle.gemspec
+- lib/fickle.rb
+- lib/fickle/abstract_backend.rb
+- lib/fickle/abstract_feature_set.rb
+- lib/fickle/backends.rb
+- lib/fickle/backends/memory.rb
+- lib/fickle/backends/memory/feature_set.rb
+- lib/fickle/class_methods.rb
+- lib/fickle/config.rb
+- lib/fickle/controllers.rb
+- lib/fickle/model_extensions.rb
+- lib/fickle/railtie.rb
+- lib/fickle/routes.rb
+- lib/fickle/version.rb
+- lib/fickle/view_helpers.rb
+- lib/generators/fickle/install/USAGE
+- lib/generators/fickle/install/install_generator.rb
+- lib/generators/fickle/install/templates/fickle.css
+- lib/generators/fickle/install/templates/fickle.js
+- lib/generators/fickle/install/templates/fickle.rb.erb
+- spec/class_methods_spec.rb
+- spec/feature_set_spec.rb
+- spec/fickle_spec.rb
+- spec/model_extensions_spec.rb
+- spec/spec_helper.rb
+- spec/view_helpers_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fickle
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: The feature library for rails that can't make up its mind
+test_files: 
+- spec/class_methods_spec.rb
+- spec/feature_set_spec.rb
+- spec/fickle_spec.rb
+- spec/model_extensions_spec.rb
+- spec/spec_helper.rb
+- spec/view_helpers_spec.rb