flip2 1.1.1

data/config/routes.rb

@@ -0,0 +1,14 @@
+Flip::Engine.routes.draw do
+
+  scope module: "flip" do
+
+    resources :features, path: "", only: [ :index ] do
+
+      resources :strategies,
+        only: [ :update, :destroy ]
+
+    end
+
+  end
+
+end

data/flip.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "flip/version"
+
+Gem::Specification.new do |s|
+  s.name        = "flip2"
+  s.version     = Flip::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [""]
+  s.email       = [""]
+  s.homepage    = ""
+  s.summary     = %q{A feature flipper for Rails web applications.}
+  s.description = %q{Declarative API for specifying features, switchable in declaration, database and cookies.}
+  s.license  = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("activesupport", ">= 3.0", "< 5.1")
+  s.add_dependency("i18n")
+
+  s.add_development_dependency("rspec", "~> 2.5")
+  s.add_development_dependency("rspec-its")
+  s.add_development_dependency("rake")
+end

data/lib/flip/abstract_strategy.rb

@@ -0,0 +1,26 @@
+module Flip
+  class AbstractStrategy
+
+    def name
+      self.class.name.split("::").last.gsub(/Strategy$/, "").underscore
+    end
+
+    def description; ""; end
+
+    # Whether the strategy knows the on/off state of the switch.
+    def knows? definition; raise; end
+
+    # Given the state is known, whether it is on or off.
+    def on? definition; raise; end
+
+    # Whether the feature can be switched on and off at runtime.
+    # If true, the strategy must also respond to switch! and delete!
+    def switchable?
+      false
+    end
+
+    def switch! key, on; raise; end
+    def delete! key; raise; end
+
+  end
+end

data/lib/flip/cacheable.rb

@@ -0,0 +1,25 @@
+module Flip
+  module Cacheable
+
+    def use_feature_cache=(value)
+      @use_feature_cache = value
+    end
+
+    def use_feature_cache
+      @use_feature_cache
+    end
+
+    def start_feature_cache
+      @use_feature_cache = true
+      @features = nil
+    end
+
+    def feature_cache
+      return @features if @features
+      @features = {}
+      all.each { |f| @features[f.key] = f }
+      @features
+    end
+
+  end
+end

data/lib/flip/controller_filters.rb

@@ -0,0 +1,25 @@
+module Flip
+  # ControllerFilters is a name that refers to the fact that Rails
+  # before_action and after_action used to be before_filter and
+  # after_filter.
+  module ControllerFilters
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def require_feature key, options = {}
+        before_action options do
+          flip_feature_disabled key unless Flip.on? key
+        end
+      end
+
+    end
+
+    def flip_feature_disabled key
+      redirect_to root_path
+      # raise Flip::Forbidden.new(key)
+    end
+
+  end
+end

data/lib/flip/cookie_strategy.rb

@@ -0,0 +1,67 @@
+# Uses cookie to determine feature state.
+module Flip
+  class CookieStrategy < AbstractStrategy
+
+    def description
+      "Uses cookies to apply only to your session."
+    end
+
+    def knows? definition
+      cookies.key? cookie_name(definition)
+    end
+
+    def on? definition
+      cookie = cookies[cookie_name(definition)]
+      cookie_value = cookie.is_a?(Hash) ? cookie['value'] : cookie
+      cookie_value === 'true'
+    end
+
+    def switchable?
+      true
+    end
+
+    def switch! key, on
+      cookies[cookie_name(key)] = {
+        'value' => (on ? "true" : "false"),
+        'domain' => :all
+      }
+    end
+
+    def delete! key
+      cookies.delete cookie_name(key)
+    end
+
+    def self.cookies= cookies
+      @cookies = cookies
+    end
+
+    def cookie_name(definition)
+      definition = definition.key unless definition.is_a? Symbol
+      "flip_#{definition}"
+    end
+
+    private
+
+    def cookies
+      self.class.instance_variable_get(:@cookies) || {}
+    end
+
+    # Include in ApplicationController to push cookies into CookieStrategy.
+    # Uses before_action and after_action rather than around_action to
+    # avoid pointlessly adding to stack depth.
+    module Loader
+      extend ActiveSupport::Concern
+      included do
+        before_action :flip_cookie_strategy_before
+        after_action :flip_cookie_strategy_after
+      end
+      def flip_cookie_strategy_before
+        CookieStrategy.cookies = cookies
+      end
+      def flip_cookie_strategy_after
+        CookieStrategy.cookies = nil
+      end
+    end
+
+  end
+end

data/lib/flip/database_strategy.rb

@@ -0,0 +1,46 @@
+# Database backed system-wide
+module Flip
+  class DatabaseStrategy < AbstractStrategy
+
+    def initialize(model_klass = Feature)
+      @klass = model_klass
+    end
+
+    def description
+      "Database backed, applies to all users."
+    end
+
+    def knows? definition
+      !!feature(definition)
+    end
+
+    def on? definition
+      feature(definition).enabled?
+    end
+
+    def switchable?
+      true
+    end
+
+    def switch! key, enable
+      record = @klass.where(key: key.to_s).first_or_initialize
+      record.enabled = enable
+      record.save!
+    end
+
+    def delete! key
+      @klass.where(key: key.to_s).first.try(:destroy)
+    end
+
+    private
+
+    def feature(definition)
+      if @klass.respond_to?(:use_feature_cache) && @klass.use_feature_cache
+        @klass.feature_cache[definition.key.to_s]
+      else
+        @klass.where(key: definition.key.to_s).first
+      end
+    end
+
+  end
+end

