introduce Feature.Name and Feature.NamingConvention

mexx · mexx · commit cdc1b133cbbb · 2012-11-27T22:46:30.000+01:00
diff --git a/Source/FeatureSwitcher.Configuration/AppConfig.cs b/Source/FeatureSwitcher.Configuration/AppConfig.cs
@@ -63,7 +63,7 @@ private FeaturesSection FeaturesSection
             get { return _features ?? SectionGroup.GetFeaturesSection(_settings.SectionGroupName, _settings.IgnoreConfigurationErrors); }
         }
 
-        public bool? IsEnabled(string feature)
+        public bool? IsEnabled(Feature.Name feature)
         {
             return Features(feature).GetValueOrDefault(Default(feature).GetValueOrDefault());
         }
diff --git a/Source/FeatureSwitcher.Configuration/AppConfigDefault.cs b/Source/FeatureSwitcher.Configuration/AppConfigDefault.cs
@@ -9,7 +9,7 @@ public AppConfigDefault(DefaultSection defaultSection)
             _defaultSection = defaultSection;
         }
 
-        public bool? IsEnabled(string feature)
+        public bool? IsEnabled(Feature.Name feature)
         {
             if (_defaultSection == null)
                 return null;
diff --git a/Source/FeatureSwitcher.Configuration/AppConfigFeatures.cs b/Source/FeatureSwitcher.Configuration/AppConfigFeatures.cs
@@ -9,12 +9,12 @@ public AppConfigFeatures(FeaturesSection features)
             _features = features;
         }
 
-        public bool? IsEnabled(string feature)
+        public bool? IsEnabled(Feature.Name feature)
         {
             if (_features == null)
                 return null;
 
-            var featureElement = _features.Features[feature];
+            var featureElement = _features.Features[feature.Value];
 
             if (featureElement == null)
                 return null;
diff --git a/Source/FeatureSwitcher.Contexteer/Configuration/FeatureConfigurationFor.cs b/Source/FeatureSwitcher.Contexteer/Configuration/FeatureConfigurationFor.cs
@@ -7,10 +7,10 @@ namespace FeatureSwitcher.Configuration
     internal class FeatureConfigurationFor<TContext> : IConfigureFeaturesFor<TContext>, IConfigureBehaviorFor<TContext>, IConfigureNamingFor<TContext>
         where TContext : IContext
     {
-        private Func<TContext, Feature.NameOf[]> _nameOf;
-        private Func<TContext, Feature.NameOf[]> NameOf
+        private Func<TContext, Feature.NamingConvention[]> _namingConvention;
+        private Func<TContext, Feature.NamingConvention[]> NamingConvention
         {
-            get { return _nameOf ?? (ctx => null); }
+            get { return _namingConvention ?? (ctx => null); }
         }
         private Func<TContext, Feature.Behavior[]> _behavior;
         private Func<TContext, Feature.Behavior[]> Behavior
@@ -38,19 +38,19 @@ IConfigureFeaturesFor<TContext> IConfigureFeaturesFor<TContext>.And
             get { return this; }
         }
 
-        public IConfigureNaming NamedBy
+        IConfigureNaming IConfigureFeatures.NamedBy
         {
             get { return this; }
         }
 
-        public IConfigureBehavior ConfiguredBy
+        IConfigureBehavior IConfigureFeatures.ConfiguredBy
         {
             get { return this; }
         }
 
-        IConfigureFeaturesFor<TContext> IConfigureNamingFor<TContext>.Custom(Func<TContext, Feature.NameOf[]> naming)
+        IConfigureFeaturesFor<TContext> IConfigureNamingFor<TContext>.Custom(Func<TContext, Feature.NamingConvention[]> namingConventions)
         {
-            _nameOf = naming;
+            _namingConvention = namingConventions;
             return this;
         }
 
@@ -60,9 +60,9 @@ IConfigureFeaturesFor<TContext> IConfigureBehaviorFor<TContext>.Custom(Func<TCon
             return this;
         }
 
-        IConfigureFeatures IConfigureNaming.Custom(params Feature.NameOf[] nameOfs)
+        IConfigureFeatures IConfigureNaming.Custom(params Feature.NamingConvention[] namingConventions)
         {
-            return (this as IConfigureNamingFor<TContext>).Custom(ctx => nameOfs);
+            return (this as IConfigureNamingFor<TContext>).Custom(ctx => namingConventions);
         }
 
         IConfigureFeatures IConfigureBehavior.Custom(params Feature.Behavior[] behaviors)
@@ -73,7 +73,7 @@ IConfigureFeatures IConfigureBehavior.Custom(params Feature.Behavior[] behaviors
         public Feature.Configuration For(TContext context)
         {
             return new Feature.Configuration(
-                type => (NameOf(context) ?? new Feature.NameOf[0]).Where(x => x != null).Select(x => x(type)).FirstOrDefault(x => x != null),
+                type => (NamingConvention(context) ?? new Feature.NamingConvention[0]).Where(x => x != null).Select(x => x(type)).FirstOrDefault(x => x != null),
                 name => (Behavior(context) ?? new Feature.Behavior[0]).Select(x => x(name)).FirstOrDefault(x => x.HasValue),
                 typeof(TContext) != typeof(Default) ? FeatureConfiguration.For(Default.Context) : Feature.Configuration.Current);
         }
diff --git a/Source/FeatureSwitcher.Contexteer/Configuration/IConfigureNamingFor.cs b/Source/FeatureSwitcher.Contexteer/Configuration/IConfigureNamingFor.cs
@@ -15,6 +15,6 @@ public interface IConfigureNamingFor<out TContext> : IConfigureNaming
         /// </summary>
         /// <param name="namingConventions">The naming conventions to use.</param>
         /// <returns>the extension point for features configuration in contexts of type <typeparamref name="TContext"/>.</returns>
-        IConfigureFeaturesFor<TContext> Custom(Func<TContext, Feature.NameOf[]> namingConventions);
+        IConfigureFeaturesFor<TContext> Custom(Func<TContext, Feature.NamingConvention[]> namingConventions);
     }
 }
