arturo 2.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e275461050b9b145ee015ef8344c75c5acdaef28
-  data.tar.gz: 32ddd85665d038f1edf89a82542f85d8f321a3b0
+SHA256:
+  metadata.gz: f3dd4873bb989ef7051937ac1b4ba16a49cc5691cc920d51b6714f330cd6b191
+  data.tar.gz: 0e8dfa652180dcba96d51779fa5734a128f1233b01467c4d77f79b80dadfcc23
 SHA512:
-  metadata.gz: 5fc9a22f85c3e363c4c5364181d655ba67b62018c6d7ec9dc93fbdfd5c46bfb53f3c41fb1839c97bf4f61d50c6903ecb2532bcae88f220ed71c6b8b17c6f5a9f
-  data.tar.gz: 69f0ca4bd8b469737eba1289b492250f8924b29cf84a729f171cf7f060236eafa868dbdf699491615d5a0601a54b33b81bfd2de56afd5d57cf3dfee82c45d0f5
+  metadata.gz: 1f8df1180d466898b1f0992e15fedf692769cee73a52efcd6d905d0ec9a09d2f69eb7a69a847e9a724ec8ab25ef01c8417f9854a0400ddc222efc5fa0583fe83
+  data.tar.gz: 719901f7640c53c7f767c6d0a7c5249029e40ea6b0903b4554f2030417b8374e400902eff2d22cf5afe24987a78eb20f51c5ae4dde93cd123204a71f49c61e59

data/CHANGELOG.md

@@ -1,3 +1,93 @@
+## Unreleased
+
+## v4.1.1
+
+Fixes missing indifferent_access import
+
+## v4.1.0
+
+Removes upper boundary on ActiveRecord.
+
+Drops support for Ruby < 3.0.
+
+Drops support for Rails < 6.0.
+
+## v4.0.1
+
+Fixes loading issues for apps not using the Rails engine.
+
+## v4.0.0
+
+Stops loading the Rails engine automatically. If you are using the engine, you need to require it explicitly by adding `require 'arturo/engine'` to `application.rb`.
+
+Adds support for Ruby 3.3.
+
+Returns false immediately for `feature_enabled_for?` calls with `nil` recipients.
+
+## v3.0.0
+
+Converts the Feature model into a mixin that should be used by services via a model generator.
+
+Brings back the `warm_cache!` method.
+
+Adds support for Rails 7.1.
+
+## v2.8.0
+
+Drop support for Ruby 2.6
+
+Drop Support for Rails 5.0 & 5.1
+
+Add support for Ruby 3.2
+
+## v2.7.0
+
+Adds ability to register cache update listeners with Arturo::FeatureCaching::AllStrategy that are called when the cache is updated
+
+## v2.6.0
+
+Add support for Rails 7.0
+
+Add support for Ruby 3.0 & 3.1
+
+Drop support for Rails 4.2
+
+Drop support for Ruby 2.4 & 2.5
+
+## v2.5.4
+
+Bug fix: Explicitly require rails engine to avoid errors that ::Rails::Engine cannot be found.
+
+## v2.5.3
+
+Bug fix: Allow using Arturo with ActiveRecord, but without all of Rails.
+
+## v2.5.2
+
+Drop support for Rails 3.2.
+
+Add support for Rails 6.1.
+
+Switch CI from Travis to GitHub Actions.
+
+## v2.2.0
+
+Bug fix: making a feature-update request that fails strict params checks now returns a sensible error instead of throwing an exception
+
+Improvement: better failed-to-update error messages
+
+Support Matrix changes: add Rails 5.0, drop Rails 3.2, add Ruby 2.1.7, add Ruby 2.2.3, drop Ruby 1.9.3
+
+## v2.1.0
+
+Bug fix: `Arturo::SpecialHandling` always compares symbols as strings
+
+Improvmement: Rails 4.2 compatibility
+
+Improvement: relax minitest version constraints
+
+Improvement: add `set_feature!` method to complement `enable_feature!`and `disable_feature!`
+
 ## v2.0.0
 
 Bug fix: add missing require to initializer.

data/README.md

@@ -2,16 +2,14 @@
 
 Arturo provides feature sliders for Rails. It lets you turn features on and off
 just like
