detour 0.0.3 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae9c93918889c5377f07579be0dcb784a5ed6007
+  data.tar.gz: c0b1be203e73c179a460a508b0e8ef1c520c1b57
+SHA512:
+  metadata.gz: c349a69e7e806ac938dc1857817eec6a9a89ea4542f638374b1194102684bf85e420ae683cadd976ec1d316385d770e60619983096253fb173335f265b1ec9b3
+  data.tar.gz: 2320eba53839ee27c664ef1b1407a140ce21e88ad233bf82f0b8c35fa5431cc660beee97124a6f3aa8226f38cda3b24f1960d8235ab7d9f122a0abc145d421fe

data/README.md

@@ -107,20 +107,8 @@ flagged into a specific feature. The `#has_feature?` method provided by
 
 ### Determining if a record is flagged into a feature
 
-`#has_feature?` has two methods of use. The first one, where it is passed a
-block, will increment a `failure_count` on the given feature if the block
-raises an exception (the exception is again raised after incrementing). This
-currently does not alter the behavior of the feature, but it services a metrics
-purpose:
-
-```ruby
-current_user.has_feature? :new_user_interface do
-  render_new_user_interface
-end
-```
-
-When not given a block, it simply returns a boolean, and does not watch for
-exceptions:
+Call the `#has_feature?` method on an instance of your class that implements
+`acts_as_flaggable`.
 
 ```ruby
 if current_user.has_feature? :new_user_interface
@@ -128,17 +116,6 @@ if current_user.has_feature? :new_user_interface
 end
 ```
 
-Want to make use of both? `#has_feature?` returns a boolean even when passed
-a block:
-
-```ruby
-if current_user.has_feature? :new_user_interface do
-  render_new_user_interface
-end; else
-  render_old_user_interface
-end
-```
-
 ### Defining programmatic groups
 
 A specific group of records matching a given block can be flagged into a

data/app/assets/javascripts/detour/add_fields.js

@@ -0,0 +1,7 @@
+$(document).on('click', 'form .add-fields', function(e) {
+  e.preventDefault();
+  var time   = new Date().getTime(),
+      regexp = new RegExp($(this).data('id'), 'g');
+
+  $(this).before($(this).data('fields').replace(regexp, time));
+});

data/app/assets/javascripts/detour/delete_feature.js

