detour 0.0.1 → 0.0.2

data/app/assets/stylesheets/detour/main.css

@@ -0,0 +1,49 @@
+@font-face {
+  font-family: 'Glyphicons Halflings';
+  src: url('/assets/glyphicons-halflings-regular.eot');
+  src: url('/assets/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'), url('/assets/glyphicons-halflings-regular.woff') format('woff'), url('/assets/glyphicons-halflings-regular.ttf') format('truetype'), url('/assets/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg');
+}
+
+body {
+  padding-bottom: 40px;
+}
+
+.panel-danger {
+  margin-top: 20px;
+}
+
+.panel-danger ul {
+  margin-bottom: 0;
+}
+
+.modal-body .panel-danger {
+  margin-top: 0;
+}
+
+.table-responsive {
+  padding-top: 60px;
+}
+
+table.table tbody tr td {
+  vertical-align: middle;
+}
+
+.group-header {
+  display: block;
+  width: 10px;
+  white-space: nowrap;
+
+  -webkit-transform: rotate(-30deg);
+  -moz-transform: rotate(-30deg);
+  -ms-transform: rotate(-30deg);
+  -o-transform: rotate(-30deg);
+  transform: rotate(-30deg);
+}
+
+.percentage-header {
+  width: 120px;
+}
+
+.counter-header {
+  width: 80px;
+}

data/app/controllers/detour/application_controller.rb

@@ -0,0 +1,12 @@
+class Detour::ApplicationController < ActionController::Base
+  def index
+  end
+
+  private
+
+  def ensure_flaggable_type_exists
+    unless Detour.config.flaggable_types.map(&:tableize).include? params[:flaggable_type]
+      raise ActionController::RoutingError.new("Not Found")
+    end
+  end
+end

data/app/controllers/detour/features_controller.rb

@@ -0,0 +1,19 @@
+class Detour::FeaturesController < Detour::ApplicationController
+  def create
+    @feature = Detour::Feature.new(params[:feature])
+
+    if @feature.save
+      flash[:notice] = "Your feature has been successfully created."
+      render :success
+    else
+      render :error
+    end
+  end
+
+  def destroy
+    @feature = Detour::Feature.find(params[:id])
+    @feature.destroy
+    flash[:notice] = "Feature #{@feature.name} has been deleted."
+    redirect_to flags_path(params[:flaggable_type])
+  end
+end

data/app/controllers/detour/flaggable_flags_controller.rb

@@ -0,0 +1,90 @@
+require "indefinite_article"
+
+class Detour::FlaggableFlagsController < Detour::ApplicationController
+  before_filter :ensure_flaggable_type_exists
+
+  def index
+    feature = Detour::Feature.find_by_name!(feature_name)
+    @flags  = feature.send("#{flag_type}_flags").where(flaggable_type: flaggable_class.to_s)
+  end
+
+  def create
+    @feature = Detour::Feature.find_by_name! feature_name
+    ids      = params[:ids].split(",")
+    @errors   = []
+
+    Detour::Feature.transaction do
+      begin
+        ids.each do |id|
+          flaggable = flaggable_class.flaggable_find! id
+          flag      = @feature.send("#{flaggable_type}_#{flag_type.pluralize}").new flaggable: flaggable
+
+          unless flag.save
+            @errors.concat flag.errors.full_messages
+          end
+        end
+      rescue ActiveRecord::RecordNotFound => e
+        @errors << e.message
+      end
+
+      if @errors.any?
+        raise ActiveRecord::Rollback
+      end
+    end
+
+    if @errors.empty?
+      flash[:notice] = success_message
+      render :success
+    else
+      render :error
+    end
+  end
+
+  def destroy
+    feature = Detour::Feature.find_by_name!(feature_name)
+    @flag   = feature.send("#{flag_type}_flags").find(params[:id])
+    @flag.destroy
+    flash[:notice] = "#{feature_name} #{flag_noun} for #{flaggable_class} #{@flag.flaggable.send flaggable_class.detour_flaggable_find_by} has been deleted."
+    redirect_to send("#{flag_type}_flags_path", feature.name, flaggable_type)
+  end
+
+  private
+
+  def feature_name
+    params[:feature_name]
+  end
+  helper_method :feature_name
+
+  def flaggable_type
+    params[:flaggable_type]
+  end
+  helper_method :flaggable_type
+
+  def flaggable_class
+    flaggable_type.classify.constantize
+  end
+  helper_method :flaggable_class
+
+  def flag_type
+    request.path.split("/")[2].underscore.singularize
+  end
+  helper_method :flag_type
+
+  def flag_verb
+    flag_type == "flag_in" ? "flagged in to" : "opted out of"
+  end
+  helper_method :flag_verb
+
+  def flag_noun
+    flag_type.dasherize
+  end
+  helper_method :flag_noun
+
+  def success_message
+    plural = params[:ids].split(",").length > 1
+    klass  = plural ? flaggable_class.to_s.pluralize : flaggable_class
+    has    = plural ? "have" : "has"
+
+    flash[:notice] = "#{klass} #{params[:ids].split(",").join(", ")} #{has} been #{flag_verb} #{@feature.name}"
+  end
+end

