ee_arturo 1.3.4

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,10 @@
+module Arturo
+  class Engine < ::Rails::Engine
+    ActiveSupport.on_load(:action_controller) do
+      include Arturo::FeatureAvailability
+      helper  Arturo::FeatureAvailability
+      include Arturo::ControllerFilters
+      helper  Arturo::FeatureManagement
+    end
+  end
+end

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_caching.rb

@@ -0,0 +1,83 @@
+module Arturo
+
+  # To be extended by Arturo::Feature if you want to enable
+  # in-memory caching.
+  # NB: Arturo's feature caching only works when using
+  # Arturo::Feature.to_feature or when using the helper methods
+  # in Arturo and Arturo::FeatureAvailability.
+  # NB: if you have multiple application servers, you almost certainly
+  # want to clear this cache after each request:
+  #
+  #   class ApplicationController < ActionController::Base
+  #     after_filter { Arturo::Feature.clear_feature_cache }
+  #   end
+  #
+  # Alternatively, you could redefine Arturo::Feature.feature_cache
+  # to use a shared cache like Memcached.
+  module FeatureCaching
+
+    def self.extended(base)
+      class <<base
+        alias_method_chain :to_feature, :caching
+        attr_accessor :cache_ttl, :feature_cache, :nil_marker
+      end
+      base.cache_ttl = 0
+      base.feature_cache = Arturo::FeatureCaching::Cache.new
+      base.nil_marker = Arturo::Feature.new
+    end
+
+    def caches_features?
+      self.cache_ttl.to_i > 0
+    end
+
+    # Wraps Arturo::Feature.to_feature with in-memory caching.
+    def to_feature_with_caching(feature_or_symbol)
+      if !self.caches_features?
+        return to_feature_without_caching(feature_or_symbol)
+      elsif (feature_or_symbol.kind_of?(Arturo::Feature))
+        feature_cache.write(feature_or_symbol.symbol, feature_or_symbol, :expires_in => cache_ttl)
+        feature_or_symbol
+      elsif (cached_feature = feature_cache.read(feature_or_symbol.to_sym))
+        cached_feature == nil_marker ? nil : cached_feature
+      else
+        f = to_feature_without_caching(feature_or_symbol)
+        feature_cache.write(feature_or_symbol.to_sym, f.nil? ? nil_marker : f, :expires_in => cache_ttl)
+        f
+      end
+    end
+
+    protected
+
+    # Quack like a Rails cache.
+    class Cache
+      def initialize
+        @data = {} # of the form {key => [value, expires_at or nil]}
+      end
+      def read(name, options = nil)
+        name = name.to_s
+        value, expires_at = *@data[name]
+        if value && (expires_at.blank? || expires_at > Time.now)
+          value
+        else
+          nil
+        end
+      end
+      def write(name, value, options = nil)
+        name = name.to_s
+        expires_at = if options && options.respond_to?(:[]) && options[:expires_in]
+          Time.now + options.delete(:expires_in)
+        else
+          nil
+        end
+        value.freeze.tap do |val|
+          @data[name] = [value, expires_at]
+        end
+      end
+      def clear
+        @data.clear
+      end
+    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/middleware.rb

