Пример #1
0
        public void Build(BuildCtx buildCtx, BuildResult buildResult, int iterationId)
        {
            var tryDetectChanges = !buildCtx.ProjectStructureChanged;

            buildResult.HasError = false;
            if (!buildResult.Incremental || !tryDetectChanges)
            {
                buildResult.RecompiledIncrementaly.Clear();
            }
            var buildModuleCtx = new BuildModuleCtx()
            {
                BuildCtx    = buildCtx,
                Owner       = this,
                Result      = buildResult,
                ToCheck     = new OrderedHashSet <string>(),
                IterationId = iterationId
            };

            try
            {
                ProjectOptions.BuildCache.StartTransaction();
                ITSCompiler compiler = null;
                try
                {
                    if (!tryDetectChanges)
                    {
                        if (!ProjectOptions.TypeScriptVersionOverride && DevDependencies != null &&
                            DevDependencies.Contains("typescript"))
                        {
                            ProjectOptions.Tools.SetTypeScriptPath(Owner.FullPath);
                        }
                        else
                        {
                            ProjectOptions.Tools.SetTypeScriptVersion(ProjectOptions.TypeScriptVersion);
                        }
                    }
                    compiler = buildCtx.CompilerPool.GetTs(DiskCache, buildCtx.CompilerOptions);
                    var trueTSVersion = compiler.GetTSVersion();
                    buildCtx.ShowTsVersion(trueTSVersion);
                    ProjectOptions.ConfigurationBuildCacheId = ProjectOptions.BuildCache.MapConfiguration(trueTSVersion,
                                                                                                          JsonConvert.SerializeObject(buildCtx.CompilerOptions, Formatting.None, TSCompilerOptions.GetSerializerSettings()));
                }
                finally
                {
                    if (compiler != null)
                    {
                        buildCtx.CompilerPool.ReleaseTs(compiler);
                    }
                }
                if (buildModuleCtx.Result.CommonSourceDirectory == null)
                {
                    buildModuleCtx.Result.CommonSourceDirectory = Owner.FullPath;
                }
                buildResult.TaskForSemanticCheck = buildCtx.StartTypeCheck().ContinueWith((task) =>
                {
                    if (task.IsCompletedSuccessfully)
                    {
                        buildResult.SemanticResult = task.Result;
                        buildResult.NotifySemanticResult(task.Result);
                    }
                });
                if (tryDetectChanges)
                {
                    if (!buildModuleCtx.CrawlChanges())
                    {
                        buildResult.Incremental = true;
                        goto noDependencyChangeDetected;
                    }
                    buildCtx.ProjectStructureChanged = true;
                    buildResult.Incremental          = false;
                    buildModuleCtx.Result.JavaScriptAssets.Clear();
                    foreach (var info in buildModuleCtx.Result.Path2FileInfo)
                    {
                        info.Value.IterationId = iterationId - 1;
                    }
                }
                buildModuleCtx.CrawledCount = 0;
                buildModuleCtx.ToCheck.Clear();
                ProjectOptions.HtmlHeadExpanded = buildModuleCtx.ExpandHtmlHead(ProjectOptions.HtmlHead);
                if (buildCtx.MainFile != null)
                {
                    buildModuleCtx.CheckAdd(PathUtils.Join(Owner.FullPath, buildCtx.MainFile), FileCompilationType.Unknown);
                }
                if (buildCtx.ExampleSources != null)
                {
                    foreach (var src in buildCtx.ExampleSources)
                    {
                        buildModuleCtx.CheckAdd(PathUtils.Join(Owner.FullPath, src), FileCompilationType.Unknown);
                    }
                }
                if (buildCtx.TestSources != null)
                {
                    foreach (var src in buildCtx.TestSources)
                    {
                        buildModuleCtx.CheckAdd(PathUtils.Join(Owner.FullPath, src), FileCompilationType.Unknown);
                    }
                }

                if (ProjectOptions.IncludeSources != null)
                {
                    foreach (var src in ProjectOptions.IncludeSources)
                    {
                        buildModuleCtx.CheckAdd(PathUtils.Join(Owner.FullPath, src), FileCompilationType.Unknown);
                    }
                }

                buildModuleCtx.Crawl();
                noDependencyChangeDetected :;
                ProjectOptions.CommonSourceDirectory = buildModuleCtx.Result.CommonSourceDirectory;
                if (ProjectOptions.SpriteGeneration)
                {
                    ProjectOptions.SpriteGenerator.ProcessNew();
                }
                var hasError = false;
                foreach (var item in buildModuleCtx.Result.Path2FileInfo)
                {
                    if (item.Value.HasError)
                    {
                        hasError = true;
                        break;
                    }
                }
                buildModuleCtx.Result.HasError = hasError;
                if (ProjectOptions.BuildCache.IsEnabled)
                {
                    buildModuleCtx.StoreResultToBuildCache(buildModuleCtx.Result);
                }
            }
            finally
            {
                ProjectOptions.BuildCache.EndTransaction();
            }
        }