-[feature flippers](http://code.flickr.com/blog/2009/12/02/flipping-out/),
+[feature flippers](https://code.flickr.net/2009/12/02/flipping-out/),
 but offers more fine-grained control. It supports deploying features only for
-a given percent* of your users and whitelisting and blacklisting users based
+a given percentage of your users and whitelisting and blacklisting users based
 on any criteria you can express in Ruby.
 
-    * The selection isn't random. It's not even pseudo-random. It's completely
-      deterministic. This assures that if a user has a feature on Monday, the
-      user will still have it on Tuesday (unless, of course, you *decrease*
-      the feature's deployment percentage or change its white- or blacklist
-      settings).
+The selection is deterministic. So if a user has a feature on Monday, the
+user will still have it on Tuesday (unless you *decrease* the feature's
+deployment percentage or change its white- or blacklist settings).
 
 ### A quick example
 
@@ -19,38 +17,44 @@ Trish, a developer is working on a new feature: a live feed of recent postings
 in the user's city that shows up in the user's sidebar. First, she uses Arturo's
 view helpers to control who sees the sidebar widget:
 
-    <%# in app/views/layout/_sidebar.html.erb: %>
-    <% if_feature_enabled(:live_postings) do %>
-    <div class='widget'>
-      <h3>Recent Postings</h3>
-      <ol id='live_postings'>
-      </ol>
-    </div>
-    <% end %>
+```ERB
+<%# in app/views/layout/_sidebar.html.erb: %>
+  <% if_feature_enabled(:live_postings) do %>
+  <div class='widget'>
+    <h3>Recent Postings</h3>
+    <ol id='live_postings'>
+    </ol>
+  </div>
+<% end %>
+```
 
 Then Trish writes some Javascript that will poll the server for recent
 postings and put them in the sidebar widget:
 
-    // in public/javascript/live_postings.js:
-    $(function() {
-      var livePostingsList = $('#live_postings');
-      if (livePostingsList.length > 0) {
-        var updatePostingsList = function() {
-          livePostingsList.load('/listings/recent');
-          setTimeout(updatePostingsList, 30);
-        }
-        updatePostingsList();
-      }
-    });
+```js
+// in public/javascript/live_postings.js:
+$(function() {
+  var livePostingsList = $('#live_postings');
+  if (livePostingsList.length > 0) {
+    var updatePostingsList = function() {
+      livePostingsList.load('/listings/recent');
+      setTimeout(updatePostingsList, 30);
+    }
+    updatePostingsList();
+  }
+});
+```
 
 Trish uses Arturo's Controller filters to control who has access to
 the feature:
 
-    # in app/controllers/postings_controller:
-    class PostingsController < ApplicationController
-      require_feature :live_postings, :only => :recent
-      # ...
-    end
+```Ruby
+# in app/controllers/postings_controller:
+class PostingsController < ApplicationController
+  require_feature :live_postings, only: :recent
+  # ...
+end
+```
 
 Trish then deploys this code to production. Nobody will see the feature yet,
 since it's not on for anyone. (In fact, the feature doesn't yet exist
@@ -66,18 +70,9 @@ feature and deploy it to all users.
 
 ## Installation
 
-### In Rails 3 or 4, with Bundler
-
-    gem 'arturo', '~> 1.0'
-
-### In Rails 3 or 4, without Bundler
-
-    $ gem install arturo --version="~> 1.0"
-
-### In Rails 2.3
-
-Rails 2.3 is no longer supported and has been archived on the
-[`rails_2_3` branch](http://github.com/jamesarosen/arturo/tree/rails_2_3).
+```Ruby
+gem 'arturo'
+```
 
 ## Configuration
 
@@ -85,24 +80,34 @@ Rails 2.3 is no longer supported and has been archived on the
 
 #### Run the generators:
 
-    $ rails g arturo:migration
-    $ rails g arturo:initializer
-    $ rails g arturo:routes
-    $ rails g arturo:assets
+```
+rails g arturo:migration
+rails g arturo:initializer
+rails g arturo:routes
+rails g arturo:assets
+rails g arturo:feature_model
+```
 
 #### Run the migration:
 
-    $ rake db:migrate
+```
+rake db:migrate
+```
 
 #### Edit the generated migration as necessary
 
 #### Edit the configuration
 
+#### Edit the Feature model
+
+By default, the generated model `Arturo::Feature` inherits from `ActiveRecord::Base`. However, if you’re using multiple databases your models should inherit from an abstract class that specifies a database connection, not directly from `ActiveRecord::Base`. Update the generated model in `app/models/arturo/feature.rb` to make it use a correct database.
+
 ##### Initializer
 
 Open up the newly-generated `config/initializers/arturo_initializer.rb`.
 There are configuration options for the following:
 
+ * logging capabilities (see [logging](#logging))
  * the method that determines whether a user has permission to manage features
    (see [admin permissions](#adminpermissions))
  * the method that returns the object that has features
@@ -113,20 +118,29 @@ There are configuration options for the following:
 
 ##### CSS
 
-Open up the newly-generated `public/stylehseets/arturo_customizations.css`.
+Open up the newly-generated `public/stylesheets/arturo_customizations.css`.
 You can add any overrides you like to the feature configuration page styles
-here. **Do not** edit `public/stylehseets/arturo.css` as that file may be
+here. **Do not** edit `public/stylesheets/arturo.css` as that file may be
 overwritten in future updates to Arturo.
 
 ### In other frameworks
 
 Arturo is a Rails engine. I want to promote reuse on other frameworks by
 extracting key pieces into mixins, though this isn't done yet. Open an
-[issue](http://github.com/jamesarosen/arturo/issues) and I'll be happy to
+[issue](http://github.com/zendesk/arturo/issues) and I'll be happy to
 work with you on support for your favorite framework.
 
 ## Deep-Dive
 
+### <span id='logging'>Logging</span>
+
+You can provide a logger in order to inspect Arturo usage.
+A potential implementation for Rails would be:
+
+```Ruby
+Arturo.logger = Rails.logger
+```
+
 ### <span id='adminpermissions'>Admin Permissions</span>
 
 `Arturo::FeatureManagement#may_manage_features?` is a method that is run in
@@ -134,15 +148,19 @@ 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?
+```Ruby
+current_user.present? && current_user.admin?
+```
 
 You can change the implementation in
 `config/initializers/arturo_initializer.rb`. A reasonable implementation
 might be
 
-    Arturo.permit_management do
-      signed_in? && current_user.can?(:manage_features)
-    end
+```Ruby
+Arturo.permit_management do
+  signed_in? && current_user.can?(:manage_features)
+end
+```
 
 ### <span id='featurerecipients'>Feature Recipients</span>
 
@@ -163,15 +181,19 @@ The default implementation simply returns `current_user`. Like
 in `config/initializers/arturo_initializer.rb`. If you want to deploy features
 on a per-account basis, a reasonable implementation might be
 
-    Arturo.feature_recipient do
-      current_account
-    end
+```Ruby
+Arturo.feature_recipient do
+  current_account
+end
+```
 
 or
 
-    Arturo.feature_recipient do
-      current_user.account
-    end
+```Ruby
+Arturo.feature_recipient do
+  current_user.account
+end
+```
 
 If the block returns `nil`, the feature will be disabled.
 
@@ -182,24 +204,30 @@ will have a feature. For example, if all premium users should have the
 `:awesome` feature, place the following in
 `config/initializers/arturo_initializer.rb`:
 
-    Arturo::Feature.whitelist(:awesome) do |user|
-      user.account.premium?
-    end
+```Ruby
+Arturo::Feature.whitelist(:awesome) do |user|
+  user.account.premium?
+end
+```
 
 If, on the other hand, no users on the free plan should have the
 `:awesome` feature, place the following in
 `config/initializers/arturo_initializer.rb`:
 
-    Arturo::Feature.blacklist(:awesome) do |user|
-      user.account.free?
-    end
+```Ruby
+Arturo::Feature.blacklist(:awesome) do |user|
+  user.account.free?
+end
+```
 
 If you want to whitelist or blacklist large groups of features at once, you
 can move the feature argument into the block:
 
-    Arturo::Feature.whitelist do |feature, user|
-      user.account.has?(feature.to_sym)
-    end
+```Ruby
+Arturo::Feature.whitelist do |feature, user|
+  user.account.has?(feature.to_sym)
+end
+```
 
 ### Feature Conditionals
 
@@ -214,12 +242,14 @@ use a before filter. The following will raise a 403 Forbidden error for
 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
-    end
+```Ruby
+class BookHoldsController < ApplicationController
+  require_feature :hold_book
+end
+```
 
 `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
+to `before_action`, so you can use `:only` and `:except` to specify exactly
 which actions are filtered.
 
 If you want to customize the page that is rendered on 403 Forbidden
@@ -229,26 +259,32 @@ check there before falling back on Arturo's forbidden page.
 
 #### Conditional Evaluation
 
-Both controllers and views have access to the `if_feature_enabled` and
+Both controllers and views have access to the `if_feature_enabled?` and
 `feature_enabled?` methods. The former is used like so:
 
-    <% if_feature_enabled?(:reserve_table) %>
-      <%= link_to 'Reserve a table', new_restaurant_reservation_path(:restaurant_id => @restaurant) %>
-    <% end %>
+```ERB
+<% if_feature_enabled?(:reserve_table) %>
+  <%= link_to 'Reserve a table', new_restaurant_reservation_path(:restaurant_id => @restaurant) %>
+<% end %>
+```
 
 The latter can be used like so:
 
-    def widgets_for_sidebar
-      widgets = []
-      widgets << twitter_widget if feature_enabled?(:twitter_integration)
-      ...
-      widgets
-    end
+```Ruby
+def widgets_for_sidebar
+  widgets = []
+  widgets << twitter_widget if feature_enabled?(:twitter_integration)
+  ...
+  widgets
+end
+```
 
 #### Rack Middleware
 
-    require 'arturo'
-    use Arturo::Middleware, :feature => :my_feature
+```Ruby
+require 'arturo'
+use Arturo::Middleware, feature: :my_feature
+```
 
 #### Outside a Controller
 
@@ -256,11 +292,15 @@ 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)
+```Ruby
+Arturo.feature_enabled_for?(:foo, recipient)
+```
 
 or the slightly fancier
 
-    Arturo.foo_enabled_for?(recipient)
+```Ruby
+Arturo.foo_enabled_for?(recipient)
+```
 
 Both check whether the `foo` feature exists and is enabled for `recipient`.
 
@@ -276,15 +316,24 @@ To enable caching `Feature` lookups, mix `Arturo::FeatureCaching` into
 `Arturo::Feature` and set the `cache_ttl`. This is best done in an
 initializer:
 
-    Arturo::Feature.extend(Arturo::FeatureCaching)
-    Arturo::Feature.cache_ttl = 10.minutes
+```Ruby
+Arturo::Feature.extend(Arturo::FeatureCaching)
+Arturo::Feature.cache_ttl = 10.minutes
+```
 
 You can also warm the cache on startup:
 
-    Arturo::Feature.warm_cache!
+```Ruby
+Arturo::Feature.warm_cache!
+```
 
 This will pre-fetch all `Feature`s and put them in the cache.
 
+To use the current cache state when you can't fetch updates from origin:
+
+```Ruby
+Arturo::Feature.extend_cache_on_failure = true
+```
 
 The following is the **intended** support for integration with view caching:
 
@@ -302,6 +351,6 @@ on [Sliders](http://en.wikipedia.org/wiki/Sliders).
 
 ## Quality Metrics
 
-[![Build Status](https://travis-ci.org/jamesarosen/arturo.png?branch=master)](https://travis-ci.org/jamesarosen/arturo)
+[![Build Status](https://github.com/zendesk/arturo/workflows/CI/badge.svg)](https://github.com/zendesk/arturo/actions?query=workflow%3ACI)
 
-[![Code Quality](https://codeclimate.com/github/jamesarosen/arturo.png)](https://codeclimate.com/github/jamesarosen/arturo)
+[![Code Quality](https://codeclimate.com/github/zendesk/arturo.png)](https://codeclimate.com/github/zendesk/arturo)

data/app/controllers/arturo/features_controller.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'action_controller'
 require 'arturo/feature_params_support'
 
@@ -13,17 +14,10 @@ module Arturo
     include Arturo::FeatureManagement
     include Arturo::FeatureParamsSupport
 
-    unloadable
     respond_to :html, :json, :xml
-    before_filter :require_permission
-    before_filter :load_feature, :only => [ :show, :edit, :update, :destroy ]
 
-    if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
-      def arturo_engine
-        self
-      end
-      helper_method :arturo_engine
-    end
+    before_action :require_permission
+    before_action :load_feature, :only => [ :show, :edit, :update, :destroy ]
 
     def index
       @features = Arturo::Feature.all
@@ -37,7 +31,7 @@ module Arturo
         feature = Arturo::Feature.find_by_id(id)
         if feature.blank?
           errors << t('arturo.features.flash.no_such_feature', :id => id)
-        elsif feature.update_attributes(attributes)
+        elsif feature.update(attributes)
           updated_count += 1
         else
           errors << t('arturo.features.flash.error_updating', :id => id, :errors => feature.errors.full_messages.to_sentence)
@@ -76,11 +70,11 @@ module Arturo
     end
 
     def update
-      if @feature.update_attributes(feature_params)
+      if @feature.update(feature_params)
         flash[:notice] = t('arturo.features.flash.updated', :name => @feature.to_s)
         redirect_to arturo_engine.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.name, :errors => @feature.errors.full_messages.join("\n"))
         render :action => 'edit'
       end
     end
@@ -110,4 +104,3 @@ module Arturo
   end
 
 end
-

data/app/helpers/arturo/features_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
   module FeaturesHelper
     include ActionView::Helpers::TagHelper

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <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>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <%= form_for(feature, :as => 'feature', :url => (feature.new_record? ? arturo_engine.features_path : arturo_engine.feature_path(feature))) do |form| %>
   <fieldset>
     <legend><%= legend %></legend>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <h2><%= t('.title', :name => @feature.name) %></h2>
 
 <%= arturo_flash_messages %>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <h2><%= t('.title') %></h2>
 
 <%= arturo_flash_messages %>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <h2><%= t('.title') %></h2>
 
 <%= arturo_flash_messages %>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <h2><%= t('.title') %></h2>
 
 <%= arturo_flash_messages %>

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

@@ -1,3 +1,4 @@
+<%# frozen_string_literal: true %>
 <h2><%= t('.title', :name => @feature.name) %></h2>
 
 <%= arturo_flash_messages %>

data/config/locales/en.yml

@@ -35,7 +35,7 @@ en:
         created: "Created %{name}"
         error_creating: "Sorry, there was an error creating the feature."
         updated: "Updated %{name}"
-        error_updating: "Could not update feature #%{id}: %{errors}."
+        error_updating: "Could not update %{name}: %{errors}."
         removed: "Removed %{name}"
         error_removing: "Sorry, there was an error removing %{name}"
     no_such_feature:

data/config/routes.rb

@@ -1,13 +1,5 @@
-if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
-  Rails.application.routes.draw do
-    scope "/arturo" do
-      resources :features, :controller => "arturo/features"
-      put 'features', :to => 'arturo/features#update_all', :as => 'features'
-    end
-  end
-else
-  Arturo::Engine.routes.draw do
-    resources :features, :controller => 'arturo/features'
-    put 'features', :to => 'arturo/features#update_all', :as => 'features_update_all'
-  end
+# frozen_string_literal: true
+Arturo::Engine.routes.draw do
+  resources :features, :controller => 'arturo/features'
+  put 'features', :to => 'arturo/features#update_all', :as => 'features_update_all'
 end

data/lib/arturo/controller_filters.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arturo
 
   # Adds before filters to controllers for specifying that actions
@@ -13,13 +14,13 @@ module Arturo
     end
 
     def on_feature_disabled(feature_name)
-      render :text => 'Forbidden', :status => 403
+      render :plain => 'Forbidden', :status => 403
     end
 
     module ClassMethods
 
       def require_feature(name, options = {})
-        before_filter options do |controller|
+        send(:before_action, options) do |controller|
           unless controller.feature_enabled?(name)
             controller.on_feature_disabled(name)
           end

data/lib/arturo/engine.rb

@@ -1,15 +1,9 @@
-require 'arturo/controller_filters'
+# frozen_string_literal: true
 require 'arturo/middleware'
+require 'rails/engine'
 
 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
-
     root = File.expand_path("../../..", __FILE__)
     config.autoload_paths = ["#{root}/app/helpers", "#{root}/app/controllers"]
     config.eager_load_paths = []