flip_the_switch 0.4.0 → 1.0.0

data/spec/flip_the_switch/cli_spec.rb

@@ -16,15 +16,15 @@ describe FlipTheSwitch::Cli do
   end
 
   shared_examples_for 'generator' do
-    let(:feature_reader) { double(FlipTheSwitch::Reader::Features, feature_states: {'something' => true}) }
+    let(:feature_reader) { double(FlipTheSwitch::Reader::Features, features: features_for_hash('something' => true)) }
     let(:generator) { double(generator_class) }
 
     context 'when no options given' do
       let(:options) { [] }
 
       before do
-        FlipTheSwitch::Reader::Features.stub(:new).with(Dir.pwd, 'default').and_return(feature_reader)
-        generator_class.stub(:new).with(Dir.pwd, 'something' => true).and_return(generator)
+        FlipTheSwitch::Reader::Features.stub(:new).with(File.join(Dir.pwd, 'features.json'), 'default').and_return(feature_reader)
+        generator_class.stub(:new).with(Dir.pwd, features_for_hash('something' => true)).and_return(generator)
       end
 
       it 'generates using default options' do
@@ -36,17 +36,11 @@ describe FlipTheSwitch::Cli do
     context 'when options given' do
       before do
         FlipTheSwitch::Reader::Features.stub(:new).with('input', 'environment').and_return(feature_reader)
-        generator_class.stub(:new).with('output', {
-            'something' => true,
-            'en' => true,
-            'abled' => true,
-            'dis' => false,
-            'appointing' => false
-        }).and_return(generator)
+        generator_class.stub(:new).with('output', features_for_hash('something' => true)).and_return(generator)
       end
 
       context 'using full name' do
-        let(:options) { %w(--input=input --environment=environment --output=output --enabled=en,abled --disabled=dis,appointing) }
+        let(:options) { %w(--input=input --environment=environment --output=output) }
 
         it 'generates using the options given' do
           expect(generator).to receive(:generate)
@@ -55,7 +49,7 @@ describe FlipTheSwitch::Cli do
       end
 
       context 'using aliases' do
-        let(:options) { %w(-i=input -n=environment -o=output -e=en,abled -d=dis,appointing) }
+        let(:options) { %w(-i=input -n=environment -o=output) }
 
         it 'generates using the options given' do
           expect(generator).to receive(:generate)
@@ -65,6 +59,12 @@ describe FlipTheSwitch::Cli do
     end
   end
 
+  def features_for_hash(hash)
+    hash.map { |feature, enabled|
+      FlipTheSwitch::Feature.new(feature, enabled)
+    }
+  end
+
   context 'when plist command called' do
     let(:command) { 'plist' }
     let(:generator_class) { FlipTheSwitch::Generator::Plist }

data/spec/flip_the_switch/environment_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe FlipTheSwitch::Environment do
+  subject(:environment) { described_class.new('main_environment') }
+  let(:sub_environment) { described_class.new('sub_environment', [], 'main_environment') }
+
+  describe '#has_parent?' do
+    context 'when has a parent' do
+      specify {
+        expect(sub_environment.has_parent?).to be_true
+      }
+    end
+
+    context 'when has NO parent' do
+      specify {
+        expect(environment.has_parent?).to be_false
+      }
+    end
+  end
+end

data/spec/flip_the_switch/feature_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe FlipTheSwitch::Feature do
+  subject(:feature) { described_class.new('main_feature', true, 'hmm', [sub_feature]) }
+  let(:sub_feature) { described_class.new('sub_feature', false, nil, [], 'main_feature') }
+
+  describe '#has_parent?' do
+    context 'when has a parent' do
+      specify {
+        expect(sub_feature.has_parent?).to be_true
+      }
+    end
+
+    context 'when has NO parent' do
+      specify {
+        expect(feature.has_parent?).to be_false
+      }
+    end
+  end
+end

data/spec/flip_the_switch/generator/category_spec.rb

