abstract_feature_branch 0.7.1 → 0.8.0

data/lib/generators/abstract_feature_branch/install_generator.rb

@@ -5,6 +5,7 @@ module AbstractFeatureBranch
 
       desc "Installs Abstract Feature Branch by generating basic configuration files, including git ignored local one."
       def copy_config
+        template "lib/tasks/abstract_feature_branch.rake", "lib/tasks/abstract_feature_branch.rake"
         template "config/initializers/abstract_feature_branch.rb", "config/initializers/abstract_feature_branch.rb"
         template "config/features.example.yml", "config/features.yml"
         template "config/features.local.yml", "config/features.local.yml"

data/lib/generators/templates/config/features.local.yml

@@ -2,6 +2,7 @@
 # It is recommended to use this file only for temporary overrides. Once done, make final change in main .yml
 defaults: &defaults
 
+
 development:
   <<: *defaults
 

data/lib/generators/templates/config/initializers/abstract_feature_branch.rb

@@ -4,5 +4,8 @@ AbstractFeatureBranch.application_root = Rails.root
 # Application environment (e.g. "development", "staging" or "production")
 AbstractFeatureBranch.application_environment = Rails.env.to_s
 
+# Abstract Feature Branch logger
+AbstractFeatureBranch.logger = Rails.logger
+
 # Pre-loads application features to improve performance of first web-page hit
 AbstractFeatureBranch.load_application_features

data/lib/generators/templates/lib/tasks/abstract_feature_branch.rake

@@ -0,0 +1,9 @@
+require 'abstract_feature_branch'
+namespace :abstract_feature_branch do
+
+  desc "Beautify YAML of specified feature file via file_path argument or all feature files when no argument specified (config/features.yml, config/features.local.yml, and config/features/**/*.yml) by sorting features by name and eliminating extra empty lines"
+  task :beautify_files, :file_path do |_, args|
+    AbstractFeatureBranch::FileBeautifier.process(args[:file_path])
+  end
+
+end

data/spec/abstract_feature_branch/file_beautifier_spec.rb

