public void Apply(MixinConfigurationBuilder configurationBuilder, Assembly attributeTarget)
{
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
ArgumentUtility.CheckNotNull("attributeTarget", attributeTarget);
configurationBuilder.ForClass(TargetType).AddMixinDependency(DependentMixin, Dependency);
}
public void SetUp()
{
_mockRepository = new MockRepository();
_configurationBuilderMock = _mockRepository.StrictMock <MixinConfigurationBuilder>((MixinConfiguration)null);
_analyzer = new HasComposedInterfaceMarkerAnalyzer();
}
private void AnalyzeAssembly(MixinConfigurationBuilder configurationBuilder, Assembly assembly)
{
foreach (var assemblyAnalyzer in _assemblyAnalyzers)
{
assemblyAnalyzer.Analyze(assembly, configurationBuilder);
}
}
public void Apply(MixinConfigurationBuilder mixinConfigurationBuilder, Type interfaceType)
{
ArgumentUtility.CheckNotNull("mixinConfigurationBuilder", mixinConfigurationBuilder);
ArgumentUtility.CheckNotNull("interfaceType", interfaceType);
mixinConfigurationBuilder.ForClass(TargetType).AddComposedInterface(interfaceType);
}
public void SetUp()
{
_mockRepository = new MockRepository();
_configurationBuilderMock = _mockRepository.StrictMock <MixinConfigurationBuilder> ((MixinConfiguration)null);
_assembly = GetType().Assembly;
}
public void Apply(MixinConfigurationBuilder mixinConfigurationBuilder, Type targetClassType)
{
ArgumentUtility.CheckNotNull("mixinConfigurationBuilder", mixinConfigurationBuilder);
ArgumentUtility.CheckNotNull("targetClassType", targetClassType);
mixinConfigurationBuilder.ForClass(targetClassType).SuppressMixin(MixinToIgnore);
}
public void AddMixinToClass_WithSelfSuppressor()
{
var builder = new MixinConfigurationBuilder(null);
builder.AddMixinToClass(
MixinKind.Extending, typeof(object), typeof(int), MemberVisibility.Private, new Type[0], new[] { typeof(int) }, _mixinContextOrigin);
}
private void AnalyzeType(MixinConfigurationBuilder configurationBuilder, Type type)
{
foreach (var typeAnalyzer in _typeAnalyzers)
{
typeAnalyzer.Analyze(type, configurationBuilder);
}
}
public void SetUp()
{
_mockRepository = new MockRepository();
_parentBuilderMock = _mockRepository.StrictMock <MixinConfigurationBuilder> ((MixinConfiguration)null);
_classBuilder = new ClassContextBuilder(_parentBuilderMock, typeof(BaseType2));
_classBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (_parentBuilderMock, typeof(BaseType2));
_mixinBuilderMock = _mockRepository.StrictMock <MixinContextBuilder> (_classBuilderMock, typeof(BT2Mixin1), MixinContextOriginObjectMother.Create());
}
public void ForClass_Twice()
{
var builder = new MixinConfigurationBuilder(null);
ClassContextBuilder classBuilder = builder.ForClass(typeof(BaseType1));
ClassContextBuilder classBuilder2 = builder.ForClass(typeof(BaseType1));
Assert.That(classBuilder2, Is.SameAs(classBuilder));
}
public void Apply(MixinConfigurationBuilder configurationBuilder, Assembly attributeTarget)
{
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
ArgumentUtility.CheckNotNull("attributeTarget", attributeTarget);
var origin = MixinContextOrigin.CreateForCustomAttribute(this, attributeTarget);
Apply(configurationBuilder, MixinKind, TargetType, MixinType, origin);
}
public void ForClass_Generic()
{
var builder = new MixinConfigurationBuilder(null);
ClassContextBuilder classBuilder = builder.ForClass <BaseType1> ();
Assert.That(classBuilder.TargetType, Is.SameAs(typeof(BaseType1)));
Assert.That(classBuilder.Parent, Is.SameAs(builder));
Assert.That(builder.ClassContextBuilders, Has.Member(classBuilder));
}
public void SetUp()
{
_mockRepository = new MockRepository();
_typeAnalyzerMock = _mockRepository.StrictMock <IMixinDeclarationAnalyzer <Type> > ();
_assemblyAnalyzerMock = _mockRepository.StrictMock <IMixinDeclarationAnalyzer <Assembly> > ();
_fakeConfigurationBuilder = _mockRepository.Stub <MixinConfigurationBuilder> ((MixinConfiguration)null);
}
public void BuildConfiguration()
{
var builder = new MixinConfigurationBuilder(null);
builder.ForClass <BaseType1> ();
MixinConfiguration configuration = builder.BuildConfiguration();
Assert.That(configuration.ClassContexts.Count, Is.EqualTo(1));
Assert.That(configuration.ClassContexts.ContainsWithInheritance(typeof(BaseType1)), Is.True);
}
public void Apply(MixinConfigurationBuilder configurationBuilder, Type attributeTarget)
{
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
ArgumentUtility.CheckNotNull("attributeTarget", attributeTarget);
Type mixinType = CloseOverMixinTypeArguments(attributeTarget);
var origin = MixinContextOrigin.CreateForCustomAttribute(this, attributeTarget);
Apply(configurationBuilder, MixinKind.Extending, TargetType, mixinType, origin);
}
public void Intitialization_WithoutParent()
{
var builder = new MixinConfigurationBuilder(null);
Assert.That(builder.ParentConfiguration, Is.Null);
Assert.That(builder.ClassContextBuilders, Is.Empty);
MixinConfiguration configuration = builder.BuildConfiguration();
Assert.That(configuration.ClassContexts.Count, Is.EqualTo(0));
}
public void Apply(MixinConfigurationBuilder configurationBuilder, Type attributeTarget)
{
try
{
configurationBuilder.ForClass(attributeTarget).AddMixin <NullMixin> ();
}
catch (Exception ex)
{
throw new ConfigurationException(ex.Message, ex);
}
}
public void BuildConfiguration_IncludesParentConfiguration_WithComposedInterfaces()
{
var existingClassContext = new ClassContext(typeof(BaseType3), new MixinContext[0], new[] { typeof(IBaseType31) });
var parentConfiguration = new MixinConfiguration(new ClassContextCollection(existingClassContext));
var builder = new MixinConfigurationBuilder(parentConfiguration);
MixinConfiguration configuration = builder.BuildConfiguration();
Assert.That(configuration.GetContext(typeof(BaseType3)).ComposedInterfaces, Has.Member(typeof(IBaseType31)));
}
public void ClassContextInheritance_Base_FromSameConfiguration()
{
MixinConfiguration configuration = new MixinConfigurationBuilder(null)
.ForClass <DerivedNullTarget> ().AddMixin(typeof(NullMixin2))
.ForClass <NullTarget> ().AddMixin(typeof(NullMixin))
.BuildConfiguration();
ClassContext derivedContext = configuration.GetContext(typeof(DerivedNullTarget));
Assert.That(derivedContext.Mixins.Count, Is.EqualTo(2));
Assert.That(derivedContext.Mixins.ContainsKey(typeof(NullMixin)), Is.True);
Assert.That(derivedContext.Mixins.ContainsKey(typeof(NullMixin2)), Is.True);
}
public void ClassContextInheritance_TypeDefinition_FromSameConfiguration()
{
MixinConfiguration configuration = new MixinConfigurationBuilder(null)
.ForClass <GenericTargetClass <int> > ().AddMixin(typeof(NullMixin2))
.ForClass(typeof(GenericTargetClass <>)).AddMixin(typeof(NullMixin))
.BuildConfiguration();
ClassContext derivedContext = configuration.GetContext(typeof(GenericTargetClass <int>));
Assert.That(derivedContext.Mixins.Count, Is.EqualTo(2));
Assert.That(derivedContext.Mixins.ContainsKey(typeof(NullMixin)), Is.True);
Assert.That(derivedContext.Mixins.ContainsKey(typeof(NullMixin2)), Is.True);
}
public virtual void Analyze(TAnalyzedEntity entity, MixinConfigurationBuilder configurationBuilder)
{
ArgumentUtility.CheckNotNull("entity", entity);
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
var attributes = _attributeProvider(entity);
foreach (var attribute in attributes)
{
attribute.Apply(configurationBuilder, entity);
}
}
public void Intitialization_WithParent()
{
var parent = new MixinConfiguration(new ClassContextCollection(ClassContextObjectMother.Create(typeof(string))));
var builder = new MixinConfigurationBuilder(parent);
Assert.That(builder.ParentConfiguration, Is.SameAs(parent));
Assert.That(builder.ClassContextBuilders, Is.Empty);
MixinConfiguration configuration = builder.BuildConfiguration();
Assert.That(configuration.ClassContexts.Count, Is.EqualTo(1));
Assert.That(configuration.ClassContexts.ContainsWithInheritance(typeof(string)), Is.True);
}
/// <summary>
/// Analyzes the information added so far to this builder and creates a new <see cref="MixinConfiguration"/> from that data.
/// </summary>
/// <returns>An <see cref="MixinConfiguration"/> derived from the configuration specified in the builder's constructor containing
/// <see cref="ClassContext"/> and <see cref="MixinContext"/> objects based on the information added so far.</returns>
public MixinConfiguration BuildConfiguration()
{
s_log.InfoFormat("Building mixin configuration from {0} types.", _allTypes.Count);
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to build mixin configuration: {elapsed}."))
{
var typeAnalyzers = new IMixinDeclarationAnalyzer <Type>[] { CreateAttributeAnalyzer <Type>(), new HasComposedInterfaceMarkerAnalyzer() };
var assemblyAnalyzers = new IMixinDeclarationAnalyzer <Assembly>[] { CreateAttributeAnalyzer <Assembly> () };
var configurationAnalyzer = new DeclarativeConfigurationAnalyzer(typeAnalyzers, assemblyAnalyzers);
var configurationBuilder = new MixinConfigurationBuilder(_parentConfiguration);
configurationAnalyzer.Analyze(_allTypes, configurationBuilder);
return(configurationBuilder.BuildConfiguration());
}
}
public void BuildConfiguration_IncludesParentConfiguration_WithClassContext_Unmodified()
{
var existingContext = ClassContextObjectMother.Create(typeof(BaseType1), typeof(BT1Mixin1));
var parentConfiguration = new MixinConfiguration(new ClassContextCollection(existingContext));
var builder = new MixinConfigurationBuilder(parentConfiguration);
MixinConfiguration configuration = builder.BuildConfiguration();
Assert.That(configuration.ClassContexts.Count, Is.EqualTo(1));
var classContext = configuration.GetContext(typeof(BaseType1));
Assert.That(classContext, Is.Not.Null);
Assert.That(classContext.Mixins.ContainsKey(typeof(BT1Mixin1)), Is.True);
Assert.That(classContext.Mixins.ContainsKey(typeof(BT1Mixin2)), Is.False);
}
public void Analyze(Type type, MixinConfigurationBuilder configurationBuilder)
{
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
var composedInterfaceMarkers = (from ifc in type.GetInterfaces()
where ifc.IsGenericType
let genericTypeDef = ifc.GetGenericTypeDefinition()
where genericTypeDef == typeof(IHasComposedInterface <>)
let composedInterface = ifc.GetGenericArguments().Single()
where !composedInterface.ContainsGenericParameters
select composedInterface).ToArray();
if (composedInterfaceMarkers.Length > 0)
{
configurationBuilder.ForClass(type).AddComposedInterfaces(composedInterfaceMarkers);
}
}
public void Analyze(IEnumerable <Type> types, MixinConfigurationBuilder configurationBuilder)
{
ArgumentUtility.CheckNotNull("types", types);
ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder);
var assemblies = new HashSet <Assembly>();
foreach (var type in types)
{
AnalyzeType(configurationBuilder, type);
if (!assemblies.Contains(type.Assembly))
{
assemblies.Add(type.Assembly);
AnalyzeAssembly(configurationBuilder, type.Assembly);
}
}
}
public void BuildFrom()
{
MixinConfiguration previousConfiguration = MixinConfiguration.ActiveConfiguration;
MixinConfiguration parentConfiguration = new MixinConfigurationBuilder(null)
.ForClass <BaseType2>().AddMixin(typeof(BT2Mixin1)).BuildConfiguration();
Assert.That(MixinConfiguration.ActiveConfiguration.ClassContexts.ContainsWithInheritance(typeof(BaseType1)), Is.True);
using (MixinConfiguration.BuildFrom(parentConfiguration).ForClass <BaseType7> ().AddMixin <BT7Mixin0> ().EnterScope())
{
Assert.That(MixinConfiguration.ActiveConfiguration, Is.Not.SameAs(previousConfiguration));
Assert.That(MixinConfiguration.ActiveConfiguration, Is.Not.SameAs(parentConfiguration));
Assert.That(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType7)), Is.Not.Null);
Assert.That(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType7)).Mixins.ContainsKey(typeof(BT7Mixin0)), Is.True);
Assert.That(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1)), Is.Null);
Assert.That(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType2)), Is.Not.Null);
}
Assert.That(MixinConfiguration.ActiveConfiguration, Is.SameAs(previousConfiguration));
}
protected void Apply(
MixinConfigurationBuilder configurationBuilder,
MixinKind mixinKind,
Type targetType,
Type mixinType,
MixinContextOrigin origin)
{
ArgumentUtility.CheckNotNull("targetType", targetType);
ArgumentUtility.CheckNotNull("mixinType", mixinType);
ArgumentUtility.CheckNotNull("origin", origin);
try
{
configurationBuilder.AddMixinToClass(
mixinKind, targetType, mixinType, IntroducedMemberVisibility, AdditionalDependencies, SuppressedMixins, origin);
}
catch (Exception ex)
{
throw new ConfigurationException(ex.Message, ex);
}
}
public void ClassContextInheritance_WithOverrides_FromSameConfiguration()
{
MixinConfiguration configuration = new MixinConfigurationBuilder(null)
.ForClass(typeof(NullTarget)).AddMixin(typeof(NullMixin))
.ForClass(typeof(GenericTargetClass <>)).AddMixin(typeof(NullMixin))
.ForClass <DerivedNullTarget> ().AddMixin(typeof(DerivedNullMixin))
.ForClass <GenericTargetClass <int> > ().AddMixin(typeof(DerivedNullMixin))
.BuildConfiguration();
ClassContext derivedContext1 = configuration.GetContext(typeof(DerivedNullTarget));
Assert.That(derivedContext1.Mixins.Count, Is.EqualTo(1));
Assert.That(derivedContext1.Mixins.ContainsKey(typeof(DerivedNullMixin)), Is.True);
Assert.That(derivedContext1.Mixins.ContainsKey(typeof(NullMixin)), Is.False);
ClassContext derivedContext2 = configuration.GetContext(typeof(GenericTargetClass <int>));
Assert.That(derivedContext2.Mixins.Count, Is.EqualTo(1));
Assert.That(derivedContext2.Mixins.ContainsKey(typeof(DerivedNullMixin)), Is.True);
Assert.That(derivedContext2.Mixins.ContainsKey(typeof(NullMixin)), Is.False);
}
public void SetUp()
{
_mockRepository = new MockRepository();
_configurationBuilderMock = _mockRepository.StrictMock <MixinConfigurationBuilder>((MixinConfiguration)null);
}