public override SDProject RunStep(SDProject sdProject)
        {
            if (string.IsNullOrEmpty(_stepInput.CoreConfigSection.DocLanguage))
                throw new SDBuildException(_stepInput.SDBuildStrings.NoDocLanguage);

            if (_stepInput.CoreConfigSection.OutputPath == null)
                throw new SDBuildException(_stepInput.SDBuildStrings.NoOutputPathGiven);

            if (!Directory.Exists(_stepInput.CoreConfigSection.OutputPath))
            {
                Directory.CreateDirectory(_stepInput.CoreConfigSection.OutputPath);
            }

            foreach (var exporter in _stepInput.AllExporters)
            {
                if (_stepInput.CoreConfigSection.ActivatedExporters.Contains(exporter.ExporterName))
                {
                    exporter.OnRequirementsWarning += (m) => ExecuteOnBuildMessage(m);
                    if (!exporter.CheckRequirements())
                    {
                        throw new SDBuildException(_stepInput.SDBuildStrings.RequirementError);
                    }
                }
            }

            return _checkConfigStep.RunStep(sdProject);
        }
        public void Export(SDProject sdProject, string outputPath)
        {
            _docCount = sdProject.DocumentationLanguages.Count;
            _docIndex = 0;

            foreach(var targetFx in sdProject.GetAllAvailableTargetFxs())
            {
                if (ApiEmpty(sdProject, targetFx))
                {
                    continue;
                }

                foreach (var docLanguage in sdProject.DocumentationLanguages)
                {
                    StepInput.InitStepinput(sdProject, targetFx, Path.Combine(outputPath, docLanguage), docLanguage, _localController.GetLocalStringsOrDefault<ChmStrings>(docLanguage), _chmStrings, _chmConfig);

                    var steps = new List<StepBase>();
                    steps.Add(new CopyStep(0, 10));
                    steps.Add(new TemplateStep(10, 50));
                    steps.Add(new CompileStep(50, 90));
                    steps.Add(new SaveAndCleanStep(90, 100));

                    foreach (var step in steps)
                    {
                        ExecuteOnStepProgress(step.StepRange.ProgressStart);

                        step.OnStepMessage += ExecuteOnStepMessage;
                        step.OnStepProgress += ExecuteOnStepProgress;
                        step.RunStep();
                    }

                    _docIndex++;
                }
            }            
        }
        public void Export(SDProject sdProject, string outputPath)
        {
            _docCount = sdProject.DocumentationLanguages.Count;
            _docIndex = 0;
            foreach (var docLanguage in sdProject.DocumentationLanguages)
            {
                StepInput.InitStepinput(sdProject, Path.Combine(outputPath, docLanguage), docLanguage, _localController.GetLocalStringsOrDefault<HtmlStrings>(docLanguage), _htmlStrings, _htmlConfig);

                var steps = new List<StepBase>();
                steps.Add(new PreStep(0, 5));
                steps.Add(new CopyThemeStep(5, 25));
                steps.Add(new CreateDataStep(25, 100));

                foreach(var step in steps)
                {
                    ExecuteOnStepProgress(step.StepRange.ProgressStart);

                    step.OnStepMessage += ExecuteOnStepMessage;
                    step.OnStepProgress += ExecuteOnStepProgress;
                    step.RunStep();

                    ExecuteOnStepProgress(step.StepRange.ProgressEnd);
                }

                _docIndex++;
            }
        }
        public void Export(SDProject sdProject, string outputPath)
        {
            _sdProject = sdProject;
            _outputPath = outputPath;
            _docCount = sdProject.DocumentationLanguages.Count;
            _docIndex = 0;

            foreach (var docLanguage in sdProject.DocumentationLanguages)
            {
                var currentOutputPath = Path.Combine(outputPath, docLanguage);
                _currentDocLanguage = docLanguage;

                ExecuteOnStepMessage(_wordStrings.LoadingTemplate);
                ExecuteOnStepProgress(10);
                var docBuilder = new DocBuilder(_sdProject, _localController.GetLocalStringsOrDefault<WordStrings>(_currentDocLanguage), _currentDocLanguage, currentOutputPath);

                ExecuteOnStepProgress(20);
                ExecuteOnStepMessage(_wordStrings.CreatingDocument);
                docBuilder.BuildDocument();

                ExecuteOnStepProgress(80);
                ExecuteOnStepMessage(_wordStrings.SavingDocument);
                docBuilder.SaveToOutputFolder();

                ExecuteOnStepProgress(90);
                ExecuteOnStepMessage(_wordStrings.DeleteTmp);
                Directory.Delete(Path.Combine(_outputPath, _currentDocLanguage, "tmp"), true);

                _docIndex++;
            }
        }
 public BaseApiBuilder(WordTemplater wordTemplater, SDProject sdProject, WordStrings wordStrings, string docLanguage)
 {
     _wordTemplater = wordTemplater;
     _sdProject = sdProject;
     _wordStrings = wordStrings;
     _docLanguage = docLanguage;
 }
