This is a public, read-only report. Striff reads this repository's docs, turns each sentence that makes a claim about the code into a rule, and checks the rule against the code on the default branch. How this works
Each sentence below has a stale name: a type the default branch doesn't declare, or declares somewhere else. Edit the doc so it matches the code, or bring the type back.
GoneCurrentDateSkill
For time-related filters, first check the current date using CurrentDateSkill.
The repository once had Extensions/Signum.Agent/Skills/CurrentDateSkill.cs. It doesn't now. Closest name there: CurrentDateInfo.
Values in a comparison are parsed using FilterValueConverter.TryParse, this means:
FilterValueConverter has TryParse
Holds
ThreadVariables are created using the ThreadVariable<T> static method.
Statics has a ThreadVariable method
Holds
CleanThreadContextAndAssert method asserts that all the thread variables have been cleaned, cleaning them and throwing and exception if not.
Statics has a CleanThreadContextAndAssert method
Holds
SessionVariable<T> can be set and get by accessing his Value property with no special ceremony (as opposed to ThreadVariable<T>, that are meant to be used in using statements).
SessionVariable has Value
Holds
Session variables also contain an optional ValueFactory property that will be called the first time the value is accessed to generate the initial value.
SessionVariable has ValueFactory
Holds
The actual meaning of 'session' depends on the object stored in SessionFactory static property, that has to be set just once at the very beginning of the application.
Statics has SessionFactory
Holds
ScopedSessionFactory: This session factory wraps any other session giving the user the ability to override the session in a block of code using ScopeSessionFactory.OverrideSession.
ScopeSessionFactory has OverrideSession
Holds
There are several types of QueryToken, such as ColumnToken, EntityPropertyToken, CountToken, and AggregateToken, all with a Parent property forming a chain.
4 rules from this sentence
ColumnToken has Parent
Holds
EntityPropertyToken has Parent
Holds
CountToken has Parent
Holds
AggregateToken has Parent
Holds
Accessible in-memory using MList<T>.RowIdValue.OldIndex (old) and just IndexOf (live).
MList has IndexOf
Holds
In the last select, you can force a sub-expression to be evaluated in SQL using InSql extension method, defined in LinqHints.
LinqHints has an InSql method
Holds
SchemaBuilder is the class that takes your entities as an input and generates a Schema as an output.
SchemaBuilder depends on Schema
Holds
public class ObjectName : IEquatable<ObjectName> { public string Name { get; } public SchemaName Schema { get; } //Mandatory, default dbo
3 rules from this sentence
ObjectName depends on SchemaName
Holds
ObjectName has Name
Holds
ObjectName has Schema
Holds
public class SchemaName : IEquatable<SchemaName> { public string Name { get; } public DatabaseName Database { get; } //Optional
3 rules from this sentence
SchemaName depends on DatabaseName
Holds
SchemaName has Name
Holds
SchemaName has Database
Holds
public class DatabaseName : IEquatable<DatabaseName> { public string Name { get; } public ServerName Server { get; } //Optional
3 rules from this sentence
DatabaseName depends on ServerName
Holds
DatabaseName has Name
Holds
DatabaseName has Server
Holds
public class ServerName : IEquatable<ServerName> { public string Name { get; } public ServerName(string name) ; }
ServerName has Name
Holds
Even MList<T> and Lite<T> inherit from this Modifiable.
MList extends Modifiable
Holds
Basically Modifiable contains the property Modified of type ModifiedState.
Modifiable has Modified
Holds
Modifiable defines the PreSaving and PostRetriving virtual methods, that will be called just before saving an object and just after retrieving it.
Modifiable has a PreSaving method
Holds
Additionally, Entity also contains optional concurrency support using Ticks field that stores the current version of the entity.
Entity has a Ticks field
Holds
By using an interface inheriting from IEntity, instead of a class inheriting from Entity, implementers are free to inherit from the class they want.