public RulesetValidator(IValidationRuleset ruleset, string text) :
this(ruleset)
{
iCalendarText = text;
try
{
iCalendarSerializer serializer = new iCalendarSerializer();
// Turn off speed optimization so line/col from
// antlr are accurate.
serializer.OptimizeForSpeed = false;
iCalendar = serializer.Deserialize(new StringReader(text), typeof(iCalendar)) as iCalendar;
}
catch (antlr.RecognitionException ex)
{
_RecognitionError = new ValidationErrorWithLookup(
"calendarParseError",
ValidationErrorType.Error,
true,
ex.line,
ex.column);
}
}
public RulesetValidator(IValidationRuleset ruleset, string text) :
this(ruleset)
{
iCalendarText = text;
try
{
iCalendarSerializer serializer = new iCalendarSerializer();
// Turn off speed optimization so line/col from
// antlr are accurate.
serializer.OptimizeForSpeed = false;
iCalendar = serializer.Deserialize(new StringReader(text), typeof(iCalendar)) as iCalendar;
}
catch (antlr.RecognitionException ex)
{
_RecognitionError = new ValidationErrorWithLookup(
"calendarParseError",
ValidationErrorType.Error,
true,
ex.line,
ex.column);
}
}
public TextValidationSerializer(
IValidationRuleset ruleset,
IValidationResult[] validationResults) :
this()
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
public TextValidationSerializer(
IValidationRuleset ruleset,
IValidationResult[] validationResults) :
this()
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
public RulesetValidator(IResourceManager mgr, ILogger logger, IValidationRuleset ruleset, string text, bool verifyValidatorsExist)
: this(mgr, logger, ruleset)
{
iCalendarText = text;
if (verifyValidatorsExist)
VerifyValidatorsExist();
}
public TextValidationSerializer(
IValidationRuleset ruleset,
ITestResult[] testResults) :
this()
{
Ruleset = ruleset;
TestResults = testResults;
}
public TextValidationSerializer(
IValidationRuleset ruleset,
ITestResult[] testResults) :
this()
{
Ruleset = ruleset;
TestResults = testResults;
}
public TextValidationSerializer(
IResourceManager mgr,
IValidationRuleset ruleset,
IValidationResultCollection validationResults)
: this(mgr)
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
public TextValidationSerializer(
IResourceManager mgr,
IValidationRuleset ruleset,
ITestResult[] testResults)
: this(mgr)
{
Ruleset = ruleset;
TestResults = testResults;
}
public XmlValidationSerializer(
IXmlDocumentProvider docProvider,
IValidationRuleset ruleset,
IValidationResult[] validationResults) :
this(docProvider)
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
public XmlValidationSerializer(
IXmlDocumentProvider docProvider,
IValidationRuleset ruleset,
IValidationResult[] validationResults) :
this(docProvider)
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
public XmlValidationSerializer(
IResourceManager mgr,
IXmlDocumentProvider docProvider,
IValidationRuleset ruleset,
ITestResult[] testResults)
: this(mgr, docProvider)
{
Ruleset = ruleset;
TestResults = testResults;
}
public XmlValidationSerializer(
IResourceManager mgr,
IXmlDocumentProvider docProvider,
IValidationRuleset ruleset,
IValidationResultCollection validationResults)
: this(mgr, docProvider)
{
Ruleset = ruleset;
ValidationResults = validationResults;
}
static void Main(string[] args)
{
try
{
_Arguments = new CommandLineArgumentList(args, StringComparison.CurrentCultureIgnoreCase);
IXmlDocumentProvider docProvider = null;
// Initialize our xml document provider
if (File.Exists("icalvalidSchema.zip"))
{
docProvider = new XmlDocumentZipExtractor("icalvalidSchema.zip");
}
else if (Directory.Exists("icalvalidSchema"))
{
docProvider = new LocalXmlDocumentProvider("icalvalidSchema");
}
else
{
throw new Exception("A valid schema directory or zip file could not be located!");
}
// Setup the language to use for validation/tests
SetupLanguage(docProvider);
IValidationRuleset selectedRuleset = LoadRuleset(docProvider);
if (_Arguments.Contains(_SchemaValidationArgument))
{
SchemaTest(docProvider);
LanguageKeyValidation(docProvider);
}
else
{
// Determine whether we are performing a self test, or
// validating an iCalendar file...
if (_Arguments.Contains(_TestArgument))
{
SelfTest(docProvider, selectedRuleset);
}
else
{
ValidateFile(docProvider, selectedRuleset);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void SelfTest(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
if (serializer != null)
{
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
RulesetValidator validator = new RulesetValidator(selectedRuleset);
Console.Write(string.Format(
ResourceManager.GetString("performingSelfTest"),
ResourceManager.GetString(selectedRuleset.NameString))
);
serializer.TestResults = validator.Test();
Console.WriteLine(ResourceManager.GetString("done"));
}
try
{
serializer.Serialize(stream, encoding);
}
finally
{
stream.Close();
}
}
}
static IValidationRuleset LoadRuleset(IXmlDocumentProvider docProvider)
{
// Load some rulesets
XmlValidationRulesetLoader loader = new XmlValidationRulesetLoader(docProvider);
List <IValidationRuleset> rulesets = new List <IValidationRuleset>(loader.Load());
// Determine a validation ruleset to use
string validatorName = "Strict_2_0";
if (_Arguments.Contains(_ValidatorArgument))
{
validatorName = _Arguments[_ValidatorArgument].Value;
}
// Select the ruleset
IValidationRuleset selectedRuleset = rulesets.Find(
delegate(IValidationRuleset rs)
{
return(string.Equals(rs.Name, validatorName, StringComparison.CurrentCultureIgnoreCase));
}
);
return(selectedRuleset);
}
public RulesetValidator(IResourceManager mgr, IValidationRuleset ruleset, string text)
: this(mgr, new NullLogger(), ruleset, text, false)
{
}
static void ValidateFile(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
bool needsMoreArguments = false;
if (serializer != null)
{
string iCalText = null;
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
if (_Arguments.Contains(_FileArgument))
{
// Load the calendar from a local file
Console.Write(ResourceManager.GetString("loadingCalendar"));
FileStream fs = new FileStream(_Arguments[_FileArgument].Value, FileMode.Open, FileAccess.Read);
if (fs != null)
{
StreamReader sr = new StreamReader(fs);
iCalText = sr.ReadToEnd();
sr.Close();
}
Console.WriteLine(ResourceManager.GetString("Done"));
}
else if (_Arguments.Contains(_UriArgument))
{
// Load the calendar from a Uri
Console.Write(ResourceManager.GetString("loadingCalendar"));
Uri uri = new Uri(_Arguments[_UriArgument].Value);
string
username = null,
password = null;
if (_Arguments.Contains(_UsernameArgument))
{
username = _Arguments[_UsernameArgument].Value;
if (_Arguments.Contains(_PasswordArgument))
{
password = _Arguments[_PasswordArgument].Value;
}
}
WebClient client = new WebClient();
if (username != null && password != null)
{
client.Credentials = new System.Net.NetworkCredential(username, password);
}
iCalText = client.DownloadString(uri);
Console.WriteLine(ResourceManager.GetString("Done"));
}
else
{
needsMoreArguments = true;
}
if (needsMoreArguments)
{
WriteDescription();
}
else
{
if (iCalText == null)
{
throw new Exception(ResourceManager.GetString("calendarNotFound"));
}
else
{
RulesetValidator rulesetValidator = new RulesetValidator(selectedRuleset, iCalText);
if (rulesetValidator != null)
{
Console.Write(string.Format(
ResourceManager.GetString("validatingCalendar"),
ResourceManager.GetString(selectedRuleset.NameString)
));
serializer.ValidationResults = rulesetValidator.Validate();
Console.WriteLine(ResourceManager.GetString("done"));
}
}
}
}
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
try
{
serializer.Serialize(stream, encoding);
}
finally
{
stream.Close();
}
}
}
public RulesetValidator(IResourceManager mgr, ILogger logger, IValidationRuleset ruleset, string text)
: this(mgr, logger, ruleset, text, false)
{
}
public RulesetValidator(IValidationRuleset ruleset)
{
_Ruleset = ruleset;
}
protected byte[] Setup()
{
byte[] bytes = new byte[0];
Debug = new Debug();
Debug.Initialize();
ISerializationSettings settings = SerializationContext.Default.GetService<ISerializationSettings>();
settings.ParsingMode = ParsingModeType.Loose;
settings.EnsureAccurateLineNumbers = true;
settings.StoreExtraSerializationData = true;
DocumentProvider = new DirectoryXmlDocumentProvider(Path.Combine(Request.PhysicalApplicationPath, "icalvalidSchema"));
SelectedRuleset = null;
try
{
ResourceManager = new ResourceManager();
// Setup the language to use for validation/tests
SetupLanguage();
SelectedRuleset = LoadRuleset();
}
catch (ValidationRuleLoadException e)
{
Utils.StoreExceptionBlob("Setup: " + e.Message + e.StackTrace);
bytes = Response.Output.Encoding.GetBytes(e.Message);
}
return bytes;
}
static void ValidateFile(string filename, IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
bool needsMoreArguments = false;
if (serializer != null)
{
string iCalText = null;
long byteCount = 0;
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
// Load the calendar from a local file
Console.Write(ResourceManager.GetString("loadingCalendar"));
FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read);
if (fs != null)
{
// Get the calendar path so it can be reported later
_CalendarPath = Path.GetFullPath(filename);
StreamReader sr = new StreamReader(fs);
byteCount = fs.Length;
iCalText = sr.ReadToEnd();
sr.Close();
}
Console.WriteLine(ResourceManager.GetString("Done"));
if (iCalText == null)
{
throw new Exception(ResourceManager.GetString("calendarNotFound"));
}
else
{
RulesetValidator rulesetValidator = new RulesetValidator(ResourceManager, selectedRuleset, iCalText);
if (rulesetValidator != null)
{
Console.Write(string.Format(
ResourceManager.GetString("validatingCalendar"),
ResourceManager.GetString(selectedRuleset.NameString)
));
serializer.ValidationResults = rulesetValidator.Validate();
// Set the original text for the validation
serializer.ValidationResults.CalendarPath = _CalendarPath;
serializer.ValidationResults.CalendarText = iCalText;
serializer.ValidationResults.ByteCount = byteCount;
Console.WriteLine(ResourceManager.GetString("done"));
}
}
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
try
{
serializer.Serialize(stream, encoding, permalink: "");
}
finally
{
stream.Close();
}
}
}
}
public RulesetValidator(IValidationRuleset ruleset)
{
_Ruleset = ruleset;
}
static void ValidateFile(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
bool needsMoreArguments = false;
if (serializer != null)
{
string iCalText = null;
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
if (_Arguments.Contains(_FileArgument))
{
// Load the calendar from a local file
Console.Write(ResourceManager.GetString("loadingCalendar"));
FileStream fs = new FileStream(_Arguments[_FileArgument].Value, FileMode.Open, FileAccess.Read);
if (fs != null)
{
StreamReader sr = new StreamReader(fs);
iCalText = sr.ReadToEnd();
sr.Close();
}
Console.WriteLine(ResourceManager.GetString("Done"));
}
else if (_Arguments.Contains(_UriArgument))
{
// Load the calendar from a Uri
Console.Write(ResourceManager.GetString("loadingCalendar"));
Uri uri = new Uri(_Arguments[_UriArgument].Value);
string
username = null,
password = null;
if (_Arguments.Contains(_UsernameArgument))
{
username = _Arguments[_UsernameArgument].Value;
if (_Arguments.Contains(_PasswordArgument))
password = _Arguments[_PasswordArgument].Value;
}
WebClient client = new WebClient();
if (username != null && password != null)
client.Credentials = new System.Net.NetworkCredential(username, password);
iCalText = client.DownloadString(uri);
Console.WriteLine(ResourceManager.GetString("Done"));
}
else
{
needsMoreArguments = true;
}
if (needsMoreArguments)
{
WriteDescription();
}
else
{
if (iCalText == null)
{
throw new Exception(ResourceManager.GetString("calendarNotFound"));
}
else
{
RulesetValidator rulesetValidator = new RulesetValidator(selectedRuleset, iCalText);
if (rulesetValidator != null)
{
Console.Write(string.Format(
ResourceManager.GetString("validatingCalendar"),
ResourceManager.GetString(selectedRuleset.NameString)
));
serializer.ValidationResults = rulesetValidator.Validate();
Console.WriteLine(ResourceManager.GetString("done"));
}
}
}
}
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
try
{
serializer.Serialize(stream, encoding);
}
finally
{
stream.Close();
}
}
}
static void SelfTest(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
if (serializer != null)
{
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
RulesetValidator validator = new RulesetValidator(selectedRuleset);
Console.Write(string.Format(
ResourceManager.GetString("performingSelfTest"),
ResourceManager.GetString(selectedRuleset.NameString))
);
serializer.TestResults = validator.Test();
Console.WriteLine(ResourceManager.GetString("done"));
}
try
{
serializer.Serialize(stream, encoding);
}
finally
{
stream.Close();
}
}
}
static void ValidateFile(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
bool needsMoreArguments = false;
if (serializer != null)
{
string iCalText = null;
long byteCount = 0;
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
if (_Arguments.Contains(_FileArgument))
{
// Load the calendar from a local file
Console.Write(ResourceManager.GetString("loadingCalendar"));
FileStream fs = new FileStream(_Arguments[_FileArgument].Value, FileMode.Open, FileAccess.Read);
if (fs != null)
{
// Get the calendar path so it can be reported later
_CalendarPath = Path.GetFullPath(_Arguments[_FileArgument].Value);
StreamReader sr = new StreamReader(fs);
byteCount = fs.Length;
iCalText = sr.ReadToEnd();
sr.Close();
}
Console.WriteLine(ResourceManager.GetString("Done"));
}
else if (_Arguments.Contains(_UriArgument))
{
// Load the calendar from a Uri
Console.Write(ResourceManager.GetString("loadingCalendar"));
Uri uri = new Uri(_Arguments[_UriArgument].Value);
string
username = null,
password = null;
// Determine if credentials were included in the Uri
// NOTE: this is not recommended practice for numerous
// security reasons.
if (!string.IsNullOrEmpty(uri.UserInfo))
{
// Extract the embedded credentials from the Uri
string[] parts = uri.UserInfo.Split(':');
if (parts.Length == 2)
{
username = parts[0];
password = parts[1];
}
}
if (_Arguments.Contains(_UsernameArgument))
{
username = _Arguments[_UsernameArgument].Value;
if (_Arguments.Contains(_PasswordArgument))
password = _Arguments[_PasswordArgument].Value;
}
WebClient client = new WebClient();
if (username != null && password != null)
client.Credentials = new System.Net.NetworkCredential(username, password);
// Get the calendar path so it can be reported later
_CalendarPath = uri.OriginalString;
iCalText = client.DownloadString(uri);
byteCount = client.Encoding.GetByteCount(iCalText);
Console.WriteLine(ResourceManager.GetString("Done"));
}
else
{
needsMoreArguments = true;
}
if (needsMoreArguments)
{
WriteDescription();
}
else
{
if (iCalText == null)
{
throw new Exception(ResourceManager.GetString("calendarNotFound"));
}
else
{
RulesetValidator rulesetValidator = new RulesetValidator(ResourceManager, selectedRuleset, iCalText);
if (rulesetValidator != null)
{
Console.Write(string.Format(
ResourceManager.GetString("validatingCalendar"),
ResourceManager.GetString(selectedRuleset.NameString)
));
serializer.ValidationResults = rulesetValidator.Validate();
// Set the original text for the validation
serializer.ValidationResults.CalendarPath = _CalendarPath;
serializer.ValidationResults.CalendarText = iCalText;
serializer.ValidationResults.ByteCount = byteCount;
Console.WriteLine(ResourceManager.GetString("done"));
}
}
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
try
{
serializer.Serialize(stream, encoding, permalink: "");
}
finally
{
stream.Close();
}
// Open the output file, if requested
OpenOutputFile(serializer);
}
}
}
}
public RulesetValidator(IResourceManager mgr, IValidationRuleset ruleset, string text, bool verifyValidatorsExist)
: this(mgr, new NullLogger(), ruleset, text, verifyValidatorsExist)
{
}
static void SelfTest(IXmlDocumentProvider docProvider, IValidationRuleset selectedRuleset)
{
IValidationSerializer serializer = GetSerializer(docProvider);
if (serializer != null)
{
Stream stream;
Encoding encoding;
SetupStream(serializer, out stream, out encoding);
if (selectedRuleset != null)
{
serializer.Ruleset = selectedRuleset;
Console.WriteLine(string.Format(
ResourceManager.GetString("performingSelfTest"),
ResourceManager.GetString(selectedRuleset.NameString))
);
RulesetValidator validator = new RulesetValidator(ResourceManager, selectedRuleset);
validator.TestProgress +=
delegate(object sender, TestProgressEventArgs e)
{
Console.CursorLeft = 0;
Console.Write(
string.Format(
ResourceManager.GetString("testProgress"),
e.Passed + e.Failed + e.NotRun,
e.TotalTests
)
);
};
serializer.TestResults = validator.Test();
}
try
{
serializer.Serialize(stream, encoding, permalink:"");
}
finally
{
stream.Close();
}
// Open the output file, if requested
OpenOutputFile(serializer);
}
}
public RulesetValidator(IResourceManager mgr, ILogger logger, IValidationRuleset ruleset)
: base(mgr, logger)
{
_Ruleset = ruleset;
}
