flip_the_switch 0.4.0 → 1.0.0

data/flip_the_switch.gemspec

@@ -4,12 +4,13 @@ Gem::Specification.new do |s|
   s.email = %w(mg.england@gmail.com rob@robsiwek.com)
   s.summary = 'A simple library to help enabling/disabling features on iOS/Mac applications.'
   s.homepage = 'https://github.com/michaelengland/FlipTheSwitch'
-  s.version = '0.4.0'
+  s.version = '1.0.0'
   s.license = 'MIT'
 
   s.add_dependency 'activesupport', '~> 3.2'
   s.add_dependency 'thor', '~> 0.19'
   s.add_dependency 'plist', '~> 3.1'
+  s.add_dependency 'json-schema', '~> 2.5'
 
   s.files = `git ls-files`.split($\)
   s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }

data/lib/flip_the_switch.rb

@@ -1,3 +1,5 @@
 require 'flip_the_switch/errors'
+require 'flip_the_switch/feature'
+require 'flip_the_switch/environment'
 require 'flip_the_switch/reader'
 require 'flip_the_switch/generator'

data/lib/flip_the_switch/cli.rb

@@ -9,25 +9,26 @@ module FlipTheSwitch
     end
 
     public
-    class_option :input, type: :string, aliases: '-i', default: defaults[:input], desc: 'Location of the directory containing features.yml file to read'
+    class_option :input, type: :string, aliases: '-i', default: defaults[:input], desc: 'Filename or directory containing features.yml file to read'
     class_option :environment, type: :string, aliases: '-n', default: defaults[:environment], desc: 'Name of environment to read from in features.yml file'
-    class_option :enabled, type: :string, aliases: '-e', default: defaults[:enabled], desc: 'Extra features to be set as enabled'
-    class_option :disabled, type: :string, aliases: '-d', default: defaults[:disabled], desc: 'Extra features to be set as disabled'
 
     desc 'plist', 'Auto-generates a Features.plist file for enabled/disabled features'
-    method_option :output, type: :string, aliases: '-o', default: defaults[:plist_output], desc: 'Location of the directory in which Features.plist file will be created'
+    method_option :output, type: :string, aliases: '-o', default: defaults[:plist_output], desc: 'Filename or directory in which Features.plist file will be created'
+
     def plist
       plist_generator.generate
     end
 
     desc 'category', 'Auto-generates .h & .m files for enabled/disabled features'
     method_option :output, type: :string, aliases: '-o', default: defaults[:category_output], desc: 'Location of the directory in which FlipTheSwitch+Features.{h,m} files will be created'
+
     def category
       category_generator.generate
     end
 
     desc 'settings', 'Auto-generates settings.bundle files for enabling/disabling features from iOS settings menu'
     method_option :output, type: :string, aliases: '-o', default: defaults[:settings_output], desc: 'Location of the directory in which FlipTheSwitch+Features.{h,m} files will be created'
+
     def settings
       settings_generator.generate
     end
@@ -35,43 +36,34 @@ module FlipTheSwitch
     private
 
     def plist_generator
-      Generator::Plist.new(output, feature_states)
+      Generator::Plist.new(output, features)
     end
 
     def category_generator
-      Generator::Category.new(output, feature_states)
+      Generator::Category.new(output, features)
     end
 
     def settings_generator
-      Generator::Settings.new(output, feature_states)
+      Generator::Settings.new(output, features)
     end
 
     def output
       options['output']
     end
 
-    def feature_states
-      feature_reader.feature_states.
-          merge(enabled_states).
-          merge(disabled_states)
+    def features
+      feature_reader.features
     end
 
     def feature_reader
-      Reader::Features.new(options['input'], options['environment'])
-    end
-
-    def enabled_states
-      states_for(options['enabled'].split(','), true)
-    end
-
-    def disabled_states
-      states_for(options['disabled'].split(','), false)
+      Reader::Features.new(input, options['environment'])
     end
 
-    def states_for(array, default)
-      array.inject({}) do |h, feature|
-        h[feature] = default
-        h
+    def input
+      if File.directory?(options['input'])
+        File.join(options['input'], 'features.json')
+      else
+        options['input']
       end
     end
   end

data/lib/flip_the_switch/environment.rb

@@ -0,0 +1,11 @@
+module FlipTheSwitch
+  class Environment < Struct.new(:name, :features, :parent_name)
+    def initialize(name, features = [], parent_name = nil)
+      super(name, features, parent_name)
+    end
+
+    def has_parent?
+      parent_name
+    end
+  end
+end

