private static Type CreateType(TypeDescription/*!*/ typeInfo) {
Type baseType = typeInfo.BaseType;
if (baseType.IsSealed) {
throw new NotSupportedException("Can't inherit from a sealed type.");
}
string typeName = GetName(baseType);
TypeBuilder tb = Snippets.Shared.DefinePublicType(typeName, baseType);
Utils.Log(typeName, "TYPE_BUILDER");
IFeatureBuilder[] features = new IFeatureBuilder[typeInfo.Features.Count];
RubyTypeEmitter emitter = new RubyTypeEmitter(tb);
for (int i = 0; i < typeInfo.Features.Count; i++) {
features[i] = typeInfo.Features[i].MakeBuilder(tb);
}
foreach (IFeatureBuilder feature in features) {
feature.Implement(emitter);
}
if (!typeInfo.NoOverrides) {
emitter.OverrideMethods(baseType);
}
Type result = emitter.FinishType();
lock (_typeFeatures) {
_typeFeatures.Add(result, typeInfo.Features);
}
return result;
}
private static void InterceptWithTrait(IFeatureBuilder featureBuilder, Action <object> withTraitCalled)
{
A.CallTo(() => featureBuilder.WithTrait(A <IFeatureTrait> .Ignored))
.WithAnyArguments()
.Invokes(call => withTraitCalled(call.Arguments[0]))
.Returns(featureBuilder);
}
public IFeature Describe(IFeatureBuilder builder)
{
return builder.AsA<IAnonymousUser>()
.GivenThat<IPrecondition>()
.When<ITrigger>()
.Then<IFunctionality>()
.Build(() => "");
}
/// <summary>
/// Adds a default value to the feature.
/// </summary>
/// <param name="featureBuilder">The feature builder.</param>
/// <param name="defaultValue">The default value.</param>
/// <exception cref="ArgumentNullException"><paramref name="featureBuilder"/> is <see langword="null" />.</exception>
/// <returns>The feature builder given in <paramref name="featureBuilder"/>.</returns>
public static IFeatureBuilder WithDefaultValue(this IFeatureBuilder featureBuilder, bool defaultValue)
{
if (featureBuilder == null)
{
throw new ArgumentNullException(nameof(featureBuilder));
}
featureBuilder.WithTrait(new DefaultValueTrait(defaultValue));
return(featureBuilder);
}
public void AddsDependentFeatureTrait(IFeatureBuilder featureBuilder, IFeature dependentFeature)
{
object dependentFeatureTrait = null;
InterceptWithTrait(featureBuilder, o => dependentFeatureTrait = o);
IFeatureBuilder result = FeatureBuilderTraitExtensions.DependentOn(featureBuilder, dependentFeature);
Assert.Same(featureBuilder, result);
Assert.NotNull(dependentFeatureTrait);
Assert.IsType <DependentFeatureTrait>(dependentFeatureTrait);
Assert.Equal(dependentFeature, ((DependentFeatureTrait)dependentFeatureTrait).DependentFeature);
}
public void AddsDefaultValueTrait(IFeatureBuilder featureBuilder, bool defaultValue)
{
object defaultValueTrait = null;
InterceptWithTrait(featureBuilder, o => defaultValueTrait = o);
IFeatureBuilder result = FeatureBuilderTraitExtensions.WithDefaultValue(featureBuilder, defaultValue);
Assert.Same(featureBuilder, result);
Assert.NotNull(defaultValueTrait);
Assert.IsType <DefaultValueTrait>(defaultValueTrait);
Assert.Equal(defaultValue, ((DefaultValueTrait)defaultValueTrait).DefaultValue);
}
/// <summary>
/// Adds a dependency trait to the feature.
/// </summary>
/// <param name="featureBuilder">The feature builder.</param>
/// <param name="dependentFeature">The feature to be dependent on.</param>
/// <exception cref="ArgumentNullException">Either <paramref name="featureBuilder"/> or <paramref name="dependentFeature"/> is <see langword="null" />.</exception>
/// <returns>The feature builder given in <paramref name="featureBuilder"/>.</returns>
public static IFeatureBuilder DependentOn(this IFeatureBuilder featureBuilder, IFeature dependentFeature)
{
if (featureBuilder == null)
{
throw new ArgumentNullException(nameof(featureBuilder));
}
if (dependentFeature == null)
{
throw new ArgumentNullException(nameof(dependentFeature));
}
featureBuilder.WithTrait(new DependentFeatureTrait(dependentFeature));
return(featureBuilder);
}
public void WithDefaultValueAddsDefaultValueTrait(IFeatureBuilder featureBuilder, bool defaultValue)
{
object defaultValueTrait = null;
A.CallTo(() => featureBuilder.WithTrait(A<IFeatureTrait>.Ignored))
.WithAnyArguments()
.Invokes(call => defaultValueTrait = call.Arguments[0])
.Returns(featureBuilder);
IFeatureBuilder result = FeatureBuilderTraitExtensions.WithDefaultValue(featureBuilder, defaultValue);
Assert.Same(featureBuilder, result);
Assert.NotNull(defaultValueTrait);
Assert.IsType<DefaultValueTrait>(defaultValueTrait);
Assert.Equal(defaultValue, ((DefaultValueTrait) defaultValueTrait).DefaultValue);
}
public void WithDefaultValueAddsDefaultValueTrait(IFeatureBuilder featureBuilder, bool defaultValue)
{
object defaultValueTrait = null;
A.CallTo(() => featureBuilder.WithTrait(A <IFeatureTrait> .Ignored))
.WithAnyArguments()
.Invokes(call => defaultValueTrait = call.Arguments[0])
.Returns(featureBuilder);
IFeatureBuilder result = FeatureBuilderTraitExtensions.WithDefaultValue(featureBuilder, defaultValue);
Assert.Same(featureBuilder, result);
Assert.NotNull(defaultValueTrait);
Assert.IsType <DefaultValueTrait>(defaultValueTrait);
Assert.Equal(defaultValue, ((DefaultValueTrait)defaultValueTrait).DefaultValue);
}
private static Type CreateType(TypeDescription /*!*/ typeInfo)
{
Type baseType = typeInfo.BaseType;
if (baseType.IsSealed())
{
throw new NotSupportedException(
String.Format(CultureInfo.InvariantCulture, "Can't inherit from a sealed type {0}.",
RubyContext.GetQualifiedNameNoLock(baseType, null, false))
);
}
#if FEATURE_REFEMIT
string typeName = GetName(baseType);
TypeBuilder tb = Snippets.Shared.DefinePublicType(typeName, baseType);
Utils.Log(typeName, "TYPE_BUILDER");
IFeatureBuilder[] features = new IFeatureBuilder[typeInfo.Features.Count];
RubyTypeEmitter emitter = new RubyTypeEmitter(tb);
for (int i = 0; i < typeInfo.Features.Count; i++)
{
features[i] = typeInfo.Features[i].MakeBuilder(tb);
}
foreach (IFeatureBuilder feature in features)
{
feature.Implement(emitter);
}
if (!typeInfo.NoOverrides)
{
emitter.OverrideMethods(baseType);
}
Type result = emitter.FinishType();
lock (_typeFeatures) {
_typeFeatures.Add(result, typeInfo.Features);
}
return(result);
#else
throw new NotSupportedException("Creating new CLR types is not supported on this platform.");
#endif
}
private static Type CreateType(TypeDescription/*!*/ typeInfo)
{
Type baseType = typeInfo.BaseType;
if (baseType.IsSealed()) {
throw new NotSupportedException(
String.Format(CultureInfo.InvariantCulture, "Can't inherit from a sealed type {0}.",
RubyContext.GetQualifiedNameNoLock(baseType, null, false))
);
}
#if FEATURE_REFEMIT
string typeName = GetName(baseType);
TypeBuilder tb = Snippets.Shared.DefinePublicType(typeName, baseType);
Utils.Log(typeName, "TYPE_BUILDER");
IFeatureBuilder[] features = new IFeatureBuilder[typeInfo.Features.Count];
RubyTypeEmitter emitter = new RubyTypeEmitter(tb);
for (int i = 0; i < typeInfo.Features.Count; i++) {
features[i] = typeInfo.Features[i].MakeBuilder(tb);
}
foreach (IFeatureBuilder feature in features) {
feature.Implement(emitter);
}
if (!typeInfo.NoOverrides) {
emitter.OverrideMethods(baseType);
}
Type result = emitter.FinishType();
lock (_typeFeatures) {
_typeFeatures.Add(result, typeInfo.Features);
}
return result;
#else
throw new NotSupportedException("Creating new CLR types is not supported on this platform.");
#endif
}
public void ThrowsWhenGivenNullDependentFeature(IFeatureBuilder featureBuilder)
{
Assert.Throws <ArgumentNullException>(
() => FeatureBuilderTraitExtensions.DependentOn(featureBuilder, null));
}
public FeatureBasedRecommendationEngine(IFeatureBuilder featureBuilder, IEnumerable<IRelatedItemsProvider> relatedItemsReaders)
{
_featureBuilder = featureBuilder;
_relatedItemsProviders = relatedItemsReaders.ToList();
}
public FeatureBasedRecommendationEngine(IFeatureBuilder featureBuilder, IEnumerable <IRelatedItemsProvider> relatedItemsReaders)
{
_featureBuilder = featureBuilder;
_relatedItemsProviders = relatedItemsReaders.ToList();
}
