arturo 0.2.3.8 → 1.0.0

data/HISTORY.md

@@ -1,16 +0,0 @@
-## v 1.1.0 - cleanup
- * changed `require_feature!` to `require_feature`
- * replaced `Arturo.permit_management` and `Arturo.feature_recipient`
-   blocks with instance methods
-   `Arturo::FeatureManagement.may_manage_features?` and
-   `Arturo::FeatureAvailability.feature_recipient`
-
-## v 1.0.0 - Initial Release
- * `require_feature!` controller filter
- * `if_feature_enabled` controller and view method
- * `feature_enabled?` controller and view method
- * CRUD for features
- * `Arturo.permit_management` to configure management permission
- * `Arturo.feature_recipient` to configure on what basis features are deployed
- * whitelists and blacklists
- 

data/lib/arturo/feature_caching.rb

@@ -1,141 +0,0 @@
-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
-
-    # A marker in the cache to record the fact that the feature with the
-    # given symbol doesn't exist.
-    NO_SUCH_FEATURE = :NO_SUCH_FEATURE
-
-    def self.extended(base)
-      class << base
-        alias_method_chain :to_feature, :caching
-        attr_accessor :cache_ttl, :feature_cache, :feature_caching_strategy
-      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.feature_cache = Arturo::FeatureCaching::Cache.new
-      base.feature_caching_strategy = AllStrategy
-    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 !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 = feature_caching_strategy.fetch(feature_cache, symbol) { to_feature_without_caching(symbol) }
-        feature unless feature == NO_SUCH_FEATURE
-      end
-    end
-
-    def warm_cache!
-      warn "Deprecated, no longer necessary!"
-    end
-
-    class AllStrategy
-      class << self
-        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)
-          end
-
-          features[symbol] || NO_SUCH_FEATURE
-        end
-
-        def expire(cache, symbol)
-          cache.delete("arturo.all")
-        end
-
-        private
-
-        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)
-          mark_as_current!(cache)
-        end
-
-        def mark_as_current!(cache)
-          cache.write("arturo.current", true, :expires_in => Arturo::Feature.cache_ttl)
-        end
-      end
-    end
-
-    class OneStrategy
-      def self.fetch(cache, symbol, &block)
-        if feature = cache.read("arturo.#{symbol}")
-          feature
-        else
-          cache.write("arturo.#{symbol}", yield || NO_SUCH_FEATURE, :expires_in => Arturo::Feature.cache_ttl)
-        end
-      end
-
-      def self.expire(cache, symbol)
-        cache.delete("arturo.#{symbol}")
-      end
-    end
-
-    # 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)
-        value, expires_at = *@data[name]
-        if value && (expires_at.blank? || expires_at > Time.now)
-          value
-        else
-          nil
-        end
-      end
-
-      def delete(name)
-        @data.delete(name)
-      end
-
-      def write(name, value, options = nil)
-        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_management.rb

@@ -1,23 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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/range_form_support.rb

@@ -1,17 +0,0 @@
-module Arturo
-  module RangeFormSupport
-
-    module HelperMethods
-      def range_field(object_name, method, options = {})
-        ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("range", options)
-      end
-    end
-
-    module FormBuilderMethods
-      def range_field(method, options = {})
-        @template.send('range_field', @object_name, method, objectify_options(options))
-      end
-    end
-
-  end
-end

data/lib/arturo/test_support.rb

@@ -1,32 +0,0 @@
-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 = feature.class.find(feature.id) if feature.frozen?
-      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 = feature.class.find(feature.id) if feature.frozen?
-      feature.update_attributes(:deployment_percentage => 0)
-    end
-  end
-
-end

data/lib/generators/arturo/arturo_generator.rb

@@ -1,40 +0,0 @@
-require 'rails_generator'
-
-class ArturoGenerator < Rails::Generator::Base
-  def manifest
-    record do |m|
-      m.file 'initializer.rb',              'config/initializers/arturo_initializer.rb'
-      m.file 'arturo.css',                  'public/stylesheets/arturo.css', :collision => :force
-      m.file 'arturo_customizations.css',   'public/stylesheets/arturo_customizations.css', :collision => :skip
-      m.file 'arturo.js',                   'public/javascripts/arturo.js'
-      m.file 'semicolon.png',               'public/images/semicolon.png'
-      m.migration_template 'migration.rb',  'db/migrate', :migration_file_name => 'create_features'
-      add_feature_routes(m)
-    end
-  end
-
-  protected
-
-  def source_root
-    File.expand_path('../templates', __FILE__)
-  end
-
-  def banner
-    %{Usage: #{$0} #{spec.name}\nCopies an initializer; copies CSS, JS, and PNG assets; generates a migration; adds routes/}
-  end
-
-  def add_feature_routes(manifest)
-    sentinel = 'ActionController::Routing::Routes.draw do |map|'
-    logger.route "map.resources features"
-    unless options[:pretend]
-      manifest.gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
-        "#{match}#{feature_routes}\n"
-      end
-    end
-  end
-
-  def feature_routes
-    "\n  map.resources :features,  :controller => 'arturo/features'" +
-    "\n  map.features  'features', :controller => 'arturo/features', :action => 'update_all', :conditions => { :method => :put }"
-  end
-end

data/rails/init.rb

@@ -1,7 +0,0 @@
-if ActiveSupport::Dependencies.respond_to?(:autoload_once_paths)
-  # 2.3.9+
-  ActiveSupport::Dependencies.autoload_once_paths << lib_path
-elsif ActiveSupport::Dependencies.respond_to?(:load_once_paths)
-  # 2.3.8-
-  ActiveSupport::Dependencies.load_once_paths << lib_path
-end