enphase-arturo 1.3.2

data/app/models/arturo/feature.rb

@@ -0,0 +1,75 @@
+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 }.with_indifferent_access
+
+    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.where(:symbol => feature_or_symbol.to_sym).first
+    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
+      persisted? ? "#{id}-#{symbol.to_s.parameterize}" : nil
+    end
+
+    def inspect
+      "<Arturo::Feature #{name}, deployed to #{deployment_percentage}%>"
+    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 + (self.id || 1) + 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/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

@@ -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/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