diff --git a/Source/FeatureSwitcher.Specs/Domain/EnableByName.cs b/Source/FeatureSwitcher.Specs/Domain/EnableByName.cs
@@ -1,21 +1,11 @@
-using System;
-using FeatureSwitcher.Configuration;
-
 namespace FeatureSwitcher.Specs.Domain
 {
-    public class EnableByName<T> 
+    public static class EnableByName<T>
         where T : IFeature
     {
-        public readonly static EnableByName<T> Instance = new EnableByName<T>();
-
-        public bool? IsEnabled(string feature)
+        public static bool? IsEnabled(Feature.Name name)
         {
-            return Features.OfType<T>.EnabledByTypeName(feature);
-        }
-
-        public string For(Type featureType)
-        {
-            return Features.OfType<T>.NamedByTypeName(featureType);
+            return typeof(T).Name == name.Value ? true : (bool?)null;
         }
     }
 }
diff --git a/Source/FeatureSwitcher.Specs/When_behavior_is_not_configured_in_context_and_configured_general.cs b/Source/FeatureSwitcher.Specs/When_behavior_is_not_configured_in_context_and_configured_general.cs
@@ -13,25 +13,25 @@ public class When_behavior_is_not_configured_in_context_and_configured_general :
                             {
                                 Features.Are.
                                     ConfiguredBy.Custom(
-                                        EnableByName<Basic>.Instance.IsEnabled,
-                                        EnableByName<Simple>.Instance.IsEnabled, 
-                                        EnableByName<Complex>.Instance.IsEnabled).And.
+                                        EnableByName<Basic>.IsEnabled,
+                                        EnableByName<Simple>.IsEnabled, 
+                                        EnableByName<Complex>.IsEnabled).And.
                                     NamedBy.TypeName();
 
                                 In<BusinessBranch>.Contexts.FeaturesAre().
                                     NamedBy.TypeFullName();
                             };
 
-        Behaves_like<Enabled<Basic>> a_disabled_basic_feature;
-        Behaves_like<EnabledInDefault<Basic>> a_disabled_basic_feature_in_default;
+        Behaves_like<Enabled<Basic>> an_enabled_basic_feature;
+        Behaves_like<EnabledInDefault<Basic>> an_enabled_basic_feature_in_default;
         Behaves_like<DisabledInHeadquaters<Basic>> a_disabled_basic_feature_in_headquarters;
 
