arturo 2.1.0 → 4.1.1

data/lib/arturo/feature_availability.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # A mixin that provides #feature_enabled? and #if_feature_enabled
@@ -24,7 +25,7 @@ module Arturo
     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.

data/lib/arturo/feature_caching.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'arturo/no_such_feature'
 
 module Arturo
@@ -18,48 +19,63 @@ module Arturo
   # to use a shared cache like Memcached.
   module FeatureCaching
 
+    module PrependMethods
+      # Wraps Arturo::Feature.to_feature with in-memory caching.
+      def to_feature(feature_or_symbol)
+        if !caches_features?
+          super
+        elsif feature_or_symbol.kind_of?(Arturo::Feature)
+          feature_or_symbol
+        else
+          symbol = feature_or_symbol.to_sym
+          feature_caching_strategy.fetch(feature_cache, symbol) { super(symbol) }
+        end
+      end
+    end
+
     def self.extended(base)
       class << base
-        alias_method_chain :to_feature, :caching
+        prepend PrependMethods
         attr_accessor :cache_ttl, :feature_cache, :feature_caching_strategy
+        attr_writer :extend_cache_on_failure
       end
       base.send(:after_save) do |f|
         f.class.feature_caching_strategy.expire(f.class.feature_cache, f.symbol.to_sym) if f.class.caches_features?
       end
       base.cache_ttl = 0
+      base.extend_cache_on_failure = false
       base.feature_cache = Arturo::FeatureCaching::Cache.new
       base.feature_caching_strategy = AllStrategy
     end
 
-    def caches_features?
-      self.cache_ttl.to_i > 0
+    def extend_cache_on_failure?
+      !!@extend_cache_on_failure
     end
 
-    # Wraps Arturo::Feature.to_feature with in-memory caching.
-    def to_feature_with_caching(feature_or_symbol)
-      if !caches_features?
-        to_feature_without_caching(feature_or_symbol)
-      elsif feature_or_symbol.kind_of?(Arturo::Feature)
-        feature_or_symbol
-      else
-        symbol = feature_or_symbol.to_sym
-        feature_caching_strategy.fetch(feature_cache, symbol) { to_feature_without_caching(symbol) }
-      end
+    def caches_features?
+      self.cache_ttl.to_i > 0
     end
 
     def warm_cache!
-      warn "Deprecated, no longer necessary!"
+      to_feature(:fake_feature_to_force_cache_warming)
     end
 
     class AllStrategy
       class << self
+        ##
+        # @param cache [Arturo::Cache] cache backend
+        # @param symbol [Symbol] arturo identifier
+        # @return [Arturo::Feature, Arturo::NoSuchFeature] 
+        #
         def fetch(cache, symbol, &block)
-          features = cache.read("arturo.all")
-
-          unless cache_is_current?(cache, features)
-            features = Hash[Arturo::Feature.all.map { |f| [f.symbol.to_sym, f] }]
-            mark_as_current!(cache)
-            cache.write("arturo.all", features, :expires_in => Arturo::Feature.cache_ttl * 10)
+          existing_features = cache.read("arturo.all")
+
+          features = if cache_is_current?(cache, existing_features)
+            existing_features
+          else
+            arturos_from_origin(fallback: existing_features).tap do |updated_features|
+              update_and_extend_cache!(cache, updated_features)
+            end
           end
 
           features[symbol] || Arturo::NoSuchFeature.new(symbol)
@@ -69,17 +85,96 @@ module Arturo
           cache.delete("arturo.all")
         end
 
+        def register_cache_update_listener(&block)
+          cache_update_listeners << block
+        end
+
         private
 
+        def cache_update_listeners
+          @cache_update_listeners ||= []
+        end
+
+        ##
+        # @param fallback [Hash] features to use on database failure
+        # @return [Hash] updated features from origin or fallback
+        # @raise [ActiveRecord::ActiveRecordError] on database failure
+        #   without cache extension option
+        #
+        def arturos_from_origin(fallback:)
+          Arturo::Feature.all.to_h { |f| [f.symbol.to_sym, f] }
+        rescue ActiveRecord::ActiveRecordError
+          raise unless Arturo::Feature.extend_cache_on_failure?
+
+          if fallback.blank?
+            log_empty_cache
+            raise
+          else
+            log_stale_cache
+            fallback
+          end
+        end
+
+        ##
+        # @return [Boolean] whether the current cache has to be updated from origin
+        # @raise [ActiveRecord::ActiveRecordError] on database failure
+        #   without cache extension option
+        #
         def cache_is_current?(cache, features)
           return unless features
           return true if cache.read("arturo.current")
-          return false if features.values.map(&:updated_at).compact.max != Arturo::Feature.maximum(:updated_at)
+
+          begin
+            return false if origin_changed?(features)  
+          rescue ActiveRecord::ActiveRecordError
+            raise unless Arturo::Feature.extend_cache_on_failure?
+
+            if features.blank?
+              log_empty_cache
+              raise
+            else
+              log_stale_cache
+              update_and_extend_cache!(cache, features)
+            end
+
+            return true
+          end
           mark_as_current!(cache)
         end
 