data/lib/flip_the_switch/feature.rb

@@ -0,0 +1,11 @@
+module FlipTheSwitch
+  class Feature < Struct.new(:name, :enabled, :description, :sub_features, :parent_name)
+    def initialize(name, enabled, description = nil, sub_features = [], parent_name = nil)
+      super(name, enabled, description, sub_features, parent_name)
+    end
+
+    def has_parent?
+      parent_name
+    end
+  end
+end

data/lib/flip_the_switch/generator/base.rb

@@ -1,13 +1,13 @@
 module FlipTheSwitch
   module Generator
     class Base
-      def initialize(output, feature_states)
+      def initialize(output, features)
         @output = output
-        @feature_states = feature_states
+        @features = features
       end
 
       protected
-      attr_reader :output, :feature_states
+      attr_reader :output, :features
     end
   end
 end

data/lib/flip_the_switch/generator/category.rb

@@ -33,11 +33,11 @@ module FlipTheSwitch
       end
 
       def header_file
-        File.join(output, 'FlipTheSwitch+Features.h')
+        File.join(output, 'FTSFlipTheSwitch+Features.h')
       end
 
       def implementation_file
-        File.join(output, 'FlipTheSwitch+Features.m')
+        File.join(output, 'FTSFlipTheSwitch+Features.m')
       end
 
       def header
@@ -49,7 +49,7 @@ module FlipTheSwitch
       end
 
       def render(template)
-        ERB.new(template).result(binding)
+        ERB.new(template, nil, '-').result(binding)
       end
 
       def header_template
@@ -64,8 +64,16 @@ module FlipTheSwitch
         File.read(File.expand_path("../#{name}.erb", __FILE__))
       end
 
-      def feature_names
-        feature_states.keys.map(&:to_s)
+      def all_features
+        features.flat_map { |feature|
+          feature_and_sub_features(feature)
+        }
+      end
+
+      def feature_and_sub_features(feature)
+        [feature] + feature.sub_features.flat_map { |sub_feature|
+          feature_and_sub_features(sub_feature)
+        }
       end
     end
   end

data/lib/flip_the_switch/generator/header.h.erb

@@ -1,11 +1,18 @@
 /* AUTO-GENERATED. DO NOT ALTER */
-#import <FlipTheSwitch/FlipTheSwitch.h>
+#import <FlipTheSwitch/FTSFlipTheSwitch.h>
 
-@interface FlipTheSwitch (Features)
-<% for feature in feature_names %>
-+ (BOOL)is<%= feature.camelize %>Enabled;
-+ (void)enable<%= feature.camelize %>;
-+ (void)disable<%= feature.camelize %>;
-+ (void)set<%= feature.camelize %>Enabled:(BOOL)enabled;
-<% end %>
+@interface FTSFlipTheSwitch (Features)
+<% all_features.each do |feature| -%>
+<% if feature.description -%>
+// <%= feature.description %>
+<% end -%>
++ (BOOL)is<%= feature.name.camelize %>Enabled;
++ (void)enable<%= feature.name.camelize %>;
++ (void)disable<%= feature.name.camelize %>;
++ (void)set<%= feature.name.camelize %>Enabled:(BOOL)enabled;
++ (void)reset<%= feature.name.camelize %>;
++ (NSString *)<%= feature.name.camelize(:lower) %>Key;
+
+<% end -%>
++ (void)resetAll;
 @end

data/lib/flip_the_switch/generator/implementation.m.erb

@@ -1,26 +1,50 @@
 /* AUTO-GENERATED. DO NOT ALTER */
-#import "FlipTheSwitch+Features.h"
+#import "FTSFlipTheSwitch+Features.h"
 
-@implementation FlipTheSwitch (Features)
-<% for feature in feature_names %>
-+ (BOOL)is<%= feature.camelize %>Enabled
+@implementation FTSFlipTheSwitch (Features)
+
+<% all_features.each do |feature| -%>
++ (BOOL)is<%= feature.name.camelize %>Enabled
+{
+<% if feature.has_parent? -%>
+    return [self is<%= feature.parent_name.camelize %>Enabled] &&
+        [[FTSFlipTheSwitch sharedInstance] isFeatureEnabled:[self <%= feature.name.camelize(:lower) %>Key]];
+<% else -%>
+    return [[FTSFlipTheSwitch sharedInstance] isFeatureEnabled:[self <%= feature.name.camelize(:lower) %>Key]];
+<% end -%>
+}
+
++ (void)enable<%= feature.name.camelize %>
 {
-    return [[FlipTheSwitch sharedInstance] isFeatureEnabled:@"<%= feature %>"];
+    [[FTSFlipTheSwitch sharedInstance] enableFeature:[self <%= feature.name.camelize(:lower) %>Key]];
 }
 
