public static IOperable <T> TheFirst <T>(this IListBuilder <T> listBuilder, int amount)
{
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
Guard.Against(amount < 1, "TheFirst amount must be 1 or greater");
Guard.Against(amount > listBuilderImpl.Capacity, "TheFirst amount must be less than the size of the list that is being generated");
var declaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(), 0, amount - 1);
return((IOperable <T>)listBuilderImpl.AddDeclaration(declaration));
}
public void TheFirstShouldReturnARangeDeclaration()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 0);
listBuilderImpl.Capacity.Returns(30);
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
listBuilderImpl.AddDeclaration(Arg.Is <RangeDeclaration <MyClass> >(y => y.Start == 0 && y.End == 9)).Returns(rangeDeclaration);
var declaration = ListBuilderExtensions.TheFirst(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
public void ShouldBeAbleToUseSection()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 10, 19);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.Capacity.Returns(20);
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
listBuilderImpl.AddDeclaration(Arg.Is <RangeDeclaration <MyClass> >(y => y.Start == 10 && y.End == 19)).Returns(rangeDeclaration);
var whereSection = (RangeDeclaration <MyClass>)ListBuilderExtensions.Section(listBuilderImpl, 10, 19);
Assert.That(whereSection.Start, Is.EqualTo(10));
Assert.That(whereSection.End, Is.EqualTo(19));
}
public static IOperable <T> TheLast <T>(this IListBuilder <T> listBuilder, int amount)
{
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
// TODO: Put these in a specification
Guard.Against(amount < 1, "TheLast amount must be 1 or greater");
Guard.Against(amount > listBuilderImpl.Capacity, "TheLast amount must be less than the size of the list that is being generated");
int start = listBuilderImpl.Capacity - amount;
var declaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(), start, listBuilderImpl.Capacity - 1);
return((IOperable <T>)listBuilderImpl.AddDeclaration(declaration));
}
public void ShouldOnlyAddTheDeclarationIfTheRangeIsValid()
{
IDeclarationQueue <MyClass> declarationQueue = Substitute.For <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 9);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
declarationQueue.GetLastItem().Returns(rangeDeclaration);
listBuilderImpl.Declarations.Returns(declarationQueue);
listBuilderImpl.AddDeclaration(Arg.Any <RangeDeclaration <MyClass> >()).Throws(new BuilderException(""));
Assert.Throws <BuilderException>(
() => ListBuilderExtensions.TheNext(listBuilderImpl, 30)
);
}
public QueryScope(CompilerContext ctx, Scope parent, RangeDeclaration lt, SourceLocation startLocation)
: base(ctx, parent, null, startLocation)
{
Parameters = new ParametersCompiled(
new ImplicitQueryParameter(
lt.VariableName,
this,
lt.Span));
ProcessParameters();
if (parent != null)
{
base.CheckParentConflictName(parent.TopLevel, lt.VariableName, lt.Span);
}
}
public void ShouldBeAbleToUseThePrevious()
{
IDeclarationQueue <MyClass> declarationQueue = Substitute.For <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 10, 19);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
declarationQueue.GetLastItem().Returns(rangeDeclaration);
listBuilderImpl.Declarations.Returns(declarationQueue);
listBuilderImpl.AddDeclaration(Arg.Any <RangeDeclaration <MyClass> >()).Returns((IDeclaration <MyClass>)null);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
var thePreviousDeclaration = (RangeDeclaration <MyClass>)ListBuilderExtensions.ThePrevious(listBuilderImpl, 10);
Assert.That(thePreviousDeclaration.Start, Is.EqualTo(0));
Assert.That(thePreviousDeclaration.End, Is.EqualTo(9));
}
public void TheNextShouldReturnRangeDeclaration()
{
IDeclarationQueue <MyClass> declarationQueue = Substitute.For <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 9);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
declarationQueue.GetLastItem().Returns(rangeDeclaration);
listBuilderImpl.Declarations.Returns(declarationQueue);
listBuilderImpl.AddDeclaration(Arg.Any <RangeDeclaration <MyClass> >()).Returns((IDeclaration <MyClass>)null);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
var andTheNextDeclaration = (RangeDeclaration <MyClass>)ListBuilderExtensions.TheNext(listBuilderImpl, 10);
andTheNextDeclaration.Start.ShouldBe(10);
andTheNextDeclaration.End.ShouldBe(19);
}
public void TheFirstShouldReturnARangeDeclaration()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 0);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(30);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Matches(y => y.Start == 0 && y.End == 9))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var declaration = ListBuilderExtensions.TheFirst(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
}
public void TheFirstShouldReturnARangeDeclaration()
{
var rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 0, 0);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(30);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Matches(y => y.Start == 0 && y.End == 9))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var declaration = ListBuilderExtensions.TheFirst(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
}
public void LastRangeShouldBeTheCapacityMinusTheRangeSizeAndOneLessThanTheCapacity()
{
const int rangeSize = 10;
const int startIndex = listSize - rangeSize; // 20
const int endIndex = listSize - 1; // 29
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 0);
listBuilderImpl.BuilderSettings.Returns(new BuilderSettings());
listBuilderImpl.Capacity.Returns(listSize);
listBuilderImpl.CreateObjectBuilder().Returns((IObjectBuilder <MyClass>)null);
listBuilderImpl.AddDeclaration(Arg.Is <RangeDeclaration <MyClass> >(y => y.Start == startIndex && y.End == endIndex)).Returns(rangeDeclaration);
var declaration = ListBuilderExtensions.TheLast(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
public static IOperable <T> Section <T>(this IListBuilder <T> listBuilder, int start, int end)
{
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
var capacity = listBuilderImpl.Capacity;
// TODO: Put these in a specification
Guard.Against(start < 0, "Section - start must be zero or greater");
Guard.Against(start >= capacity, "Section - start must be less than the capacity");
Guard.Against(end < 1, "Section - end must be greater than one");
Guard.Against(end >= capacity, "Section - end must be less than the capacity");
Guard.Against(start >= end, "Section - end must be greater than start");
var declaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(), start, end);
return((IOperable <T>)listBuilderImpl.AddDeclaration(declaration));
}
public void ShouldBeAbleToUseSection()
{
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 10, 19);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(20);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Matches(y => y.Start == 10 && y.End == 19))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var whereSection = (RangeDeclaration <MyClass>)ListBuilderExtensions.Section(listBuilderImpl, 10, 19);
Assert.That(whereSection.Start, Is.EqualTo(10));
Assert.That(whereSection.End, Is.EqualTo(19));
}
}
public void ShouldOnlyAddTheDeclarationIfTheRangeIsValid()
{
IDeclarationQueue <MyClass> declarationQueue = mocks.StrictMock <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 9);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Is.TypeOf)).Throw(new BuilderException(""));
}
using (mocks.Playback())
{
Assert.Throws <BuilderException>(
() => ListBuilderExtensions.TheNext(listBuilderImpl, 30)
);
}
}
public static IOperable <T> TheRest <T>(this IListBuilder <T> listBuilder)
{
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
var lastDeclaration = listBuilderImpl.Declarations.GetLastItem();
var rangeDeclaration = lastDeclaration as RangeDeclaration <T>;
if (rangeDeclaration == null)
{
throw new BuilderException("Before using TheNext you must have just used a RangeDeclaration - i.e. (TheFirst or Section)");
}
int start = rangeDeclaration.End + 1;
int end = listBuilderImpl.Length - start;
var andTheNextDeclaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(),
start, listBuilderImpl.Length - 1);
listBuilderImpl.AddDeclaration(andTheNextDeclaration);
return(andTheNextDeclaration);
}
public void ShouldBeAbleToUseThePrevious()
{
IDeclarationQueue <MyClass> declarationQueue = mocks.StrictMock <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 10, 19);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Is.TypeOf)).Return(null);
}
using (mocks.Playback())
{
var thePreviousDeclaration = (RangeDeclaration <MyClass>)ListBuilderExtensions.ThePrevious(listBuilderImpl, 10);
Assert.That(thePreviousDeclaration.Start, Is.EqualTo(0));
Assert.That(thePreviousDeclaration.End, Is.EqualTo(9));
}
}
public void LastRangeShouldBeTheCapacityMinusTheRangeSizeAndOneLessThanTheCapacity()
{
const int rangeSize = 10;
const int startIndex = listSize - rangeSize; // 20
const int endIndex = listSize - 1; // 29
var rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 0);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(listSize).Repeat.Times(3);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Matches(y => y.Start == startIndex && y.End == endIndex))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var declaration = ListBuilderExtensions.TheLast(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
}
public static IOperable <T> ThePrevious <T>(this IListBuilder <T> listBuilder, int amount)
{
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
var lastDeclaration = listBuilderImpl.Declarations.GetLastItem();
var rangeDeclaration = lastDeclaration as RangeDeclaration <T>;
if (rangeDeclaration == null)
{
throw new BuilderException("Before using ThePrevious you must have just used a RangeDeclaration - i.e. (TheFirst or Section)");
}
int start = rangeDeclaration.Start - amount;
int end = start + amount - 1;
var andTheNextDeclaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(),
start, end);
listBuilderImpl.AddDeclaration(andTheNextDeclaration);
return(andTheNextDeclaration);
}
public void TheNextShouldReturnRangeDeclaration()
{
IDeclarationQueue <MyClass> declarationQueue = mocks.StrictMock <IDeclarationQueue <MyClass> >();
RangeDeclaration <MyClass> rangeDeclaration = new RangeDeclaration <MyClass>(listBuilderImpl, null, 0, 9);
using (mocks.Record())
{
listBuilderImpl.Stub(x => x.BuilderSettings).Return(new BuilderSettings());
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg <RangeDeclaration <MyClass> > .Is.TypeOf)).Return(null);
}
using (mocks.Playback())
{
listBuilderImpl.Stub(x => x.BuilderSettings).Return(new BuilderSettings());
var andTheNextDeclaration = (RangeDeclaration <MyClass>)ListBuilderExtensions.TheNext(listBuilderImpl, 10);
Assert.That(andTheNextDeclaration.Start, Is.EqualTo(10));
Assert.That(andTheNextDeclaration.End, Is.EqualTo(19));
}
}
public static IOperable <T> TheNext <T>(this IListBuilder <T> listBuilder, int amount)
{
// TODO: Put this in a specification
Guard.Against(amount < 1, "TheNext - amount must be one or greater");
var listBuilderImpl = GetListBuilderImpl <T>(listBuilder);
var lastDeclaration = listBuilderImpl.Declarations.GetLastItem();
var rangeDeclaration = lastDeclaration as RangeDeclaration <T>;
if (rangeDeclaration == null)
{
throw new BuilderException("Before using TheNext you must have just used a RangeDeclaration - i.e. (TheFirst or Section)");
}
int start = rangeDeclaration.End + 1;
int end = start + amount - 1;
var andTheNextDeclaration = new RangeDeclaration <T>(listBuilderImpl, listBuilderImpl.CreateObjectBuilder(),
start, end);
listBuilderImpl.AddDeclaration(andTheNextDeclaration);
return(andTheNextDeclaration);
}
protected static Expression CreateRangeVariableType(
TopLevelScope scope,
ParseContext parseContext,
RangeDeclaration declaration,
Expression initializer)
{
var anonInitializer = new AnonymousObjectInitializer
{
FileName = declaration.FileName,
Span = initializer.Span,
};
anonInitializer.MemberDeclarators.Add(new AnonymousMemberDeclarator(scope.Parameters[0]));
anonInitializer.MemberDeclarators.Add(
new RangeAnonymousMemberDeclarator(
initializer,
declaration));
return(new AnonymousObjectCreationExpression
{
FileName = declaration.FileName,
Span = declaration.Span,
Initializer = anonInitializer
});
}
public void ShouldBeAbleToUseSection()
{
var rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 10, 19);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(20);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Matches(y => y.Start == 10 && y.End == 19))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var whereSection = (RangeDeclaration<MyClass>)ListBuilderExtensions.Section(listBuilderImpl, 10, 19);
Assert.That(whereSection.Start, Is.EqualTo(10));
Assert.That(whereSection.End, Is.EqualTo(19));
}
}
public RangeAnonymousMemberDeclarator(Expression initializer, RangeDeclaration parameter)
: base(initializer, parameter.VariableName, parameter.Span)
{
}
public void ShouldBeAbleToUseThePrevious()
{
IDeclarationQueue<MyClass> declarationQueue = mocks.StrictMock<IDeclarationQueue<MyClass>>();
RangeDeclaration<MyClass> rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 10, 19);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Is.TypeOf)).Return(null);
}
using (mocks.Playback())
{
var thePreviousDeclaration = (RangeDeclaration<MyClass>)ListBuilderExtensions.ThePrevious(listBuilderImpl, 10);
Assert.That(thePreviousDeclaration.Start, Is.EqualTo(0));
Assert.That(thePreviousDeclaration.End, Is.EqualTo(9));
}
}
public void ShouldOnlyAddTheDeclarationIfTheRangeIsValid()
{
IDeclarationQueue<MyClass> declarationQueue = mocks.StrictMock<IDeclarationQueue<MyClass>>();
RangeDeclaration<MyClass> rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 0, 9);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Is.TypeOf)).Throw(new BuilderException(""));
}
using (mocks.Playback())
{
Assert.Throws<BuilderException>(
() => ListBuilderExtensions.TheNext(listBuilderImpl, 30)
);
}
}
public void LastRangeShouldBeTheCapacityMinusTheRangeSizeAndOneLessThanTheCapacity()
{
const int rangeSize = 10;
const int startIndex = listSize - rangeSize; // 20
const int endIndex = listSize - 1; // 29
var rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 0, 0);
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Capacity).Return(listSize).Repeat.Times(3);
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Matches(y => y.Start == startIndex && y.End == endIndex))).Return(rangeDeclaration);
}
using (mocks.Playback())
{
var declaration = ListBuilderExtensions.TheLast(listBuilderImpl, 10);
Assert.That(declaration, Is.SameAs(rangeDeclaration));
}
}
public void TheNextShouldReturnRangeDeclaration()
{
IDeclarationQueue<MyClass> declarationQueue = mocks.StrictMock<IDeclarationQueue<MyClass>>();
RangeDeclaration<MyClass> rangeDeclaration = new RangeDeclaration<MyClass>(listBuilderImpl, null, 0, 9);
using (mocks.Record())
{
listBuilderImpl.Stub(x => x.BuilderSetup).Return(new BuilderSetup());
listBuilderImpl.Expect(x => x.CreateObjectBuilder()).Return(null);
declarationQueue.Expect(x => x.GetLastItem()).Return(rangeDeclaration);
listBuilderImpl.Expect(x => x.Declarations).Return(declarationQueue);
listBuilderImpl.Expect(x => x.AddDeclaration(Arg<RangeDeclaration<MyClass>>.Is.TypeOf)).Return(null);
}
using (mocks.Playback())
{
listBuilderImpl.Stub(x => x.BuilderSetup).Return(new BuilderSetup());
var andTheNextDeclaration = (RangeDeclaration<MyClass>)ListBuilderExtensions.TheNext(listBuilderImpl, 10);
Assert.That(andTheNextDeclaration.Start, Is.EqualTo(10));
Assert.That(andTheNextDeclaration.End, Is.EqualTo(19));
}
}
public SelectManyClause(TopLevelScope scope, RangeDeclaration lt, Expression expr)
: base(scope, expr)
{
RangeVariable = lt;
}
public TransparentParameter(QueryScope scope, ParametersCompiled parent, RangeDeclaration identifier)
: base(ParameterNamePrefix + Counter++, scope, identifier.Span)
{
Parent = parent;
Identifier = identifier.VariableName;
}
public QueryScope(CompilerContext ctx, Scope parent, ParametersCompiled parameters, RangeDeclaration lt, SourceLocation startLocation)
: base(ctx, parent, null, startLocation)
{
Parameters = new ParametersCompiled(
parameters[0],
new ImplicitQueryParameter(
lt.VariableName,
this,
lt.Span));
ProcessParameters();
}
public void AddTransparentParameter(RangeDeclaration name)
{
base.CheckParentConflictName(this, name.VariableName, name.Span);
Parameters = new ParametersCompiled(new TransparentParameter(this, Parameters, name));
}
