Example #1
0
        /// <summary>
        ///     Use the YAML serializer to dump objects
        /// </summary>
        public static string Dump(object o)
        {
            var serializer = ModelDeserializerFactory.Fetch(ModelFormat.Yaml);
            var text       = serializer.Serialize(o);

            return(text);
        }
Example #2
0
        public void Run()
        {
            var models  = NamedFileFactory.ToNamedFiles(_options.Models, NameProvider.IndexedModel);
            var outputs = NamedFileFactory.ToNamedFiles(_options.Output, NameProvider.IndexedOutput);

            var lastModelDate      = GetLastWrittenDates(models.Select(m => m.Path), DateTime.MinValue, false).Max();
            var earliestOutputDate = GetLastWrittenDates(outputs.Select(m => m.Path), DateTime.MinValue, true).Min();
            var templateDate       = GetLastWrittenDates(new[] { _options.Template }, DateTime.MinValue, false).Max();

            var lastInputDate = lastModelDate > templateDate ? lastModelDate : templateDate;


            //check if there is nothing to do...
            if (_options.Lazy && (lastInputDate < earliestOutputDate))
            {
                return;
            }


            var template = TryReadFile(_options.Template);

            var engine = new ApplicationEngine(_runtime)
                         .WithHelpers()
                         .WithDefinitions(_options.Definitions)
                         .WithTemplate(template);

            foreach (var model in models)
            {
                var modelText = TryReadFile(model.Path);
                var format    = ModelDeserializerFactory.FormatFromExtension(model.Path);
                engine = engine.WithModel(model.Name, modelText, format);
            }

            engine = engine.WithIncludePaths(_options.Include);

            if (!_options.HideEnvironment)
            {
                engine = engine.WithEnvironmentVariables();
            }

            engine.Render();

            foreach (var engineError in engine.Errors)
            {
                Console.Error.WriteLine(engineError);
            }

            if (engine.HasErrors)
            {
                _sys.GetOrQuit <int>(() => throw new ApplicationException(), "");
            }


            if (outputs.Any())
            {
                foreach (var output in outputs)
                {
                    var text = engine.GetOutputFromVariable(output.Name);
                    _sys.TryOrQuit(() => _runtime.FileSystem.WriteAllText(output.Path, text),
                                   $"Unable to write output to {output.Path}");
                }
            }
            else
            {
                var outputStrings = engine.GetOutput(10);
                for (var i = 0; i < outputs.Length; i++)
                {
                    var text = outputStrings[i];
                    if (text.Length == 0)
                    {
                        continue;
                    }
                    Console.WriteLine($"----------------- output{i} -------------------");
                    Console.WriteLine(text);
                }
            }
        }