Exemple #6
0
        internal static SDProject ParseProject()
        {
            var testProjectPath =
                Path.Combine(
                Path.GetDirectoryName(Assembly.GetAssembly(typeof(Regression1)).Location),
                "..", "..", "..", "SharpDox.TestProject", "SharpDox.TestProject.csproj");
            
            var coreConfig = Mock.Of<ICoreConfigSection>(
                c => c.InputFile == testProjectPath &&
                c.ProjectName == "TestProject" &&
                c.DocLanguage == "en" &&
                c.ExcludedIdentifiers == new ObservableCollection<string>());
            
            var configController = Mock.Of<IConfigController>(
                c=> c.GetConfigSection<ICoreConfigSection>() == coreConfig);

            var stepInput = new StepInput(configController, new NRefactoryParser(Mock.Of<ParserStrings>()), new SDBuildStrings(), null);

            var config = new List<StepBase>();
            var checkConfig = new CheckConfigStep(stepInput, 0, 15);

            config.Add(new ParseProjectStep(stepInput, 0, 50));
            config.Add(new ParseCodeStep(stepInput, 50, 100));

            var sdProject = new SDProject();
            foreach (var step in config)
            {
                sdProject = step.RunStep(sdProject);
            }

            return sdProject;
        }
        private void ParseCompleted(SDProject sdProject)
        {
            Application.Current.Dispatcher.BeginInvoke(
                DispatcherPriority.Background,
                new Action(() => {
                    TreeView = new VisibilityItemList(_sharpDoxConfig);

                    if (sdProject != null)
                    {                        
                        foreach (var sdSolution in sdProject.Solutions.Values)
                        {
                            foreach (var sdRepository in sdSolution.Repositories)
                            {
                                foreach (var sdNamespace in sdRepository.GetAllNamespaces())
                                {
                                    TreeView.Add(new NamespaceViewModel(sdNamespace, _sharpDoxConfig));
                                    TreeLoaded = true;
                                }
                            }
                        }
                    }

                    IsTreeRefreshing = false;
                }));
        }
Exemple #8
0
 internal void ExecuteOnBuildCompleted(SDProject sdProject)
 {
     if (OnBuildCompleted != null)
     {
         OnBuildCompleted(sdProject);
     }
     ExecuteOnStepMessage("");
 }
 public static void InitStepinput(SDProject sdProject, string outputPath, string currentLanguage, HtmlStrings docStrings, HtmlStrings htmlStrings, HtmlConfig htmlConfig)
 {
     SDProject = sdProject;
     OutputPath = outputPath;
     CurrentLanguage = currentLanguage;
     DocStrings = docStrings;
     HtmlStrings = htmlStrings;
     HtmlConfig = htmlConfig;
 }
