arturo 0.2.3.8 → 1.0.0

data/README.md

@@ -1,10 +1,3 @@
-## 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
@@ -55,7 +48,7 @@ the feature:
 
     # in app/controllers/postings_controller:
     class PostingsController < ApplicationController
-      require_feature :live_postings, :only => :recent
+      require_feature! :live_postings, :only => :recent
       # ...
     end
 
@@ -71,27 +64,25 @@ 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>
+## Installation
 
-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 3, with Bundler
 
-### In Rails 2.3, with Bundler
+    gem 'arturo', '~> 1.0'
 
-In your `Gemfile`:
+### In Rails 3, without Bundler
 
-    gem 'arturo', :git => 'git://github.com/jamesarosen/arturo.git',
-                  :version => '~> 0.2.3'
+    $ gem install arturo --version="~> 1.0"
+
+**Note**: the following two sections describe the **intended** use of
+Arturo with Rails 2. Arturo does not yet have Rails 2 support.
 
-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`:
+### In Rails 2, with Bundler
 
-    config.gem 'arturo', :version => '~> 0.2.3'
+    gem 'arturo', :git => 'git://github.com/jamesarosen/arturo.git',
+                  :tag => 'rails_2_3'
 
-### In Rails 2.3, without Bundler
+### In Rails 2, 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
@@ -101,18 +92,12 @@ checkout.
 
 ### 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:
+#### Run the migrations:
 
-    $ rake db:migrate
+    $ rails g arturo:migration
+    $ rails g arturo:initializer
+    $ rails g arturo:route
+    $ rails g arturo:assets
 
 #### Edit the configuration
 
@@ -121,10 +106,10 @@ checkout.
 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
+ * the block 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
+ * the block that yields the object that has features
+   (a User, Person, or Account, see
    [feature recipients](#featurerecipients))
  * whitelists and blacklists for features
    (see [white- and blacklisting](#wblisting))
@@ -147,19 +132,20 @@ work with you on support for your favorite framework.
 
 ### <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
+`Arturo.permit_management` is a block that is run in the context of
+a Controller instance. It should return `true` iff the current user
+can manage permissions. Configure the block in
 `config/initializers/arturo_initializer.rb`. A reasonable implementation
 might be
 
     Arturo.permit_management do
-      signed_in? && current_user.can?(:manage_features)
+      current_user.admin?
+    end
+
+or
+
+    Arturo.permit_management do
+      signed_in? && signed_in_person.can?(:manage_features)
     end
 
 ### <span id='featurerecipients'>Feature Recipients</span>
@@ -171,23 +157,35 @@ 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`.
+`Arturo.feature_recipient` is intended to support these many use cases. It is a
+block 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. Like `Arturo.permit_management`, it is configured in
+`config/initializers/arturo_initializer.rb`. It should return an `Object` that
+responds to `#id`. If you want to deploy features on a per-user basis, a
+reasonable implementation might be
 
-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.thing_that_has_features do
+      current_user
+    end
+
+or
+
+    Arturo.thing_that_has_features do
+      signed_in_person
+    end
+
+If, on the other hand, you have accounts that have many users and you
+want to deploy features on a per-account basis, a reasonable implementation
+might be
 
-    Arturo.feature_recipient do
+    Arturo.thing_that_has_features do
       current_account
     end
 
 or
 
-    Arturo.feature_recipient do
+    Arturo.thing_that_has_features do
       current_user.account
     end
 
@@ -226,10 +224,10 @@ 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
+      require_feature! :hold_book
     end
 
