Esempio n. 1
0
 public TemplateFileGenerator(ITemplateResolver resolver, ITemplateRepository repository, IFileSystem fileSystem, ExecutionContext executionContext)
 {
     this.resolver         = resolver;
     this.repository       = repository;
     this.fileSystem       = fileSystem;
     this.executionContext = executionContext;
 }
Esempio n. 2
0
        public static ICloudFormationRequestBuilder Create(ITemplateResolver templateResolver,
                                                           string templateFile,
                                                           string templateParameterFile,
                                                           bool filesInPackage,
                                                           ICalamariFileSystem fileSystem,
                                                           IVariables variables,
                                                           string stackName,
                                                           List <string> capabilities,
                                                           bool disableRollback,
                                                           string roleArn,
                                                           IEnumerable <KeyValuePair <string, string> > tags,
                                                           StackArn stack,
                                                           Func <IAmazonCloudFormation> clientFactory)
        {
            var resolvedTemplate   = templateResolver.Resolve(templateFile, filesInPackage, variables);
            var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables);

            if (!string.IsNullOrWhiteSpace(templateParameterFile) && !resolvedParameters.Some())
            {
                throw new CommandException("Could not find template parameters file: " + templateParameterFile);
            }

            return(new CloudFormationTemplate(() => variables.Evaluate(fileSystem.ReadFile(resolvedTemplate.Value)),
                                              CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables),
                                              stackName,
                                              capabilities,
                                              disableRollback,
                                              roleArn,
                                              tags,
                                              stack,
                                              clientFactory,
                                              variables));
        }
Esempio n. 3
0
 public MailBodyBuilder(ITemplateCompiler compiler, ITemplateProvider provider, ITemplateResolver resolver)
     : this()
 {
     _compiler = compiler;
     _provider = provider;
     _resolver = resolver;
 }
 public AssembleCommandHandler(IProjectContextFactory projectContextFactory, ITemplateResolver templateResolver, ITemplateInvoker templateInvoker, ISolutionPathResolver solutionPathResolver)
 {
     _projectContextFactory = projectContextFactory;
     _templateResolver      = templateResolver;
     _templateInvoker       = templateInvoker;
     _solutionPathResolver  = solutionPathResolver;
 }
Esempio n. 5
0
        /// <summary>
        /// Sets the resolver used to locate unknown templates.
        /// </summary>
        /// <param name="resolver">The resolver instance to use.</param>
        /// <returns>The current configuration builder.</returns>
        public IConfigurationBuilder ResolveUsing(ITemplateResolver resolver)
        {
            //Contract.Requires(resolver != null);

            _config.Resolver = resolver;
            return(this);
        }
