arturo 2.2.0 → 3.0.0

data/lib/arturo/feature.rb

@@ -1,41 +1,49 @@
+# frozen_string_literal: true
 require 'active_record'
+require 'active_support'
 
-# a stub
-# possible TODO: remove and and refactor into an acts_as_feature mixin
 module Arturo
-  class Feature < ::ActiveRecord::Base
-
+  module FeatureMethods
+    extend ActiveSupport::Concern
     include Arturo::SpecialHandling
 
-    Arturo::Feature::SYMBOL_REGEX = /^[a-zA-z][a-zA-Z0-9_]*$/
+    SYMBOL_REGEX = /^[a-zA-z][a-zA-Z0-9_]*$/
     DEFAULT_ATTRIBUTES = { :deployment_percentage => 0 }.with_indifferent_access
 
-    attr_accessible :symbol, :deployment_percentage if ActiveRecord::VERSION::MAJOR < 4
-    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 Arturo::NoSuchFeature
-    def self.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)
+    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
 
-    # 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.find_feature(feature_or_symbol)
-      feature = to_feature(feature_or_symbol)
-      feature.is_a?(Arturo::NoSuchFeature) ? nil : feature
+    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
@@ -54,11 +62,12 @@ module Arturo
       return false if feature_recipient.nil?
       return false if blacklisted?(feature_recipient)
       return true if  whitelisted?(feature_recipient)
-      passes_threshold?(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
 
@@ -74,14 +83,8 @@ module Arturo
       "<Arturo::Feature #{name}, deployed to #{deployment_percentage}%>"
     end
 
-    def self.last_updated_at
-      maximum(:updated_at)
-    end
-
-    protected
-
-    def passes_threshold?(feature_recipient)
-      threshold = self.deployment_percentage || 0
+    # 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

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
@@ -36,32 +37,45 @@ module Arturo
       class << base
         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 extend_cache_on_failure?
+      !!@extend_cache_on_failure
+    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)
@@ -71,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
@@ -91,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_params_support.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # Mix in to FeaturesController. Provides the logic for getting parameters

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 = '3.0.0'
+end

data/lib/arturo.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 module Arturo
-
+  require 'arturo/null_logger'
   require 'arturo/special_handling'
+  require 'arturo/feature'
   require 'arturo/feature_availability'
   require 'arturo/feature_management'
   require 'arturo/feature_caching'
-  require 'arturo/engine' if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR >= 3
+  require 'arturo/engine' if defined?(Rails)
 
   class << self
     # Quick check for whether a feature is enabled for a recipient.
@@ -15,5 +17,13 @@ module Arturo
       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

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