-`require_feature` accepts as a second argument a `Hash` that it passes on
+`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.
 
@@ -256,34 +254,15 @@ The latter can be used like so:
       widgets
     end
 
-#### Rack Middleware
-
-    require 'arturo'
-    use Arturo::Middleware, :feature => :my_feature
-
-#### Outside a Controller
-
-If you want to check availability outside of a controller or view (really
-outside of something that has `Arturo::FeatureAvailability` mixed in), you
-can ask either
-
-    Arturo.feature_enabled_for?(:foo, recipient)
-
-or the slightly fancier
-
-    Arturo.foo_enabled_for?(recipient)
-
-Both check whether the `foo` feature exists and is enabled for `recipient`.
-
 #### 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
+strange behavior when a use 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
+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
@@ -293,4 +272,4 @@ percentage. See `Arturo::CacheSupport` for more information.
 
 Arturo gets its name from
 [Professor Maximillian Arturo](http://en.wikipedia.org/wiki/Maximillian_Arturo)
-on [Sliders](http://en.wikipedia.org/wiki/Sliders).
+on [Sliders](http://en.wikipedia.org/wiki/Sliders).

data/app/controllers/arturo/features_controller.rb

@@ -1,23 +1,30 @@
 require 'action_controller'
 
+# TODO: this doesn't do anything radically out of the ordinary.
+#       Are there Rails 3 patterns/mixins/methods I can use
+#       to clean it up a bit?
 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 < ApplicationController
-    include Arturo::FeatureManagement
-
+  class FeaturesController < base
+    unloadable
+    respond_to :html, :json, :xml
     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
+      respond_with @features
     end
 
     def update_all
@@ -43,20 +50,12 @@ module Arturo
     end
 
     def show
-      respond_to do |format|
-        format.html { }
-        format.json { render :json => @feature }
-        format.xml  { render :xml  => @feature }
-      end
+      respond_with @feature
     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
+      respond_with @feature
     end
 
     def create
@@ -71,11 +70,7 @@ module Arturo
     end
 
     def edit
-      respond_to do |format|
-        format.html { }
-        format.json { render :json => @feature }
-        format.xml  { render :xml  => @feature }
-      end
+      respond_with @feature
     end
 
     def update
@@ -83,7 +78,7 @@ module Arturo
         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)
+          flash[:alert] = t('arturo.features.flash.error_updating', :name => @feature.to_s)
         render :action => 'edit'
       end
     end
@@ -100,7 +95,7 @@ module Arturo
     protected
 
     def require_permission
-      unless may_manage_features?
+      unless Arturo.permit_management?(self)
         render :action => 'forbidden', :status => 403
         return false
       end

data/app/helpers/arturo/features_helper.rb

@@ -23,5 +23,15 @@ module Arturo
     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)
+      if feature.errors[attribute].any?
+        content_tag(:ul, :class => 'errors') do
+          feature.errors[attribute].map { |msg| content_tag(:li, msg, :class => 'error') }.join(''.html_safe)
+        end
+      else
+        ''
+      end
+    end
   end
 end

data/app/models/arturo/feature.rb

@@ -8,7 +8,7 @@ module Arturo
     include Arturo::SpecialHandling
 
     Arturo::Feature::SYMBOL_REGEX = /^[a-zA-z][a-zA-Z0-9_]*$/
-    DEFAULT_ATTRIBUTES = { :deployment_percentage => 0 }.with_indifferent_access
+    DEFAULT_ATTRIBUTES = { :deployment_percentage => 0 }
 
     attr_readonly :symbol
 
@@ -25,11 +25,7 @@ module Arturo
     # @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
-
-    def self.find_feature(*args)
-      to_feature(*args)
+      self.where(:symbol => feature_or_symbol.to_sym).first
     end
 
     # Create a new Feature
@@ -60,29 +56,21 @@ module Arturo
     end
 
     def to_param
-      new_record? ? nil : "#{id}-#{symbol.to_s.parameterize}"
+      persisted? ? "#{id}-#{symbol.to_s.parameterize}" : nil
     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 || !feature_recipient.id
+      return false if threshold == 0
       return true if threshold == 100
-      (((feature_recipient.id + (self.id || 1) + 17) * 13) % 100) < threshold
+      (((feature_recipient.id + 17) * 13) % 100) < threshold
+      
     end
   end
 end

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

@@ -1,19 +1,15 @@
-<% form_for(:feature, feature,
-                      :url => (feature.new_record? ? features_path : feature_path(feature)),
-                      :html => {
-                        :method => (feature.new_record? ? :post : :put)
-                      }) do |form| %>
+<%= form_for(feature, :as => 'feature', :url => (feature.new_record? ? features_path : feature_path(feature))) do |form| %>
   <fieldset>
     <legend><%= legend %></legend>
 
-    <%= error_messages_for(:feature, :object => feature) %>
-
     <%= 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>

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

@@ -1,5 +1,5 @@
 <h2><%= t('.title') %></h2>
-<% form_tag(features_path, :method => 'put', 'data-update-path' => feature_path(:id => ':id'), :remote => true) do %>
+<%= form_tag(features_path, :method => 'put', 'data-update-path' => feature_path(:id => ':id'), :remote => true) do %>
   <fieldset>
     <legend><%= t('.title') %></legend>
     <table class='features'>

data/config/routes.rb

@@ -0,0 +1,14 @@
+# In Rails edge, the engine can have its own route set
+# and be mounted within an application at a sub-URL.
+# In 3.0.1, this is not yet available.
+
+# TODO replace this with the commented-out version below
+Rails.application.routes.draw do
+  resources :features, :controller => 'arturo/features'
+  put 'features', :to => 'arturo/features#update_all', :as => 'features'
+end
+
+# Arturo::Engine.routes.draw do
+#   resources :features, :controller => 'arturo/features'
+#   put 'features', :to => 'arturo/features#update_all', :as => 'features'
+# end

data/lib/arturo.rb

@@ -1,38 +1,9 @@
 module Arturo
 
+  require 'arturo/configuration'
   require 'arturo/special_handling'
   require 'arturo/feature_availability'
-  require 'arturo/feature_management'
-  require 'arturo/feature_caching'
   require 'arturo/controller_filters'
-  require 'arturo/range_form_support'
-  require 'arturo/middleware'
-  require 'arturo/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 2 && Rails::VERSION::MINOR == 3
+  require 'arturo/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
 
-  class <<self
-
-    # Quick check for whether a feature is enabled for a recipient.
-    # @param [String, Symbol] feature_name
-    # @param [#id] recipient
-    # @return [true,false] whether the feature exists and is enabled for the recipient
-    def feature_enabled_for?(feature_name, recipient)
-      f = self::Feature.to_feature(feature_name)
-      f && f.enabled_for?(recipient)
-    end
-
-    ENABLED_FOR_METHOD_NAME = /^(\w+)_enabled_for\?$/
-
-    def respond_to?(symbol)
-      symbol.to_s =~ ENABLED_FOR_METHOD_NAME || super(symbol)
-    end
-
-    def method_missing(symbol, *args, &block)
-      if (args.length == 1 && match = ENABLED_FOR_METHOD_NAME.match(symbol.to_s))
-        feature_enabled_for?(match[1], args[0])
-      else
-        super(symbol, *args, &block)
-      end
-    end
-
-  end
 end