-+ (void)enable<%= feature.camelize %>
++ (void)disable<%= feature.name.camelize %>
 {
-    [[FlipTheSwitch sharedInstance] enableFeature:@"<%= feature %>"];
+    [[FTSFlipTheSwitch sharedInstance] disableFeature:[self <%= feature.name.camelize(:lower) %>Key]];
 }
 
-+ (void)disable<%= feature.camelize %>
++ (void)set<%= feature.name.camelize %>Enabled:(BOOL)enabled
 {
-    [[FlipTheSwitch sharedInstance] disableFeature:@"<%= feature %>"];
+    [[FTSFlipTheSwitch sharedInstance] setFeature:[self <%= feature.name.camelize(:lower) %>Key] enabled:enabled];
 }
 
-+ (void)set<%= feature.camelize %>Enabled:(BOOL)enabled
++ (void)reset<%= feature.name.camelize %>
 {
-    [[FlipTheSwitch sharedInstance] setFeature:@"<%= feature %>" enabled:enabled];
+    [[FTSFlipTheSwitch sharedInstance] resetFeature:[self <%= feature.name.camelize(:lower) %>Key]];
 }
-<% end %>
+
++ (NSString *)<%= feature.name.camelize(:lower) %>Key
+{
+    return @"<%= feature.name %>";
+}
+
+<% end -%>
++ (void)resetAll
+{
+<% all_features.each do |feature| -%>
+    [self reset<%= feature.name.camelize %>];
+<% end -%>
+}
+
 @end

data/lib/flip_the_switch/generator/plist.rb

@@ -10,8 +10,26 @@ module FlipTheSwitch
 
       private
 
+      def feature_states
+        features.inject({}) do |states, feature|
+          states.merge(feature.name => feature_hash(feature))
+        end
+      end
+
+      def feature_hash(feature)
+        if feature.description
+          {enabled: feature.enabled, description: feature.description}
+        else
+          {enabled: feature.enabled}
+        end
+      end
+
       def output_file
-        File.join(output, 'Features.plist')
+        if File.directory?(output)
+          File.join(output, 'Features.plist')
+        else
+          output
+        end
       end
     end
   end

data/lib/flip_the_switch/generator/settings.rb

@@ -47,7 +47,7 @@ module FlipTheSwitch
       end
 
       def write_features_plist
-        ::Plist::Emit.save_plist(features, features_plist)
+        ::Plist::Emit.save_plist(feature_properties, features_plist)
       end
 
       def delete_file(file)
@@ -82,17 +82,17 @@ module FlipTheSwitch
         ]
       end
 
-      def features
+      def feature_properties
         {PreferenceSpecifiers: feature_toggles}
       end
 
       def feature_toggles