data/lib/flip/declarable.rb

@@ -0,0 +1,24 @@
+module Flip
+  module Declarable
+
+    def self.extended(base)
+      FeatureSet.reset
+    end
+
+    # Adds a new feature definition, creates predicate method.
+    def feature(key, options = {})
+      FeatureSet.instance << Flip::Definition.new(key, options)
+    end
+
+    # Adds a strategy for determining feature status.
+    def strategy(strategy)
+      FeatureSet.instance.add_strategy strategy
+    end
+
+    # The default response, boolean or a Proc to be called.
+    def default(default)
+      FeatureSet.instance.default = default
+    end
+
+  end
+end

data/lib/flip/declaration_strategy.rb

@@ -0,0 +1,20 @@
+# Uses :default option passed to feature declaration.
+# May be boolean or a Proc to be passed the definition.
+module Flip
+  class DeclarationStrategy < AbstractStrategy
+
+    def description
+      "The default status declared with the feature."
+    end
+
+    def knows? definition
+      !definition.options[:default].nil?
+    end
+
+    def on? definition
+      default = definition.options[:default]
+      default.is_a?(Proc) ? default.call(definition) : default
+    end
+
+  end
+end

data/lib/flip/definition.rb

@@ -0,0 +1,21 @@
+module Flip
+  class Definition
+
+    attr_accessor :key
+    attr_accessor :options
+
+    def initialize(key, options = {})
+      @key = key
+      @options = options.reverse_merge \
+        description: key.to_s.humanize + "."
+    end
+
+    alias :name :key
+    alias :to_s :key
+
+    def description
+      options[:description]
+    end
+
+  end
+end

data/lib/flip/engine.rb

@@ -0,0 +1,9 @@
+module Flip
+  class Engine < ::Rails::Engine
+
+    initializer "flip.blarg" do
+      ActionController::Base.send(:include, Flip::CookieStrategy::Loader)
+    end
+
+  end
+end

data/lib/flip/facade.rb

@@ -0,0 +1,18 @@
+module Flip
+  module Facade
+
+    def on?(feature)
+      FeatureSet.instance.on? feature
+    end
+
+    def reset
+      FeatureSet.reset
+    end
+
+    def method_missing(method, *parameters)
+      super unless method =~ %r{^(.*)\?$}
+      FeatureSet.instance.on? $1.to_sym
+    end
+
+  end
+end

data/lib/flip/feature_set.rb

@@ -0,0 +1,57 @@
+module Flip
+  class FeatureSet
+
+    def self.instance
+      @instance ||= self.new
+    end
+
+    def self.reset
+      @instance = nil
+    end
+
+    # Sets the default for definitions which fall through the strategies.
+    # Accepts boolean or a Proc to be called.
+    attr_writer :default
+
+    def initialize
+      @definitions = Hash.new { |_, k| raise "No feature declared with key #{k.inspect}" }
+      @strategies = Hash.new { |_, k| raise "No strategy named #{k}. Valid strategies are #{@strategies.keys}" }
+      @default = false
+    end
+
+    # Whether the given feature is switched on.
+    def on? key
+      d = @definitions[key]
+      @strategies.each_value { |s| return s.on?(d) if s.knows?(d) }
+      default_for d
+    end
+
+    # Adds a feature definition to the set.
+    def << definition
+      @definitions[definition.key] = definition
+    end
+
+    # Adds a strategy for determing feature status.
+    def add_strategy(strategy)
+      strategy = strategy.new if strategy.is_a? Class
+      @strategies[strategy.name] = strategy
+    end
+
+    def strategy(klass)
+      @strategies[klass]
+    end
+
+    def default_for(definition)
+      @default.is_a?(Proc) ? @default.call(definition) : @default
+    end
+
+    def definitions
+      @definitions.values
+    end
+
+    def strategies
+      @strategies.values
+    end
+
+  end
+end

data/lib/flip/forbidden.rb

@@ -0,0 +1,7 @@
+module Flip
+  class Forbidden < StandardError
+    def initialize(key)
+      super("requires :#{key} feature")
+    end
+  end
+end

data/lib/flip/version.rb

@@ -0,0 +1,3 @@
+module Flip
+  VERSION = "1.1.1"
+end

data/lib/flip2.rb

@@ -0,0 +1,28 @@
+# ActiveSupport dependencies.
+%w{
+  concern
+  inflector
+  core_ext/hash/reverse_merge
+  core_ext/object/blank
+}.each { |name| require "active_support/#{name}" }
+
+# Flip files.
+%w{
+  abstract_strategy
+  cacheable
+  controller_filters
+  cookie_strategy
+  database_strategy
+  declarable
+  declaration_strategy
+  definition
+  facade
+  feature_set
+  forbidden
+}.each { |name| require "flip/#{name}" }
+
+require "flip/engine" if defined?(Rails)
+
+module Flip
+  extend Facade
+end