+        def formatted_log(namespace, msg)
+          "[Arturo][#{namespace}] #{msg}"
+        end
+
+        def log_empty_cache
+          Arturo.logger.error(formatted_log('extend_cache_on_failure', 'Fallback cache is empty'))
+        end
+
+        def log_stale_cache
+          Arturo.logger.warn(formatted_log('extend_cache_on_failure', 'Falling back to stale cache'))
+        end
+
+        ##
+        # @return [True]
+        #
         def mark_as_current!(cache)
-          cache.write("arturo.current", true, :expires_in => Arturo::Feature.cache_ttl)
+          cache.write("arturo.current", true, expires_in: Arturo::Feature.cache_ttl)
+        end
+
+        ##
+        # The Arturo origin might return a big payload, so checking for the latest
+        # update is a cheaper operation.
+        #
+        # @return [Boolean] if origin has been updated since the last cache update.
+        #
+        def origin_changed?(features)
+          features.values.map(&:updated_at).compact.max != Arturo::Feature.maximum(:updated_at)
+        end
+
+        def update_and_extend_cache!(cache, features)
+          mark_as_current!(cache)
+          cache.write("arturo.all", features, expires_in: Arturo::Feature.cache_ttl * 10)
+          cache_update_listeners.each(&:call)
         end
       end
     end
@@ -89,7 +184,7 @@ module Arturo
         if feature = cache.read("arturo.#{symbol}")
           feature
         else
-          cache.write("arturo.#{symbol}", yield || Arturo::NoSuchFeature.new(symbol), :expires_in => Arturo::Feature.cache_ttl)
+          cache.write("arturo.#{symbol}", yield || Arturo::NoSuchFeature.new(symbol), expires_in: Arturo::Feature.cache_ttl)
         end
       end
 

data/lib/arturo/feature_factories.rb

@@ -1,8 +1,9 @@
-FactoryGirl.define do
+# frozen_string_literal: true
+FactoryBot.define do
   sequence(:feature_symbol) { |n| "feature_#{n}".to_sym }
 
   factory :feature, :class => Arturo::Feature do
     symbol                { generate(:feature_symbol) }
     deployment_percentage { rand(101) }
   end
-end
+end

data/lib/arturo/feature_management.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # A mixin that is included by Arturo::FeaturesController and is declared

data/lib/arturo/feature_methods.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Arturo
+  module FeatureMethods
+    extend ActiveSupport::Concern
+    include Arturo::SpecialHandling
+
+    SYMBOL_REGEX = /^[a-zA-z][a-zA-Z0-9_]*$/
+    DEFAULT_ATTRIBUTES = { :deployment_percentage => 0 }.with_indifferent_access
+
+    included do
+      attr_readonly :symbol
+
+      validates_presence_of :symbol, :deployment_percentage
+      validates_uniqueness_of :symbol, :allow_blank => true, :case_sensitive => false
+      validates_numericality_of :deployment_percentage,
+                                :only_integer => true,
+                                :allow_blank => true,
+                                :greater_than_or_equal_to => 0,
+                                :less_than_or_equal_to => 100
+    end
+
+    class_methods do
+      # Looks up a feature by symbol. Also accepts a Feature as input.
+      # @param [Symbol, Arturo::Feature] feature_or_symbol a Feature or the Symbol of a Feature
+      # @return [Arturo::Feature, Arturo::NoSuchFeature] the Feature if found, else Arturo::NoSuchFeature
+      def to_feature(feature_or_symbol)
+        return feature_or_symbol if feature_or_symbol.kind_of?(self)
+
+        symbol = feature_or_symbol.to_sym.to_s
+        self.where(:symbol => symbol).first || Arturo::NoSuchFeature.new(symbol)
+      end
+
+      # Looks up a feature by symbol. Also accepts a Feature as input.
+      # @param [Symbol, Arturo::Feature] feature_or_symbol a Feature or the Symbol of a Feature
+      # @return [Arturo::Feature, nil] the Feature if found, else nil
+      def find_feature(feature_or_symbol)
+        feature = to_feature(feature_or_symbol)
+        feature.is_a?(Arturo::NoSuchFeature) ? nil : feature
+      end
+
+      def last_updated_at
+        maximum(:updated_at)
+      end
+    end
+
+    # Create a new Feature
+    def initialize(*args, &block)
+      args[0] = DEFAULT_ATTRIBUTES.merge(args[0].try(:to_h) || {})
+      super(*args, &block)
+    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, deployment_percentage || 0)
+    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
+
+    # made public so as to allow for thresholds stored outside of the model
+    def passes_threshold?(feature_recipient, threshold)
+      return true if threshold == 100
+      return false if threshold == 0 || !feature_recipient.id
+      (((feature_recipient.id + (self.id || 1) + 17) * 13) % 100) < threshold
+    end
+  end
+end

data/lib/arturo/feature_params_support.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # Mix in to FeaturesController. Provides the logic for getting parameters
@@ -18,14 +19,16 @@ module Arturo
       PERMITTED_ATTRIBUTES = [ :symbol, :deployment_percentage ]
 
       def feature_params
