public BottleConfigurationDef(string provenance)
{
_objectDef = new ObjectDef(typeof(AssertBottleConfiguration));
_objectDef.DependencyByValue(provenance);
_rules = _objectDef.EnumerableDependenciesOf <IBottleConfigurationRule>();
}
void IDependencyVisitor.List(ListDependency dependency)
{
var elements = dependency.Items.Select(instanceFor).ToArray();
var instance = new EnumerableInstance(elements);
Dependencies.Add(dependency.DependencyType, instance);
}
public void add_type()
{
var dependency = new ListDependency(typeof(ISomethingDoer[]));
dependency.AddType(typeof(ASomethingDoer)).Type.ShouldEqual(typeof(ASomethingDoer));
dependency.Items.Count.ShouldEqual(1);
}
public void accepting_the_visitor()
{
var visitor = MockRepository.GenerateMock <IDependencyVisitor>();
var dependency = new ListDependency(typeof(IList <ISomethingDoer>));
dependency.AcceptVisitor(visitor);
visitor.AssertWasCalled(x => x.List(dependency));
}
void IDependencyVisitor.List(ListDependency dependency)
{
_components.AddRange(dependency
.Items
.Select(def => new WindsorDependencyVisitor(dependency.ElementType, def, true))
.SelectMany(v => v.Registrations()));
_registration.DependsOn(Dependency.OnComponentCollection(dependency.DependencyType,
dependency.Items.Select(def => def.Name).ToArray()));
}
public void add_value()
{
var doer = new ASomethingDoer();
var dependency = new ListDependency(typeof(ISomethingDoer[]));
dependency.AddValue(doer);
dependency.Items.Count.ShouldEqual(1);
dependency.Items[0].Value.ShouldBeTheSameAs(doer);
}
void IDependencyVisitor.List(ListDependency dependency)
{
var items = dependency.Items.ToArray();
// Register the type-based items.
foreach (ObjectDef definition in items.Where(def => def.Value == null))
{
var registration = new ObjectDefRegistration(_builder, definition, false, true);
registration.Register(definition.Type);
}
SetDependencyList(dependency.DependencyType, dependency.ElementType, items);
}
protected override ObjectDef buildObjectDef()
{
var def = new ObjectDef(typeof(OutputBehavior <>), _resourceType);
Type mediaType = typeof(IMedia <>).MakeGenericType(_resourceType);
Type enumerableType = typeof(IEnumerable <>).MakeGenericType(mediaType);
var dependency = new ListDependency(enumerableType);
dependency.AddRange(Writers.OfType <IContainerModel>().Select(x => x.ToObjectDef()));
def.Dependency(dependency);
return(def);
}
protected override ObjectDef buildObjectDef()
{
var def = new ObjectDef(typeof(InputBehavior <>), _inputType);
var readerType = typeof(IReader <>).MakeGenericType(_inputType);
var enumerableType = typeof(IEnumerable <>).MakeGenericType(readerType);
var dependency = new ListDependency(enumerableType);
dependency.AddRange(Readers.OfType <IContainerModel>().Select(x => x.ToObjectDef()));
def.Dependency(dependency);
return(def);
}
protected override sealed ObjectDef buildObjectDef()
{
var objectDef = new ObjectDef(behaviorType().MakeGenericType(InputType));
var mediaReaderType = getReaderWriterType().MakeGenericType(InputType);
var readerDependencies = new ListDependency(typeof(IEnumerable <>).MakeGenericType(mediaReaderType));
readerDependencies.AddRange(createBuilderDependencies());
objectDef.Dependency(readerDependencies);
return(objectDef);
}
public void Should_satisfy_dependency()
{
var def = new ObjectDef(typeof(NeedListOfDoers));
var doer1 = new ASomethingDoer();
var doers = new ListDependency(typeof(IEnumerable <ISomethingDoer>));
doers.AddValue(doer1);
doers.AddType(typeof(BSomethingDoer));
def.Dependency(doers);
def.Dependencies.ShouldHaveCount(1);
}
public void build_an_object_with_a_list_dependency()
{
var def = new ObjectDef(typeof(ClassWithSomethings));
var listDependency = new ListDependency(typeof(IList <ISomething>));
listDependency.AddType(typeof(SomethingA));
listDependency.AddType(typeof(SomethingB));
listDependency.AddValue(new SomethingC());
def.Dependencies.Add(listDependency);
var instance = new ObjectDefInstance(def);
var container = new Container();
var @object = container.GetInstance <ClassWithSomethings>(instance);
@object.Somethings[0].ShouldBeOfType <SomethingA>();
@object.Somethings[1].ShouldBeOfType <SomethingB>();
@object.Somethings[2].ShouldBeOfType <SomethingC>();
}
public UIControls DrawUIInput(Dependency dependency)
{
if (mTool == null)
{
return(null);
}
UIPainterItem item = new UIPainterItem();
item.mDependency = dependency;
switch (dependency.showType)
{
case PropShowType.CLASS:
break;
case PropShowType.ENUM:
EnumDependency enumDependency = dependency as EnumDependency;
item.Controls = mTool.DrawEnumInputArea(dependency.propInfo.Name, dependency.Value, enumDependency.EnumStructList);
break;
case PropShowType.LIST:
ListDependency listDependency = dependency as ListDependency;
MethodInfo mi = typeof(UIDrawTool).GetMethod("DrawListInputArea");
item.Controls = mi.MakeGenericMethod(listDependency.GenericType).Invoke(mTool, new object[] {
dependency.propInfo.Name,
dependency.Value,
new Func <object>(() => {
return(DrawUIInput(listDependency.GenericDependency[0]));
})
}) as UIControls;
break;
case PropShowType.PRIMITIVE:
item.Controls = mTool.DrawPrimativeInputArea(dependency.propInfo.Name, dependency.Value);
break;
}
uiLogicItems.Add(item);
return(item.Controls);
}
public ConfigureModelValidationFailureExpression(Func <Type, bool> predicate, ListDependency policies)
{
_predicate = predicate;
_policies = policies;
}
public ValidationFailureExpression(ListDependency policies)
{
_policies = policies;
}
void IDependencyVisitor.List(ListDependency dependency)
{
var elements = dependency.Items.Select(instanceFor).ToArray();
ChildArray(dependency.DependencyType).Contains(elements);
}