Esempio n. 6
0
 public DeployService(IFileSystem fileSystem, ITemplateResolver resolver, ITargetParser targetParser, ExecutionContext executionContext)
 {
     this.fileSystem       = fileSystem;
     this.resolver         = resolver;
     this.targetParser     = targetParser;
     this.executionContext = executionContext;
 }
 public CommandDefinitionContentProvider(IFileSystem fileSystem, ITemplateResolver templateResolver, ITemplateRepository templateRepository, ICodeLanguage codeLanguage)
 {
     this.fileSystem         = fileSystem;
     this.templateResolver   = templateResolver;
     this.templateRepository = templateRepository;
     this.codeLanguage       = codeLanguage;
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="mailAttributes"></param>
 /// <param name="mailSender"></param>
 /// <param name="templateResolver"></param>
 protected HBSMailerBase(MailAttributes mailAttributes = null, IMailSender mailSender = null, ITemplateResolver templateResolver = null, ITemplateService templateService = null)
 {
     MailAttributes    = mailAttributes ?? new MailAttributes();
     MailSender        = mailSender ?? new SmtpMailSender();
     _templateResolver = templateResolver;
     ViewBag           = new ExpandoObject();
     _templateService  = templateService;
 }
Esempio n. 9
0
 public void Resolve(ITemplateResolver resolver)
 {
     resolved = resolver.Resolve(link);
     if (resolved == null)
     {
         throw new Exception(string.Format("Could not resolve {0} link", link));
     }
 }
        public RazorViewParser(ITemplateResolver resolver)
		{
			if (resolver == null)
				throw new ArgumentNullException("resolver");

			var config = new TemplateServiceConfiguration { Resolver = resolver };
			_templateService = new TemplateService(config);
		}
Esempio n. 11
0
        /// <summary>
        /// Adds a resolver used to resolve named template content.
        /// </summary>
        /// <param name="resolver">The resolver to add.</param>
        public void AddResolver(ITemplateResolver resolver)
        {
            if (resolver == null)
            {
                throw new ArgumentNullException("resolver");
            }

            templateResolvers.Add(resolver);
        }
Esempio n. 12
0
        public CppContentProvider(IFileSystem fileSystem, ITemplateResolver resolver)
        {
            this.fileSystem = fileSystem;
            this.resolver   = resolver;
            string pathSeparator = Regex.Escape(new string(Path.DirectorySeparatorChar, 1));

            relativeDirectoryRegex = new Regex(@"[^" + pathSeparator + @"]+(?:[" + pathSeparator + @"](?<split>.*))?",
                                               RegexOptions.Compiled);
        }
        /// <summary>
        ///     Sets the template resolver.
        /// </summary>
        /// <param name="templateResolverType">The template resolver type.</param>
        private void SetTemplateResolver(string templateResolverType)
        {
            var type = GetType(templateResolverType);

            if (type != null)
            {
                Resolver = GetInstance <ITemplateResolver>(type);
            }
        }
Esempio n. 14
0
 public InitCommandHandler(ITemplateResolver templateResolver,
                           IProjectContextFactory projectContextFactory,
                           ITemplateInvoker templateInvoker,
                           AssembleCommandHandler assembleCommandHandler)
 {
     _templateResolver       = templateResolver;
     _projectContextFactory  = projectContextFactory;
     _templateInvoker        = templateInvoker;
     _assembleCommandHandler = assembleCommandHandler;
 }
Esempio n. 15
0
 public RazorConfiguration(ITemplateResolver templateResolver)
 {
     BaseTemplateType     = typeof(RazorTemplate <>);
     EncodedStringFactory = new RawStringFactory();
     Namespaces           = new HashSet <string>
     {
         "System",
         "RazorEngine"
     };
     Resolver = templateResolver;
 }
Esempio n. 16
0
        private void AddValidTemplate(Assembly assembly,ICollection<Template> templates,  ITemplateModel modelInstance)
        {
            _resolver = new EmbeddedTemplateResolver(assembly);
            Template template = new Template();
            template.Name = _nameFormatter.GetName(modelInstance);
            template.Text = _resolver.GetTemplate(template.Name);
            template.Model = modelInstance;

            if (!String.IsNullOrEmpty(template.Text))
            {
                templates.Add(template);
            }
        }
        public RazorViewParser(ITemplateResolver resolver)
        {
            if (resolver == null)
            {
                throw new ArgumentNullException("resolver");
            }

            var config = new TemplateServiceConfiguration {
                Resolver = resolver
            };

            _templateService = new TemplateService(config);
        }
Esempio n. 18
0
        public static void Defaults(ITemplateResolver templateResolver)
        {
            var buildTemplate = B.AutoMock <Template>().Subject;

            buildTemplate.Name         = "Psake";
            buildTemplate.TemplateType = TemplateType.Build;

            var sourceTemplate = B.AutoMock <Template>().Subject;

            sourceTemplate.Name         = "VisualStudio";
            sourceTemplate.TemplateType = TemplateType.Source;

            templateResolver.Templates = new[] { buildTemplate, sourceTemplate };
        }
Esempio n. 19
0
        public RazorMailer(string baseDir = null)
        {
            baseDir = baseDir ?? GetDefaultBaseDir();

            var defaultResolver = new DefaultResolver(baseDir);

            this.templateResolver = defaultResolver;
            this.emailResolver    = defaultResolver;
            this.templateService  = new TemplateService(new EmailTemplateConfiguration(baseDir)
            {
                Resolver = defaultResolver
            });

            Razor.SetTemplateService(templateService);
        }
Esempio n. 20
0
        public void Resolve(ITemplateResolver resolver)
        {
            inherited = new ITemplateSet[inheritedNotResolved.Length];
            for (int i = 0; i < inheritedNotResolved.Length; i++)
            {
                inherited[i] = resolver.Resolve(inheritedNotResolved[i]);
            }

            foreach (object obj in templates.Values)
            {
                if (obj is ITemplateSet)
                {
                    (obj as ITemplateSet).Resolve(resolver);
                }
            }
        }
Esempio n. 21
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="templateResolver"></param>
 /// <param name="viewSettings"></param>
 public TemplateService(ITemplateResolver templateResolver, ViewSettings viewSettings)
 {
     _templateResolver = templateResolver;
     _hbsService       = Handlebars.Create();
     RegisterHelpers(viewSettings);
     _templateResolver.GetAllPartialTemplates().ForEach(template =>
     {
         try
         {
             _hbsService.RegisterTemplate(template.Key, template.Value);
         }
         catch (System.Exception ex)
         {
             throw new System.Exception($"Error at template key = {template.Key}", ex);
         }
     });
 }
Esempio n. 22
0
        /// <summary>
        /// Initializes a new instance of the <see cref="TemplateManager"/> class.
        /// </summary>
        /// <param name="templateResolver">The template resolver.</param>
        /// <param name="stackOperation">Stack operation being performed</param>
        /// <param name="logger">Logger to send error messages to.</param>
        public TemplateManager(ITemplateResolver templateResolver, StackOperation stackOperation, ILogger logger)
        {
            this.templateResolver = templateResolver;
            this.logger           = logger;
            this.stackOperation   = stackOperation;

            try
            {
                this.TemplateParameters =
                    TemplateParser.Create(templateResolver.FileContent).GetParameters().ToList();
            }
            catch (Exception e)
            {
                this.logger?.LogError($"Error parsing CloudFormation Template: {e.Message}");
                this.logger?.LogError(e.StackTrace);
                throw;
            }
        }
Esempio n. 23
0
        public RazorMailer(ITemplateServiceConfiguration config, IEmailResolver emailResolver)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            if (config.Resolver == null)
            {
                throw new ArgumentException("Custom configuration must specify a resolver");
            }
            if (emailResolver == null)
            {
                throw new ArgumentNullException("emailResolver");
            }

            this.emailResolver    = emailResolver;
            this.templateResolver = config.Resolver;
            this.templateService  = new TemplateService(config);
        }
        public static IAppBuilder UseRazor(this IAppBuilder appBuilder, Action<IRouteTable> initRoutes, IFileSystem fileSystem = null, ITemplateResolver templateResolver = null)
        {
            if (appBuilder == null)
            {
                throw new ArgumentNullException("appBuilder");
            }
            if (initRoutes == null)
            {
                throw new ArgumentNullException("initRoutes");
            }

            var routes = new RouteTable(fileSystem ?? new PhysicalFileSystem(""));
            initRoutes(routes);
            var renderer = new RazorRenderer();
            var config = new TemplateServiceConfiguration
            {
                Resolver = templateResolver ?? new FileSystemTempleteResolver(fileSystem ?? new PhysicalFileSystem(""))
            };
            var templateService = new TemplateService(config);
            RazorEngine.Razor.SetTemplateService(templateService);

            var middleware = new RazorMiddleware(routes, renderer);
            return appBuilder.UseHandlerAsync(middleware.Handle);
        }
        /// <summary>
        /// Initialises a new instance of <see cref="DelegateTemplateResolver"/>.
        /// </summary>
        /// <param name="resolver">The resolver delegate.</param>
        public WrapperTemplateManager(ITemplateResolver resolver)
        {
            Contract.Requires(resolver != null);

            _resolver = resolver;
        }