Пример #2
0
        public void ApplySourceInfo(ISourceReplacer sourceReplacer, SourceInfo sourceInfo, BuildResult buildResult)
        {
            if (sourceInfo == null)
            {
                return;
            }

            if (sourceInfo.Assets != null)
            {
                foreach (var a in sourceInfo.Assets)
                {
                    if (a.Name == null)
                    {
                        continue;
                    }
                    var assetName = a.Name;
                    if (assetName.StartsWith("resource:"))
                    {
                        assetName = assetName.Substring(9);
                    }
                    sourceReplacer.Replace(a.StartLine, a.StartCol, a.EndLine, a.EndCol, "\"" + buildResult.ToOutputUrl(assetName) + "\"");
                }
            }

            if (sourceInfo.Sprites != null)
            {
                if (SpriteGeneration)
                {
                    var spriteHolder  = SpriteGenerator;
                    var outputSprites = spriteHolder.Retrieve(sourceInfo.Sprites);
                    foreach (var os in outputSprites)
                    {
                        var s = os.Me;
                        if (s.Name == null)
                        {
                            continue;
                        }
                        if (s.HasColor == true && s.Color == null)
                        {
                            // Modify method name to b.spritebc and remove first parameter with sprite name
                            sourceReplacer.Replace(s.StartLine, s.StartCol, s.ColorStartLine, s.ColorStartCol, sourceInfo.BobrilImport + ".spritebc(");
                            // Replace parameters after color with sprite size and position
                            sourceReplacer.Replace(s.ColorEndLine, s.ColorEndCol, s.EndLine, s.EndCol, "," + os.owidth + "," + os.oheight + "," + os.ox + "," + os.oy + ")");
                        }
                        else
                        {
                            // Modify method name to b.spriteb and replace parameters with sprite size and position
                            sourceReplacer.Replace(s.StartLine, s.StartCol, s.EndLine, s.EndCol, sourceInfo.BobrilImport + ".spriteb(" + os.owidth + "," + os.oheight + "," + os.ox + "," + os.oy + ")");
                        }
                    }
                }
                else
                {
                    foreach (var s in sourceInfo.Sprites)
                    {
                        if (s.Name == null)
                        {
                            continue;
                        }
                        sourceReplacer.Replace(s.NameStartLine, s.NameStartCol, s.NameEndLine, s.NameEndCol, "\"" + buildResult.ToOutputUrl(s.Name) + "\"");
                    }
                }
            }

            var trdb = TranslationDb;

            if (trdb != null && sourceInfo.Translations != null)
            {
                foreach (var t in sourceInfo.Translations)
                {
                    if (t.Message == null)
                    {
                        continue;
                    }
                    if (t.JustFormat)
                    {
                        continue;
                    }
                    var id      = trdb.AddToDB(t.Message, t.Hint, t.WithParams);
                    var finalId = trdb.MapId(id);
                    sourceReplacer.Replace(t.StartLine, t.StartCol, t.EndLine, t.EndCol, "" + finalId);
                    sourceReplacer.Replace(t.StartHintLine, t.StartHintCol, t.EndHintLine, t.EndHintCol, null);
                }
            }

            var styleDefs = sourceInfo.StyleDefs;

            if (styleDefs != null)
            {
                var styleDefNaming = StyleDefNaming;
                var styleDefPrefix = PrefixStyleNames;
                foreach (var s in styleDefs)
                {
                    var skipEx = s.IsEx ? 1 : 0;
                    if (s.UserNamed)
                    {
                        if (styleDefNaming == StyleDefNamingStyle.AddNames ||
                            styleDefNaming == StyleDefNamingStyle.PreserveNames)
                        {
                            if (styleDefPrefix.Length > 0)
                            {
                                if (s.Name != null)
                                {
                                    sourceReplacer.Replace(s.StartLine, s.StartCol, s.EndLine, s.EndCol, "\"" + styleDefPrefix + s.Name + "\"");
                                }
                                else
                                {
                                    sourceReplacer.Replace(s.StartLine, s.StartCol, s.StartLine, s.StartCol, "\"" + styleDefPrefix + "\"+(");
                                    sourceReplacer.Replace(s.EndLine, s.EndCol, s.EndLine, s.EndCol, ")");
                                }
                            }
                        }
                        else
                        {
                            sourceReplacer.Replace(s.BeforeNameLine, s.BeforeNameCol, s.EndLine, s.EndCol, "");
                        }
                    }
                    else
                    {
                        if (styleDefNaming == StyleDefNamingStyle.AddNames && s.Name != null)
                        {
                            var padArgs = (s.ArgCount == 1 + (s.IsEx ? 1 : 0)) ? ",undefined" : "";
                            sourceReplacer.Replace(s.BeforeNameLine, s.BeforeNameCol, s.BeforeNameLine, s.BeforeNameCol, padArgs + ",\"" + styleDefPrefix + s.Name + "\"");
                        }
                    }
                }
            }
        }