Exemple #10
0
        public virtual void StartBuild()
        {
            try
            {
                _buildMessenger.ExecuteOnBuildProgress(0);
                _buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.StartingBuild);

                var sdProject = new SDProject();
                foreach (var step in _buildSteps)
                {
                    _buildMessenger.ExecuteOnBuildMessage(string.Format(_sdBuildStrings.StartingStep, step.StepName));
                    _buildMessenger.ExecuteOnBuildProgress(step.StepRange.ProgressStart);
                    _buildMessenger.ExecuteOnStepProgress(0);

                    step.OnBuildProgress += _buildMessenger.ExecuteOnBuildProgress;
                    step.OnBuildMessage += _buildMessenger.ExecuteOnBuildMessage;
                    step.OnStepMessage += _buildMessenger.ExecuteOnStepMessage;
                    step.OnStepProgress += _buildMessenger.ExecuteOnStepProgress;

                    sdProject = step.RunStep(sdProject);

                    _buildMessenger.ExecuteOnStepProgress(100);
                }

                _buildMessenger.ExecuteOnBuildProgress(100);
                _buildMessenger.ExecuteOnStepMessage(string.Empty);
                _buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.BuildSuccess);
                _buildMessenger.ExecuteOnBuildCompleted(sdProject);
            }
            catch (Exception ex)
            {
                if (ex is ThreadAbortException)
                {
                    _buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.BuildStopped);
                    _buildMessenger.ExecuteOnStepProgress(0);
                    _buildMessenger.ExecuteOnBuildProgress(0);

                    _buildMessenger.ExecuteOnBuildStopped();
                }
                else
                {
                    Trace.TraceError(ex.ToString());                    

                    if (ex is SDBuildException)
                    {
                        _buildMessenger.ExecuteOnBuildMessage(ex.Message);
                    }

                    _buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.CouldNotEndBuild);
                    _buildMessenger.ExecuteOnStepProgress(100);
                    _buildMessenger.ExecuteOnBuildProgress(100);

                    _buildMessenger.ExecuteOnBuildFailed();
                }
            }
        }
 public static void InitStepinput(SDProject sdProject, SDTargetFx targetFx, string outputPath, string currentLanguage, ChmStrings docStrings, ChmStrings chmStrings, ChmConfig chmConfig)
 {
     SDProject = sdProject;
     CurrentTargetFx = targetFx;
     OutputPath = outputPath;
     TmpPath = Path.Combine(outputPath, "tmp-" + currentLanguage);
     CurrentLanguage = currentLanguage;
     DocStrings = docStrings;
     ChmStrings = chmStrings;
     ChmConfig = chmConfig;
 }
Exemple #12
0
        public override SDProject RunStep(SDProject sdProject)
        {
            _stepInput.CodeParser.OnStepMessage += ExecuteOnStepMessage;
            _stepInput.CodeParser.OnStepProgress += ExecuteOnStepProgress;

            var solutionList = new List<string>(sdProject.Solutions.Keys);
            foreach (var solution in solutionList)
            {
                sdProject.Solutions[solution] = _stepInput.CodeParser.GetParsedSolution(solution, _stepInput.CoreConfigSection, sdProject.Tokens, false, true);
            }

            return sdProject;
        }
        public override SDProject RunStep(SDProject sdProject)
        {
            _stepInput.CodeParser.OnStepMessage += ExecuteOnStepMessage;
            _stepInput.CodeParser.OnStepProgress += ExecuteOnStepProgress;

            var solutionList = new List<string>(sdProject.Solutions.Keys);
            foreach (var solution in solutionList)
            {
                sdProject.Solutions[solution] = _stepInput.CodeParser.GetStructureParsedSolution(solution);
            }

            return sdProject;
        }