-        Behaves_like<Enabled<Simple>> a_disabled_simple_feature;
-        Behaves_like<EnabledInDefault<Simple>> a_disabled_simple_feature_in_default;
+        Behaves_like<Enabled<Simple>> an_enabled_simple_feature;
+        Behaves_like<EnabledInDefault<Simple>> an_enabled_simple_feature_in_default;
         Behaves_like<DisabledInHeadquaters<Simple>> an_enabled_feature_in_headquarters;
 
-        Behaves_like<Enabled<Complex>> a_disabled_complex_feature;
-        Behaves_like<EnabledInDefault<Complex>> a_disabled_complex_feature_in_default;
+        Behaves_like<Enabled<Complex>> an_enabled_complex_feature;
+        Behaves_like<EnabledInDefault<Complex>> an_enabled_complex_feature_in_default;
         Behaves_like<DisabledInHeadquaters<Complex>> a_disabled_complex_feature_in_headquarters;
     }
 }
diff --git a/Source/FeatureSwitcher.Specs/When_chaining_application_configuration_and_partial_configurations.cs b/Source/FeatureSwitcher.Specs/When_chaining_application_configuration_and_partial_configurations.cs
@@ -12,11 +12,11 @@ public class When_chaining_application_configuration_and_partial_configurations
                         Features.Are
                             .ConfiguredBy.Custom(
                                 new AppConfig(true).Features,
-                                EnableByName<Simple>.Instance.IsEnabled,
+                                EnableByName<Simple>.IsEnabled,
                                 new AppConfig(true).Default).And
                             .NamedBy.Custom(
-                                EnableByName<Simple>.Instance.For,
-                                Features.OfAnyType.NamedByTypeFullName);
+                                Features.OfType<Simple>.NamedByTypeName,
+                                Features.OfType<Complex>.NamedByTypeFullName);
 
         Behaves_like<Disabled<Basic>> a_disabled_basic_feature;
         Behaves_like<DisabledInDefault<Basic>> a_disabled_basic_feature_in_default;
diff --git a/Source/FeatureSwitcher.Specs/When_chaining_multiple_partial_configurations.cs b/Source/FeatureSwitcher.Specs/When_chaining_multiple_partial_configurations.cs
@@ -9,8 +9,8 @@ namespace FeatureSwitcher.Specs
     public class When_chaining_multiple_partial_configurations : WithCleanUp
     {
         Establish ctx = () => Features.Are.
-                                  ConfiguredBy.Custom(EnableByName<Simple>.Instance.IsEnabled, EnableByName<Complex>.Instance.IsEnabled).And.
-                                  NamedBy.Custom(EnableByName<Simple>.Instance.For, EnableByName<Complex>.Instance.For);
+                                  ConfiguredBy.Custom(EnableByName<Simple>.IsEnabled, EnableByName<Complex>.IsEnabled).And.
+                                  NamedBy.Custom(Features.OfType<Simple>.NamedByTypeName, Features.OfType<Complex>.NamedByTypeName);
 
         Behaves_like<Disabled<Basic>> a_disabled_basic_feature;
         Behaves_like<DisabledInDefault<Basic>> a_disabled_basic_feature_in_default;
diff --git a/Source/FeatureSwitcher.Specs/When_chaining_multiple_partial_configurations_and_contexts.cs b/Source/FeatureSwitcher.Specs/When_chaining_multiple_partial_configurations_and_contexts.cs
@@ -13,16 +13,16 @@ public class When_chaining_multiple_partial_configurations_and_contexts : WithCl
         Establish ctx = () =>
                             {
                                 Features.Are
-                                    .ConfiguredBy.Custom(EnableByName<Simple>.Instance.IsEnabled, EnableByName<Complex>.Instance.IsEnabled).And
-                                    .NamedBy.Custom(EnableByName<Simple>.Instance.For, EnableByName<Complex>.Instance.For);
+                                    .ConfiguredBy.Custom(EnableByName<Simple>.IsEnabled, EnableByName<Complex>.IsEnabled).And
+                                    .NamedBy.Custom(Features.OfType<Simple>.NamedByTypeName, Features.OfType<Complex>.NamedByTypeName);
 
                                 In<Default>.Contexts.FeaturesAre()
-                                    .AlwaysDisabled().And
+                                    .ConfiguredBy.Custom(Features.OfType<Simple>.Disabled, Features.OfType<Basic>.Disabled, Features.OfAnyType.Enabled).And
                                     .NamedBy.TypeFullName();
 
                                 In<BusinessBranch>.Contexts.FeaturesAre()
-                                    .ConfiguredBy.Custom(EnableByName<Basic>.Instance.IsEnabled).And
-                                    .NamedBy.Custom(EnableByName<Basic>.Instance.For);
+                                    .ConfiguredBy.Custom(EnableByName<Basic>.IsEnabled).And
+                                    .NamedBy.Custom(Features.OfType<Basic>.NamedByTypeName);
                             };
 
         Behaves_like<Enabled<Simple>> an_enabled_feature_simple;
@@ -34,7 +34,7 @@ public class When_chaining_multiple_partial_configurations_and_contexts : WithCl
         Behaves_like<EnabledInHeadquaters<Basic>> an_enabled_feature_basic_in_headquarters;
 
         Behaves_like<Enabled<Complex>> an_enabled_feature_complex;
-        Behaves_like<DisabledInDefault<Complex>> a_disabled_feature_complex_in_default;
-        Behaves_like<DisabledInHeadquaters<Complex>> a_disabled_feature_complex_in_headquarters;
+        Behaves_like<EnabledInDefault<Complex>> an_enabled_feature_complex_in_default;
+        Behaves_like<EnabledInHeadquaters<Complex>> an_enabled_feature_complex_in_headquarters;
     }
 }
