green_flag 0.1.0

data/app/assets/stylesheets/green_flag/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/controllers/green_flag/admin/feature_decision_summaries_controller.rb

@@ -0,0 +1,33 @@
+class GreenFlag::Admin::FeatureDecisionSummariesController < ApplicationController
+
+  def show
+    feature_id = params[:feature_id]
+    feature = GreenFlag::Feature.find(feature_id)
+
+    render :json => summary(feature)
+  end
+
+  def update
+    feature_id = params[:feature_id]
+    feature = GreenFlag::Feature.find(feature_id)
+
+    if params[:forget_enabled]
+      feature.forget_non_manual_decisions!(true)
+    end
+    if params[:forget_disabled]
+      feature.forget_non_manual_decisions!(false)
+    end
+
+    render :json => summary(feature)
+  end
+
+private
+
+  def summary(feature)
+    {
+      enabled: feature.enabled_count,
+      disabled: feature.disabled_count,
+    }
+  end
+
+end

data/app/controllers/green_flag/admin/features_controller.rb

@@ -0,0 +1,32 @@
+class GreenFlag::Admin::FeaturesController < ApplicationController
+
+  layout 'green_flag/application'
+
+  def index
+    @features = GreenFlag::Feature.all
+  end
+
+  def show
+    @feature = GreenFlag::Feature.find(params[:id])
+    @visitor_groups = GreenFlag::VisitorGroup.all.map { |group| { key: group.key, description: group.description } }
+  end
+
+  def current_visitor_status
+    @feature = GreenFlag::Feature.find(params[:id])
+    fd = GreenFlag::FeatureDecision.for_feature(@feature.id).where(site_visitor_id: current_site_visitor.id).first
+    render :json => { status: status_text(fd) }
+  end
+
+private
+
+  def status_text(feature_decison)
+    if feature_decison.nil? || feature_decison.undecided?
+      "Undecided"
+    elsif feature_decison.enabled?
+      "Enabled"
+    else
+      "Disabled"
+    end
+  end
+
+end

data/app/controllers/green_flag/admin/rule_lists_controller.rb

@@ -0,0 +1,28 @@
+class GreenFlag::Admin::RuleListsController < ApplicationController
+
+  def show
+    feature_id = params[:feature_id]
+    feature = GreenFlag::Feature.find(feature_id)
+    rules = feature.rules
+
+    render :json => rules.to_json(methods: :group_description)
+  end
+
+  def update
+    feature_id = params[:feature_id].to_i
+    rule_array = params['_json'] || []
+
+    filter_rules(rule_array)
+
+    rules = GreenFlag::Rule.set_rules!(feature_id, rule_array)
+    render :json => rules.to_json(methods: :group_description)
+  end
+
+private
+
+  def filter_rules(rule_array)
+    rule_array.each do |rule|
+      rule.delete('group_description')
+    end
+  end
+end

data/app/controllers/green_flag/admin/white_list_users_controller.rb

@@ -0,0 +1,39 @@
+class GreenFlag::Admin::WhiteListUsersController < ApplicationController
+
+  def index
+    feature_id = params[:feature_id]
+    users = GreenFlag::FeatureDecision.whitelisted_users(feature_id)
+
+    users.each { |u| u.include_root_in_json = false }
+
+    respond_to do |format|
+      format.js { render :json => users.to_json }
+    end
+  end
+
+  def create
+    feature_id = params[:feature_id]
+    feature = GreenFlag::Feature.find(feature_id)
+
+    user = User.where(email: params[:email]).first
+    GreenFlag::FeatureDecision.whitelist_user!(feature.code, user)
+
+    user.include_root_in_json = false
+
+    respond_to do |format|
+      format.js { render :json => user.to_json }
+    end
+  end
+
+  def destroy
+    feature_id = params[:feature_id]
+    user_id = params[:id]
+
+    fd = GreenFlag::FeatureDecision.for_user(user_id).for_feature(feature_id).first
+    fd.destroy
+
+    respond_to do |format|
+      format.js { render :json => '' }
+    end
+  end
+end

data/app/controllers/green_flag/site_visitor_management.rb