@@ -1,9 +1,11 @@
 require 'spec_helper'
 
 describe FlipTheSwitch::Generator::Category do
-  subject(:category) { described_class.new(output, feature_states) }
-  let(:output) { 'spec/resources' }
-  let(:feature_states) { {'first_feature' => true, 'second_feature' => false} }
+  subject(:category) { described_class.new(output, features) }
+  let(:output) { 'tmp' }
+  let(:first_feature) { FlipTheSwitch::Feature.new('first_feature', true, 'This is the first feature', [second_feature]) }
+  let(:second_feature) { FlipTheSwitch::Feature.new('second_feature', false, nil, [], 'first_feature') }
+  let(:features) { [first_feature] }
   let(:expected_header_file) { File.read('spec/resources/expected_header.h') }
   let(:expected_implementation_file) { File.read('spec/resources/expected_implementation.m') }
 
@@ -12,16 +14,16 @@ describe FlipTheSwitch::Generator::Category do
     delete_implementation_if_exists
   end
 
-  it 'writes a FlipTheSwitch+Features.h file with the category header' do
+  it 'writes a FTSFlipTheSwitch+Features.h file with the category header' do
     subject.generate
 
-    expect(File.read(output_name_with('h'))).to eql(expected_header_file)
+    expect(output_with('h')).to eql(expected_header_file)
   end
 
-  it 'writes a FlipTheSwitch+Features.m file with the category implementation' do
+  it 'writes a FTSFlipTheSwitch+Features.m file with the category implementation' do
     subject.generate
 
-    expect(File.read(output_name_with('m'))).to eql(expected_implementation_file)
+    expect(output_with('m')).to eql(expected_implementation_file)
   end
 
   private
@@ -38,7 +40,11 @@ describe FlipTheSwitch::Generator::Category do
     File.delete(output_name_with(suffix)) if File.exists?(output_name_with(suffix))
   end
 
+  def output_with(suffix)
+    File.read(output_name_with(suffix))
+  end
+
   def output_name_with(suffix)
-    "#{output}/FlipTheSwitch+Features.#{suffix}"
+    "#{output}/FTSFlipTheSwitch+Features.#{suffix}"
   end
 end

data/spec/flip_the_switch/generator/plist_spec.rb

@@ -1,19 +1,35 @@
 require 'spec_helper'
 
 describe FlipTheSwitch::Generator::Plist do
-  subject(:plist) { described_class.new(output, feature_states) }
-  let(:output) { 'spec/resources' }
-  let(:feature_states) { {enabled_feature: true, disabled_feature: false} }
-  let(:output_file) { 'spec/resources/Features.plist' }
+  subject(:plist) { described_class.new(output, features) }
+  let(:features) { [
+    FlipTheSwitch::Feature.new('enabled_feature', true, nil),
+    FlipTheSwitch::Feature.new('disabled_feature', false, 'is disabled description')
+  ] }
+  let(:output_file) { 'tmp/Features.plist' }
+  let(:actual_output_file) { File.read(output_file) }
   let(:expected_plist_file) { File.read('spec/resources/ExpectedFeatures.plist') }
 
   after do
     File.delete(output_file) if File.exists?(output_file)
   end
 
-  it 'writes a Features.plist file with the enabled features set' do
-    subject.generate
+  shared_examples "a plist writer" do |output, output_file|
+    let(:output) { output }
+    let(:output_file) { output_file }
 
-    expect(File.read(output_file)).to eql(expected_plist_file)
+    it "writes a #{File.basename(output_file)} file with the features set" do
+      subject.generate
+
+      expect(File.read(output_file)).to eql(expected_plist_file)
+    end
+  end
+
+  context 'When the output is a directory' do
+    it_behaves_like "a plist writer", 'spec/resources', 'spec/resources/Features.plist'
+  end
+
+  context 'when the output is a file' do
+    it_behaves_like "a plist writer", 'spec/resources/DasPlist.plist', 'spec/resources/DasPlist.plist'
   end
 end

data/spec/flip_the_switch/generator/settings_spec.rb

