예제 #1
0
        ProgramNode ParseModule(ModulePath?path, SourceText source, SyntaxContext context)
        {
            var msg = path != null ? $" with path '{path}'" : string.Empty;

            if (!_loading.Add(source.FullPath))
            {
                throw new ModuleLoadException($"Module{msg} could not be loaded due to circular 'use' declarations.");
            }

            try
            {
                if (context.Parses.ContainsKey(source.FullPath))
                {
                    throw new ModuleLoadException($"Module{msg} was already loaded previously.");
                }

                var lex   = LanguageLexer.Lex(source);
                var parse = LanguageParser.Parse(lex, SyntaxMode.Normal);

                context.AddParse(source.FullPath, parse);

                foreach (var diag in lex.Diagnostics)
                {
                    context.AddDiagnostic(diag);
                }

                foreach (var diag in parse.Diagnostics)
                {
                    context.AddDiagnostic(diag);
                }

                var analysis = LanguageAnalyzer.Analyze(parse, this, context);

                foreach (var diag in analysis.Diagnostics)
                {
                    context.AddDiagnostic(diag);
                }

                return(analysis.IsSuccess ? (ProgramNode)parse.Tree : throw new ModuleLoadException(
                           $"Module{msg} failed to load due to syntax and/or semantic errors."));
            }
            finally
            {
                _ = _loading.Remove(source.FullPath);
            }
        }
예제 #2
0
        /// <summary>
        /// This is the main entry point for your service replica.
        /// This method executes when this replica of your service becomes primary and has write status.
        /// </summary>
        /// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service replica.</param>
        protected override async Task RunAsync(CancellationToken cancellationToken)
        {
            IReliableDictionary <string, string> myDictionary = await StateManager.GetOrAddAsync <IReliableDictionary <string, string> >("offsetDictionary");

            var            eventHubClient = EventHubClient.CreateFromConnectionString(Config.EhConnectionString, Config.EhCommentPath);
            EventHubClient publishClient  = EventHubClient.CreateFromConnectionString(Config.EhConnectionString, Config.EhAnalyticPath);

            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();

                using (ITransaction tx = StateManager.CreateTransaction())
                {
                    StateHandler stateHandler = new StateHandler(tx, StateManager);

                    EventReader reader = new EventReader(eventHubClient, stateHandler);

                    IEnumerable <AnalysedRedditComment> comments = await reader.GetComments();

                    IEnumerable <IReadOnlyDictionary <string, AnalysedRedditComment> > batches = BatchComments(comments, BatchSize);

                    foreach (IReadOnlyDictionary <string, AnalysedRedditComment> batch in batches)
                    {
                        LanguageAnalyzer  languageAnalyzer  = new LanguageAnalyzer();
                        SentimentAnalyzer sentimentAnalyzer = new SentimentAnalyzer();
                        KeyPhraseAnalyzer keyPhraseAnalyzer = new KeyPhraseAnalyzer();

                        await languageAnalyzer.DoAnalysis(batch); // do language analysis first

                        await sentimentAnalyzer.DoAnalysis(batch);

                        await keyPhraseAnalyzer.DoAnalysis(batch);

                        ProcessMessages(batch.Values, publishClient);
                    }

                    // If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
                    // discarded, and nothing is saved to the secondary replicas.
                    await tx.CommitAsync();
                }

                await Task.Delay(TimeSpan.FromSeconds(PullDelay), cancellationToken);
            }
            // ReSharper disable once FunctionNeverReturns
        }
예제 #3
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            JObject o      = JObject.Load(reader);
            var     result = existingValue as Dictionary <string, AnalyzerBase> ?? new Dictionary <string, AnalyzerBase>();

            foreach (var childProperty in o.Children <JProperty>())
            {
                var propertyName = childProperty.Name;
                var typeProperty = ((JObject)childProperty.Value).Property("type");
                typeProperty.Remove();

                var      typePropertyValue = typeProperty.Value.ToString();
                Language language;
                if (Enum.TryParse(typePropertyValue, true, out language))
                {
                    typePropertyValue = "Language";
                }

                var          itemType = Type.GetType("Nest." + typePropertyValue + "Analyzer", false, true);
                AnalyzerBase item;
                if (itemType == typeof(LanguageAnalyzer))
                {
                    item = new LanguageAnalyzer(language);
                    serializer.Populate(childProperty.Value.CreateReader(), item);
                }
                else if (itemType != null)
                {
                    item = serializer.Deserialize(childProperty.Value.CreateReader(), itemType) as AnalyzerBase;
                }
                else
                {
                    continue;
                }

                result[propertyName] = item;
            }
            return(result);
        }