@@ -0,0 +1,51 @@
+module GreenFlag::SiteVisitorManagement
+  COOKIE_NAME = 'green_flag_site_visitor'
+
+  def self.included(base)
+    base.before_filter :set_site_visitor
+    base.helper_method :feature_enabled?
+  end
+
+  # Ensure we have a cookie
+  def set_site_visitor
+    ensure_code_cookie
+    record_login(current_user) if current_user
+  end
+
+  # Make sure the current SiteVisitor is the correct visitor for this user
+  def record_login(user)
+    self.current_site_visitor = GreenFlag::SiteVisitor.for_user!(user, current_site_visitor)
+  end
+
+  # Finds or creates a GreenFlag::SiteVisitor
+  def current_site_visitor
+    @current_site_visitor ||= begin
+      code = ensure_code_cookie
+      GreenFlag::SiteVisitor.for_visitor_code!(code)
+    end
+  end
+
+  def feature_enabled?(feature_code)
+    @features_enabled ||= {}
+    if @features_enabled[feature_code].nil?
+      visitor_id = current_site_visitor.id
+      @features_enabled[feature_code] = GreenFlag::FeatureDecision.feature_enabled?(feature_code, visitor_id)
+    end
+    @features_enabled[feature_code]
+  end
+
+private
+
+  def current_site_visitor=(visitor)
+    @current_site_visitor = visitor
+    cookies.permanent[COOKIE_NAME] = current_site_visitor.visitor_code
+  end
+
+  def ensure_code_cookie
+    unless cookies[COOKIE_NAME]
+      cookies.permanent[COOKIE_NAME] = GreenFlag::SiteVisitor.new_code
+    end
+    cookies[COOKIE_NAME]
+  end
+
+end

data/app/helpers/green_flag/application_helper.rb

@@ -0,0 +1,4 @@
+module GreenFlag
+  module ApplicationHelper
+  end
+end

data/app/models/green_flag/feature.rb

@@ -0,0 +1,84 @@
+class GreenFlag::Feature < ActiveRecord::Base
+  attr_protected #none
+
+  has_many :rules, :conditions => proc { "version_number = #{self.version_number}" }, order: 'order_by'
+  has_many :feature_decisions
+  has_many :feature_events
+
+  validates_presence_of :code
+
+  self.include_root_in_json = false
+
+  def self.for_code!(code)
+    feature = where(code: code.to_s).first
+    unless feature
+      feature = create!(code: code.to_s)
+    end
+    feature
+  rescue ActiveRecord::RecordNotUnique, PG::Error => ex
+    # Race condition
+    where(code: code.to_s).first || raise
+  end
+
+  def decide_if_enabled_for_visitor(site_visitor_id)
+    fd_query         = GreenFlag::FeatureDecision.where(feature_id: id, site_visitor_id: site_visitor_id)
+    feature_decision = fd_query.first_or_initialize
+
+    if feature_decision.undecided?
+      decide_feature_decision(feature_decision)
+    end
+
+    feature_decision
+  end
+
+  def enabled_count
+    feature_decisions.enabled.count
+  end
+
+  def disabled_count
+    feature_decisions.disabled.count
+  end
+
+  def forget_non_manual_decisions!(enabled)
+    non_manual_fds = feature_decisions.non_manual.where(enabled: enabled)
+
+    if non_manual_fds.count > 0
+      create_feature_event(enabled, non_manual_fds.count)
+      non_manual_fds.delete_all
+    end
+  end
+
+  def latest_version
+    last_rule = GreenFlag::Rule.order('version_number DESC').where(feature_id: id).first
+
+    last_rule.present? ? last_rule.version_number : version_number
+  end
+  
+  private
+
+  def decide_feature_decision(feature_decision)
+    matched_rule = rules.find { |rule| rule.applies_to?(feature_decision.site_visitor) }
+
+    if matched_rule
+      feature_decision.rule_id = matched_rule.id
+      feature_decision.enabled = !!matched_rule.decision?
+    end
+
+    saved_feature_decision(feature_decision)
+  end
+
+  def saved_feature_decision(feature_decision)
+    save_result = feature_decision.safe_save!
+
+    if save_result == true
+      feature_decision
+    else
+      save_result
+    end
+  end
+
+  def create_feature_event(enabled, count)
+    event_type_code = (enabled == true ? GreenFlag::FeatureEvent::ENABLED_DECISIONS_FORGOTTEN : GreenFlag::FeatureEvent::DISABLED_DECISIONS_FORGOTTEN)
+    GreenFlag::FeatureEvent.create!(feature_id: id, event_type_code: event_type_code, count: count)
+  end
+end

data/app/models/green_flag/feature_decision.rb