Exemple #14
0
        public override SDProject RunStep(SDProject sdProject)
        {
            if (string.IsNullOrEmpty(_stepInput.CoreConfigSection.ProjectName))
                throw new SDBuildException(_stepInput.SDBuildStrings.NoProjectNameGiven);

            if (_stepInput.CoreConfigSection.InputFile == null)
                throw new SDBuildException(_stepInput.SDBuildStrings.NoProjectGiven);

            if (!File.Exists(_stepInput.CoreConfigSection.InputFile.ResolvePath(Environment.CurrentDirectory)))
                throw new SDBuildException(_stepInput.SDBuildStrings.ProjectNotFound);

            return sdProject;
        }
Exemple #15
0
        public override SDProject RunStep(SDProject sdProject)
        {
            _stepInput.CodeParser.OnDocLanguageFound += sdProject.AddDocumentationLanguage;
            _stepInput.CodeParser.OnStepMessage += ExecuteOnStepMessage;
            _stepInput.CodeParser.OnStepProgress += ExecuteOnStepProgress;

            var solutionList = new List<string>(sdProject.Solutions.Keys);
            foreach (var solution in solutionList)
            {
                sdProject.Solutions[solution] = _stepInput.CodeParser.GetFullParsedSolution(solution, _stepInput.CoreConfigSection, sdProject.Tokens);
            }

            return sdProject;
        }
 private bool ApiEmpty(SDProject sdProject, SDTargetFx targetFx)
 {
     var empty = true;
     foreach (var solution in sdProject.Solutions.Values)
     {
         var sdRepository = solution.Repositories.SingleOrDefault(r => r.TargetFx.Identifier == targetFx.Identifier);
         if (sdRepository != null && sdRepository.GetAllNamespaces().Count > 0)
         {
             empty = false;
             break;
         }
     }
     return empty;
 }
        public DocBuilder(SDProject sdProject, WordStrings wordStrings, string docLanguage, string outputPath)
        {
            _sdProject = sdProject;
            _wordStrings = wordStrings;
            _docLanguage = docLanguage;
            _outputPath = outputPath;

            _templatePath = Helper.EnsureCopy(
                                Path.Combine(Path.GetDirectoryName(GetType().Assembly.Location), "templates", "sharpDox.docx"),
                                Path.Combine(outputPath, "tmp"));
            _wordTemplater = new WordTemplater(_templatePath);

            _apiBuilder = new ApiBuilder(_wordTemplater, _sdProject, _wordStrings, _docLanguage, outputPath);
            _articleBuilder = new ArticleBuilder(_wordTemplater, _sdProject, _apiBuilder);
        }
Exemple #18
0
        private void RunAllExporters(SDProject sdProject)
        {
            var i = 0d;
            foreach (var exporter in _stepInput.AllExporters)
            {
                if (_stepInput.CoreConfigSection.ActivatedExporters.Contains(exporter.ExporterName))
                {
                    var outputPath = GetOutputPath(_stepInput.CoreConfigSection.OutputPath, exporter.ExporterName);

                    ExecuteOnStepMessage(string.Format(_stepInput.SDBuildStrings.RunningExporter, exporter.ExporterName));
                    exporter.OnStepMessage += (m) => ExecuteOnStepMessage(string.Format("[{0}] {1}", exporter.ExporterName, m));
                    exporter.OnStepProgress += (p) => ExecuteOnStepProgress((int)(((double)p / _stepInput.CoreConfigSection.ActivatedExporters.Count) + (i / _stepInput.CoreConfigSection.ActivatedExporters.Count * 100)));
                    exporter.Export(sdProject, outputPath);
                    i++;
                }
            }
        }
 // The export function gets the parsed solution and the output path.
 public void Export(SDProject sdProject, string outputPath)
 {
     var csv = string.Empty;
     foreach(var solution in sdProject.Solutions.Values)
     {
         // Get all types in the current solution.
         // Grouped by type identifiers and repositories (targetfx)
         var types = solution.GetAllSolutionTypes();
         foreach (var groupedTypes in types.Values)
         {
             var type = groupedTypes.First().Value;
             ExecuteOnStepMessage("Creating entry for " + type.Fullname);
             csv += string.Format("{1}{0}{2}{0}{3}", _csvConfig.Divider, type.Fullname, type.Name, type.Namespace) + Environment.NewLine;
         }
     }
     File.WriteAllText(Path.Combine(outputPath, "types.csv"), csv);
 }
