arturo 0.2.3.1

data/HISTORY.md

@@ -0,0 +1,16 @@
+## v 1.1.0 - cleanup
+ * changed `require_feature!` to `require_feature`
+ * replaced `Arturo.permit_management` and `Arturo.feature_recipient`
+   blocks with instance methods
+   `Arturo::FeatureManagement.may_manage_features?` and
+   `Arturo::FeatureAvailability.feature_recipient`
+
+## v 1.0.0 - Initial Release
+ * `require_feature!` controller filter
+ * `if_feature_enabled` controller and view method
+ * `feature_enabled?` controller and view method
+ * CRUD for features
+ * `Arturo.permit_management` to configure management permission
+ * `Arturo.feature_recipient` to configure on what basis features are deployed
+ * whitelists and blacklists
+ 

data/README.md

@@ -0,0 +1,277 @@
+## Rails 2.3
+
+This is the Rails 2.3 branch of Arturo. It is available as a gem with the
+version number `0.2.3.x`. See [Installation](#installation), below. For
+Rails 3.0 support, see the
+[master branch](http://github.com/jamesarosen/arturo).
+
+## What
+
+Arturo provides feature sliders for Rails. It lets you turn features on and off
+just like
+[feature flippers](http://code.flickr.com/blog/2009/12/02/flipping-out/),
+but offers more fine-grained control. It supports deploying features only for
+a given percent* of your users and whitelisting and blacklisting users based
+on any criteria you can express in Ruby.
+
+    * The selection isn't random. It's not even pseudo-random. It's completely
+      deterministic. This assures that if a user has a feature on Monday, the
+      user will still have it on Tuesday (unless, of course, you *decrease*
+      the feature's deployment percentage or change its white- or blacklist
+      settings).
+
+### A quick example
+
+Trish, a developer is working on a new feature: a live feed of recent postings
+in the user's city that shows up in the user's sidebar. First, she uses Arturo's
+view helpers to control who sees the sidebar widget:
+
+    <%# in app/views/layout/_sidebar.html.erb: %>
+    <% if_feature_enabled(:live_postings) do %>
+    <div class='widget'>
+      <h3>Recent Postings</h3>
+      <ol id='live_postings'>
+      </ol>
+    </div>
+    <% end %>
+
+Then Trish writes some Javascript that will poll the server for recent
+postings and put them in the sidebar widget:
+
+    // in public/javascript/live_postings.js:
+    $(function() {
+      var livePostingsList = $('#live_postings');
+      if (livePostingsList.length > 0) {
+        var updatePostingsList = function() {
+          livePostingsList.load('/listings/recent');
+          setTimeout(updatePostingsList, 30);
+        }
+        updatePostingsList();
+      }
+    });
+
+Trish uses Arturo's Controller filters to control who has access to
+the feature:
+
+    # in app/controllers/postings_controller:
+    class PostingsController < ApplicationController
+      require_feature :live_postings, :only => :recent
+      # ...
+    end
+
+Trish then deploys this code to production. Nobody will see the feature yet,
+since it's not on for anyone. (In fact, the feature doesn't yet exist
+in the database, which is the same as being deployed to 0% of users.) A week
+later, when the company is ready to start deploying the feature to a few
+people, the product manager, Vijay, signs in to their site and navigates
+to `/features`, adds a new feature called "live_postings" and sets its
+deployment percentage to 3%. After a few days, the operations team decides
+that the increase in traffic is not going to overwhelm their servers, and
+Vijay can bump the deployment percentage up to 50%. A few more days go by
+and they clean up the last few bugs they found with the "live_postings"
+feature and deploy it to all users.
+
+## <span id='installation'>Installation</span>
+
+Arturo's support for Rails 2.3 is available as a gem with version
+numbers matching `0.2.3.x`. The best strategy is to use the
+"pessimistic" gem version `"~> 0.2.3"`, which will get you the
+latest version of Rails 2.3 support.
+
+### In Rails 2.3, with Bundler
+
+In your `Gemfile`:
+
+    gem 'arturo', :git => 'git://github.com/jamesarosen/arturo.git',
+                  :version => '~> 0.2.3'
+
+Unfortunately, Rails 2.3 won't automatically load Arturo as a Plugin
+(and thus not pick up its "engine-ness") without **also** declaring
+it as a Rails gem. Thus, in `config/environment.rb`:
+
+    config.gem 'arturo', :version => '~> 0.2.3'
+
+### In Rails 2.3, without Bundler
+
+Put the `rails_2_3` branch of `git://github.com/jamesarosen/arturo.git` into
+your `vendor/plugins/` directory. You can use Git submodules or a simple
+checkout.
+
+## Configuration
+
+### In Rails
+
+#### Run the generators:
+
+    $ script/generate arturo:migration
+    $ script/generate arturo:initializer
+    $ script/generate arturo:route
+    $ script/generate arturo:assets
+
+#### Edit the generated migration as necessary
+
+#### Run the migration:
+
+    $ rake db:migrate
+
+#### Edit the configuration
+
+##### Initializer
+
+Open up the newly-generated `config/initializers/arturo_initializer.rb`.
+There are configuration options for the following:
+
+ * the method that determines whether a user has permission to manage features
+   (see [admin permissions](#adminpermissions))
+ * the method that returns the object that has features
+   (e.g. User, Person, or Account; see
+   [feature recipients](#featurerecipients))
+ * whitelists and blacklists for features
+   (see [white- and blacklisting](#wblisting))
+
+##### CSS
+
+Open up the newly-generated `public/stylehseets/arturo_customizations.css`.
+You can add any overrides you like to the feature configuration page styles
+here. **Do not** edit `public/stylehseets/arturo.css` as that file may be
+overwritten in future updates to Arturo.
+
+### In other frameworks
+
+Arturo is a Rails engine. I want to promote reuse on other frameworks by
+extracting key pieces into mixins, though this isn't done yet. Open an
+[issue](http://github.com/jamesarosen/arturo/issues) and I'll be happy to
+work with you on support for your favorite framework.
+
+## Deep-Dive
+
+### <span id='adminpermissions'>Admin Permissions</span>
+
+`Arturo::FeatureManagement#may_manage_features?` is a method that is run in
+the context of a Controller or View instance. It should return `true` if
+and only if the current user may manage permissions. The default implementation
+is as follows:
+
+    current_user.present? && current_user.admin?
+
+You can change the implementation in
+`config/initializers/arturo_initializer.rb`. A reasonable implementation
+might be
+
+    Arturo.permit_management do
+      signed_in? && current_user.can?(:manage_features)
+    end
+
+### <span id='featurerecipients'>Feature Recipients</span>
+
+Clients of Arturo may want to deploy new features on a per-user, per-project,
+per-account, or other basis. For example, it is likely Twitter deployed
+"#newtwitter" on a per-user basis. Conversely, Facebook -- at least in its
+early days -- may have deployed features on a per-university basis. It wouldn't
+make much sense to deploy a feature to one user of a Basecamp project but not
+to others, so 37Signals would probably want a per-project or per-account basis.
+
+`Arturo::FeatureAvailability#feature_recipient` is intended to support these
+many use cases. It is a method that returns the current "thing" (a user, account,
+project, university, ...) that is a member of the category that is the basis for
+deploying new features. It should return an `Object` that responds to `#id`.
+
+The default implementation simply returns `current_user`. Like
+`Arturo::FeatureManagement#may_manage_features?`, this method can be configured
+in `config/initializers/arturo_initializer.rb`. If you want to deploy features
+on a per-account basis, a reasonable implementation might be
+
+    Arturo.feature_recipient do
+      current_account
+    end
+
+or
+
+    Arturo.feature_recipient do
+      current_user.account
+    end
+
+If the block returns `nil`, the feature will be disabled.
+
+### <span id='wblisting'>Whitelists & Blacklists</span>
+
+Whitelists and blacklists allow you to control exactly which users or accounts
+will have a feature. For example, if all premium users should have the
+`:awesome` feature, place the following in
+`config/initializers/arturo_initializer.rb`:
+
+    Arturo::Feature.whitelist(:awesome) do |user|
+      user.account.premium?
+    end
+
+If, on the other hand, no users on the free plan should have the
+`:awesome` feature, place the following in
+`config/initializers/arturo_initializer.rb`:
+
+    Arturo::Feature.blacklist(:awesome) do |user|
+      user.account.free?
+    end
+
+### Feature Conditionals
+
+All that configuration is just a waste of time if Arturo didn't modify the
+behavior of your application based on feature availability. There are a few
+ways to do so.
+
+#### Controller Filters
+
+If an action should only be available to those with a feature enabled,
+use a before filter. The following will raise a 403 Forbidden error for
+every action within `BookHoldsController` that is invoked by a user who
+does not have the `:hold_book` feature.
+
+    class BookHoldsController < ApplicationController
+      require_feature :hold_book
+    end
+
+`require_feature` accepts as a second argument a `Hash` that it passes on
+to `before_filter`, so you can use `:only` and `:except` to specify exactly
+which actions are filtered.
+
+If you want to customize the page that is rendered on 403 Forbidden
+responses, put the view in
+`RAILS_ROOT/app/views/arturo/features/forbidden.html.erb`. Rails will
+check there before falling back on Arturo's forbidden page.
+
+#### Conditional Evaluation
+
+Both controllers and views have access to the `if_feature_enabled` and
+`feature_enabled?` methods. The former is used like so:
+
+    <% if_feature_enabled?(:reserve_table) %>
+      <%= link_to 'Reserve a table', new_restaurant_reservation_path(:restaurant_id => @restaurant) %>
+    <% end %>
+
+The latter can be used like so:
+
+    def widgets_for_sidebar
+      widgets = []
+      widgets << twitter_widget if feature_enabled?(:twitter_integration)
+      ...
+      widgets
+    end
+
+#### Caching
+
+**Note**: Arturo does not yet have caching support. Be very careful when
+caching actions or pages that involve feature detection as you will get
+strange behavior when a user who has access to a feature requests a page
+just after one who does not (and vice versa). The following is the
+**intended** support for caching.
+
+Both the `require_feature` before filter and the `if_feature_enabled` block
+evaluation automatically append a string based on the feature's
+`last_modified` timestamp to cache keys that Rails generates. Thus, you don't
+have to worry about expiring caches when you increase a feature's deployment
+percentage. See `Arturo::CacheSupport` for more information.
+
+## The Name
+
+Arturo gets its name from
+[Professor Maximillian Arturo](http://en.wikipedia.org/wiki/Maximillian_Arturo)
+on [Sliders](http://en.wikipedia.org/wiki/Sliders).

data/app/controllers/arturo/features_controller.rb

@@ -0,0 +1,125 @@
+require 'action_controller'
+
+module Arturo
+
+  begin
+    require 'application_controller'
+  rescue LoadError
+    # do nothing
+  end
+
+  base = Object.const_defined?(:ApplicationController) ? ApplicationController : ActionController::Base
+
+  # Handles all Feature actions. Clients of the Arturo engine
+  # should redefine Arturo::FeaturesController#permitted? to
+  # return true only for users who are permitted to manage features.
+  class FeaturesController < base
+    include Arturo::FeatureManagement
+
+    unloadable
+    before_filter :require_permission
+    before_filter :load_feature, :only => [ :show, :edit, :update, :destroy ]
+
+    def index
+      @features = Arturo::Feature.all
+      respond_to do |format|
+        format.html { }
+        format.json { render :json => @features }
+        format.xml  { render :xml  => @features }
+      end
+    end
+
+    def update_all
+      updated_count = 0
+      errors = []
+      features_params = params[:features] || {}
+      features_params.each do |id, attributes|
+        feature = Arturo::Feature.find_by_id(id)
+        if feature.blank?
+          errors << t('arturo.features.flash.no_such_feature', :id => id)
+        elsif feature.update_attributes(attributes)
+          updated_count += 1
+        else
+          errors << t('arturo.features.flash.error_updating', :id => id)
+        end
+      end
+      if errors.any?
+        flash[:error] = errors
+      else
+        flash[:success] = t('arturo.features.flash.updated_many', :count => updated_count)
+      end
+      redirect_to features_path
+    end
+
+    def show
+      respond_to do |format|
+        format.html { }
+        format.json { render :json => @feature }
+        format.xml  { render :xml  => @feature }
+      end
+    end
+
+    def new
+      @feature = Arturo::Feature.new(params[:feature])
+      respond_to do |format|
+        format.html { }
+        format.json { render :json => @feature }
+        format.xml  { render :xml  => @feature }
+      end
+    end
+
+    def create
+      @feature = Arturo::Feature.new(params[:feature])
+      if @feature.save
+        flash[:notice] = t('arturo.features.flash.created', :name => @feature.to_s)
+        redirect_to features_path
+      else
+        flash[:alert] = t('arturo.features.flash.error_creating', :name => @feature.to_s)
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      respond_to do |format|
+        format.html { }
+        format.json { render :json => @feature }
+        format.xml  { render :xml  => @feature }
+      end
+    end
+
+    def update
+      if @feature.update_attributes(params[:feature])
+        flash[:notice] = t('arturo.features.flash.updated', :name => @feature.to_s)
+        redirect_to feature_path(@feature)
+      else
+          flash[:alert] = t('arturo.features.flash.error_updating', :name => @feature.to_s)
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      if @feature.destroy
+        flash[:notice] = t('arturo.features.flash.removed', :name => @feature.to_s)
+      else
+        flash[:alert] = t('arturo.features.flash.error_removing', :name => @feature.to_s)
+      end
+      redirect_to features_path
+    end
+
+    protected
+
+    def require_permission
+      unless may_manage_features?
+        render :action => 'forbidden', :status => 403
+        return false
+      end
+    end
+
+    def load_feature
+      @feature ||= Arturo::Feature.find(params[:id])
+    end
+
+  end
+
+end
+

data/app/helpers/arturo/features_helper.rb

@@ -0,0 +1,38 @@
+require 'action_view/helpers/tag_helper'
+require 'action_view/helpers/form_tag_helper'
+
+module Arturo
+  module FeaturesHelper
+    include ActionView::Helpers::TagHelper
+
+    def deployment_percentage_range_and_output_tags(name, value, options = {})
+      id = sanitize_to_id(name)
+      options = {
+        'type' => 'range',
+        'name' => name,
+        'id' => id,
+        'value' => value,
+        'min' => '0',
+        'max' => '100',
+        'step' => '1',
+        'class' => 'deployment_percentage'
+      }.update(options.stringify_keys)
+      tag(:input, options) + deployment_percentage_output_tag(id, value)
+    end
+
+    def deployment_percentage_output_tag(id, value)
+      content_tag(:output, value, { 'for' => id, 'class' => 'deployment_percentage no_js' })
+    end
+
+    def error_messages_for(feature, attribute)
+      errors = feature.errors.on(attribute)
+      if errors && errors.any?
+        content_tag(:ul, :class => 'errors') do
+          errors.map { |msg| content_tag(:li, msg, :class => 'error') }.join(''.html_safe)
+        end
+      else
+        ''
+      end
+    end
+  end
+end

data/app/models/arturo/feature.rb

@@ -0,0 +1,85 @@
+require 'active_record'
+
+# a stub
+# possible TODO: remove and and refactor into an acts_as_feature mixin
+module Arturo
+  class Feature < ::ActiveRecord::Base
+
+    include Arturo::SpecialHandling
+
+    Arturo::Feature::SYMBOL_REGEX = /^[a-zA-z][a-zA-Z0-9_]*$/
+    DEFAULT_ATTRIBUTES = { :deployment_percentage => 0 }
+
+    attr_readonly :symbol
+
+    validates_presence_of :symbol, :deployment_percentage
+    validates_uniqueness_of :symbol, :allow_blank => true
+    validates_numericality_of :deployment_percentage,
+                                            :only_integer => true,
+                                            :allow_blank => true,
+                                            :greater_than_or_equal_to => 0,
+                                            :less_than_or_equal_to => 100
+
+    # Looks up a feature by symbol. Also accepts a Feature as input.
+    # @param [Symbol, Arturo::Feature] feature_or_name a Feature or the Symbol of a Feature
+    # @return [Arturo::Feature, nil] the Feature if found, else nil
+    def self.to_feature(feature_or_symbol)
+      return feature_or_symbol if feature_or_symbol.kind_of?(self)
+      self.find(:first, :conditions => { :symbol => feature_or_symbol.to_s })
+    end
+
+    # Create a new Feature
+    def initialize(attributes = {})
+      super(DEFAULT_ATTRIBUTES.merge(attributes || {}))
+    end
+
+    # @param [Object] feature_recipient a User, Account,
+    #                 or other model with an #id method
+    # @return [true,false] whether or not this feature is enabled
+    #                      for feature_recipient
+    # @see Arturo::SpecialHandling#whitelisted?
+    # @see Arturo::SpecialHandling#blacklisted?
+    def enabled_for?(feature_recipient)
+      return false if feature_recipient.nil?
+      return false if blacklisted?(feature_recipient)
+      return true if  whitelisted?(feature_recipient)
+      passes_threshold?(feature_recipient)
+    end
+
+    def name
+      return I18n.translate("arturo.feature.nameless") if symbol.blank?
+      I18n.translate("arturo.feature.#{symbol}", :default => symbol.to_s.titleize)
+    end
+
+    def to_s
+      "Feature #{name}"
+    end
+
+    def to_param
+      new_record? ? nil : "#{id}-#{symbol.to_s.parameterize}"
+    end
+
+    def inspect
+      "<Arturo::Feature #{name}, deployed to #{deployment_percentage}%>"
+    end
+
+    def symbol
+      sym = read_attribute(:symbol).to_s
+      sym.blank? ? nil : sym.to_sym
+    end
+
+    def symbol=(sym)
+      write_attribute(:symbol, sym.to_s)
+    end
+
+    protected
+
+    def passes_threshold?(feature_recipient)
+      threshold = self.deployment_percentage || 0
+      return false if threshold == 0
+      return true if threshold == 100
+      (((feature_recipient.id + 17) * 13) % 100) < threshold
+      
+    end
+  end
+end

data/app/views/arturo/features/_feature.html.erb

@@ -0,0 +1,5 @@
+<tr class='feature' id="feature_<%= feature.id %>">
+  <td><code class='ruby symbol'><%= feature.symbol %></code></td>
+  <td><%= deployment_percentage_range_and_output_tags("features[#{feature.id}][deployment_percentage]", feature.deployment_percentage) %></td>
+  <td><%= link_to t('.edit'), edit_feature_path(feature), :rel => 'edit', :class => 'edit' %></td>
+</tr>

data/app/views/arturo/features/_form.html.erb

@@ -0,0 +1,16 @@
+<% form_for(feature, :as => 'feature', :url => (feature.new_record? ? features_path : feature_path(feature))) do |form| %>
+  <fieldset>
+    <legend><%= legend %></legend>
+
+    <%= form.label(:symbol) %>
+    <%= form.text_field(:symbol, :required => 'required', :pattern => Arturo::Feature::SYMBOL_REGEX.source, :class => 'symbol') %>
+    <%= error_messages_for(feature, :symbol) %>
+
+    <%= form.label(:deployment_percentage) %>
+    <%= form.range_field(:deployment_percentage, :min => '0', :max => '100', :step => '1', :class => 'deployment_percentage') %>
+    <%= deployment_percentage_output_tag 'feature_deployment_percentage', feature.deployment_percentage %>
+    <%= error_messages_for(feature, :deployment_percentage) %>
+
+    <footer><%= form.submit %></footer>
+  </fieldset>
+<% end %>

data/app/views/arturo/features/edit.html.erb

@@ -0,0 +1,2 @@
+<h2><%= t('.title', :name => @feature.name) %></h2>
+<%= render :partial => 'form', :locals => { :feature => @feature, :legend =>  t('.legend', :name => @feature.name) } %>

data/app/views/arturo/features/forbidden.html.erb

@@ -0,0 +1,2 @@
+<h2><%= t('.title') %></h2>
+<p><%= t('.text') %></p>

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

@@ -0,0 +1,29 @@
+<h2><%= t('.title') %></h2>
+<% form_tag(features_path, :method => 'put', 'data-update-path' => feature_path(:id => ':id'), :remote => true) do %>
+  <fieldset>
+    <legend><%= t('.title') %></legend>
+    <table class='features'>
+      <col class='name' />
+      <col class='deployment_percentage' />
+      <col class='edit' />
+      <thead>
+        <tr>
+          <th><%= t('activerecord.attributes.arturo/feature.name') %></th>
+          <th><%= t('activerecord.attributes.arturo/feature.deployment_percentage') %></th>
+          <th>&nbsp;</th>
+        </tr>
+      </thead>
+      <tfoot>
+        <tr><th colspan='4'><%= link_to t('.new'), new_feature_path %> <%= submit_tag %></th></tr>
+      </tfoot>
+      <tbody>
+        <% @features.each do |f| %>
+          <%= render :partial => 'feature', :locals => { :feature => f } %>
+        <% end %>
+        <% if @features.none? %>
+        <tr class='if_no_features'><td colspan='4'><%= t('.none_yet') %></td></tr>
+        <% end %>
+      </tbody>
+    </table>
+  </fieldset>
+<% end %>

data/app/views/arturo/features/new.html.erb

@@ -0,0 +1,2 @@
+<h2><%= t('.title') %></h2>
+<%= render :partial => 'form', :locals => { :feature => @feature, :legend =>  t('.legend') } %>

data/app/views/arturo/features/show.html.erb

@@ -0,0 +1,2 @@
+<h2><%= t('.title', :name => @feature.name) %></h2>
+<p>Deployment percentage: <%= @feature.deployment_percentage %></p>

data/config/locales/en.yml

@@ -0,0 +1,40 @@
+en:
+  activerecord:
+    models:
+      "arturo/feature": "Feature"
+    attributes:
+      "arturo/feature":
+        symbol: "Symbol"
+        name: "Name"
+        deployment_percentage: "Deployment Percentage"
+  arturo:
+    feature:
+      nameless: "(no name)"
+    features:
+      index:
+        title: 'Features'
+        new: 'New'
+        none_yet: No features yet.
+      new:
+        title: New Feature
+        legend: "New Feature"
+      edit:
+        title: "Edit Feature %{name}"
+        legend: "Edit Feature %{name}"
+      feature:
+        edit: 'Edit'
+      show:
+        title: "Feature %{name}"
+      forbidden:
+        title: Forbidden
+        text: You do not have permission to access that resource.
+      flash:
+        no_such_feature: "No such feature: {id}"
+        error_updating: "Error updating feature #{id}"
+        updated_many: "Updated {count} feature(s)"
+        created: "Created {name}"
+        error_creating: "Sorry, there was an error creating the feature."
+        updated: "Updated {name}"
+        error_updating: "Sorry, there was an error updating {name}"
+        removed: "Removed {name}"
+        error_removing: "Sorry, there was an error removing {name}"

data/lib/arturo.rb

@@ -0,0 +1,10 @@
+module Arturo
+
+  require 'arturo/special_handling'
+  require 'arturo/feature_availability'
+  require 'arturo/feature_management'
+  require 'arturo/controller_filters'
+  require 'arturo/range_form_support'
+  require 'arturo/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 2 && Rails::VERSION::MINOR == 3
+
+end

data/lib/arturo/controller_filters.rb

@@ -0,0 +1,33 @@
+module Arturo
+
+  # Adds before filters to controllers for specifying that actions
+  # require features to be enabled for the requester.
+  #
+  # To configure how the controller responds when the feature is
+  # *not* enabled, redefine #on_feature_disabled(feature_name).
+  # It must render or raise an exception.
+  module ControllerFilters
+
+    def self.included(base)
+      base.extend Arturo::ControllerFilters::ClassMethods
+    end
+
+    def on_feature_disabled(feature_name)
+      render :text => 'Forbidden', :status => 403
+    end
+
+    module ClassMethods
+
+      def require_feature(name, options = {})
+        before_filter options do |controller|
+          unless controller.feature_enabled?(name)
+            controller.on_feature_disabled(name)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/arturo/engine.rb

@@ -0,0 +1,15 @@
+ActionController::Base.class_eval do
+  include Arturo::FeatureAvailability
+  helper  Arturo::FeatureAvailability
+  include Arturo::ControllerFilters
+  helper  Arturo::FeatureManagement
+  helper  Arturo::RangeFormSupport::HelperMethods
+end
+
+ActionView::Helpers::FormBuilder.instance_eval do
+  include Arturo::RangeFormSupport::FormBuilderMethods
+end
+
+require 'rails_generator'
+generators_path = File.expand_path('../../generators', __FILE__)
+Rails::Generator::Base.sources << Rails::Generator::PathSource.new(:arturo, generators_path)

data/lib/arturo/feature_availability.rb

@@ -0,0 +1,37 @@
+module Arturo
+
+  # A mixin that provides #feature_enabled? and #if_feature_enabled
+  # methods; to be mixed in by Controllers and Helpers. The including
+  # class must return some "thing that has features" (e.g. a User, Person,
+  # or Account) when Arturo.feature_recipient is bound to an instance
+  # and called.
+  #
+  # @see Arturo.feature_recipient
+  module FeatureAvailability
+
+    def feature_enabled?(symbol_or_feature)
+      feature = ::Arturo::Feature.to_feature(symbol_or_feature)
+      return false if feature.blank?
+      feature.enabled_for?(feature_recipient)
+    end
+
+    def if_feature_enabled(symbol_or_feature, &block)
+      if feature_enabled?(symbol_or_feature)
+        block.call
+      else
+        nil
+      end
+    end
+
+    # By default, returns current_user.
+    # 
+    # If you would like to change this implementation, it is recommended
+    # you do so in config/initializers/arturo_initializer.rb
+    # @return [Object] the recipient of features.
+    def feature_recipient
+      current_user
+    end
+
+  end
+
+end

data/lib/arturo/feature_factories.rb

@@ -0,0 +1,4 @@
+Factory.define :feature, :class => Arturo::Feature do |f|
+  f.sequence(:symbol) { |n| "feature_#{n}".to_sym }
+  f.deployment_percentage { |_| rand(101) }
+end

data/lib/arturo/feature_management.rb

@@ -0,0 +1,23 @@
+module Arturo
+
+  # A mixin that is included by Arturo::FeaturesController and is declared
+  # as a helper for all views. It provides a single method,
+  # may_manage_features?, that returns whether or not the current user
+  # may manage features. By default, it is implemented as follows:
+  # 
+  #   def may_manage_features?
+  #     current_user.present? && current_user.admin?
+  #   end
+  # 
+  # If you would like to change this implementation, it is recommended
+  # you do so in config/initializers/arturo_initializer.rb
+  module FeatureManagement
+
+    # @return [true,false] whether the current user may manage features
+    def may_manage_features?
+      current_user.present? && current_user.admin?
+    end
+
+  end
+
+end

data/lib/arturo/range_form_support.rb

@@ -0,0 +1,17 @@
+module Arturo
+  module RangeFormSupport
+
+    module HelperMethods
+      def range_field(object_name, method, options = {})
+        ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("range", options)
+      end
+    end
+
+    module FormBuilderMethods
+      def range_field(method, options = {})
+        @template.send('range_field', @object_name, method, objectify_options(options))
+      end
+    end
+
+  end
+end

data/lib/arturo/special_handling.rb

@@ -0,0 +1,62 @@
+module Arturo
+
+  # Adds whitelist and blacklist support to individual features by name.
+  # Blacklists override whitelists. (In the world of Apache, Features
+  # are "(deny,allow)".)
+  # @example
+  #   # allow admins:
+  #   Arturo::Feature.whitelist(:some_feature) do |user|
+  #     user.is_admin?
+  #   end
+  #
+  #   # disallow for small accounts:
+  #   Arturo::Feature.blacklist(:another_feature) do |user|
+  #     user.account.small?
+  #   end
+  #
+  # Blacklists and whitelists can be defined before the feature exists
+  # and are not persisted, so they are best defined in initializers.
+  # This is particularly important if your application runs in several
+  # different processes or on several servers.
+  module SpecialHandling
+
+    def self.included(base)
+      base.extend Arturo::SpecialHandling::ClassMethods
+    end
+
+    module ClassMethods
+      def whitelists
+        @whitelists ||= {}
+      end
+
+      def blacklists
+        @blacklists ||= {}
+      end
+
+      def whitelist(feature_symbol, &block)
+        whitelists[feature_symbol.to_sym] = block
+      end
+
+      def blacklist(feature_symbol, &block)
+        blacklists[feature_symbol.to_sym] = block
+      end
+    end
+
+    protected
+
+    def whitelisted?(feature_recipient)
+      x_listed?(self.class.whitelists, feature_recipient)
+    end
+
+    def blacklisted?(feature_recipient)
+      x_listed?(self.class.blacklists, feature_recipient)
+    end
+
+    def x_listed?(list_map, feature_recipient)
+      list = list_map[self.symbol.to_sym]
+      list.present? && list.call(feature_recipient)
+    end
+
+  end
+
+end

data/lib/generators/arturo/arturo_generator.rb

@@ -0,0 +1,40 @@
+require 'rails_generator'
+
+class ArturoGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.file 'initializer.rb',              'config/initializers/arturo_initializer.rb'
+      m.file 'arturo.css',                  'public/stylesheets/arturo.css', :collision => :force
+      m.file 'arturo_customizations.css',   'public/stylesheets/arturo_customizations.css', :collision => :skip
+      m.file 'arturo.js',                   'public/javascripts/arturo.js'
+      m.file 'semicolon.png',               'public/images/semicolon.png'
+      m.migration_template 'migration.rb',  'db/migrate', :migration_file_name => 'create_features'
+      add_feature_routes(m)
+    end
+  end
+
+  protected
+
+  def source_root
+    File.expand_path('../templates', __FILE__)
+  end
+
+  def banner
+    %{Usage: #{$0} #{spec.name}\nCopies an initializer; copies CSS, JS, and PNG assets; generates a migration; adds routes/}
+  end
+
+  def add_feature_routes(manifest)
+    sentinel = 'ActionController::Routing::Routes.draw do |map|'
+    logger.route "map.resources features"
+    unless options[:pretend]
+      manifest.gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+        "#{match}#{feature_routes}\n"
+      end
+    end
+  end
+
+  def feature_routes
+    "\n  map.resources :features,  :controller => 'arturo/features'" +
+    "\n  map.features  'features', :controller => 'arturo/features', :action => 'update_all', :conditions => { :method => :put }"
+  end
+end

data/lib/generators/arturo/templates/arturo.css

@@ -0,0 +1,67 @@
+/*
+  WARNING:
+
+  Do not edit this file. Any changes you make to this file will be overwritten
+  when you regenerate the arturo assets (which happens when you upgrade the gem).
+  Instead, make customizations to arturo_customizations.css.
+ */
+
+.features code.symbol:before { content: ":"; }
+
+.features { border-collapse: collapse; }
+
+.features thead tr:last-child th { border-bottom: 1px solid; }
+.features tfoot tr:first-child th { border-top: 1px solid; }
+
+.features th, .features td {
+  margin: 0;
+  padding: 0.5em 1.5em;
+  text-align: left;
+}
+
+input.deployment_percentage[type=range] { width: 200px; }
+
+output.deployment_percentage.no_js { display: none; }
+output.deployment_percentage { margin-left: 1em; }
+output.deployment_percentage:after { content: "%"; }
+
+.features a[rel=edit] { visibility: hidden; }
+.features tr:hover a[rel=edit] { visibility: inherit; }
+
+.features tfoot th {
+  text-align: right;
+}
+
+.features tfoot th * + * {
+  margin-left: 2em;
+}
+
+.feature_new label, .feature_edit label { font-weight: bold; }
+
+.feature_new  label, .feature_new  .errors,
+.feature_edit label, .feature_edit .errors {
+  display: block;
+}
+
+.feature_new  label + input, .feature_new  label + textarea, .feature_new  label + select, 
+.feature_edit label + input, .feature_edit label + textarea, .feature_edit label + select {
+  margin-top: 0.5em;
+}
+
+.feature_new  input + label, .feature_new  textarea + label, .feature_new  select + label, 
+.feature_edit input + label, .feature_edit textarea + label, .feature_edit select + label {
+  margin-top: 1.5em;
+}
+
+.feature_new input[type=text], .feature_edit input[type=text] { padding: 0.5em; }
+
+.feature_new  input.symbol, .feature_edit input.symbol {
+  background: transparent url('/images/semicolon.png') no-repeat 3px 4px;
+  font-family: "DejaVu Sans Mono", "Droid Sans Mono", "Mondale", monospace;
+  padding-left: 9px;
+}
+
+.feature_new .errors, .feature_edit .errors { color: red; }
+.feature_new :invalid { border-color: red; }
+
+.feature_new footer, .feature_edit footer { margin-top: 2em; }

data/lib/generators/arturo/templates/arturo.js

@@ -0,0 +1,23 @@
+if (typeof(jQuery) === 'function') {
+  jQuery.arturo = {
+    agentSupportsHTML5Output: ('for' in jQuery('<output />')),
+
+    linkAndShowOutputs: function() {
+      if (jQuery.arturo.agentSupportsHTML5Output) {
+        jQuery('.features output,.feature_new output,.feature_edit output').each(function(i, output) {
+          var output = jQuery(output);
+          var input = jQuery('#' + output.attr('for'));
+          input.change(function() {
+            console.log('input value changed to ' + input.val());
+            output.val(input.val());
+          });
+          output.removeClass('no_js');
+        });
+      }
+    }
+  };
+  
+  jQuery(function() {
+    jQuery.arturo.linkAndShowOutputs();
+  });
+}

data/lib/generators/arturo/templates/arturo_customizations.css

@@ -0,0 +1 @@
+/* Make any customizations to the Arturo styles here */

data/lib/generators/arturo/templates/initializer.rb

@@ -0,0 +1,29 @@
+require 'arturo'
+
+# Configure who may manage features here.
+# The following is the default implementation.
+# Arturo::FeatureManagement.class_eval do
+#   def may_manage_features?
+#     current_user.present? && current_user.admin?
+#   end
+# end
+
+# Configure what receives features here.
+# The following is the default implementation.
+# Arturo::FeatureAvailability.class_eval do
+#   def feature_recipient
+#     current_user
+#   end
+# end
+
+# Whitelists and Blacklists:
+#
+# Enable feature one for all admins:
+# Arturo::Feature.whitelist(:feature_one) do |user|
+#   user.admin?
+# end
+#
+# Disable feature two for all small accounts:
+# Arturo::Feature.blacklist(:feature_two) do |user|
+#   user.account.small?
+# end

data/lib/generators/arturo/templates/migration.rb

@@ -0,0 +1,17 @@
+require 'active_support/core_ext'
+
+class CreateFeatures < ActiveRecord::Migration
+  def self.up
+    create_table :features do |t|
+      t.string   :symbol, :null => false
+      t.integer  :deployment_percentage, :null => false
+      #Any additional fields here
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :features
+  end
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification 
+name: arturo
+version: !ruby/object:Gem::Version 
+  hash: 81
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 3
+  - 1
+  version: 0.2.3.1
+platform: ruby
+authors: 
+- James A. Rosen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-31 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 3
+        - 8
+        version: 2.3.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id006
+description: Deploy features incrementally to your users
+email: james.a.rosen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/arturo/controller_filters.rb
+- lib/arturo/engine.rb
+- lib/arturo/feature_availability.rb
+- lib/arturo/feature_factories.rb
+- lib/arturo/feature_management.rb
+- lib/arturo/range_form_support.rb
+- lib/arturo/special_handling.rb
+- lib/arturo.rb
+- lib/generators/arturo/arturo_generator.rb
+- lib/generators/arturo/templates/arturo.css
+- lib/generators/arturo/templates/arturo.js
+- lib/generators/arturo/templates/arturo_customizations.css
+- lib/generators/arturo/templates/initializer.rb
+- lib/generators/arturo/templates/migration.rb
+- lib/generators/arturo/templates/semicolon.png
+- app/controllers/arturo/features_controller.rb
+- app/helpers/arturo/features_helper.rb
+- app/models/arturo/feature.rb
+- app/views/arturo/features/_feature.html.erb
+- app/views/arturo/features/_form.html.erb
+- app/views/arturo/features/edit.html.erb
+- app/views/arturo/features/forbidden.html.erb
+- app/views/arturo/features/index.html.erb
+- app/views/arturo/features/new.html.erb
+- app/views/arturo/features/show.html.erb
+- config/locales/en.yml
+- README.md
+- HISTORY.md
+has_rdoc: true
+homepage: http://github.com/jamesarosen/arturo
+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: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: Feature sliders, wrapped up in an engine
+test_files: []
+