data/app/controllers/detour/flags_controller.rb

@@ -0,0 +1,18 @@
+class Detour::FlagsController < Detour::ApplicationController
+  before_filter :ensure_flaggable_type_exists
+
+  def index
+    @flag_form = Detour::FlagForm.new(params[:flaggable_type])
+  end
+
+  def update
+    @flag_form = Detour::FlagForm.new(params[:flaggable_type])
+
+    if @flag_form.update_attributes(params)
+      flash[:notice] = "Your flags have been successfully updated."
+      redirect_to flags_path
+    else
+      render :index
+    end
+  end
+end

data/app/helpers/detour/application_helper.rb

@@ -0,0 +1,32 @@
+module Detour::ApplicationHelper
+  def table(&block)
+    content_tag :div, class: "table-responsive" do
+      content_tag :table, class: "table table-striped" do
+        yield
+      end
+    end
+  end
+
+  def modal(options, &block)
+    content_tag :div, id: options[:id], class: "modal #{options[:fade].present?}", tabindex: "-1", role: "dialog", aria_labbeledby: "#{options[:id]}-modal-label", aria_hidden: "true" do
+      content_tag :div, class: "modal-dialog" do
+        content_tag :div, class: "modal-content" do
+          content_tag(:div, class: "modal-header") do
+            content_tag :button, "×", class: "close", data_dismiss: "modal", aria_hidden: "true"
+            content_tag :h4, options[:title], id: "#{options[:id]}-modal-label"
+          end +
+
+          content_tag(:div, class: "modal-body") do
+            yield
+          end
+        end
+      end
+    end
+  end
+
+  def modal_footer(&block)
+    content_tag :div, class: "modal-footer" do
+      yield
+    end
+  end
+end

data/app/helpers/detour/flaggable_flags_helper.rb

@@ -0,0 +1,5 @@
+module Detour::FlaggableFlagsHelper
+  def flag_title
+    flag_noun.capitalize
+  end
+end

data/app/helpers/detour/flags_helper.rb

@@ -0,0 +1,7 @@
+module Detour::FlagsHelper
+  def spacer_count
+    names_count = @flag_form.group_names.length
+    difference  = 10 - names_count
+    count       = difference < 0 ? 0 : difference
+  end
+end

data/app/models/detour/concerns/countable_flag.rb

@@ -0,0 +1,19 @@
+module Detour::Concerns
+  module CountableFlag
+    extend ActiveSupport::Concern
+
+    included do
+      after_save    :step_count
+      after_destroy :step_count
+
+      private
+
+      def step_count
+        count = feature.send("#{flag_type}_count_for", flaggable_type.tableize)
+        count = destroyed? ? count - 1 : count + 1
+        feature.send("#{flag_type}_counts")[flaggable_type.tableize] = count
+        feature.save!
+      end
+    end
+  end
+end

data/app/models/detour/concerns/flag_actions.rb