@@ -1,13 +1,11 @@
-$(function () {
-  $('.delete-feature').on('click', function (e) {
-    var href    = $(e.currentTarget).data('path'),
-        feature = $(e.currentTarget).closest('td').next().text(),
-        $modal  = $('#delete-feature'),
-        $name   = $modal.find('.feature-name'),
-        $link   = $modal.find('a');
+$(document).on('click', '.delete-feature', function (e) {
+  var href    = $(e.currentTarget).data('path'),
+      feature = $(e.currentTarget).closest('td').next().text(),
+      $modal  = $('#delete-feature'),
+      $name   = $modal.find('.feature-name'),
+      $link   = $modal.find('a');
 
-    $link.attr('href', href);
-    $name.text(feature.trim());
-    $modal.modal('show');
-  });
+  $link.attr('href', href);
+  $name.text(feature.trim());
+  $modal.modal('show');
 });

data/app/assets/javascripts/detour/delete_flag.js

@@ -1,13 +1,11 @@
-$(function () {
-  $('.delete-flag').on('click', function (e) {
-    var href    = $(e.currentTarget).data('path'),
-        id      = $(e.currentTarget).closest('td').next().text(),
-        $modal  = $('#delete-flag'),
-        $id     = $modal.find('.flaggable-identifier'),
-        $link   = $modal.find('a');
+$(document).on('click', '.delete-flag', function (e) {
+  var href    = $(e.currentTarget).data('path'),
+      id      = $(e.currentTarget).closest('td').next().text(),
+      $modal  = $('#delete-flag'),
+      $id     = $modal.find('.flaggable-identifier'),
+      $link   = $modal.find('a');
 
-    $link.attr('href', href);
-    $id.text(id.trim());
-    $modal.modal('show');
-  });
+  $link.attr('href', href);
+  $id.text(id.trim());
+  $modal.modal('show');
 });

data/app/assets/javascripts/detour/delete_group.js

@@ -0,0 +1,5 @@
+$(document).on('click', '.delete-group', function (e) {
+  e.preventDefault();
+  var $modal  = $('#delete-group');
+  $modal.modal('show');
+});

data/app/assets/javascripts/detour/feature_lines.js

@@ -0,0 +1,23 @@
+$(function() {
+  $('.feature-lines').each(function() {
+    var lines  = $(this).data('lines').split(','),
+        prefix = $(this).data('prefix');
+
+    $(this).popover({
+      html     : true,
+      content  : function() { return lineList(prefix, lines) },
+      placement: 'bottom'
+    });
+  });
+
+  function lineList(prefix, lines) {
+    var str = '<ul>';
+
+    lines.forEach(function(line) {
+      line = '<li><a href="' + prefix + line + '">' + line + '</a></li>';
+      str += line;
+    });
+
+    return str;
+  }
+});

data/app/assets/javascripts/detour/modals.js

@@ -1,3 +1,4 @@
 $(document).on('hidden.bs.modal', '.modal', function () {
   $('.panel', this).remove();
+  $('form', this)[0].reset();
 });

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

@@ -4,6 +4,14 @@
   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');
 }
 
+.popover {
+  max-width: none;
+}
+
+.popover ul {
+  padding-left: 10px;
+}
+
 body {
   padding-bottom: 40px;
 }
@@ -47,3 +55,7 @@ table.table tbody tr td {
 .counter-header {
   width: 80px;
 }
+
+.delete-group {
+  margin-left: 0.5em;
+}

data/app/controllers/detour/features_controller.rb

@@ -4,9 +4,10 @@ class Detour::FeaturesController < Detour::ApplicationController
 
     if @feature.save
       flash[:notice] = "Your feature has been successfully created."
-      render :success
+      render "detour/shared/success"
     else
-      render :error
+      @model = @feature
+      render "detour/shared/error"
     end
   end
 

data/app/controllers/detour/flaggable_flags_controller.rb

@@ -1,90 +1,22 @@
 require "indefinite_article"
 
 class Detour::FlaggableFlagsController < Detour::ApplicationController
+  include Detour::FlaggableFlagsHelper
+
   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)
+    @feature = Detour::Feature.find_by_name!(params[:feature_name])
   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
+  def update
+    @feature = Detour::Feature.find_by_name!(params[:feature_name])
 
-      if @errors.any?
-        raise ActiveRecord::Rollback
-      end
-    end
-
-    if @errors.empty?
-      flash[:notice] = success_message
-      render :success
+    if @feature.update_attributes(params[:feature])
+      flash[:notice] = "Your #{flag_noun.pluralize} have been updated"
+      redirect_to send("#{flag_type}_flags_path", feature_name: params[:feature_name], flaggable_type: params[:flaggable_type])
     else
-      render :error
+      render :index
     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/groups_controller.rb

@@ -0,0 +1,39 @@
+class Detour::GroupsController < Detour::ApplicationController
+  def index
+    @groups = Detour::Group.all
+  end
+
+  def show
+    @group = Detour::Group.find(params[:id])
+  end
+
+  def create
+    @group = Detour::Group.new(params[:group])
+
+    if @group.save
+      flash[:notice] = "Your group has been successfully created."
+      render "detour/shared/success"
+    else
+      @model = @group
+      render "detour/shared/error"
+    end
+  end
+
+  def update
+    @group = Detour::Group.find(params[:id])
+
+    if @group.update_attributes(params[:group])
+      flash[:notice] = "Your group has been successfully updated."
+      redirect_to group_path @group
+    else
+      render :show
+    end
+  end
+
+  def destroy
+    @group = Detour::Group.find(params[:id])
+    @group.destroy
+    flash[:notice] = "Group \"#{@group.name}\" has been deleted."
+    redirect_to groups_path
+  end
+end

data/app/helpers/detour/application_helper.rb

@@ -1,4 +1,15 @@
 module Detour::ApplicationHelper
+  def link_to_add_fields(name, f, association, template = nil)
+    new_object = f.object.send(association).klass.new
+    template ||= "#{association.to_s.singularize}_fields"
+    id = new_object.object_id
+    fields = f.fields_for(association, new_object, child_index: id) do |builder|
+      render("#{template}", f: builder)
+    end
+
+    link_to name, "javascript:void(0)", class: "add-fields btn btn-default", data: { id: id, fields: fields.gsub("\n", "") }
+  end
+
   def table(&block)
     content_tag :div, class: "table-responsive" do
       content_tag :table, class: "table table-striped" do

data/app/helpers/detour/flaggable_flags_helper.rb

@@ -1,5 +1,25 @@
 module Detour::FlaggableFlagsHelper
+  def feature_name
+    params[:feature_name]
+  end
+
+  def flag_noun
+    flag_type.dasherize
+  end
+
   def flag_title
     flag_noun.capitalize
   end
+
+  def flag_type
+    request.path.split("/")[2].underscore.singularize
+  end
+
+  def flag_verb
+    flag_type == "flag_in" ? "flagged in to" : "opted out of"
+  end
+
+  def flaggable_type
+    params[:flaggable_type]
+  end
 end

data/app/helpers/detour/flags_helper.rb

@@ -1,6 +1,10 @@
 module Detour::FlagsHelper
+  def github_prefix
+    "https://github.com/#{ENV["DETOUR_GITHUB_REPO"]}/blob/#{ENV["DETOUR_GITHUB_BRANCH"]}/"
+  end
+
   def spacer_count
-    names_count = @flag_form.group_names.length
+    names_count = @flag_form.groups.length
     difference  = 10 - names_count
     count       = difference < 0 ? 0 : difference
   end

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

@@ -0,0 +1,21 @@
+module Detour::Concerns
+  module Keepable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :to_keep
+    end
+
+    def to_keep
+      @to_keep || (!marked_for_destruction? && !new_record?)
+    end
+
+    def keep_or_destroy(params = {})
+      if params["to_keep"] == "1"
+        self.to_keep = true
+      else
+        mark_for_destruction
+      end
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
 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.
+    # to it either via direct flagging-in, percentage, or by database or defined
+    # group membership.
     #
     # @example
     #   feature.match?(current_user)
@@ -11,7 +12,10 @@ module Detour::Concerns
     #
     # @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)
+      match_id?(instance)                ||
+        match_percentage?(instance)      ||
+        match_database_groups?(instance) ||
+        match_defined_groups?(instance)
     end
 
     # Determines whether or not the given instance has had the feature rolled out
@@ -48,25 +52,40 @@ module Detour::Concerns
     end
 
     # Determines whether or not the given instance has had the feature rolled out
-    # to it via group membership.
+    # to it via database group membership.
     #
     # @example
-    #   feature.match_groups?(current_user)
+    #   feature.match_database_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 database group membership.
+    def match_database_groups?(instance)
+      database_group_flags.where(flaggable_type: instance.class).map(&:members).flatten.uniq.include? instance
+    end
+
+    # Determines whether or not the given instance has had the feature rolled out
+    # to it via defined group membership.
+    #
+    # @example
+    #   feature.match_defined_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)
+    def match_defined_groups?(instance)
       klass = instance.class.to_s
 
-      return unless Detour.config.defined_groups[klass]
+      return unless Detour::DefinedGroup.by_type(klass).any?
 
-      group_names = group_flags.find_all_by_flaggable_type(klass).collect(&:group_name)
+      group_names = defined_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.to_s
+      Detour::DefinedGroup.by_type(klass).collect { |name, group|
+        group.test(instance) if group_names.include? group.name
       }.any?
     end
   end

data/app/models/detour/database_group_flag.rb

@@ -0,0 +1,30 @@
+class Detour::DatabaseGroupFlag < Detour::Flag
+  include Detour::Concerns::Keepable
+
+  validates_presence_of   :group_id
+  validates_presence_of   :flaggable_type
+  validates_uniqueness_of :feature_id, scope: :group_id
+
+  attr_accessible :group_id
+
+  belongs_to :group
+  has_many   :memberships, through: :group
+
+  def members
+    flaggable_class.joins(%Q{INNER JOIN "detour_memberships" ON "#{flaggable_type.downcase.pluralize}"."id" = "detour_memberships"."member_id"}).where(detour_memberships: { group_id: group.id })
+  end
+
+  def group_name
+    group.name
+  end
+
+  def group_type
+    "database"
+  end
+
+  private
+
+  def flaggable_class
+    flaggable_type.constantize
+  end
+end

data/app/models/detour/defined_group.rb

@@ -0,0 +1,21 @@
+class Detour::DefinedGroup
+  attr_reader :name
+  alias :id :name
+
+  def initialize(name, test)
+    @name = name.to_s
+    @test = test
+  end
+
+  def to_s
+    name
+  end
+
+  def test(arg)
+    @test.call(arg)
+  end
+
+  def self.by_type(type)
+    Detour.config.defined_groups.fetch(type.to_s, {}).with_indifferent_access
+  end
+end

data/app/models/detour/defined_group_flag.rb

@@ -0,0 +1,28 @@
+# A group of flaggable records of a given class may be flagged into a feature
+# with this class.
+class Detour::DefinedGroupFlag < Detour::Flag
+  include Detour::Concerns::Keepable
+
+  validates_presence_of   :group_name
+  validates_uniqueness_of :feature_id, scope: [:flaggable_type, :group_name]
+
+  attr_accessible :group_name
+
+  def group
+    find_group || build_group
+  end
+
+  def group_type
+    "defined"
+  end
+
+  private
+
+  def find_group
+    Detour::DefinedGroup.by_type(flaggable_type)[group_name]
+  end
+
+  def build_group
+    Detour::DefinedGroup.new(group_name, ->{})
+  end
+end

data/app/models/detour/feature.rb

@@ -2,7 +2,6 @@
 # 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
 
@@ -10,13 +9,15 @@ class Detour::Feature < ActiveRecord::Base
   serialize :opt_out_counts, JSON
 
   has_many :flag_in_flags
-  has_many :group_flags
+  has_many :defined_group_flags
+  has_many :database_group_flags
   has_many :percentage_flags
   has_many :opt_out_flags
   has_many :flags, dependent: :destroy
 
   validates_presence_of   :name
   validates_uniqueness_of :name
+  validates_format_of     :name, with: /\A[\w-]+\Z/
 
   attr_accessible :name
 
@@ -69,7 +70,7 @@ class Detour::Feature < ActiveRecord::Base
 
       File.open path do |file|
         file.each_line.with_index(1) do |line, i|
-          line.scan(/\.has_feature\?\s*\(*:(\w+)/).each do |match, _|
+          line.scan(/\.has_feature\?\s*\(?[:"]([\w-]+)/).each do |match, _|
             (hash[match] ||= new(name: match)).lines << "#{path}#L#{i}"
           end
         end

data/app/models/detour/flag_in_flag.rb

@@ -1,12 +1,5 @@
 # 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
+class Detour::FlagInFlag < Detour::FlaggableFlag
   validates_uniqueness_of :feature_id, scope: [:flaggable_type, :flaggable_id]
-
-  attr_accessible :flaggable
 end

data/app/models/detour/flaggable_flag.rb

@@ -0,0 +1,24 @@
+class Detour::FlaggableFlag < Detour::Flag
+  include Detour::Concerns::CountableFlag
+
+  belongs_to :flaggable, polymorphic: true
+
+  validates_presence_of :flaggable
+
+  attr_accessor   :flaggable_key
+  attr_accessible :flaggable
+  attr_accessible :flaggable_key
+
+  before_validation :set_flaggable
+
+  private
+
+  def set_flaggable
+    unless flaggable || !flaggable_key
+      self.flaggable_id = flaggable_type.constantize.flaggable_find!(flaggable_key).id
+    end
+  rescue ActiveRecord::RecordNotFound
+    errors.add(flaggable_type, "\"#{flaggable_key}\" could not be found")
+    false
+  end
+end

data/app/models/detour/group.rb

@@ -0,0 +1,17 @@
+class Detour::Group < ActiveRecord::Base
+  validates :name,           presence: true, uniqueness: { scope: :flaggable_type }
+  validates :flaggable_type, presence: true, inclusion: { in: Detour.config.flaggable_types }
+  has_many :memberships, dependent: :destroy
+
+  accepts_nested_attributes_for :memberships, allow_destroy: true
+
+  attr_accessible :name, :flaggable_type, :memberships_attributes
+
+  def to_s
+    name
+  end
+
+  def flaggable_class
+    flaggable_type.constantize
+  end
+end