diff --git a/Source/FeatureSwitcher.Specs/When_naming_is_not_configured_in_context_and_configured_general.cs b/Source/FeatureSwitcher.Specs/When_naming_is_not_configured_in_context_and_configured_general.cs
@@ -14,7 +14,7 @@ public class When_naming_is_not_configured_in_context_and_configured_general : W
             Features.Are.NamedBy.TypeName();
 
             In<BusinessBranch>.Contexts.FeaturesAre().
-                ConfiguredBy.Custom(EnableByName<Simple>.Instance.IsEnabled);
+                ConfiguredBy.Custom(Features.OfType<Simple>.Enabled);
         };
 
 
diff --git a/Source/FeatureSwitcher.Specs/When_using_partial_configuration.cs b/Source/FeatureSwitcher.Specs/When_using_partial_configuration.cs
@@ -9,8 +9,8 @@ namespace FeatureSwitcher.Specs
     public class When_using_partial_configuration : WithCleanUp
     {
         Establish ctx = () => Features.Are.
-                                  ConfiguredBy.Custom(EnableByName<Simple>.Instance.IsEnabled).And.
-                                  NamedBy.Custom(EnableByName<Simple>.Instance.For);
+                                  ConfiguredBy.Custom(EnableByName<Simple>.IsEnabled).And.
+                                  NamedBy.Custom(Features.OfType<Simple>.NamedByTypeName);
 
         Behaves_like<Disabled<Basic>> a_disabled_basic_feature;
         Behaves_like<DisabledInDefault<Basic>> a_disabled_basic_feature_in_default;
diff --git a/Source/FeatureSwitcher.Specs/When_using_partial_configuration_and_contexts.cs b/Source/FeatureSwitcher.Specs/When_using_partial_configuration_and_contexts.cs
@@ -13,16 +13,16 @@ public class When_using_partial_configuration_and_contexts : WithCleanUp
         Establish ctx = () =>
                             {
                                 Features.Are.
-                                    ConfiguredBy.Custom(EnableByName<Simple>.Instance.IsEnabled).And.
-                                    NamedBy.Custom(EnableByName<Simple>.Instance.For);
+                                    ConfiguredBy.Custom(EnableByName<Simple>.IsEnabled).And.
+                                    NamedBy.Custom(Features.OfType<Simple>.NamedByTypeName);
 
                                 In<Default>.Contexts.FeaturesAre().
-                                    ConfiguredBy.Custom(EnableByName<Basic>.Instance.IsEnabled).And.
-                                    NamedBy.Custom(EnableByName<Basic>.Instance.For);
+                                    ConfiguredBy.Custom(EnableByName<Basic>.IsEnabled).And.
+                                    NamedBy.Custom(Features.OfType<Basic>.NamedByTypeName);
 
                                 In<BusinessBranch>.Contexts.FeaturesAre().
-                                    ConfiguredBy.Custom(EnableByName<Complex>.Instance.IsEnabled).And.
-                                    NamedBy.Custom(EnableByName<Complex>.Instance.For);
+                                    ConfiguredBy.Custom(EnableByName<Complex>.IsEnabled).And.
+                                    NamedBy.Custom(Features.OfType<Complex>.NamedByTypeName);
                             };
 
         Behaves_like<Disabled<Basic>> a_disabled_feature_basic;
diff --git a/Source/FeatureSwitcher/Configuration/Features.ConfigurationBuilder.cs b/Source/FeatureSwitcher/Configuration/Features.ConfigurationBuilder.cs
@@ -5,12 +5,12 @@ namespace FeatureSwitcher.Configuration
     public static partial class Features
     {
         /// <summary>
-        /// Builder for features configuration.
+        /// Builder for feature configuration.
         /// </summary>
-        public class ConfigurationBuilder : IConfigureFeatures, IConfigureNaming, IConfigureBehavior
+        private class ConfigurationBuilder : IConfigureFeatures, IConfigureNaming, IConfigureBehavior
         {
             private readonly Feature.Configuration _fallback;
-            private Feature.NameOf _namingConvention;
+            private Feature.NamingConvention _namingConvention;
             private Feature.Behavior _behavior;
 
             /// <summary>
@@ -46,7 +46,7 @@ IConfigureBehavior IConfigureFeatures.ConfiguredBy
                 get { return this; }
             }
 
-            IConfigureFeatures IConfigureNaming.Custom(params Feature.NameOf[] namingConventions)
+            IConfigureFeatures IConfigureNaming.Custom(params Feature.NamingConvention[] namingConventions)
             {
                 _namingConvention = null;
                 if (namingConventions != null)
diff --git a/Source/FeatureSwitcher/Configuration/Features.OfAnyType.cs b/Source/FeatureSwitcher/Configuration/Features.OfAnyType.cs
@@ -1,3 +1,5 @@
+using System;
+
 namespace FeatureSwitcher.Configuration
 {
     public static partial class Features
@@ -8,28 +10,45 @@ public static partial class Features
         public static class OfAnyType
         {
             /// <summary>
-            /// Gets the behavior which enables any feature.
+            /// Enables any feature.
             /// </summary>
-            public static Feature.Behavior Enabled { get; private set; }
+            /// <param name="featureName">The name of the feature.</param>
+            /// <returns>always <c>true</c>.</returns>
+            public static bool? Enabled(Feature.Name featureName)
+            {
+                return true;
+            }
+
             /// <summary>
-            /// Gets the behavior which disables any feature.
+            /// Disables any feature.
             /// </summary>
-            public static Feature.Behavior Disabled { get; private set; }
+            /// <param name="featureName">The name of the feature.</param>
+            /// <returns>always <c>false</c>.</returns>
+            public static bool? Disabled(Feature.Name featureName)
+            {
+                return false;
+            }
+
             /// <summary>
-            /// Gets the naming convention which names any feature by name of the type.
+            /// Provides the name of the feature.
+            /// The value of the name is the name of <paramref name="featureType"/>.
             /// </summary>
-            public static Feature.NameOf NamedByTypeName { get; private set; }
+            /// <param name="featureType">The type of the feature.</param>
+            /// <returns>the name of the feature.</returns>
+            public static Feature.Name NamedByTypeName(Type featureType)
+            {
+                return new Feature.Name(featureType, featureType.Name);
+            }
+
             /// <summary>
-            /// Gets the naming convention which names any feature by full name of the type.
+            /// Provides the name of the feature.
+            /// The value of the name is the full name of <paramref name="featureType"/>.
             /// </summary>
-            public static Feature.NameOf NamedByTypeFullName { get; private set; }
-
-            static OfAnyType()
+            /// <param name="featureType">The type of the feature.</param>
+            /// <returns>the name of the feature.</returns>
+            public static Feature.Name NamedByTypeFullName(Type featureType)
             {
-                Enabled = name => true;
-                Disabled = name => false;
-                NamedByTypeName = type => type.Name;
-                NamedByTypeFullName = type => type.FullName;
+                return new Feature.Name(featureType, featureType.FullName);
             }
         }
     }
diff --git a/Source/FeatureSwitcher/Configuration/Features.OfType.cs b/Source/FeatureSwitcher/Configuration/Features.OfType.cs
diff --git a/Source/FeatureSwitcher/Configuration/IConfigureNaming.cs b/Source/FeatureSwitcher/Configuration/IConfigureNaming.cs
diff --git a/Source/FeatureSwitcher/Feature.Behavior.cs b/Source/FeatureSwitcher/Feature.Behavior.cs
diff --git a/Source/FeatureSwitcher/Feature.Configuration.cs b/Source/FeatureSwitcher/Feature.Configuration.cs
diff --git a/Source/FeatureSwitcher/Feature.Name.cs b/Source/FeatureSwitcher/Feature.Name.cs
diff --git a/Source/FeatureSwitcher/Feature.NamingConvention.cs b/Source/FeatureSwitcher/Feature.NamingConvention.cs
diff --git a/Source/FeatureSwitcher/FeatureSwitcher.csproj b/Source/FeatureSwitcher/FeatureSwitcher.csproj

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ private FeaturesSection FeaturesSection`
`63`	`63`	`get { return _features ?? SectionGroup.GetFeaturesSection(_settings.SectionGroupName, _settings.IgnoreConfigurationErrors); }`
`64`	`64`	`}`
`65`	`65`
`66`		`- public bool? IsEnabled(string feature)`
	`66`	`+ public bool? IsEnabled(Feature.Name feature)`
`67`	`67`	`{`
`68`	`68`	`return Features(feature).GetValueOrDefault(Default(feature).GetValueOrDefault());`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public AppConfigDefault(DefaultSection defaultSection)`
`9`	`9`	`_defaultSection = defaultSection;`
`10`	`10`	`}`
`11`	`11`
`12`		`- public bool? IsEnabled(string feature)`
	`12`	`+ public bool? IsEnabled(Feature.Name feature)`
`13`	`13`	`{`
`14`	`14`	`if (_defaultSection == null)`
`15`	`15`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,12 @@ public AppConfigFeatures(FeaturesSection features)`
`9`	`9`	`_features = features;`
`10`	`10`	`}`
`11`	`11`
`12`		`- public bool? IsEnabled(string feature)`
	`12`	`+ public bool? IsEnabled(Feature.Name feature)`
`13`	`13`	`{`
`14`	`14`	`if (_features == null)`
`15`	`15`	`return null;`
`16`	`16`
`17`		`- var featureElement = _features.Features[feature];`
	`17`	`+ var featureElement = _features.Features[feature.Value];`
`18`	`18`
`19`	`19`	`if (featureElement == null)`
`20`	`20`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ namespace FeatureSwitcher.Configuration`
`7`	`7`	`internal class FeatureConfigurationFor<TContext> : IConfigureFeaturesFor<TContext>, IConfigureBehaviorFor<TContext>, IConfigureNamingFor<TContext>`
`8`	`8`	`where TContext : IContext`
`9`	`9`	`{`
`10`		`- private Func<TContext, Feature.NameOf[]> _nameOf;`
`11`		`- private Func<TContext, Feature.NameOf[]> NameOf`
	`10`	`+ private Func<TContext, Feature.NamingConvention[]> _namingConvention;`
	`11`	`+ private Func<TContext, Feature.NamingConvention[]> NamingConvention`
`12`	`12`	`{`
`13`		`- get { return _nameOf ?? (ctx => null); }`
	`13`	`+ get { return _namingConvention ?? (ctx => null); }`
`14`	`14`	`}`
`15`	`15`	`private Func<TContext, Feature.Behavior[]> _behavior;`
`16`	`16`	`private Func<TContext, Feature.Behavior[]> Behavior`
`@@ -38,19 +38,19 @@ IConfigureFeaturesFor<TContext> IConfigureFeaturesFor<TContext>.And`
`38`	`38`	`get { return this; }`
`39`	`39`	`}`
`40`	`40`
`41`		`- public IConfigureNaming NamedBy`
	`41`	`+ IConfigureNaming IConfigureFeatures.NamedBy`
`42`	`42`	`{`
`43`	`43`	`get { return this; }`
`44`	`44`	`}`
`45`	`45`
`46`		`- public IConfigureBehavior ConfiguredBy`
	`46`	`+ IConfigureBehavior IConfigureFeatures.ConfiguredBy`
`47`	`47`	`{`
`48`	`48`	`get { return this; }`
`49`	`49`	`}`
`50`	`50`
`51`		`- IConfigureFeaturesFor<TContext> IConfigureNamingFor<TContext>.Custom(Func<TContext, Feature.NameOf[]> naming)`
	`51`	`+ IConfigureFeaturesFor<TContext> IConfigureNamingFor<TContext>.Custom(Func<TContext, Feature.NamingConvention[]> namingConventions)`
`52`	`52`	`{`
`53`		`- _nameOf = naming;`
	`53`	`+ _namingConvention = namingConventions;`
`54`	`54`	`return this;`
`55`	`55`	`}`
`56`	`56`
`@@ -60,9 +60,9 @@ IConfigureFeaturesFor<TContext> IConfigureBehaviorFor<TContext>.Custom(Func<TCon`
`60`	`60`	`return this;`
`61`	`61`	`}`
`62`	`62`
`63`		`- IConfigureFeatures IConfigureNaming.Custom(params Feature.NameOf[] nameOfs)`
	`63`	`+ IConfigureFeatures IConfigureNaming.Custom(params Feature.NamingConvention[] namingConventions)`
`64`	`64`	`{`
`65`		`- return (this as IConfigureNamingFor<TContext>).Custom(ctx => nameOfs);`
	`65`	`+ return (this as IConfigureNamingFor<TContext>).Custom(ctx => namingConventions);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`IConfigureFeatures IConfigureBehavior.Custom(params Feature.Behavior[] behaviors)`
`@@ -73,7 +73,7 @@ IConfigureFeatures IConfigureBehavior.Custom(params Feature.Behavior[] behaviors`
`73`	`73`	`public Feature.Configuration For(TContext context)`
`74`	`74`	`{`
`75`	`75`	`return new Feature.Configuration(`
`76`		`- type => (NameOf(context) ?? new Feature.NameOf[0]).Where(x => x != null).Select(x => x(type)).FirstOrDefault(x => x != null),`
	`76`	`+ type => (NamingConvention(context) ?? new Feature.NamingConvention[0]).Where(x => x != null).Select(x => x(type)).FirstOrDefault(x => x != null),`
`77`	`77`	`name => (Behavior(context) ?? new Feature.Behavior[0]).Select(x => x(name)).FirstOrDefault(x => x.HasValue),`
`78`	`78`	`typeof(TContext) != typeof(Default) ? FeatureConfiguration.For(Default.Context) : Feature.Configuration.Current);`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ public interface IConfigureNamingFor<out TContext> : IConfigureNaming`
`15`	`15`	`/// </summary>`
`16`	`16`	`/// <param name="namingConventions">The naming conventions to use.</param>`
`17`	`17`	`/// <returns>the extension point for features configuration in contexts of type <typeparamref name="TContext"/>.</returns>`
`18`		`- IConfigureFeaturesFor<TContext> Custom(Func<TContext, Feature.NameOf[]> namingConventions);`
	`18`	`+ IConfigureFeaturesFor<TContext> Custom(Func<TContext, Feature.NamingConvention[]> namingConventions);`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,11 @@`
`1`		`-using System;`
`2`		`-using FeatureSwitcher.Configuration;`
`3`		`-`
`4`	`1`	`namespace FeatureSwitcher.Specs.Domain`
`5`	`2`	`{`
`6`		`- public class EnableByName<T>`
	`3`	`+ public static class EnableByName<T>`
`7`	`4`	`where T : IFeature`
`8`	`5`	`{`
`9`		`- public readonly static EnableByName<T> Instance = new EnableByName<T>();`
`10`		`-`
`11`		`- public bool? IsEnabled(string feature)`
	`6`	`+ public static bool? IsEnabled(Feature.Name name)`
`12`	`7`	`{`
`13`		`- return Features.OfType<T>.EnabledByTypeName(feature);`
`14`		`- }`
`15`		`-`
`16`		`- public string For(Type featureType)`
`17`		`- {`
`18`		`- return Features.OfType<T>.NamedByTypeName(featureType);`
	`8`	`+ return typeof(T).Name == name.Value ? true : (bool?)null;`
`19`	`9`	`}`
`20`	`10`	`}`
`21`	`11`	`}`