@@ -0,0 +1,77 @@
+class GreenFlag::FeatureDecision < ActiveRecord::Base
+
+  attr_protected #none
+
+  validates_presence_of :feature_id, :site_visitor_id
+
+  belongs_to :feature
+  belongs_to :site_visitor
+  belongs_to :rule 
+  
+  has_one :user, through: :site_visitor
+
+  scope :enabled, -> { where(enabled: true) }
+  scope :disabled, -> { where(enabled: false) }
+  scope :whitelisted, ->(feature_id) { 
+    for_feature(feature_id).enabled.where(manual: true).order(:created_at)
+  }
+  scope :for_user, ->(user_id) {
+    joins(:site_visitor).where('green_flag_site_visitors.user_id = ?', user_id)
+  }
+  scope :for_feature, ->(feature_id) {
+    where(feature_id: feature_id)
+  }
+  scope :non_manual, -> { where('manual is not true') }
+
+  # Check if the feature is enabled, AND store the result as a FeatureDecision
+  def self.feature_enabled?(feature_code, site_visitor_id)
+    feature = GreenFlag::Feature.for_code!(feature_code)
+    fd      = feature.decide_if_enabled_for_visitor(site_visitor_id)
+
+    fd.enabled
+  end
+
+  def self.feature_enabled_for_user?(feature_code, user)
+    feature_enabled? feature_code, GreenFlag::SiteVisitor.for_user!(user).id
+  end
+
+  # Force the given user to have the feature enabled
+  def self.whitelist_user!(feature_code, user)
+    ensure_feature_enabled(feature_code, user, true)
+  end
+
+  def self.ensure_feature_enabled(feature_code, user, manual=false)
+    feature = GreenFlag::Feature.for_code!(feature_code)
+    visitor = GreenFlag::SiteVisitor.for_user!(user)
+
+    fd = GreenFlag::FeatureDecision.where(feature_id: feature.id, 
+      site_visitor_id: visitor.id).first_or_initialize
+
+    unless fd.enabled? && fd.manual == manual
+      fd.enabled = true
+      fd.manual = manual
+      fd.save!
+    end
+    fd
+  end
+
+  def self.whitelisted_users(feature_id)
+    # inefficient, but shouldn't matter.
+    feature_decisions = whitelisted(feature_id).joins(:site_visitor => :user).all
+    users = feature_decisions.map(&:user)
+  end
+
+  def undecided?
+    self.enabled.nil?
+  end
+
+  def safe_save!
+    begin
+      save!
+      true
+    rescue ActiveRecord::RecordNotUnique, PG::Error => ex
+      # Race condition
+      self.class.where(feature_id: feature_id, site_visitor_id: site_visitor_id).first || raise
+    end
+  end
+end

data/app/models/green_flag/feature_event.rb

@@ -0,0 +1,9 @@
+class GreenFlag::FeatureEvent < ActiveRecord::Base
+  attr_accessible :event_type_code, :feature_id, :count
+
+  validates :event_type_code, presence: true
+  validates :feature_id, presence: true
+
+  ENABLED_DECISIONS_FORGOTTEN = 0
+  DISABLED_DECISIONS_FORGOTTEN = 1
+end

data/app/models/green_flag/rule.rb

@@ -0,0 +1,66 @@
+class GreenFlag::Rule < ActiveRecord::Base
+  attr_protected # none
+
+  validates :feature_id, presence: true
+  validates :group_key, presence: true
+  validates :order_by, presence: true
+  validates :percentage, presence: true, 
+    numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }
+
+  self.include_root_in_json = false
+
+  class << self
+    public
+
+    def set_rules!(feature_id, rules_array)
+      return [] if rules_array.empty?
+
+      rules = create_new_rules(feature_id, rules_array)
+
+      transaction { rules.each(&:save!) } 
+
+      rules
+    end
+
+    private
+
+    def create_new_rules(feature_id, rules_array)
+      new_version_number = increment_feature_version(feature_id)
+
+      rules_array.map do |rule_attributes|
+        rule_attributes[:feature_id] = feature_id
+        create_new_rule_version(new_version_number, rule_attributes)
+      end
+    end
+
+    def increment_feature_version(feature_id)
+      feature = GreenFlag::Feature.find(feature_id)
+
+      feature.update_attributes(version_number: feature.latest_version + 1)
+      feature.version_number
+    end
+
+    def create_new_rule_version(new_version_number, rule_attributes)
+      GreenFlag::Rule.new(rule_attributes.except(:id).merge(version_number: new_version_number))
+    end
+  end
+
+  def applies_to?(visitor)
+    visitor_group.includes_visitor?(visitor, self)
+  end
+
+  def decision?
+    r = Random.rand(100)
+    r < percentage
+  end
+
+  def group_description
+    visitor_group.description
+  end
+
+private
+
+  def visitor_group
+    GreenFlag::VisitorGroup.for_key(group_key)
+  end
+end