@@ -0,0 +1,141 @@
+module Detour::Concerns
+  module FlagActions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Add a record to the given feature. If the feature is not found, an
+      # ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.add_record_to_feature user, :new_ui
+      #
+      # @param [ActiveRecord::Base] record A record to add the feature to.
+      # @param [String,Symbol] feature_name The feature to be added to the record.
+      #
+      # @return [Detour::Flag] The
+      #   {Detour::Flag Flag} created.
+      def add_record_to_feature(record, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.flag_in_flags.where(flaggable_type: record.class.to_s, flaggable_id: record.id).first_or_create!
+      end
+
+      # Remove a record from the given feature. If the feature is not found, an
+      # ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.remove_record_from_feature user, :new_ui
+      #
+      # @param [ActiveRecord::Base] record A record to remove the feature from.
+      # @param [String,Symbol] feature_name The feature to be removed from the
+      #   record.
+      def remove_record_from_feature(record, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.flag_in_flags.where(flaggable_type: record.class.to_s, flaggable_id: record.id).destroy_all
+      end
+
+      # Opt the given record out of a feature. If the feature is not found, an
+      # ActiveRecord::RecordNotFound will be raised. An opt out ensures that no
+      # matter what, `record.rollout?(:rollout)` will always return false for any
+      # opted-out-of features.
+      #
+      # @param [ActiveRecord::Base] record A record to opt out of the feature.
+      # @param [String,Symbol] feature_name The feature to be opted out of.
+      #
+      # @example
+      #   Detour::Feature.opt_record_out_of_feature user, :new_ui
+      #
+      # @return [Detour::OptOut] The
+      #   {Detour::OptOut OptOut} created.
+      def opt_record_out_of_feature(record, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.opt_out_flags.where(flaggable_type: record.class.to_s, flaggable_id: record.id).first_or_create!
+      end
+
+      # Remove any opt out for the given record out of a feature. If the feature
+      # is not found, an ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.un_opt_record_out_of_feature user, :new_ui
+      #
+      # @param [ActiveRecord::Base] record A record to un-opt-out of the feature.
+      # @param [String,Symbol] feature_name The feature to be un-opted-out of.
+      def un_opt_record_out_of_feature(record, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.opt_out_flags.where(flaggable_type: record.class.to_s, flaggable_id: record.id).destroy_all
+      end
+
+      # Add a group to the given feature. If the feature is not found, an
+      # ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.add_group_to_feature "User", "admin", :delete_records
+      #
+      # @param [String] flaggable_type The class (as a string) that the group
+      #   should be associated with.
+      # @param [String] group_name The name of the group to have the feature
+      #   added to it.
+      # @param [String,Symbol] feature_name The feature to be added to the group.
+      #
+      # @return [Detour::Flag] The
+      #   {Detour::Flag Flag} created.
+      def add_group_to_feature(flaggable_type, group_name, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.group_flags.where(flaggable_type: flaggable_type, group_name: group_name).first_or_create!
+      end
+
+      # Remove a group from agiven feature. If the feature is not found, an
+      # ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.remove_group_from_feature "User", "admin", :delete_records
+      #
+      # @param [String] flaggable_type The class (as a string) that the group should
+      #   be removed from.
+      # @param [String] group_name The name of the group to have the feature
+      #   removed from it.
+      # @param [String,Symbol] feature_name The feature to be removed from the
+      #   group.
+      def remove_group_from_feature(flaggable_type, group_name, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.group_flags.where(flaggable_type: flaggable_type, group_name: group_name).destroy_all
+      end
+
+      # Add a percentage of records to the given feature. If the feature is not
+      # found, an ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.add_percentage_to_feature "User", 75, :delete_records
+      #
+      # @param [String] flaggable_type The class (as a string) that the percetnage
+      #   should be associated with.
+      # @param [Integer] percentage The percentage of `flaggable_type` records
+      #   that the feature will be available for.
+      # @param [String,Symbol] feature_name The feature to be added to the
+      #   percentage of records.
+      #
+      # @return [Detour::Flag] The
+      #   {Detour::Flag Flag} created.
+      def add_percentage_to_feature(flaggable_type, percentage, feature_name)
+        feature = find_by_name!(feature_name)
+
+        flag = feature.percentage_flags.where(flaggable_type: flaggable_type).first_or_initialize
+        flag.update_attributes!(percentage: percentage)
+      end
+
+      # Remove any percentage flags for the given feature. If the feature is not
+      # found, an ActiveRecord::RecordNotFound will be raised.
+      #
+      # @example
+      #   Detour::Feature.remove_percentage_from_feature "User", delete_records
+      #
+      # @param [String] flaggable_type The class (as a string) that the percetnage
+      #   should be removed from.
+      # @param [String,Symbol] feature_name The feature to have the percentage
+      #   flag removed from.
+      def remove_percentage_from_feature(flaggable_type, feature_name)
+        feature = find_by_name!(feature_name)
+        feature.percentage_flags.where(flaggable_type: flaggable_type).destroy_all
+      end
+    end
+  end
+end

data/app/models/detour/concerns/matchers.rb

@@ -0,0 +1,73 @@
+module Detour::Concerns
+  module Matchers
+    # Determines whether or not the given instance has had the feature rolled out
+    # to it either via direct flagging-in, percentage, or by group membership.
+    #
+    # @example
+    #   feature.match?(current_user)
+    #
+    # @param [ActiveRecord::Base] instance A record to be tested for feature
+    #   rollout.
+    #
+    # @return Whether or not the given instance has the feature rolled out to it.
+    def match?(instance)
+      match_id?(instance) || match_percentage?(instance) || match_groups?(instance)
+    end
+
+    # Determines whether or not the given instance has had the feature rolled out
+    # to it via direct flagging-in.
+    #
+    # @example
+    #   feature.match_id?(current_user)
+    #
+    # @param [ActiveRecord::Base] instance A record to be tested for feature
+    #   rollout.
+    #
+    # @return Whether or not the given instance has the feature rolled out to it
+    #   via direct flagging-in.
+    def match_id?(instance)
+      flag_in_flags.where(flaggable_type: instance.class.to_s, flaggable_id: instance.id).any?
+    end
+
+    # Determines whether or not the given instance has had the feature rolled out
+    # to it via percentage.
+    #
+    # @example
+    #   feature.match_percentage?(current_user)
+    #
+    # @param [ActiveRecord::Base] instance A record to be tested for feature
+    #   rollout.
+    #
+    # @return Whether or not the given instance has the feature rolled out to it
+    #   via direct percentage.
+    def match_percentage?(instance)
+      flag = percentage_flags.find(:first, conditions: ["flaggable_type = ?", instance.class.to_s])
+      percentage = flag ? flag.percentage : 0
+
+      instance.id % 10 < percentage / 10
+    end
+
+    # Determines whether or not the given instance has had the feature rolled out
+    # to it via group membership.
+    #
+    # @example
+    #   feature.match_groups?(current_user)
+    #
+    # @param [ActiveRecord::Base] instance A record to be tested for feature
+    #   rollout.
+    #
+    # @return Whether or not the given instance has the feature rolled out to it
+    #   via direct group membership.
+    def match_groups?(instance)
+      klass = instance.class.to_s
+
+      return unless Detour.config.defined_groups[klass]
+
+      group_names = group_flags.find_all_by_flaggable_type(klass).collect(&:group_name)
+
+      Detour.config.defined_groups[klass].collect { |group_name, block|
+        block.call(instance) if group_names.include? group_name
+      }.any?
+    end
+  end
+end

data/app/models/detour/feature.rb

@@ -0,0 +1,81 @@
+# Represents an individual feature that may be rolled out to a set of records
+# via individual flags, percentages, or defined groups.
+class Detour::Feature < ActiveRecord::Base
+  include Detour::Concerns::Matchers
+  include Detour::Concerns::FlagActions
+
+  self.table_name = :detour_features
+
+  serialize :flag_in_counts, JSON
+  serialize :opt_out_counts, JSON
+
+  has_many :flag_in_flags
+  has_many :group_flags
+  has_many :percentage_flags
+  has_many :opt_out_flags
+  has_many :flags, dependent: :destroy
+
+  validates_presence_of   :name
+  validates_uniqueness_of :name
+
+  attr_accessible :name
+
+  # Returns an instance variable intended to hold an array of the lines of code
+  # that this feature appears on.
+  #
+  # @return [Array<String>] The lines that this rollout appears on (if
+  #   {Detour::Feature.with_lines} has already been called).
+  def lines
+    @lines ||= []
+  end
+
+  def to_s
+    name
+  end
+
+  # Returns the number of flag-ins for a given type.
+  #
+  # @example
+  #   feature.flag_in_count_for("users")
+  #
+  # @return [Fixnum] The number of flag-ins for the given type.
+  def flag_in_count_for(type)
+    flag_in_counts[type] || 0
+  end
+
+  # Returns the number of opt-outs for a given type.
+  #
+  # @example
+  #   feature.opt_out_count_for("users")
+  #
+  # @return [Fixnum] The number of opt-outs for the given type.
+  def opt_out_count_for(type)
+    opt_out_counts[type] || 0
+  end
+
+  # Return an array of both every feature in the database as well as every
+  # feature that is checked for in `@grep_dirs`. Features that are checked
+  # for but not persisted will be returned as unpersisted instances of this
+  # class. Each instance returned will have its `@lines` set to an array
+  # containing every line in `@grep_dirs` where it is checked for.
+  #
+  # @return [Array<Detour::Feature>] Every persisted and
+  #   checked-for feature.
+  def self.with_lines
+    hash = all.each_with_object({}) { |feature, hash| hash[feature.name] = feature }
+
+    Dir[*Detour.config.grep_dirs].each do |path|
+      next unless File.file? path
+
+      File.open path do |file|
+        file.each_line.with_index(1) do |line, i|
+          line.scan(/\.has_feature\?\s*\(*:(\w+)/).each do |match, _|
+            (hash[match] ||= new(name: match)).lines << "#{path}#L#{i}"
+          end
+        end
+      end
+    end
+
+    hash.values.sort_by(&:name)
+  end
+end

data/{lib → app/models}/detour/flag.rb

@@ -6,8 +6,14 @@ class Detour::Flag < ActiveRecord::Base
 
   belongs_to :feature
 
-  validates :feature_id, presence: true
-  validates :flaggable_type, presence: true
+  validates_presence_of :feature
+  validates_presence_of :flaggable_type
 
   attr_accessible :flaggable_type
+
+  private
+
+  def flag_type
+    self.class.to_s.underscore.gsub("detour/", "").split("_")[0..-2].join("_")
+  end
 end

data/app/models/detour/flag_in_flag.rb

@@ -0,0 +1,12 @@
+# An individual record of a certain type may be flagged into a feature with
+# this class.
+class Detour::FlagInFlag < Detour::Flag
+  include Detour::Concerns::CountableFlag
+
+  belongs_to :flaggable, polymorphic: true
+
+  validates_presence_of   :flaggable
+  validates_uniqueness_of :feature_id, scope: [:flaggable_type, :flaggable_id]
+
+  attr_accessible :flaggable
+end

data/app/models/detour/group_flag.rb

@@ -0,0 +1,13 @@
+# A group of flaggable records of a given class may be flagged into a feature
+# with this class.
+class Detour::GroupFlag < Detour::Flag
+  validates_presence_of   :group_name
+  validates_uniqueness_of :feature_id, scope: [:flaggable_type, :group_name]
+
+  attr_writer     :to_keep
+  attr_accessible :group_name
+
+  def to_keep
+    @to_keep || (!marked_for_destruction? && !new_record?)
+  end
+end

data/{lib → app/models}/detour/opt_out_flag.rb

@@ -1,10 +1,12 @@
 # Ensures that a feature will never be available to the associated record,
 # even in the case of, for example, a 100% flag.
 class Detour::OptOutFlag < Detour::Flag
+  include Detour::Concerns::CountableFlag
+
   belongs_to :flaggable, polymorphic: true
 
-  validates :flaggable_id, presence: true
-  validates :feature_id, uniqueness: { scope: [:flaggable_type, :flaggable_id] }
+  validates_presence_of   :flaggable
+  validates_uniqueness_of :feature_id, scope: [:flaggable_type, :flaggable_id]
 
   attr_accessible :flaggable
 end

data/app/models/detour/percentage_flag.rb

@@ -0,0 +1,9 @@
+# A percentage of flaggable records of a given class may be flagged into a feature
+# with this class.
+class Detour::PercentageFlag < Detour::Flag
+  validates_presence_of     :percentage
+  validates_numericality_of :percentage, greater_than: 0, less_than_or_equal_to: 100
+  validates_uniqueness_of   :feature_id, scope: :flaggable_type
+
+  attr_accessible :percentage
+end

data/app/views/detour/features/_errors.html.erb

@@ -0,0 +1,11 @@
+<div class="panel panel-danger">
+  <div class="panel-heading">Whoops! There were some errors saving your feature:</div>
+
+  <div class="panel-body">
+    <ul>
+      <% @feature.errors.full_messages.each do |msg| %>
+        <li><%= msg %></li>
+      <% end %>
+    </ul>
+  </div>
+</div>

data/app/views/detour/features/_success.html.erb

@@ -0,0 +1 @@
+<div class="alert alert-success"><%= flash.notice %></div>

data/app/views/detour/features/error.js.erb

@@ -0,0 +1,5 @@
+if ($(".modal-body .panel-danger").length) {
+  $("#create-feature .modal-body .panel-danger").replaceWith("<%= j render "errors" %>");
+} else {
+  $("#create-feature .modal-body").prepend("<%= j render "errors" %>");
+}

data/app/views/detour/features/success.js.erb

@@ -0,0 +1 @@
+location.reload();

data/app/views/detour/flaggable_flags/_errors.html.erb

@@ -0,0 +1,11 @@
+<div class="panel panel-danger">
+  <div class="panel-heading">Whoops! There were some errors saving your feature:</div>
+
+  <div class="panel-body">
+    <ul>
+      <% @errors.each do |error| %>
+        <li><%= error %></li>
+      <% end %>
+    </ul>
+  </div>
+</div>