-        params.permit(:feature => PERMITTED_ATTRIBUTES)[:feature]
+        if feature = params[:feature]
+          feature.permit(PERMITTED_ATTRIBUTES)
+        end
       end
 
       def features_params
-        permitted = PERMITTED_ATTRIBUTES
         features = params[:features]
         features.each do |id, attributes|
-          features[id] = ActionController::Parameters.new(attributes).permit(*permitted)
+          attributes = attributes.to_unsafe_h if attributes.respond_to?(:to_unsafe_h)
+          features[id] = ActionController::Parameters.new(attributes).permit(*PERMITTED_ATTRIBUTES)
         end
       end
     end
@@ -35,4 +38,3 @@ module Arturo
   end
 
 end
-

data/lib/arturo/middleware.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
   # A Rack middleware that requires a feature to be present. By default,
   # checks feature availability against an `arturo.recipient` object

data/lib/arturo/no_such_feature.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # A Null-Object stand-in for a Feature.

data/lib/arturo/null_logger.rb

@@ -0,0 +1,8 @@
+module Arturo
+  class NullLogger
+    %w[info debug error fatal warn].each do |level|
+      define_method level do |_message|
+      end
+    end
+  end
+end

data/lib/arturo/special_handling.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
 module Arturo
 
   # Adds whitelist and blacklist support to individual features by name
@@ -24,13 +28,9 @@ module Arturo
   # This is particularly important if your application runs in several
   # different processes or on several servers.
   module SpecialHandling
+    extend ActiveSupport::Concern
 
-    def self.included(base)
-      base.extend Arturo::SpecialHandling::ClassMethods
-    end
-
-    module ClassMethods
-
+    class_methods do
       def whitelists
         @whitelists ||= []
       end

data/lib/arturo/test_support.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Arturo.instance_eval do
 
   # Enable a feature; create it if necessary.
@@ -9,7 +10,7 @@ Arturo.instance_eval do
   def enable_feature!(name)
     if feature = Arturo::Feature.find_feature(name)
       feature = feature.class.find(feature.id) if feature.frozen?
-      feature.update_attributes(:deployment_percentage => 100)
+      feature.update(:deployment_percentage => 100)
     else
       Arturo::Feature.create!(:symbol => name, :deployment_percentage => 100)
     end
@@ -24,7 +25,7 @@ Arturo.instance_eval do
   def disable_feature!(name)
     if feature = Arturo::Feature.find_feature(name)
       feature = feature.class.find(feature.id) if feature.frozen?
-      feature.update_attributes(:deployment_percentage => 0)
+      feature.update(:deployment_percentage => 0)
     end
   end
 

data/lib/arturo/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Arturo
+  VERSION = '4.1.1'
+end

data/lib/arturo.rb

@@ -1,19 +1,41 @@
-module Arturo
+# frozen_string_literal: true
 
-  require 'arturo/special_handling'
-  require 'arturo/feature_availability'
-  require 'arturo/feature_management'
-  require 'arturo/feature_caching'
-  require 'arturo/engine' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+require_relative 'arturo/null_logger'
+require_relative 'arturo/special_handling'
+require_relative 'arturo/feature_methods'
+require_relative 'arturo/feature_availability'
+require_relative 'arturo/feature_management'
+require_relative 'arturo/feature_caching'
+require_relative 'arturo/controller_filters'
 
+module Arturo
   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)
+      return false if recipient.nil?
+
       f = self::Feature.to_feature(feature_name)
       f && f.enabled_for?(recipient)
     end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger || NullLogger.new
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_controller) do
+  include Arturo::FeatureAvailability
+  include Arturo::ControllerFilters
+  if respond_to?(:helper)
+    helper Arturo::FeatureAvailability
+    helper Arturo::FeatureManagement
   end
 end

data/lib/generators/arturo/assets_generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rails/generators'
 
 module Arturo

data/lib/generators/arturo/feature_model_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'rails/generators'
+
+module Arturo
+  class FeatureModelGenerator < Rails::Generators::Base
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def copy_feature_model_file
+      copy_file "feature.rb", "app/models/arturo/feature.rb"
+    end
+  end
+end

data/lib/generators/arturo/initializer_generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rails/generators'
 
 module Arturo

data/lib/generators/arturo/migration_generator.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 require 'rails/generators/migration'
+require 'rails/generators/active_record'
 
 module Arturo
   class MigrationGenerator < Rails::Generators::Base
@@ -9,19 +12,16 @@ module Arturo
       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
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
     end
 
     def create_migration_file
-      migration_template 'migration.rb', 'db/migrate/create_features.rb'
+      migration_template 'migration.erb', 'db/migrate/create_features.rb', { migration_version: migration_version }
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
     end
   end
 end

data/lib/generators/arturo/routes_generator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rails/generators'
 
 module Arturo

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Arturo
+  class Feature < ::ActiveRecord::Base
+    include Arturo::FeatureMethods
+  end
+end

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'arturo'
 require 'arturo/feature'
 

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateFeatures < ActiveRecord::Migration<%= migration_version %>
+  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