Esempio n. 26
0
 public IMailBodyBuilder UseResolver(ITemplateResolver resolver) => Use(() => _resolver = resolver);
Esempio n. 27
0
 /// <summary>
 /// Adds a resolver used to resolve named template content.
 /// </summary>
 /// <param name="resolver">The resolver to add.</param>
 public static void AddResolver(ITemplateResolver resolver)
 {
     DefaultTemplateService.AddResolver(resolver);
 }
 public TemplateFileGenerator(ITemplateResolver resolver, ITemplateRepository repository, IFileSystem fileSystem)
 {
     this.resolver   = resolver;
     this.repository = repository;
     this.fileSystem = fileSystem;
 }
Esempio n. 29
0
 public TemplateService(ICalamariFileSystem fileSystem, ITemplateResolver resolver, ITemplateReplacement replacement)
 {
     this.fileSystem  = fileSystem;
     this.resolver    = resolver;
     this.replacement = replacement;
 }
Esempio n. 30
0
 public TemplateService(ICalamariFileSystem fileSystem, ITemplateResolver resolver)
 {
     this.fileSystem = fileSystem;
     this.resolver   = resolver;
 }
Esempio n. 31
0
 /// <summary>
 /// Adds a resolver used to resolve named template content.
 /// </summary>
 /// <param name="resolver">The resolver to add.</param>
 public static void AddResolver(ITemplateResolver resolver)
 {
     DefaultTemplateService.AddResolver(resolver);
 }
        /// <summary>
        /// Create a new readonly view (and copy) of the given configuration.
        /// </summary>
        /// <param name="config">the configuration to copy.</param>
        public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic;

            _activator = config.Activator;
            if (_activator == null)
            {
                throw new ArgumentNullException("config", "the configured Activator cannot be null!");
            }

            _baseTemplateType = config.BaseTemplateType;
            // Check if the baseTemplateType is valid.
            if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType))
            {
                throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!");
            }

            _cachingProvider = config.CachingProvider;
            if (_cachingProvider == null)
            {
                throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!");
            }

#if !RAZOR4
#pragma warning disable 0618 // Backwards Compat.
            _codeInspectors = config.CodeInspectors;
            if (_codeInspectors == null)
            {
                throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!");
            }
            _codeInspectors = new List <ICodeInspector>(_codeInspectors);