@@ -0,0 +1,60 @@
+module Arturo
+  # A Rack middleware that requires a feature to be present. By default,
+  # checks feature availability against an `arturo.recipient` object
+  # in the `env`. If that object is missing, this middleware always fails,
+  # even if the feature is available for everyone.
+  #
+  # ## Usage
+  #
+  #     use Arturo::Middleware, :feature => :foo
+  #
+  # ## Options
+  #
+  #  * feature -- the name of the feature to require, as a Symbol; required
+  #
+  #  * recipient -- the key in the `env` hash under which the feature
+  #                 recipient can be found; defaults to "arturo.recipient".
+  #  * on_unavailable -- a Rack-like object
+  #                      (has `#call(Hash) -> [status, headers, body]`) that
+  #                      is called when the feature is unavailable; defaults
+  #                      to returning `[ 404, {}, ['Not Found'] ]`.
+  class Middleware
+
+    MISSING_FEATURE_ERROR = "Cannot create an Arturo::Middleware without a :feature"
+
+    DEFAULT_RECIPIENT_KEY = 'arturo.recipient'
+
+    DEFAULT_ON_UNAVAILABLE = lambda { |env| [ 404, {}, ['Not Found'] ] }
+
+    def initialize(app, options = {})
+      @app = app
+      @feature = options[:feature]
+      raise ArgumentError.new(MISSING_FEATURE_ERROR) unless @feature
+      @recipient_key = options[:recipient] || DEFAULT_RECIPIENT_KEY
+      @on_unavailable = options[:on_unavailable] || DEFAULT_ON_UNAVAILABLE
+    end
+
+    def call(env)
+      if enabled_for_recipient?(env)
+        @app.call(env)
+      else
+        fail(env)
+      end
+    end
+
+    private
+
+    def enabled_for_recipient?(env)
+      ::Arturo.feature_enabled_for?(@feature, recipient(env))
+    end
+
+    def recipient(env)
+      env[@recipient_key]
+    end
+
+    def fail(env)
+      @on_unavailable.call(env)
+    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/arturo/test_support.rb

@@ -0,0 +1,30 @@
+Arturo.instance_eval do
+
+  # Enable a feature; create it if necessary.
+  # For use in testing. Not auto-required on load. To load,
+  #
+  #   require 'arturo/test_support'
+  #
+  # @param [Symbol, String] name the feature name
+  def enable_feature!(name)
+    feature = Arturo::Feature.to_feature(name)
+    if feature
+      feature.update_attributes(:deployment_percentage => 100)
+    else
+      Arturo::Feature.create!(:symbol => name, :deployment_percentage => 100)
+    end
+  end
+
+  # Disable a feature if it exists.
+  # For use in testing. Not auto-required on load. To load,
+  #
+  #   require 'arturo/test_support'
+  #
+  # @param [Symbol, String] name the feature name
+  def disable_feature!(name)
+    if (feature = Arturo::Feature.to_feature(name))
+      feature.update_attributes(:deployment_percentage => 0)
+    end
+  end
+
+end

data/lib/arturo.rb

@@ -0,0 +1,37 @@
+module Arturo
+
+  require 'arturo/special_handling'
+  require 'arturo/feature_availability'
+  require 'arturo/feature_management'
+  require 'arturo/feature_caching'
+  require 'arturo/controller_filters'
+  require 'arturo/middleware'
+  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

data/lib/generators/arturo/assets_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+
+module Arturo
+  class AssetsGenerator < Rails::Generators::Base
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def copy_assets
+      copy_file 'arturo.css',                 'public/stylesheets/arturo.css', :force => true
+      copy_file 'arturo_customizations.css',  'public/stylesheets/arturo_customizations.css', :skip => true
+      copy_file 'arturo.js',                  'public/javascripts/arturo.js'
+      copy_file 'semicolon.png',              'public/images/semicolon.png'
+    end
+
+  end
+end
+

data/lib/generators/arturo/initializer_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators'
+
+module Arturo
+  class InitializerGenerator < Rails::Generators::Base
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def copy_initializer_file
+      copy_file "initializer.rb", "config/initializers/arturo_initializer.rb"
+    end
+  end
+end

data/lib/generators/arturo/migration_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Arturo
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+     # Implement the required interface for Rails::Generators::Migration.
+     # taken from
+     # http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+    def self.next_migration_number(dirname) #:nodoc:
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/create_features.rb'
+    end
+  end
+end

data/lib/generators/arturo/routes_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators'
+
+module Arturo
+  class RoutesGenerator < Rails::Generators::Base
+
+    def add_mount
+      if Arturo::Engine.respond_to?(:routes)
+        route "mount Arturo::Engine => ''"
+      else
+        puts "This version of Rails doesn't support Engine-specific routing. Nothing to do."
+      end
+    end
+
+  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