zendesk-features 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+coverage
+rdoc
+pkg
+test/debug.log

data/README.rdoc

@@ -0,0 +1,105 @@
+= Features
+Features is a nice little gem for associating application features with an active record model in a Rails app.
+
+Developed and used on http://zendesk.com for account owners to switch different application features on and off.
+
+== Sponsored by Zendesk - Enlightened Customer Support
+
+== Description
+
+If the feature set of your application grows, some customers would like to limit the features to only include what they
+need. To enable your customers at Zendesk to customize their help desk to their needs, we developed this nice lille feature
+management system, that we thought someone else out there might find useful.
+
+You can define your feature set in a nice directly in the class that should be associated with features:
+
+  class Account < ActiveRecord::Base
+    has_features do
+      feature :archive
+      feature :ssl
+    end
+  end
+  
+Which would enable code like:
+
+  account.features.archive? # checks weather an account has the archive feature.
+  account.features.archive.create # adds the archive feature to the account
+  account.features.archive.destroy # removes the archive feature to the account
+  account.features?(:account, :ssl) # checks if the account has both the archive and ssl features
+
+You can also define feature dependencies:
+
+  class Account < ActiveRecord::Base
+    has_features do
+      feature :archive
+      feature :premium
+      feature :ssl, :requires => [:premium]
+    end
+  end
+
+Which would enable code like:
+
+  account.features.ssl.available? # returns true if all the required features of the ssl feature are met.
+  account.features.ssl.create # raises a Features::RequirementsError if the account doesn't have the premium feature
+  account.features.premium.destroy # would also destroy the ssl feature
+
+Features can also be updated with the update_attributes and update_attributes! methods.
+  
+  #assuming params include { :account => { :features => { :archive => '1', :ssl => '0' } } }
+  account.update_attributes(params[:account]) # would add the archive feature and remove the ssl feature
+  
+WARNING: You might want to protect some features from being updated with update_attributes. You can do this with:
+
+  class Account < ActiveRecord::Base
+    has_features do
+      feature :archive
+      feature :premium, :protected => true
+      feature :ssl, :requires => [:premium]
+    end
+  end
+
+This would protect the premium feature from being updated with update_attributes and update_attributes! The premium feature can only be updated with account.features.premium.create and account.features.premium.destroy.
+
+We also created a view helper to help you generate the UI for enabling and disabling features:
+
+  <% form_for(:account, :html => { :method => :put }) do |f| %>
+    <h3>
+      <%= f.feature_check_box :ssl %> Enable SSL on your account
+    </h3>
+  <% end %>
+
+== Known issues
+
+Let us know if you find any.
+
+== Requirements
+
+* ActiveRecord
+* ActionPack
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Zendesk
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "features"
+    gem.summary = %Q{Features is a nice little gem for associating application features with an active record model in a Rails app}
+    gem.email = "mick@zendesk.com"
+    gem.homepage = "http://github.com/zendesk/features"
+    gem.authors = ["Mick Staugaard", "Morten Primdahl"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "features #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/features.rb

@@ -0,0 +1,3 @@
+require 'features/feature'
+require 'features/active_record_extension'
+require 'features/features_helper'

data/lib/features/active_record_extension.rb

@@ -0,0 +1,135 @@
+module Features
+  module ActiveRecordExtension
+    module ClassMethods
+      def has_features(&block)
+        builder = FeatureTreeBuilder.new(self)
+        builder.instance_eval(&block)
+        builder.build
+
+        has_many :features, :class_name => 'Features::Feature', :dependent => :destroy do
+          def available?(feature_name)
+            @owner.features?(*Feature.sym_to_class(feature_name).required_features.map(&:to_sym))
+          end
+          
+          # Define the feature query methods, given that the feature +wiffle+ is defined,
+          # then the methods +account.features.wiffle?+ and +account.features.wiffle!+ will
+          # be available
+          Feature::LIST.each do |f|
+
+            # The query method, does this account have a given feature? account.features.wiffle?
+            define_method "#{f}?" do
+              any? { |feature| feature.matches?(f) }
+            end
+
+            # The finder method which returns the feature if present, otherwise a new instance, allows
+            # non-destructive create and delete operations:
+            #
+            #   account.features.wiffle.destroy
+            #   account.features.wiffle.create
+            #
+            # In the latter case, a the +wiffle+ feature will only be enabled if it's not already. Be careful
+            # not to confuse this method with the "feature enabled" method above, ie. avoid
+            #
+            #   format_c if account.feature.wiffle
+            #
+            define_method "#{f}" do
+              instance = detect { |feature| feature.matches?(f) }
+              instance ||= Feature.sym_to_class(f).new(@owner.class.name.underscore.to_sym => @owner)
+            end
+          end
+        end
+        
+        include Features::ActiveRecordExtension::InstanceMethods
+        alias_method_chain :update_attributes, :features
+        alias_method_chain :update_attributes!, :features
+        
+      end
+    end
+
+    module InstanceMethods
+      # Allows you to check for multiple features like account.features?(:suggestions, :suggestions_on_web)
+      def features?(*feature_names)
+        feature_names.all? { |feature_name| features.send("#{feature_name}?") }
+      end
+
+      def update_attributes_with_features(attributes)
+        update_feature_attributes(attributes)
+        update_attributes_without_features(attributes)
+      end
+
+      def update_attributes_with_features!(attributes)
+        update_feature_attributes(attributes)
+        update_attributes_without_features!(attributes)
+      end
+
+      private
+
+      def update_feature_attributes(attributes)
+        if attributes && feature_attributes = attributes.delete(:features)
+          feature_attributes.each do |feature_name, value|
+            feature = features.send(feature_name)
+            if feature.protected?
+              logger.warn("someone tried to mass update the protected #{feature_name} feature")
+            else
+              if value == '1' || value == true
+                feature.create
+              else
+                feature.destroy
+              end
+            end
+          end
+          features.reset
+        end
+      end
+    end
+    
+    class FeatureTreeBuilder
+      def initialize(owner_class)
+        @owner_class = owner_class
+        @definitions = Hash.new
+      end
+      
+      def feature(name, options = {})
+        raise("Feature name '#{name}' is too long. Max 28 characters please...") if name.to_s.size > 28
+        feature_options = options.reverse_merge({:requires => [], :dependants => [], :protected => false})
+        feature_options[:requires] = [*feature_options[:requires]].uniq
+        @definitions[name.to_sym] = feature_options
+      end
+      
+      def resolve_dependencies
+        @definitions.each do |name, options|
+          options[:requires].each do |required_feature_name|
+            @definitions[required_feature_name][:dependants] << name
+          end
+        end
+      end
+      
+      def build
+        resolve_dependencies
+        #defines the feature classes
+        @definitions.each do |name, options|
+          new_feature = Object.const_set(Feature.sym_to_name(name), Class.new(Feature))
+          new_feature.feature_owner = @owner_class
+        end
+        
+        #sets the feature classes options
+        @definitions.each do |name, options|
+          new_feature = Feature.sym_to_class(name)
+          new_feature.protect! if options[:protected]
+          new_feature.required_features = options[:requires].map {|f| Feature.sym_to_class(f)}
+          new_feature.dependant_features = options[:dependants].map {|f| Feature.sym_to_class(f)}
+
+          Feature::LIST << name
+        end
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend ClassMethods
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include Features::ActiveRecordExtension
+end

data/lib/features/feature.rb

@@ -0,0 +1,134 @@
+require 'features/active_record_extension'
+
+module Features
+  class RequirementsError < StandardError
+  end
+
+  # If you want to add a feature, simply define a suitable symbol to Feature::LIST. If for example you
+  # want to define the "wiffle feature", add :wiffle and you can subsequenctly do:
+  #
+  #   account.features.wiffle?
+  #   account.features.wiffle.destroy
+  #   account.features.wiffle.create
+  #
+  class Feature < ActiveRecord::Base
+    abstract_class = true
+  
+    LIST = []
+  
+    validate_on_create    :unique_type
+    after_create :reset_owner_association
+    after_destroy :reset_owner_association
+    before_destroy :destroy_dependant_features
+  
+    def unique_type
+      errors.add(:feature, :taken) if self.class.exists?(self.class.feature_owner_key => send(self.class.feature_owner_key))
+    end
+    
+    def available?
+      feature_owner_instance.features.available?(to_sym)
+    end
+  
+    def create
+      if new_record?
+        raise RequirementsError.new unless available?
+        super
+      end
+      self
+    end
+    
+    def matches?(sym)
+      to_sym == sym.to_sym
+    end  
+  
+    def to_sym
+      @sym ||= Feature.class_to_sym(self.class)
+    end
+    
+    def self.to_sym
+      @sym ||= Feature.class_to_sym(self)
+    end
+    
+    def self.class_to_sym(klass)
+      klass.name.tableize.tableize[0..-10].to_sym
+    end
+    
+    def self.sym_to_name(sym)
+      "#{sym.to_s.camelize}Feature"
+    end
+    
+    def self.sym_to_class(sym)
+      sym_to_name(sym).constantize
+    end
+    
+    def self.protected?
+      @protect || false
+    end
+    def protected?
+      self.class.protected?
+    end
+    
+    def self.required_features
+      @required_features ||= []
+    end
+    def required_features
+      self.class.required_features
+    end
+    
+    def self.dependant_features
+      @dependant_features ||= []
+    end
+    def dependant_features
+      self.class.dependant_features
+    end
+    
+    private
+    
+    def feature_owner_instance
+      send(self.class.feature_owner)
+    end
+    def update_owner_timestamp
+      feature_owner_instance.update_attribute(:updated_at, Time.now)
+    end
+    
+    def reset_owner_association
+      feature_owner_instance.features.reload
+    end
+    
+    def destroy_dependant_features
+      dependant_features.each do |dependant|
+        feature_owner_instance.features.send(dependant.to_sym).destroy
+      end
+    end
+    
+    def self.protect!
+      @protect = true
+    end
+    
+    def self.required_features=(required_features)
+      @required_features = required_features
+    end
+    def self.dependant_features=(dependant_features)
+      @dependant_features = dependant_features
+    end
+    
+    def self.feature_owner=(owner_class)
+      @feature_owner_sym = owner_class.name.underscore.to_sym
+      belongs_to @feature_owner_sym
+      validates_presence_of @feature_owner_sym
+      if owner_class.column_names.include?('updated_at')
+        before_create :update_owner_timestamp
+        before_destroy :update_owner_timestamp
+      end
+    end
+    
+    def self.feature_owner
+      @feature_owner_sym
+    end
+    
+    def self.feature_owner_key
+      "#{@feature_owner}_id".to_sym
+    end
+  end
+
+end

data/lib/features/features_helper.rb

@@ -0,0 +1,18 @@
+module ActionView
+  module Helpers
+    def feature_check_box(model_name, method, options = {}, checked_value = "1", unchecked_value = "0")
+      account = @template.instance_variable_get("@#{model_name}")
+      throw "feature_check_box only work on models with features" unless account.respond_to?(:features)
+      options[:checked] = account.features.send("#{method}?")
+      options[:id] ||= "#{model_name}_features_#{method}"
+      options[:name] = "#{model_name}[features][#{method}]"
+      @template.check_box(model_name, "features_#{method}", options, checked_value, unchecked_value)
+    end
+
+    class FormBuilder
+      def feature_check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+        @template.feature_check_box(@object_name, method, objectify_options(options), checked_value, unchecked_value)
+      end
+    end
+  end
+end

data/test/database.yml

@@ -0,0 +1,7 @@
+test:
+  adapter: mysql
+  encoding: utf8
+  database: features_test
+  username: root
+  password:
+  socket: /tmp/mysql.sock

data/test/features_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class Account < ActiveRecord::Base
+  has_features do
+    feature :archive_reports, :requires => [:archive, :reports]
+    feature :ssl, :protected => true
+    feature :archive
+    feature :reports
+  end
+end
+
+class FeaturesTest < ActiveSupport::TestCase
+  fixtures :accounts, :features
+  
+  test "that features can be created" do
+    a = Account.create(:name => 'name')
+    assert(a.features.empty?)
+    assert(!a.features.archive?)
+    assert(a.features.archive.create)
+    assert(a.features.size == 1)
+    assert(a.features.archive?)
+    assert(a.features.archive.id == a.features.archive.create.id)
+  end
+
+  test "that features can be destroyed" do
+    a = accounts(:account1)
+    assert(a.features.archive?)
+    assert(a.features.archive.destroy)
+    a.features.reload
+    assert(!a.features.archive?)
+  end
+
+  test "checks for features" do
+    a = accounts(:account1)
+    assert(a.features.archive?)
+    assert(a.features.ssl?)
+    assert(!a.features.reports?)
+  end
+  
+  test "validates feature requirements" do
+    a = accounts(:account1)
+    assert(a.features.reports.available?)
+    assert(!a.features.archive_reports.available?)
+    
+    assert_raises Features::RequirementsError do
+      a.features.archive_reports.create
+    end
+    
+    assert(a.features.reports.create)
+    assert(a.features.archive_reports.create)
+  end
+  
+  test "destroys dependant features when destroyed" do
+    a = accounts(:account1)
+    assert(a.features.reports.create)
+    assert(a.features.archive_reports.create)
+    
+    assert(a.features.archive.destroy)
+    a.features.reload
+    assert(!a.features.archive?)
+    assert(!a.features.archive_reports?)
+    assert(a.features.reports?)
+  end
+  
+  test "mass updating should update features" do
+    a = Account.create(:name => 'name')
+    assert(a.features.empty?)
+    assert(!a.features.archive?)
+    assert(!a.features.reports?)
+    
+    a.update_attributes(:features => {:archive => '1', :reports => '1'})
+    assert(a.features.archive?)
+    assert(a.features.reports?)
+    
+    a.update_attributes(:features => {:archive => '0', :reports => '0'})
+    assert(!a.features.archive?)
+    assert(!a.features.reports?)
+  end
+  
+  test "mass updating should not update protected features" do
+    a = Account.create(:name => 'name')
+    assert(a.features.empty?)
+    assert(!a.features.archive?)
+    assert(!a.features.ssl?)
+    
+    a.update_attributes(:features => {:archive => '1', :ssl => '1'})
+    assert(a.features.archive?)
+    assert(!a.features.ssl?)
+    
+    assert(a.features.ssl.create)
+    assert(a.features.ssl?)
+    a.update_attributes(:features => {:archive => '0', :ssl => '0'})
+    assert(!a.features.archive?)
+    assert(a.features.ssl?)
+  end
+end

data/test/fixtures/accounts.yml

@@ -0,0 +1,3 @@
+account1:
+  name: My Account
+  id: 1

data/test/fixtures/features.yml

@@ -0,0 +1,7 @@
+account1_archive:
+  account_id: 1
+  type: ArchiveFeature
+
+account1_ssl:
+  account_id: 1
+  type: SslFeature

data/test/schema.rb

@@ -0,0 +1,27 @@
+# This file is auto-generated from the current state of the database. Instead of editing this file, 
+# please use the migrations feature of Active Record to incrementally modify your database, and
+# then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your database schema. If you need
+# to create the application database on another system, you should be using db:schema:load, not running
+# all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "features", :force => true do |t|
+    t.string   "type"
+    t.integer  "account_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "accounts", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_record'
+require 'active_record/fixtures'
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection('test')
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+
+load(File.dirname(__FILE__) + "/schema.rb")
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'features'
+ 
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+ 
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+ 
+  # Add more helper methods to be used by all tests here...
+end
+
+ActiveSupport::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+$LOAD_PATH.unshift(ActiveSupport::TestCase.fixture_path)

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: zendesk-features
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Mick Staugaard
+- Morten Primdahl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mick@zendesk.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/features.rb
+- lib/features/active_record_extension.rb
+- lib/features/feature.rb
+- lib/features/features_helper.rb
+- test/database.yml
+- test/features_test.rb
+- test/fixtures/accounts.yml
+- test/fixtures/features.yml
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/zendesk/features
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Features is a nice little gem for associating application features with an active record model in a Rails app
+test_files: 
+- test/features_test.rb
+- test/schema.rb
+- test/test_helper.rb