#pragma warning restore 0618 // Backwards Compat.
#endif

            _compilerServiceFactory = config.CompilerServiceFactory;
            if (_compilerServiceFactory == null)
            {
                throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!");
            }

            _debug = config.Debug;
            _disableTempFileLocking = config.DisableTempFileLocking;
            _encodedStringFactory   = config.EncodedStringFactory;
            if (_encodedStringFactory == null)
            {
                throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!");
            }

            _language   = config.Language;
            _namespaces = config.Namespaces;
            if (_namespaces == null)
            {
                throw new ArgumentNullException("config", "the configured Namespaces cannot be null!");
            }
            _namespaces = new HashSet <string>(_namespaces);

            _referenceResolver = config.ReferenceResolver;
            if (_referenceResolver == null)
            {
                throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!");
            }

            _templateManager = config.TemplateManager;

#if NO_CONFIGURATION
            if (_templateManager == null)
            {
                throw new ArgumentNullException("config", "the configured TemplateManager cannot be null!");
            }
#else
#pragma warning disable 0618 // Backwards Compat.
            _resolver = config.Resolver;
            if (_templateManager == null)
            {
                if (_resolver != null)
                {
                    _templateManager = new Xml.WrapperTemplateManager(_resolver);
                }
                else
                {
                    throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!");
                }
            }
#pragma warning restore 0618 // Backwards Compat.
#endif
            ConfigureCompilerBuilder = config.ConfigureCompilerBuilder;
        }
 /// <summary>
 /// Initializes a new <see cref="RazorViewParser"/> with optional arguments.
 /// </summary>
 /// <param name="resolver">The <see cref="ITemplateResolver"/>. If not provided, <see cref="TemplateResolver"/> is used.</param>
 /// <param name="baseTemplateType">The <see cref="Type"/> to use as the TemplateBase.</param>
 public RazorViewParser(ITemplateResolver resolver = null, Type baseTemplateType = null)
     : this(new TemplateServiceConfiguration { BaseTemplateType = baseTemplateType, Resolver = resolver ?? new TemplateResolver() })
 {
 }
Esempio n. 34
0
 public RazorMailer(ITemplateResolver templateResolver, IEmailResolver emailResolver)
     : this(new TemplateServiceConfiguration {
     Resolver = templateResolver
 }, emailResolver)
 {
 }
        /// <summary>
        /// Create a new readonly view (and copy) of the given configuration.
        /// </summary>
        /// <param name="config">the configuration to copy.</param>
        public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic;

            _activator = config.Activator;
            if (_activator == null)
            {
                throw new ArgumentNullException("config", "the configured Activator cannot be null!");
            }

            _baseTemplateType = config.BaseTemplateType;
            // Check if the baseTemplateType is valid.
            if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType))
            {
                throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!");
            }
            
            _cachingProvider = config.CachingProvider;
            if (_cachingProvider == null)
            {
                throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!");
            }

#if !RAZOR4
#pragma warning disable 0618 // Backwards Compat.
            _codeInspectors = config.CodeInspectors;
            if (_codeInspectors == null)
            {
                throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!");
            }
            _codeInspectors = new List<ICodeInspector>(_codeInspectors);
#pragma warning restore 0618 // Backwards Compat.
#endif

            _compilerServiceFactory = config.CompilerServiceFactory;
            if (_compilerServiceFactory == null)
            {
                throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!");
            }

            _debug = config.Debug;
            _disableTempFileLocking = config.DisableTempFileLocking;
            _encodedStringFactory = config.EncodedStringFactory;
            if (_encodedStringFactory == null)
            {
                throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!");
            }

            _language = config.Language;
            _namespaces = config.Namespaces;
            if (_namespaces == null)
            {
                throw new ArgumentNullException("config", "the configured Namespaces cannot be null!");
            }
            _namespaces = new HashSet<string>(_namespaces);

            _referenceResolver = config.ReferenceResolver;
            if (_referenceResolver == null)
            {
                throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!");
            }

#pragma warning disable 0618 // Backwards Compat.
            _resolver = config.Resolver;
            _templateManager = config.TemplateManager;
            if (_templateManager == null)
            {
                if (_resolver != null)
                {
                    _templateManager = new Xml.WrapperTemplateManager(_resolver);
                }
                else
                {
                    throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!");
                }
            }
#pragma warning restore 0618 // Backwards Compat.

        }
Esempio n. 36
0
 public TemplateReplacement(ITemplateResolver resolver)
 {
     this.resolver = resolver;
 }
Esempio n. 37
0
 public TypeContentProvider(ITemplateRepository templateRepository, ITemplateResolver resolver)
 {
     this.templateRepository = templateRepository;
     this.resolver           = resolver;
 }