data/app/models/green_flag/site_visitor.rb

@@ -0,0 +1,49 @@
+# A SiteVisitor is a unique visitor to the site.
+class GreenFlag::SiteVisitor < ActiveRecord::Base
+
+  attr_protected # none
+
+  belongs_to :user
+  has_many :feature_decisions
+
+  # Finds, updates, or creates a SiteVisitor for the given user.
+  # If the user has an existing SiteVisitor, return that
+  # Otherwise, check if the given SiteVisitor can be assigned to the user.
+  # Otherwise, create a brand new SiteVisitor
+  def self.for_user!(user, visitor_to_check=nil)
+    where(user_id: user.id).first ||
+      assign_visitor_if_available(visitor_to_check, user) ||
+      create!(user_id: user.id, visitor_code: new_code)
+  rescue ActiveRecord::RecordNotUnique, PG::Error => ex
+    # Race condition - some other request created/updated a SiteVisitor with our user's id
+    where(user_id: user.id).first || raise
+  end
+
+  def self.for_visitor_code!(code)
+    where(visitor_code: code).first_or_create!
+  rescue ActiveRecord::RecordNotUnique, PG::Error => ex
+    # Race condition
+    where(visitor_code: code).first || raise
+  end
+
+  def self.new_code
+    SecureRandom.uuid
+  end
+
+  # If GreenFlag is added to an existing app, 
+  # then some users might be older than their corresponding SiteVisitors
+  def first_visited_at
+    [created_at, user.try(:created_at), DateTime.now].compact.min
+  end
+
+private
+
+  def self.assign_visitor_if_available(visitor, user)
+    if visitor && visitor.user_id.nil?
+      visitor.update_attribute(:user_id, user.id)
+      return visitor
+    end
+    nil
+  end
+
+end

data/app/models/green_flag/user_group.rb

@@ -0,0 +1,8 @@
+class GreenFlag::UserGroup < GreenFlag::VisitorGroup
+
+  def includes_visitor?(visitor, rule=nil)
+    user_exists = !!visitor.user
+    user_exists && evaluator.call(visitor.user, rule)
+  end
+
+end

data/app/models/green_flag/visitor_group.rb

@@ -0,0 +1,60 @@
+class GreenFlag::VisitorGroup
+
+  class MultipleGroupsError < StandardError; end
+  MUTEX = Mutex.new
+
+  attr_reader :key, :description
+
+  def self.define(&block)
+    instance_eval(&block)
+  end
+
+  def self.group(key, description=nil, type=GreenFlag::VisitorGroup, &block)
+    new_group = nil
+    MUTEX.synchronize do
+      key_exists = for_key(key)
+      if key_exists
+        raise MultipleGroupsError.new "Two groups with key :#{key} were defined.  Rename one of them!"
+      end
+      new_group = type.new(key, description, &block)
+      @groups ||= []
+      @groups << new_group
+    end
+    new_group
+  end
+
+  def self.user_group(key, description=nil, &block)
+    group(key, description, GreenFlag::UserGroup, &block)
+  end
+
+  def self.for_key(key)
+    all.find { |g| g.key.to_s == key.to_s }
+  end
+
+  def self.clear!
+    @groups = []
+  end
+
+  def self.all
+    @groups || []
+  end
+
+  def self.keys
+    all.map(&:key)
+  end
+
+  def initialize(key, description=nil, &block)
+    self.key = key.to_s
+    self.description = description
+    self.evaluator = block
+  end
+
+  def includes_visitor?(visitor, rule=nil)
+    evaluator.call(visitor, rule)
+  end
+
+private
+  attr_writer :key, :description, :evaluator
+  attr_reader :evaluator
+
+end

data/app/views/green_flag/admin/features/index.html.erb

@@ -0,0 +1,14 @@
+
+<div class="header clearfix">
+  <h1><%= link_to 'Green Flag', admin_features_path %></h1>
+</div>
+
+<div class="row">
+  <% @features.each do |feature| %>
+    <div class="col-md-6">
+      <h4><%= link_to feature.code, admin_feature_path(feature) %></h4>
+      <p><%= feature.description %></p>
+    </div>
+  <% end %>
+
+</div>