@@ -2,14 +2,17 @@ require 'spec_helper'
 require 'fileutils'
 
 describe FlipTheSwitch::Generator::Settings do
-  subject(:settings) { described_class.new(output, feature_states) }
+  subject(:settings) { described_class.new(output, features) }
   let(:output) { 'spec/resources' }
   let(:settings_bundle) { File.join(output, 'Settings.bundle') }
-  let(:feature_states) { {'first_feature' => true, 'second_feature' => false} }
+  let(:features) { [
+    FlipTheSwitch::Feature.new('first_feature', true, nil),
+    FlipTheSwitch::Feature.new('second_feature', false, nil)
+  ] }
   let(:root_output_file) { File.read(File.join(settings_bundle, 'Root.plist')) }
   let(:features_output_file) { File.read(File.join(settings_bundle, 'Features.plist')) }
   let(:features_output_file) { File.read(File.join(settings_bundle, 'Features.plist')) }
-  let(:expected_features_file) { File.read('spec/resources/ExpectedSettingsFeatures.plist')}
+  let(:expected_features_file) { File.read('spec/resources/ExpectedSettingsFeatures.plist') }
 
   after do
     delete_settings_bundle_if_exists

data/spec/flip_the_switch/reader/defaults_spec.rb

@@ -14,8 +14,6 @@ describe FlipTheSwitch::Reader::Defaults do
         File.write(defaults_file, YAML.dump({
             input: 'input',
             environment: 'environment',
-            enabled: 'enabled',
-            disabled: 'disabled',
             category_output: 'category_output',
             plist_output: 'plist_output',
             settings_output: 'settings_output'
@@ -30,14 +28,6 @@ describe FlipTheSwitch::Reader::Defaults do
         expect(subject.defaults[:environment]).to eql('environment')
       end
 
-      it 'returns file enabled default' do
-        expect(subject.defaults[:enabled]).to eql('enabled')
-      end
-
-      it 'returns file disabled default' do
-        expect(subject.defaults[:disabled]).to eql('disabled')
-      end
-
       it 'returns file category output default' do
         expect(subject.defaults[:category_output]).to eql('category_output')
       end
@@ -73,14 +63,6 @@ describe FlipTheSwitch::Reader::Defaults do
       expect(subject.defaults[:environment]).to eql('default')
     end
 
-    it 'returns base enabled default' do
-      expect(subject.defaults[:enabled]).to eql('')
-    end
-
-    it 'returns base disabled default' do
-      expect(subject.defaults[:disabled]).to eql('')
-    end
-
     it 'returns base category output default' do
       expect(subject.defaults[:category_output]).to eql(Dir.pwd)
     end

data/spec/flip_the_switch/reader/features_spec.rb

@@ -2,54 +2,111 @@ require 'spec_helper'
 
 describe FlipTheSwitch::Reader::Features do
   subject(:reader) { described_class.new(input, environment) }
-  let(:environment) { 'beta' }
+  let(:environment) { 'defaults' }
+  let(:input) { 'spec/resources/real/features.json' }
+
+  context 'when given an valid environment' do
+    context 'when reading a standard environment' do
+      it 'reads the enabled/disabled states of the features for the environment' do
+        expect(subject.features).to eql([
+              FlipTheSwitch::Feature.new('enabled_feature', true, 'This feature is enabled', [
+                  FlipTheSwitch::Feature.new('sub_feature', false, nil, [
+                      FlipTheSwitch::Feature.new('sub_sub_feature', false, nil, [], 'sub_feature')
+                    ], 'enabled_feature')
+                ]),
+              FlipTheSwitch::Feature.new('disabled_feature', false)
+            ])
+      end
+    end
 
-  context 'when given a real file' do
-    let(:input) { 'spec/resources/real' }
 
-    context 'when given an valid environment' do
+    context 'when reading an inherited environment' do
+      let(:environment) { 'alpha' }
+
       it 'reads the enabled/disabled states of the features for the environment' do
-        expect(subject.feature_states).to eql('enabled_feature' => true, 'disabled_feature' => false)
+        expect(subject.features).to eql([
+              FlipTheSwitch::Feature.new('enabled_feature', false, 'This feature is enabled', [
+                  FlipTheSwitch::Feature.new('sub_feature', false, nil, [
+                      FlipTheSwitch::Feature.new('sub_sub_feature', false, nil, [], 'sub_feature')
+                    ], 'enabled_feature')
+                ]),
+              FlipTheSwitch::Feature.new('disabled_feature', false)
+            ])
       end
     end
 
-    context 'when given an invalid environment' do
-      let(:environment) { 'invalid' }
+    context 'when reading an double inherited environment' do
+      let(:environment) { 'beta' }
 
-      specify do
-        expect {
-          subject.feature_states
-        }.to raise_error(FlipTheSwitch::Error::InvalidEnvironment)
+      it 'reads the enabled/disabled states of the features for the environment' do
+        expect(subject.features).to eql([
+              FlipTheSwitch::Feature.new('enabled_feature', true, 'This feature is enabled', [
+                  FlipTheSwitch::Feature.new('sub_feature', false, nil, [
+                      FlipTheSwitch::Feature.new('sub_sub_feature', false, nil, [], 'sub_feature')
+                    ], 'enabled_feature')
+                ]),
+              FlipTheSwitch::Feature.new('disabled_feature', false)
+            ])
       end
     end
   end
 
+  context 'when given an invalid environment' do
+    let(:environment) { 'invalid' }
+
+    specify do
+      expect {
+        subject.features
+      }.to raise_error(FlipTheSwitch::Error::InvalidEnvironment)
+    end
+  end
+
+  context 'when given an invalid environment' do
+    let(:environment) { 'invalid' }
+
+    specify do
+      expect {
+        subject.features
+      }.to raise_error(FlipTheSwitch::Error::InvalidEnvironment)
+    end
+  end
+
+  context 'when input is an invalid file' do
+    let(:input) { 'spec/resources/invalid_type/features.json' }
+
+    specify do
+      expect {
+        subject.features
+      }.to raise_error(FlipTheSwitch::Error::InvalidFile)
+    end
+  end
+
   context 'when given a non-existent file' do
-    let(:input) { 'spec/resources/non-existent' }
+    let(:input) { 'spec/resources/non-existent/features.json' }
 
     specify do
       expect {
-        subject.feature_states
+        subject.features
       }.to raise_error(FlipTheSwitch::Error::UnreadableFile)
     end
   end
 
   context 'when given an invalid file type' do
-    let(:input) { 'spec/resources/invalid_type' }
+    let(:input) { 'spec/resources/invalid_type/features.json' }
 
     specify do
       expect {
-        subject.feature_states
+        subject.features
       }.to raise_error(FlipTheSwitch::Error::InvalidFile)
     end
   end
 
   context 'when given an invalid file layout' do
-    let(:input) { 'spec/resources/invalid_layout' }
+    let(:input) { 'spec/resources/invalid_layout/features.json' }
 
     specify do
       expect {
-        subject.feature_states
+        subject.features
       }.to raise_error(FlipTheSwitch::Error::InvalidFile)
     end
   end

data/spec/resources/ExpectedFeatures.plist

@@ -3,8 +3,16 @@
 <plist version="1.0">
 <dict>
 	<key>disabled_feature</key>
-	<false/>
+	<dict>
+		<key>description</key>
+		<string>is disabled description</string>
+		<key>enabled</key>
+		<false/>
+	</dict>
 	<key>enabled_feature</key>
-	<true/>
+	<dict>
+		<key>enabled</key>
+		<true/>
+	</dict>
 </dict>
 </plist>

data/spec/resources/expected_header.h

@@ -1,16 +1,21 @@
 /* AUTO-GENERATED. DO NOT ALTER */
-#import <FlipTheSwitch/FlipTheSwitch.h>
-
-@interface FlipTheSwitch (Features)
+#import <FlipTheSwitch/FTSFlipTheSwitch.h>
 
+@interface FTSFlipTheSwitch (Features)
+// This is the first feature
 + (BOOL)isFirstFeatureEnabled;
 + (void)enableFirstFeature;
 + (void)disableFirstFeature;
 + (void)setFirstFeatureEnabled:(BOOL)enabled;
++ (void)resetFirstFeature;
++ (NSString *)firstFeatureKey;
 
 + (BOOL)isSecondFeatureEnabled;
 + (void)enableSecondFeature;
 + (void)disableSecondFeature;
 + (void)setSecondFeatureEnabled:(BOOL)enabled;
++ (void)resetSecondFeature;
++ (NSString *)secondFeatureKey;
 
++ (void)resetAll;
 @end

data/spec/resources/expected_implementation.m

@@ -1,46 +1,73 @@
 /* AUTO-GENERATED. DO NOT ALTER */
-#import "FlipTheSwitch+Features.h"
+#import "FTSFlipTheSwitch+Features.h"
 
-@implementation FlipTheSwitch (Features)
+@implementation FTSFlipTheSwitch (Features)
 
 + (BOOL)isFirstFeatureEnabled
 {
-    return [[FlipTheSwitch sharedInstance] isFeatureEnabled:@"first_feature"];
+    return [[FTSFlipTheSwitch sharedInstance] isFeatureEnabled:[self firstFeatureKey]];
 }
 
 + (void)enableFirstFeature
 {
-    [[FlipTheSwitch sharedInstance] enableFeature:@"first_feature"];
+    [[FTSFlipTheSwitch sharedInstance] enableFeature:[self firstFeatureKey]];
 }
 
 + (void)disableFirstFeature
 {
-    [[FlipTheSwitch sharedInstance] disableFeature:@"first_feature"];
+    [[FTSFlipTheSwitch sharedInstance] disableFeature:[self firstFeatureKey]];
 }
 
 + (void)setFirstFeatureEnabled:(BOOL)enabled
 {
-    [[FlipTheSwitch sharedInstance] setFeature:@"first_feature" enabled:enabled];
+    [[FTSFlipTheSwitch sharedInstance] setFeature:[self firstFeatureKey] enabled:enabled];
+}
+
++ (void)resetFirstFeature
+{
+    [[FTSFlipTheSwitch sharedInstance] resetFeature:[self firstFeatureKey]];
+}
+
++ (NSString *)firstFeatureKey
+{
+    return @"first_feature";
 }
 
 + (BOOL)isSecondFeatureEnabled
 {
-    return [[FlipTheSwitch sharedInstance] isFeatureEnabled:@"second_feature"];
+    return [self isFirstFeatureEnabled] &&
+        [[FTSFlipTheSwitch sharedInstance] isFeatureEnabled:[self secondFeatureKey]];
 }
 
 + (void)enableSecondFeature
 {
-    [[FlipTheSwitch sharedInstance] enableFeature:@"second_feature"];
+    [[FTSFlipTheSwitch sharedInstance] enableFeature:[self secondFeatureKey]];
 }
 
 + (void)disableSecondFeature
 {
-    [[FlipTheSwitch sharedInstance] disableFeature:@"second_feature"];
+    [[FTSFlipTheSwitch sharedInstance] disableFeature:[self secondFeatureKey]];
 }
 
 + (void)setSecondFeatureEnabled:(BOOL)enabled
 {
-    [[FlipTheSwitch sharedInstance] setFeature:@"second_feature" enabled:enabled];
+    [[FTSFlipTheSwitch sharedInstance] setFeature:[self secondFeatureKey] enabled:enabled];
+}
+
++ (void)resetSecondFeature
+{
+    [[FTSFlipTheSwitch sharedInstance] resetFeature:[self secondFeatureKey]];
+}
+
++ (NSString *)secondFeatureKey
+{
+    return @"second_feature";
+}
+
++ (void)resetAll
+{
+    [self resetFirstFeature];
+    [self resetSecondFeature];
 }
 
 @end