-        feature_states.map { |feature, state|
+        features.map { |feature|
           {
               Type: 'PSToggleSwitchSpecifier',
-              Title: feature,
-              Key: "FTS_FEATURE_#{feature}",
-              DefaultValue: state
+              Title: feature.name,
+              Key: "FTS_FEATURE_#{feature.name}",
+              DefaultValue: feature.enabled
           }
         }
       end

data/lib/flip_the_switch/reader/features.rb

@@ -1,4 +1,5 @@
-require 'yaml'
+require 'json'
+require 'json-schema'
 
 module FlipTheSwitch
   module Reader
@@ -8,45 +9,158 @@ module FlipTheSwitch
         @environment = environment
       end
 
-      def feature_states
-        if valid_file?
-          environment_states
-        else
-          raise Error::InvalidFile.new(input_file)
-        end
+      def features
+        raise Error::InvalidFile.new(input_file) unless valid_file?
+        raise Error::InvalidEnvironment.new(environment) unless environments_by_name.has_key?(environment)
+        inherited_environment(environment).features
       end
 
       private
       attr_reader :input, :environment
 
-      def valid_file?
-        file_states.is_a?(Hash) && file_states.all? { |environment, feature|
-          environment.is_a?(String) && valid_feature_hash?(feature)
-        }
+      INHERITS_KEY = 'inherits_from'
+      ENABLED_KEY = 'enabled'
+      DESCRIPTION_KEY = 'description'
+
+      def inherited_environment(env_name)
+        inherited_env = environments_by_name[env_name]
+        if inherited_env.has_parent?
+          merge_environments(inherited_env, inherited_environment(inherited_env.parent_name))
+        else
+          inherited_env
+        end
+      end
+
+      def merge_environments(overriding_env, parent_env)
+        Environment.new(
+          overriding_env.name,
+          merge_features(parent_env.features, overriding_env.features),
+          overriding_env.parent_name
+        )
       end
 
-      def valid_feature_hash?(feature_hash)
-        feature_hash.is_a?(Hash) && feature_hash.all? { |feature, state|
-          feature.is_a?(String) && !!state == state
+      def merge_features(parent_features, overriding_features)
+        parent_features.inject([]) { |merged_features, parent_feature|
+          overriding_feature = overriding_features.detect { |feature| feature.name == parent_feature.name }
+          if overriding_feature
+            merged_features.push(merge_feature(parent_feature, overriding_feature))
+          else
+            merged_features.push(parent_feature)
+          end
         }
       end
 
-      def environment_states
-        if file_states.has_key?(environment)
-          file_states[environment]
+      def merge_feature(parent_feature, child_feature)
+        Feature.new(parent_feature.name,
+          (child_feature.enabled != nil) ? child_feature.enabled : parent_feature.enabled,
+          child_feature.description ? child_feature.description : parent_feature.description,
+          sub_features(child_feature, parent_feature),
+          child_feature.parent_name
+        )
+      end
+
+      def sub_features(child_feature, parent_feature)
+        if !child_feature.sub_features.empty?
+          merge_sub_features(parent_feature.sub_features, child_feature.sub_features)
         else
-          raise Error::InvalidEnvironment.new(environment)
+          parent_feature.sub_features
         end
       end
 
-      def file_states
-        @file_states ||= YAML.load_file(input_file)
+      def merge_sub_features(parent_feature_sub_features, child_feature_sub_features)
+        child_feature_sub_features.inject([]) { |merged_sub_features, child_sub_feature|
+          merged_sub_features.push(merge_feature(related_parents_sub_feature(parent_feature_sub_features, child_sub_feature.name), child_sub_feature))
+        }
+      end
+
+      def related_parents_sub_feature(parent_feature_sub_features, sub_feature_name)
+        parent_feature_sub_features.detect { |parent_sub_feature|
+          parent_sub_feature.name == sub_feature_name
+        }
+      end
+
+      def environments_by_name
+        parse.inject({}) { |hash, env|
+          hash[env.name] = env
+          hash
+        }
+      end
+
+      def parse
+        @parse ||= json.map { |env_name, env_info|
+          parse_environment(env_name, env_info)
+        }
+      end
+
+      def parse_environment(name, info)
+        Environment.new(name, parse_environment_features(info), info[INHERITS_KEY])
+      end
+
+      def parse_environment_features(info)
+        info.select { |key, _|
+          key != INHERITS_KEY
+        }.map { |feature_name, feature_info|
+          parse_feature(feature_name, feature_info, nil)
+        }
+      end
+
+      def parse_feature(name, info, parent_name)
+        Feature.new(name, info.fetch(ENABLED_KEY), info[DESCRIPTION_KEY], parse_sub_features(info, name), parent_name)
+      end
+
+      def parse_sub_features(info, parent_name)
+        info.select { |key, _| ![ENABLED_KEY, DESCRIPTION_KEY].include?(key) }.map { |sub_name, sub_info|
+          parse_feature(sub_name, sub_info, parent_name)
+        }
+      end
+
+      def json
+        JSON.parse(input_file)
+      end
+
+      def input_file
+        File.read(input)
       rescue SystemCallError => e
         raise Error::UnreadableFile.new(e)
       end
 
-      def input_file
-        File.join(input, 'features.yml')
+      def valid_file?
+        JSON::Validator.validate(expected_schema, input_file)
+      end
+
+      def expected_schema
+        {
+          type: :object,
+          additionalProperties: {
+            type: :object,
+            additionalProperties: {
+              properties: {
+                enabled: {
+                  type: :boolean
+                },
+                description: {
+                  type: :string
+                },
+                additionalProperties: {
+                  properties: {
+                    enabled: {
+                      type: :boolean
+                    },
+                    description: {
+                      type: :string
+                    },
+                    required: [
+                      :enabled
+                    ]
+                  }
+                }
+              },
+              required: [
+                :enabled
+              ]
+            }
+          }
+        }
       end
     end
   end