예제 #4
0
        public async Task <IActionResult> AddPublicaton(NewPostRequest request)
        {
            var user = _userManager.GetBySecretKey(request.Key);

            if (user == null)
            {
                return(StatusCode((int)HttpStatusCode.Forbidden));
            }

            var extractor        = new X.Web.MetaExtractor.Extractor();
            var languageAnalyzer = new LanguageAnalyzer(Settings.Current.CognitiveServicesTextAnalyticsKey);

            try
            {
                var metadata = await extractor.Extract(new Uri(request.Link));

                var languageCode = languageAnalyzer.GetTextLanguage(metadata.Description);
                var languageId   = _localizationManager.GetLanguageId(languageCode) ?? Language.EnglishId;

                var publication = new DAL.Publication
                {
                    Title       = metadata.Title,
                    Description = metadata.Description,
                    Link        = metadata.Url,
                    Image       = metadata.Image.FirstOrDefault(),
                    Type        = metadata.Type,
                    DateTime    = DateTime.Now,
                    UserId      = user.Id,
                    CategoryId  = request.CategoryId,
                    Comment     = request.Comment,
                    LanguageId  = languageId
                };

                if (EmbededPlayer.GetPlayerSoure(request.Link) != null)
                {
                    var player = new EmbededPlayer(request.Link);
                    publication.EmbededPlayerCode = player.Render();
                }

                publication = await _publicationManager.Save(publication);

                if (publication != null)
                {
                    var model = new PublicationViewModel(publication, Settings.Current.WebSiteUrl);

                    //If we can embed main content into site page, so we can share this page.
                    var url = string.IsNullOrEmpty(model.EmbededPlayerCode) ? model.Link : model.ShareUrl;

                    await _crossPostManager.Send(request.CategoryId, request.Comment, url);

                    return(Created(new Uri(model.ShareUrl), model));
                }
                else
                {
                    throw new Exception("Can't save publication to databse");
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
 protected override void BuildLanguageAnalyzer(LanguageAnalyzer languageAnalyzer)
 {
     languageAnalyzer.StopWords = _stopwords;
 }
 protected virtual void BuildLanguageAnalyzer(LanguageAnalyzer languageAnalyzer)
 {
 }
 private void BuildLanguageAnalyzerCore(LanguageAnalyzer languageAnalyzer)
 {
     BuildLanguageAnalyzer(languageAnalyzer);
 }
 protected sealed override IEnumerable<KeyValuePair<string, AnalyzerBase>> Build()
 {
     var languageAnalyzer = new LanguageAnalyzer(Language);
     BuildLanguageAnalyzerCore(languageAnalyzer);
     yield return new KeyValuePair<string, AnalyzerBase>(Name, languageAnalyzer);
 }
 private void BuildLanguageAnalyzerCore(LanguageAnalyzer languageAnalyzer)
 {
     BuildLanguageAnalyzer(languageAnalyzer);
 }
 protected virtual void BuildLanguageAnalyzer(LanguageAnalyzer languageAnalyzer)
 {
 }
 protected override sealed IEnumerable<KeyValuePair<string, AnalyzerBase>> Build()
 {
     var languageAnalyzer = new LanguageAnalyzer(Language);
     BuildLanguageAnalyzerCore(languageAnalyzer);
     yield return new KeyValuePair<string, AnalyzerBase>(Name, languageAnalyzer);
 }
 protected override void BuildLanguageAnalyzer(LanguageAnalyzer languageAnalyzer)
 {
     languageAnalyzer.StopWords = _stopwords;
 }
예제 #13
0
        int Run(Options options)
        {
            ReadLine.AutoCompletionHandler = null;

            var loader = new StandardModuleLoader(ModuleLoaderMode.Interactive);
            var i      = 0;

            while (true)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write($"flare({i})> ");
                Console.ResetColor();

                var text      = new StringBuilder();
                var quit      = false;
                var continued = false;

                while (true)
                {
                    var input = ReadLine.Read();

                    if (input != string.Empty)
                    {
                        ReadLine.AddHistory(input);
                    }

                    var broken = false;

                    if (input == "'repl:quit")
                    {
                        quit = true;
                        break;
                    }
                    if (continued && input == "'repl:break")
                    {
                        broken = true;
                    }
                    else
                    {
                        _ = text.AppendLine(input);
                    }

                    var lex = LanguageLexer.Lex(StringSourceText.From("<repl>", text.ToString()));

                    foreach (var diag in lex.Diagnostics)
                    {
                        LogDiagnostic(diag);
                    }

                    if (!lex.IsSuccess)
                    {
                        break;
                    }

                    var parse = LanguageParser.Parse(lex, SyntaxMode.Interactive);

                    if (!broken && IsIncomplete(parse))
                    {
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.Write($".....({i})> ");
                        Console.ResetColor();

                        continued = true;

                        continue;
                    }

                    foreach (var diag in parse.Diagnostics)
                    {
                        LogDiagnostic(diag);
                    }

                    var analysis = LanguageAnalyzer.Analyze(parse, loader, new SyntaxContext());

                    foreach (var diag in analysis.Diagnostics)
                    {
                        LogDiagnostic(diag);
                    }

                    break;
                }

                if (quit)
                {
                    break;
                }

                i++;
            }

            return(0);
        }