Exemple #20
0
        public SDProject ParseNavFile(string navFile, SDProject sdProject)
        {
            var navFileLanguage = Path.GetFileNameWithoutExtension(navFile);
            sdProject.AddDocumentationLanguage(navFileLanguage);

            var articles = new List<SDArticle>();
            var levelNodes = new List<SDArticle>();

            if (navFile != null)
            {
                foreach (var line in File.ReadAllLines(navFile))
                {
                    var article = GetArticle(line, sdProject.Tokens);
                    if (article is SDDocPlaceholder)
                    {
                        var solutionFile = ((SDDocPlaceholder)article).SolutionFile;
                        sdProject.AddSolution(solutionFile);
                    }

                    var navLevel = GetNavLevel(line);

                    if (levelNodes.Count < navLevel)
                    {
                        levelNodes.Add(article);
                    }
                    else
                    {
                        levelNodes[navLevel - 1] = article;
                    }

                    if (navLevel == 1)
                    {
                        articles.Add(article);
                    }
                    else
                    {
                        article.Parent = levelNodes[navLevel - 2];
                        levelNodes[navLevel - 2].Children.Add(article);
                    }
                }
            }
            
            sdProject.Articles.Add(navFileLanguage, articles);
            return sdProject;
        }
Exemple #21
0
        public override SDProject RunStep(SDProject sdProject)
        {
            _sdProject = sdProject;
            SetProjectInfos();
            GetImages();
            ParseTokens();
            ParseDescriptions();

            if (Path.GetExtension(_stepInput.CoreConfigSection.InputFile) == ".sdnav")
            {
                ParseNavigationFiles();
            }
            else
            {
                _sdProject.Solutions.Add(_stepInput.CoreConfigSection.InputFile, new SDSolution(_stepInput.CoreConfigSection.InputFile));
            }

            return _sdProject;
        }
 public ArticleBuilder(WordTemplater wordTemplater, SDProject sdProject, ApiBuilder apiBuilder)
 {
     _wordTemplater = wordTemplater;
     _sdProject = sdProject;
     _apiBuilder = apiBuilder;
 }
 public TypeBuilder(WordTemplater wordTemplater, SDProject sdProject, WordStrings wordStrings, string docLanguage, string outputPath)
     : base(wordTemplater, sdProject, wordStrings, docLanguage) 
 {
     _outputPath = outputPath;
 }
Exemple #24
0
        public override SDProject RunStep(SDProject sdProject)
        {
            RunAllExporters(sdProject);

            return sdProject;
        }
Exemple #25
0
 public abstract SDProject RunStep(SDProject sdProject);
 public NamespaceBuilder(WordTemplater wordTemplater, SDProject sdProject, WordStrings wordStrings, string docLanguage, string outputPath)
     : base(wordTemplater, sdProject, wordStrings, docLanguage) 
 {
     _typeBuilder = new TypeBuilder(wordTemplater, sdProject, wordStrings, docLanguage, outputPath);
 }
Exemple #27
0
        private void ParseNavigationFiles()
        {
            ExecuteOnStepMessage(_stepInput.SDBuildStrings.ParsingNav);
            ExecuteOnStepProgress(50);

            var navFileParser = new SDNavParser(_stepInput.CoreConfigSection.InputFile);
            var navFiles = Directory.EnumerateFiles(Path.GetDirectoryName(_stepInput.CoreConfigSection.InputFile), "*.sdnav", SearchOption.AllDirectories);
            foreach(var navFile in navFiles)
            {
                _sdProject = navFileParser.ParseNavFile(navFile, _sdProject);
            }
        }
Exemple #28
0
 public Helper(SDProject sdProject)
 {
     _sdProject = sdProject;
 }