Пример #3
0
        void RecursiveFillOutputByAdditionalResourcesDirectory(IDirectoryCache directoryCache, string resourcesPath,
                                                               RefDictionary <string, object> filesContent, BuildResult buildResult)
        {
            Owner.DiskCache.UpdateIfNeeded(directoryCache);
            foreach (var child in directoryCache)
            {
                if (child is IDirectoryCache)
                {
                    RecursiveFillOutputByAdditionalResourcesDirectory(child as IDirectoryCache, resourcesPath,
                                                                      filesContent, buildResult);
                    continue;
                }

                if (child.IsInvalid)
                {
                    continue;
                }
                var outPathFileName = PathUtils.Subtract(child.FullPath, resourcesPath);
                buildResult.TakenNames.Add(outPathFileName);
                if (child is IFileCache)
                {
                    filesContent.GetOrAddValueRef(outPathFileName) =
                        new Lazy <object>(() =>
                    {
                        var res = ((IFileCache)child).ByteContent;
                        ((IFileCache)child).FreeCache();
                        return(res);
                    });
                }
            }
        }
Пример #4
0
 public void FillOutputByAssetsFromModules(RefDictionary <string, object> filesContent,
                                           Dictionary <string, TSProject> modules, string nodeModulesDir, BuildResult buildResult)
 {
     foreach (var keyValuePair in modules)
     {
         keyValuePair.Value.FillOutputByAssets(filesContent, buildResult, nodeModulesDir, this);
     }
 }
Пример #5
0
        public void FillOutputByAdditionalResourcesDirectory(RefDictionary <string, object> filesContent,
                                                             Dictionary <string, TSProject> buildResultModules, BuildResult buildResult)
        {
            var nodeModulesDir = Owner.Owner.FullPath;

            Owner.FillOutputByAssets(filesContent, buildResult, nodeModulesDir, this);
            FillOutputByAssetsFromModules(filesContent, buildResultModules, nodeModulesDir, buildResult);
            if (AdditionalResourcesDirectory == null)
            {
                return;
            }
            var resourcesPath = PathUtils.Join(Owner.Owner.FullPath, AdditionalResourcesDirectory);
            var item          = Owner.DiskCache.TryGetItem(resourcesPath);

            if (item is IDirectoryCache)
            {
                RecursiveFillOutputByAdditionalResourcesDirectory(item as IDirectoryCache, resourcesPath, filesContent, buildResult);
            }
        }