public NzbgetClient(IConfigService configService, IHttpProvider httpProvider, IParsingService parsingService, Logger logger)
{
_configService = configService;
_httpProvider = httpProvider;
_parsingService = parsingService;
_logger = logger;
}
protected void Test(string input, string expected, IMessageSink sink = null, IParsingService parser = null)
{
using (ParsingService.PushCurrent(parser ?? LesLanguageService.Value))
using (LNode.PushPrinter(Ecs.EcsNodePrinter.PrintPlainCSharp)) {
var c = new TestCompiler(sink ?? _sink, new UString(input));
c.Run();
Assert.AreEqual(StripExtraWhitespace(expected), StripExtraWhitespace(c.Output.ToString()));
}
}
public TrackedDownloadService(IParsingService parsingService,
ICacheManager cacheManager,
IHistoryService historyService,
Logger logger)
{
_parsingService = parsingService;
_historyService = historyService;
_cache = cacheManager.GetCache<TrackedDownload>(GetType());
_logger = logger;
}
protected virtual MacroProcessor NewLemp(int maxExpand, IParsingService inLang)
{
var lemp = new MacroProcessor(MessageSink.Default, typeof(LeMP.Prelude.BuiltinMacros));
lemp.AddMacros(typeof(LeMP.Prelude.Les.Macros));
lemp.AddMacros(typeof(LeMP.StandardMacros).Assembly);
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP"));
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude"));
if (inLang.FileExtensions.Any(e => e == "les"))
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude.Les"));
lemp.MaxExpansions = maxExpand;
return lemp;
}
public SabnzbdClient(IConfigService configService,
IHttpProvider httpProvider,
ICacheManger cacheManger,
IParsingService parsingService,
Logger logger)
{
_configService = configService;
_httpProvider = httpProvider;
_parsingService = parsingService;
_queueCache = cacheManger.GetCache<IEnumerable<QueueItem>>(GetType(), "queue");
_logger = logger;
}
public ImportDecisionMaker(IEnumerable<IRejectWithReason> specifications,
IParsingService parsingService,
IMediaFileService mediaFileService,
IDiskProvider diskProvider,
Logger logger)
{
_specifications = specifications;
_parsingService = parsingService;
_mediaFileService = mediaFileService;
_diskProvider = diskProvider;
_logger = logger;
}
public CompletedDownloadService(IConfigService configService,
IEventAggregator eventAggregator,
IHistoryService historyService,
IDownloadedEpisodesImportService downloadedEpisodesImportService,
IParsingService parsingService,
Logger logger)
{
_configService = configService;
_eventAggregator = eventAggregator;
_historyService = historyService;
_downloadedEpisodesImportService = downloadedEpisodesImportService;
_parsingService = parsingService;
_logger = logger;
}
public static string QuickRun(IParsingService inputLang, int maxExpand, string input, params Assembly[] macroAssemblies)
{
var c = new LeMP.TestCompiler(MessageSink.Trace, new UString(input));
c.Parallel = false;
c.MaxExpansions = maxExpand;
c.AddMacros(Assembly.GetExecutingAssembly());
c.MacroProcessor.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude"));
c.MacroProcessor.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude.Les"));
c.MacroProcessor.PreOpenedNamespaces.Add(Loyc.LLPG.Macros.MacroNamespace);
foreach (var assembly in macroAssemblies)
c.AddMacros(assembly);
using (ParsingService.PushCurrent(inputLang ?? ParsingService.Current))
using (LNode.PushPrinter(Ecs.EcsNodePrinter.Printer))
c.Run();
return c.Output.ToString();
}
public ImportDecisionMaker(IEnumerable<IImportDecisionEngineSpecification> specifications,
IParsingService parsingService,
IMediaFileService mediaFileService,
IDiskProvider diskProvider,
IVideoFileInfoReader videoFileInfoReader,
IDetectSample detectSample,
Logger logger)
{
_specifications = specifications;
_parsingService = parsingService;
_mediaFileService = mediaFileService;
_diskProvider = diskProvider;
_videoFileInfoReader = videoFileInfoReader;
_detectSample = detectSample;
_logger = logger;
}
public DownloadedEpisodesImportService(IDiskProvider diskProvider,
IDiskScanService diskScanService,
ISeriesService seriesService,
IParsingService parsingService,
IMakeImportDecision importDecisionMaker,
IImportApprovedEpisodes importApprovedEpisodes,
IDetectSample detectSample,
Logger logger)
{
_diskProvider = diskProvider;
_diskScanService = diskScanService;
_seriesService = seriesService;
_parsingService = parsingService;
_importDecisionMaker = importDecisionMaker;
_importApprovedEpisodes = importApprovedEpisodes;
_detectSample = detectSample;
_logger = logger;
}
protected void Test(string input, IParsingService inLang, string expected, IParsingService outLang, int maxExpand = 0xFFFF)
{
var lemp = NewLemp(maxExpand, inLang);
// The current printer affects the assert macro and contract macros
using (LNode.SetPrinter((ILNodePrinter)outLang))
{
var inputCode = new VList<LNode>(inLang.Parse(input, MessageSink.Default));
var results = lemp.ProcessSynchronously(inputCode);
var expectCode = outLang.Parse(expected, MessageSink.Default);
if (!results.SequenceEqual(expectCode))
{ // TEST FAILED, print error
string resultStr = results.Select(n => ((ILNodePrinter)outLang).Print(n)).Join("\n");
Assert.AreEqual(TestCompiler.StripExtraWhitespace(expected),
TestCompiler.StripExtraWhitespace(resultStr));
// In some tests, the text is equal even though the trees are different,
// typically because of differences in #trivia attributes between the two.
Console.WriteLine(); // it's OK, but print a hint that this occurred.
}
}
}
/// <summary>Parses a string by invoking <see cref="IParsingService.Tokenize(ICharSource, string, IMessageSink)"/> using an empty string as the file name.</summary>
public static ILexer <Token> Tokenize(this IParsingService parser, UString input, IMessageSink msgs = null)
{
return(parser.Tokenize(input, "", msgs ?? MessageSink.Default));
}
public TestTorrentRssIndexer(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, ITorrentRssParserFactory torrentRssParserFactory, Logger logger)
: base(httpClient, configService, parsingService, torrentRssParserFactory, logger)
{
}
public PushedCurrent(IParsingService @new)
{
OldValue = Current; Current = @new;
}
public IndexerBase(IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
{
_indexerStatusService = indexerStatusService;
_configService = configService;
_parsingService = parsingService;
_logger = logger;
}
public KickassTorrents(IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, indexerStatusService, configService, parsingService, logger)
{
}
public static IListSource <LNode> ParseFile(this IParsingService parser, string fileName, IMessageSink msgs = null, ParsingMode inputType = null)
{
using (var stream = new FileStream(fileName, FileMode.Open))
return(Parse(parser, stream, fileName, msgs, inputType ?? ParsingMode.File));
}
public PushedCurrent(IParsingService @new) { OldValue = Default; Default = @new; }
public Torznab(ITorznabCapabilitiesProvider torznabCapabilitiesProvider, IHttpClient httpClient, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, configService, parsingService, logger)
{
_torznabCapabilitiesProvider = torznabCapabilitiesProvider;
}
internal Parser(IFileLoader fileLoader, IParsingService parsingService)
{
_fileLoader = fileLoader;
_parsingService = parsingService;
}
public Parser()
{
_fileLoader = new FileLoader();
_parsingService = new ParsingService();
}
/// <summary>Opens the specified file and tokenizes it.</summary>
public static ILexer <Token> TokenizeFile(this IParsingService parser, string fileName, IMessageSink msgs = null)
{
using (var stream = new FileStream(fileName, FileMode.Open))
return(Tokenize(parser, stream, fileName, msgs));
}
/// <summary>Parses a Stream.</summary>
public static ILexer <Token> Tokenize(this IParsingService parser, Stream stream, string fileName, IMessageSink msgs = null)
{
return(parser.Tokenize(new StreamCharSource(stream), fileName, msgs));
}
/// <summary>Parses a Stream.</summary>
public static IListSource <LNode> Parse(this IParsingService parser, Stream stream, string fileName, ParsingMode inputType = null, IMessageSink msgs = null, bool preserveComments = true)
{
return(parser.Parse(new StreamCharSource(stream), fileName, msgs, inputType, preserveComments));
}
public static SavedValue <IParsingService> SetDefault(IParsingService newValue)
{
return(new SavedValue <IParsingService>(_default, newValue));
}
public DownloadDecisionMaker(IEnumerable<IDecisionEngineSpecification> specifications, IParsingService parsingService, Logger logger)
{
_specifications = specifications;
_parsingService = parsingService;
_logger = logger;
}
public TorrentRssIndexer(ITorrentRssParserFactory torrentRssParserFactory, IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, indexerStatusService, configService, parsingService, logger)
{
_torrentRssParserFactory = torrentRssParserFactory;
}
/// <summary>Parses a string and expects exactly one output.</summary>
/// <exception cref="InvalidOperationException">The output list was empty or contained multiple nodes.</exception>
public static LNode ParseSingle(this IParsingService parser, ICharSource text, string fileName, IMessageSink msgs = null, ParsingMode inputType = null, bool preserveComments = true)
{
var e = parser.Parse(text, fileName, msgs, inputType, preserveComments);
return(Single(e));
}
protected DownloadClientBase(IConfigService configService, IDiskProvider diskProvider, IParsingService parsingService, IRemotePathMappingService remotePathMappingService, Logger logger)
{
_configService = configService;
_diskProvider = diskProvider;
_parsingService = parsingService;
_remotePathMappingService = remotePathMappingService;
_logger = logger;
}
/// <summary>Parses a string by invoking <see cref="IParsingService.Parse(ICharSource, string, IMessageSink, ParsingMode, bool)"/> using an empty string as the file name.</summary>
public static IListSource <LNode> Parse(this IParsingService parser, UString input, IMessageSink msgs = null, ParsingMode inputType = null, bool preserveComments = true)
{
return(parser.Parse(input, "", msgs ?? MessageSink.Default, inputType, preserveComments));
}
public NzbgetClient(IConfigService configService, IHttpProvider httpProvider, IParsingService parsingService, Logger logger)
{
_configService = configService;
_httpProvider = httpProvider;
_parsingService = parsingService;
_logger = logger;
}
public StageOneParser(IListSource <Token> tokens, ISourceFile file, IMessageSink messageSink, IParsingService hostLanguage = null)
{
ErrorSink = messageSink;
Reset(tokens, file, hostLanguage);
}
public IndexerBase(IConfigService configService, IParsingService parsingService, Logger logger)
{
_configService = configService;
_parsingService = parsingService;
_logger = logger;
}
/// <summary>Sets the current language service, returning a value suitable
/// for use in a C# using statement, which will restore the old service.</summary>
/// <param name="newValue">new value of Current</param>
/// <example><code>
/// LNode code;
/// using (var old = ParsingService.PushCurrent(LesLanguageService.Value))
/// code = ParsingService.Current.ParseSingle("This is les code;");
/// </code></example>
public static PushedCurrent PushCurrent(IParsingService newValue)
{
return(new PushedCurrent(newValue));
}
public DownloadDecisionMaker(IEnumerable <IDecisionEngineSpecification> specifications, IParsingService parsingService, Logger logger)
{
_specifications = specifications;
_parsingService = parsingService;
_logger = logger;
}
public static string Print(this IParsingService self, LNode node)
{
return(self.Print(node, MessageSink.Current));
}
public AirDCPP(IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, indexerStatusService, configService, parsingService, logger)
{
}
public ParseModule(IParsingService parsingService)
{
_parsingService = parsingService;
GetResourceSingle = Parse;
}
static void ApplyLanguageOption(IMessageSink sink, string option, string value, ref IParsingService lang)
{
if (string.IsNullOrEmpty(value))
sink.Write(Severity.Error, option, "Missing value");
else {
if (!value.StartsWith("."))
value = "." + value;
if ((lang = FileNameToLanguage(value)) == null)
sink.Write(Severity.Error, option, "No language was found for extension «{0}»", value);
}
}
public PushedCurrent(IParsingService @new)
{
OldValue = Default; Default = @new;
}
private void Test(string input, IParsingService inLang, string expected, IParsingService outLang, int maxExpand = 0xFFFF)
{
var lemp = NewLemp(maxExpand);
var inputCode = new RVList<LNode>(inLang.Parse(input, _sink));
var results = lemp.ProcessSynchronously(inputCode);
var expectCode = outLang.Parse(expected, _sink);
if (!results.SequenceEqual(expectCode))
{ // TEST FAILED, print error
string resultStr = results.Select(n => outLang.Print(n, _sink)).Join("\n");
Assert.AreEqual(TestCompiler.StripExtraWhitespace(expected),
TestCompiler.StripExtraWhitespace(resultStr));
}
}
public static string Print(this IParsingService service, IEnumerable <LNode> nodes, IMessageSink msgs = null, object mode = null, string indentString = "\t", string lineSeparator = "\n")
{
return(PrintMultiple(service.Printer, nodes, msgs, mode, indentString, lineSeparator));
}
/// <summary>Unregisters a language service.</summary>
/// <param name="service">Service to unregister</param>
/// <param name="fileExtensions">File extensions affected (null to use the service's own list)</param>
/// <returns>The number of file extensions unregistered, or 0 if none.</returns>
/// <remarks>The service for a file extension is not removed unless the given service reference is equal to the registered service.</remarks>
public static int Unregister(IParsingService service, IEnumerable<string> fileExtensions = null)
{
CheckParam.IsNotNull("service", service);
fileExtensions = fileExtensions ?? service.FileExtensions;
int oldCount = _registeredLanguages.Count;
foreach (var fileExt in fileExtensions)
if (_registeredLanguages.TryGetValue(fileExt, null) == service)
_registeredLanguages = _registeredLanguages.Without(fileExt);
return oldCount - _registeredLanguages.Count;
}
public static SavedValue<IParsingService> SetDefault(IParsingService newValue)
{
return new SavedValue<IParsingService>(_default, newValue);
}
public PushedCurrent(IParsingService @new) { OldValue = Current; Current = @new; }
public DownloadDecisionMaker(IEnumerable<IRejectWithReason> specifications, IParsingService parsingService, Logger logger)
{
_specifications = specifications;
_parsingService = parsingService;
_logger = logger;
}
/// <summary>Parses a string and expects exactly one output.</summary>
/// <exception cref="InvalidOperationException">The output list was empty or contained multiple nodes.</exception>
public static LNode ParseSingle(this IParsingService parser, UString expr, IMessageSink msgs = null, ParsingMode inputType = null, bool preserveComments = true)
{
var e = parser.Parse(expr, msgs, inputType, preserveComments);
return(Single(e));
}
public TestIndexer(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, configService, parsingService, logger)
{
}
public InputOutput(ICharSource text, string fileName, IParsingService input = null, LNodePrinter outPrinter = null, string outFileName = null)
{
Text = text; FileName = fileName ?? ""; InputLang = input; OutPrinter = outPrinter; OutFileName = outFileName;
}
/// <summary>Registers a parsing service.</summary>
/// <param name="service">Service to register.</param>
/// <param name="fileExtensions">File extensions affected (null to use the service's own list)</param>
/// <returns>The number of new file extensions registered, or 0 if none.</returns>
/// <remarks>This method does not replace existing registrations.</remarks>
public static int Register(IParsingService service, IEnumerable<string> fileExtensions = null)
{
CheckParam.IsNotNull("service", service);
fileExtensions = fileExtensions ?? service.FileExtensions;
int oldCount = _registeredLanguages.Count;
foreach (var fileExt_ in service.FileExtensions) {
var fileExt = fileExt_; // make writable
if (fileExt.StartsWith("."))
fileExt = fileExt.Substring(1);
_registeredLanguages = _registeredLanguages.With(fileExt, service, false);
}
return _registeredLanguages.Count - oldCount;
}
public static IEnumerable<LNode> ParseNodes(string Text, string Identifier, IParsingService Service, MacroProcessor Processor, IMessageSink Sink)
{
var lexer = Service.Tokenize(new UString(Text), Identifier, Sink);
var nodes = Service.Parse(lexer, Sink);
return Processor.ProcessSynchronously(new VList<LNode>(nodes));
}
/// <summary>Sets the current language service, returning a value suitable
/// for use in a C# using statement, which will restore the old service.</summary>
/// <param name="newValue">new value of Current</param>
/// <example><code>
/// LNode code;
/// using (var old = ParsingService.PushCurrent(LesLanguageService.Value))
/// code = ParsingService.Current.ParseSingle("This `is` LES_code;");
/// </code></example>
public static PushedCurrent PushCurrent(IParsingService newValue) { return new PushedCurrent(newValue); }
public HttpIndexerBase(IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(indexerStatusService, configService, parsingService, logger)
{
_httpClient = httpClient;
}
public Wombles(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, configService, parsingService, logger)
{
}
public static LNode ParseSingle(this IParsingService parser, UString expr, IMessageSink msgs = null, ParsingMode inputType = null)
{
var e = parser.Parse(expr, msgs, inputType);
return(Single(e));
}
public Torznab(INewznabCapabilitiesProvider capabilitiesProvider, IHttpClient httpClient, IIndexerStatusService indexerStatusService, IConfigService configService, IParsingService parsingService, Logger logger)
: base(httpClient, indexerStatusService, configService, parsingService, logger)
{
_capabilitiesProvider = capabilitiesProvider;
}
private static IParsingService GetParsingService(ICompilerOptions Options, string Key, IParsingService Default)
{
switch (Options.GetOption<string>(Key, "").ToLower())
{
case "les":
return LesLanguageService.Value;
case "ecs":
return EcsLanguageService.Value;
case "cs":
return EcsLanguageService.WithPlainCSharpPrinter;
default:
return Default;
}
}