@@ -0,0 +1,384 @@
+require 'spec_helper'
+
+describe AbstractFeatureBranch::FileBeautifier do
+  describe '#process' do
+    before do
+      @ugly_config_application_root = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config'))
+      @ugly_config_application_reference_root = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config_reference'))
+      FileUtils.rm_rf( @ugly_config_application_root)
+      FileUtils.cp_r(@ugly_config_application_reference_root, @ugly_config_application_root)
+    end
+    after do
+      FileUtils.rm_rf( @ugly_config_application_root)
+    end
+
+    context "a file is specified" do
+      it 'gets rid of extra empty lines' do
+        feature_file_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features.yml'))
+        AbstractFeatureBranch::FileBeautifier.process(feature_file_path)
+        File.open(feature_file_path, 'r') do |file|
+          file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+defaults: &defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+development:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+test:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+staging:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+production:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+          EXPECTED_FILE_CONTENT
+        end
+      end
+
+      it 'sorts features by name under each section (e.g. environment)' do
+        local_feature_file_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features.local.yml'))
+        AbstractFeatureBranch::FileBeautifier.process(local_feature_file_path)
+        File.open(local_feature_file_path, 'r') do |file|
+          file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+defaults: &defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+development:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+test:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+staging:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+production:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+          EXPECTED_FILE_CONTENT
+        end
+      end
+
+      it 'handles comments by ignoring comments on top and deleting comments in the middle' do
+        feature_file_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features', 'including_comments.local.yml'))
+        AbstractFeatureBranch::FileBeautifier.process(feature_file_path)
+        File.open(feature_file_path, 'r') do |file|
+          file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+# This file allows you to override any feature configuration locally without it being committed to git
+# It is recommended to use this file only for temporary overrides. Once done, make final change in main .yml
+defaults: &defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+development:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+test:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+staging:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+production:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+          EXPECTED_FILE_CONTENT
+        end
+      end
+
+      it 'processes a feature empty config file' do
+        feature_file_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features', 'feature_empty_config.local.yml'))
+        AbstractFeatureBranch::FileBeautifier.process(feature_file_path)
+        File.open(feature_file_path, 'r') do |file|
+          file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+defaults: &defaults
+
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+staging:
+  <<: *defaults
+
+production:
+  <<: *defaults
+
+          EXPECTED_FILE_CONTENT
+        end
+      end
+
+      it 'processes an empty file without change or exceptions' do
+        feature_file_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features', 'empty.local.yml'))
+        AbstractFeatureBranch::FileBeautifier.process(feature_file_path)
+        File.open(feature_file_path, 'r') do |file|
+          file.readlines.join.should be_empty
+        end
+      end
+
+    end
+
+    context "a directory is specified" do
+      it 'beautifies all YAML files under specified directory recursively' do
+        feature_directory_path = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config', 'config', 'features'))
+        AbstractFeatureBranch::FileBeautifier.process(feature_directory_path)
+
+        ['public.yml', 'public.local.yml', 'admin.yml', 'admin.local.yml', 'internal/wiki.yml', 'internal/wiki.local.yml'].each do |file_path_suffix|
+          file_path = File.join(feature_directory_path, file_path_suffix)
+          File.open(file_path, 'r') do |file|
+            file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+defaults: &defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+development:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+test:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+staging:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+production:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+            EXPECTED_FILE_CONTENT
+          end
+        end
+      end
+
+      context "no file or directory is specified (process all feature files)" do
+        after do
+          AbstractFeatureBranch.initialize_application_root
+          AbstractFeatureBranch.load_application_features
+        end
+        it 'beautifies all feature files in the application' do
+          AbstractFeatureBranch.application_root = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config'))
+          AbstractFeatureBranch.load_application_features
+          AbstractFeatureBranch::FileBeautifier.process
+
+          [
+            'features.yml',
+            'features.local.yml',
+            'features/public.yml',
+            'features/public.local.yml',
+            'features/admin.yml',
+            'features/admin.local.yml',
+            'features/internal/wiki.yml',
+            'features/internal/wiki.local.yml'
+          ].each do |file_path_suffix|
+            file_path = File.join(AbstractFeatureBranch.application_root, 'config', file_path_suffix)
+            File.open(file_path, 'r') do |file|
+              file.readlines.join.should == <<-EXPECTED_FILE_CONTENT
+defaults: &defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+development:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+test:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+staging:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+production:
+  <<: *defaults
+  FEATURE1: true
+  Feature2: true
+  feature3: false
+  feature4: true
+  feature4a: true
+
+              EXPECTED_FILE_CONTENT
+            end
+          end
+        end
+
+        it 'does not beautify non-feature files in the application' do
+          AbstractFeatureBranch.application_root = File.expand_path(File.join(__FILE__, '..', '..', 'fixtures', 'application_ugly_config'))
+          AbstractFeatureBranch.load_application_features
+          AbstractFeatureBranch::FileBeautifier.process
+
+          file_path = File.join(AbstractFeatureBranch.application_root, 'config', 'another_application_configuration.yml')
+          File.open(file_path, 'r') do |file|
+            file.readlines.join.should == <<-ANOTHER_APPLICATION_CONFIGURATION_CONTENT
+common: &default_settings
+  license_key: <%= ENV["LICENSE_KEY"] %>
+  app_name: <%= ENV["APP_NAME"] %>
+  monitor_mode: true
+  developer_mode: false
+  log_level: info
+
+  browser_monitoring:
+      auto_instrument: true
+
+  audit_log:
+    enabled: false
+
+
+development:
+  <<: *default_settings
+  monitor_mode: false
+  developer_mode: true
+
+test:
+  <<: *default_settings
+  monitor_mode: false
+
+production:
+  <<: *default_settings
+  monitor_mode: true
+
+staging:
+  <<: *default_settings
+  monitor_mode: true
+  app_name: <%= ENV["APP_NAME"] %> (Staging)
+            ANOTHER_APPLICATION_CONFIGURATION_CONTENT
+          end
+
+          file_path = File.join(AbstractFeatureBranch.application_root, 'config', 'database.yml')
+          File.open(file_path, 'r') do |file|
+            file.readlines.join.should == <<-DATABASE_CONFIGURATION_CONTENT
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000
+            DATABASE_CONFIGURATION_CONTENT
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ext/feature_branch__feature_branch_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe 'feature_branch object extensions' do
+  before do
+    @app_env_backup = AbstractFeatureBranch.application_environment
+    AbstractFeatureBranch.logger.warn 'Environment variable ABSTRACT_FEATURE_BRANCH_FEATURE1 already set, potentially conflicting with another test' if ENV.keys.include?('ABSTRACT_FEATURE_BRANCH_FEATURE1')
+    AbstractFeatureBranch.logger.warn 'Environment variable Abstract_Feature_Branch_Feature2 already set, potentially conflicting with another test' if ENV.keys.include?('Abstract_Feature_Branch_Feature2')
+    AbstractFeatureBranch.logger.warn 'Environment variable abstract_feature_branch_feature3 already set, potentially conflicting with another test' if ENV.keys.include?('abstract_feature_branch_feature3')
+  end
+  after do
+    ENV.delete('ABSTRACT_FEATURE_BRANCH_FEATURE1')
+    ENV.delete('Abstract_Feature_Branch_Feature2')
+    ENV.delete('abstract_feature_branch_feature3')
+    AbstractFeatureBranch.initialize_application_root
+    AbstractFeatureBranch.load_application_features
+    AbstractFeatureBranch.application_environment = @app_env_backup
+  end
+  describe '#feature_branch' do
+    context 'class level behavior (case-insensitive string or symbol feature names)' do
+      {
+        'Feature1' => true,
+        :FEATURE2 => true,
+        :feature3 => false,
+        :admin_feature1 => true,
+        :admin_feature2 => false,
+        :public_feature1 => true,
+        :public_feature2 => false,
+        :wiki_feature1 => true,
+        :wiki_feature2 => false,
+      }.each do |feature_name, expected_branch_run|
+        it "feature branches correctly for feature #{feature_name} with expected branch run #{expected_branch_run}" do
+          feature_branch_run = false
+          feature_branch feature_name do
+            feature_branch_run = true
+          end
+          feature_branch_run.should == expected_branch_run
+        end
+      end
+    end
+    it 'returns nil and does not execute block for an invalid feature name' do
+      return_value = feature_branch :invalid_feature_that_does_not_exist do
+        fail 'feature branch block must not execute, but did.'
+      end
+      return_value.should be_nil
+    end
+    it 'supports an alternate branch of behavior for turned off features' do
+      feature_behaviors = []
+      feature_branch :feature1,
+                     :true => lambda {feature_behaviors << :feature1_true},
+                     :false => lambda {feature_behaviors << :feature1_false}
+      feature_branch :feature3,
+                     :true => lambda {feature_behaviors << :feature3_true},
+                     :false => lambda {feature_behaviors << :feature3_false}
+      feature_behaviors.should include(:feature1_true)
+      feature_behaviors.should_not include(:feature1_false)
+      feature_behaviors.should_not include(:feature3_true)
+      feature_behaviors.should include(:feature3_false)
+    end
+    it 'executes alternate branch for an invalid feature name' do
+      feature_behaviors = []
+      feature_branch :invalid_feature_that_does_not_exist,
+                     :true => lambda {feature_behaviors << :main_branch},
+                     :false => lambda {feature_behaviors << :alternate_branch}
+      feature_behaviors.should_not include(:main_branch)
+      feature_behaviors.should include(:alternate_branch)
+    end
+    it 'allows environment variables (case-insensitive booleans) to override configuration file' do
+      ENV['ABSTRACT_FEATURE_BRANCH_FEATURE1'] = 'FALSE'
+      ENV['Abstract_Feature_Branch_Feature2'] = 'False'
+      ENV['abstract_feature_branch_feature3'] = 'true'
+      AbstractFeatureBranch.load_application_features
+      features_enabled = []
+      feature_branch :feature1 do
+        features_enabled << :feature1
+      end
+      feature_branch :feature2 do
+        features_enabled << :feature2
+      end
+      feature_branch :feature3 do
+        features_enabled << :feature3
+      end
+      features_enabled.should_not include(:feature1)
+      features_enabled.should_not include(:feature2)
+      features_enabled.should include(:feature3)
+    end
+    it 'allows local configuration file to override main configuration file' do
+      features_enabled = []
+      feature_branch :feature4 do
+        features_enabled << :feature4
+      end
+      feature_branch :feature5 do
+        features_enabled << :feature5
+      end
+      feature_branch :admin_feature3 do
+        features_enabled << :admin_feature3
+      end
+      feature_branch :public_feature3 do
+        features_enabled << :public_feature3
+      end
+      feature_branch :wiki_feature3 do
+        features_enabled << :wiki_feature3
+      end
+      features_enabled.should_not include(:feature4)
+      features_enabled.should include(:feature5)
+      features_enabled.should include(:admin_feature3)
+      features_enabled.should include(:public_feature3)
+      features_enabled.should include(:wiki_feature3)
+    end
+    it 'works with an application that has no configuration files' do
+      AbstractFeatureBranch.application_root = File.join(__FILE__, '..', '..', 'fixtures', 'application_no_config')
+      AbstractFeatureBranch.load_application_features
+      feature_branch :feature1 do
+        fail 'feature branch block must not execute, but did.'
+      end
+    end
+  end
+  describe 'self#feature_branch' do
+    after do
+      Object.send(:remove_const, :TestObject)
+    end
+    # No need to retest all instance test cases, just a spot check due to implementation reuse
+    it 'feature branches instance level behavior (case-insensitive feature names)' do
+      class TestObject
+        def self.features_enabled
+          @features_enabled ||= []
+        end
+        def self.hit_me
+          feature_branch :feature1 do
+            self.features_enabled << :feature1
+          end
+          feature_branch :feature2 do
+            self.features_enabled << :feature2
+          end
+          feature_branch :feature3 do
+            self.features_enabled << :feature3
+          end
+        end
+      end
+      TestObject.hit_me
+      TestObject.features_enabled.should include(:feature1)
+      TestObject.features_enabled.should include(:feature2)
+      TestObject.features_enabled.should_not include(:feature3)
+    end
+  end
+end