public DiagnosticsModuleBuilder(IRootPathProvider rootPathProvider, IModelBinderLocator modelBinderLocator, INancyEnvironment diagnosticsEnvironment, INancyEnvironment environment)
 {
     this.rootPathProvider = rootPathProvider;
     this.serializerFactory = new DiagnosticsSerializerFactory(diagnosticsEnvironment);
     this.modelBinderLocator = modelBinderLocator;
     this.environment = environment;
 }

 /// <summary>
 /// Creates a new instance of the <see cref="DefaultDiagnostics"/> class.
 /// </summary>
 /// <param name="diagnosticsConfiguration"></param>
 /// <param name="diagnosticProviders"></param>
 /// <param name="rootPathProvider"></param>
 /// <param name="requestTracing"></param>
 /// <param name="configuration"></param>
 /// <param name="modelBinderLocator"></param>
 /// <param name="responseProcessors"></param>
 /// <param name="routeSegmentConstraints"></param>
 /// <param name="cultureService"></param>
 /// <param name="requestTraceFactory"></param>
 public DefaultDiagnostics(
     DiagnosticsConfiguration diagnosticsConfiguration,
     IEnumerable<IDiagnosticsProvider> diagnosticProviders,
     IRootPathProvider rootPathProvider,
     IRequestTracing requestTracing,
     NancyInternalConfiguration configuration,
     IModelBinderLocator modelBinderLocator,
     IEnumerable<IResponseProcessor> responseProcessors,
     IEnumerable<IRouteSegmentConstraint> routeSegmentConstraints,
     ICultureService cultureService,
     IRequestTraceFactory requestTraceFactory,
     IEnumerable<IRouteMetadataProvider> routeMetadataProviders)
 {
     this.diagnosticsConfiguration = diagnosticsConfiguration;
     this.diagnosticProviders = diagnosticProviders;
     this.rootPathProvider = rootPathProvider;
     this.requestTracing = requestTracing;
     this.configuration = configuration;
     this.modelBinderLocator = modelBinderLocator;
     this.responseProcessors = responseProcessors;
     this.routeSegmentConstraints = routeSegmentConstraints;
     this.cultureService = cultureService;
     this.requestTraceFactory = requestTraceFactory;
     this.routeMetadataProviders = routeMetadataProviders;
 }

        public static void Enable(IApplicationPipelines applicationPipelines, IRootPathProvider rootPathProvider, IStitchConfiguration configuration)
        {
            if (applicationPipelines == null)
            {
                throw new ArgumentNullException("applicationPipelines");
            }

            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (rootPathProvider == null)
            {
                throw new ArgumentNullException("rootPathProvider");
            }

            var compilerTypes =
                from type in AppDomainAssemblyTypeScanner.Types
                where typeof(ICompile).IsAssignableFrom(type)
                select type;

            var compilers = compilerTypes.Select(compiler => (ICompile) Activator.CreateInstance(compiler)).ToList();

            applicationPipelines.BeforeRequest.AddItemToStartOfPipeline(GetStitchResponse(compilers, rootPathProvider, configuration));
        }

 public static void RenderExternalJavascript(Stream responseStream, IRootPathProvider rootPath)
 {
     using (var js = new FileStream(Path.Combine(rootPath.GetRootPath(), "content/external.js"), FileMode.Open))
     {
         js.CopyTo(responseStream);
     }
 }

        public LessModule(IRootPathProvider root)
        {
            var urlPrefix = System.Configuration.ConfigurationManager.AppSettings["app:UrlPrefix"] ?? string.Empty;

            Get[urlPrefix + "/less/desktop"] = _ =>
            {
                var manifest = System.Configuration.ConfigurationManager.AppSettings["app:LessManifest"];
                if (manifest.StartsWith("/"))
                {
                    manifest = manifest.Substring(1);
                }

                manifest = manifest.Replace("/", "\\");

                var lessFile = Path.Combine(root.GetRootPath(), manifest);

                if (!File.Exists(lessFile))
                {
                    throw new FileNotFoundException("Less manifest was not found");
                }

                var less = File.ReadAllText(lessFile);

                var config = dotless.Core.configuration.DotlessConfiguration.GetDefaultWeb();
                config.Logger = typeof(dotless.Core.Loggers.AspResponseLogger);
                config.CacheEnabled = false;
                config.MinifyOutput = true;
                var css = dotless.Core.LessWeb.Parse(less, config);

                return Response.AsText(css, "text/css");
            };
        }

        private static TinyIoCContainer ConfigureContainer(IModuleKeyGenerator moduleKeyGenerator, IEnumerable<IDiagnosticsProvider> providers, IRootPathProvider rootPathProvider, IRequestTracing requestTracing, NancyInternalConfiguration configuration, DiagnosticsConfiguration diagnosticsConfiguration)
        {
            var diagContainer = new TinyIoCContainer();

            diagContainer.Register<IModuleKeyGenerator>(moduleKeyGenerator);
            diagContainer.Register<IInteractiveDiagnostics, InteractiveDiagnostics>();
            diagContainer.Register<IRequestTracing>(requestTracing);
            diagContainer.Register<IRootPathProvider>(rootPathProvider);
            diagContainer.Register<NancyInternalConfiguration>(configuration);
            diagContainer.Register<IModelBinderLocator, DefaultModelBinderLocator>();
            diagContainer.Register<IBinder, DefaultBinder>();
            diagContainer.Register<IFieldNameConverter, DefaultFieldNameConverter>();
            diagContainer.Register<BindingDefaults, BindingDefaults>();
            diagContainer.Register<ISerializer, DefaultJsonSerializer>();
            diagContainer.Register<DiagnosticsConfiguration>(diagnosticsConfiguration);

            foreach (var diagnosticsProvider in providers)
            {
                diagContainer.Register<IDiagnosticsProvider>(diagnosticsProvider, diagnosticsProvider.GetType().FullName);
            }

            foreach (var moduleType in AppDomainAssemblyTypeScanner.TypesOf<DiagnosticModule>().ToArray())
            {
                diagContainer.Register(typeof(NancyModule), moduleType, moduleKeyGenerator.GetKeyForModuleType(moduleType)).AsMultiInstance();
            }

            return diagContainer;
        }

 public CachedFeedService(IConfigSettings configSettings, IRootPathProvider rootPathProvider)
 {
     this.rootPathProvider = rootPathProvider;
     cacheMinutes = configSettings.GetAppSetting<int>("cacheminutes");
     nancyCategories = configSettings.GetAppSetting("nancycategories")
         .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DefaultResponseFormatter"/> class.
 /// </summary>
 /// <param name="rootPathProvider">The <see cref="IRootPathProvider"/> that should be used by the instance.</param>
 /// <param name="context">The <see cref="NancyContext"/> that should be used by the instance.</param>
 /// <param name="serializerFactory">An <see cref="ISerializerFactory" /> instance"/>.</param>
 /// <param name="environment">An <see cref="INancyEnvironment"/> instance.</param>
 public DefaultResponseFormatter(IRootPathProvider rootPathProvider, NancyContext context, ISerializerFactory serializerFactory, INancyEnvironment environment)
 {
     this.rootPathProvider = rootPathProvider;
     this.context = context;
     this.serializerFactory = serializerFactory;
     this.environment = environment;
 }

 public XmlFormatterExtensionsFixtures()
 {
     this.rootPathProvider = A.Fake<IRootPathProvider>();
     this.responseFormatter = new DefaultResponseFormatter(this.rootPathProvider);
     this.model = new Person { FirstName = "Andy", LastName = "Pike" };
     this.response = this.responseFormatter.AsXml(model);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ViewNotFoundException"/>.
 /// </summary>
 /// <param name="viewName">The name of the view that was being located.</param>
 /// <param name="availableViewEngineExtensions">List of available view extensions that can be rendered by the available view engines.</param>
 /// <param name="inspectedLocations">The locations that were inspected for the view.</param>
 /// <param name="rootPathProvider">An <see cref="IRootPathProvider"/> instance.</param>
 public ViewNotFoundException(string viewName, string[] availableViewEngineExtensions, string[] inspectedLocations, IRootPathProvider rootPathProvider)
 {
     this.rootPathProvider = rootPathProvider;
     this.ViewName = viewName;
     this.AvailableViewEngineExtensions = availableViewEngineExtensions;
     this.InspectedLocations = inspectedLocations;
 }

 public WebHost(IRootPathProvider rootPathProvider, Func<NancyContext> getContext)
 {
   this.rootPathProvider = rootPathProvider;
   this.getContext = getContext;
   this.logger = NLog.LogManager.GetCurrentClassLogger();
   logger.Debug("WebHost.ctor: constructed!");
 }

        public InfoModel(IRootPathProvider rootPathProvider, NancyInternalConfiguration configuration)
        {
            this.rootPathProvider = rootPathProvider;

            Configuration = new Dictionary<string, IEnumerable<string>>();
            foreach (var propertyInfo in configuration.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                var value = propertyInfo.GetValue(configuration, null);

                Configuration[propertyInfo.Name] = (!typeof(IEnumerable).IsAssignableFrom(value.GetType())) ?
                    new[] { value.ToString() } :
                    ((IEnumerable<object>)value).Select(x => x.ToString());
            }

            var properties = SettingTypes
                .SelectMany(t => t.GetProperties(BindingFlags.Static | BindingFlags.Public))
                .Where(x => x.PropertyType == typeof(bool));

            Settings = from property in properties
                       orderby property.Name
                       let value = (bool)property.GetValue(null, null)
                       select new SettingsModel
                       {
                           Name = Regex.Replace(property.Name, "[A-Z]", " $0"),
                           Value = value
                       };
        }

        public ConnectionManager(IRootPathProvider rootPathProvider)
        {
            this.factory = DbProviderFactories.GetFactory("System.Data.SQLite");
            this.databaseName = Path.Combine(rootPathProvider.GetRootPath(), "data.db");

            CreateDatabase();
        }

        public InfoModule(IRootPathProvider rootPathProvider, NancyInternalConfiguration configuration)
            : base("/info")
        {
            Get["/"] = _ => View["Info"];

            Get["/data"] = _ =>
            {
                dynamic data = new ExpandoObject();

                data.Nancy = new ExpandoObject();
                data.Nancy.Version = string.Format("v{0}", this.GetType().Assembly.GetName().Version.ToString());
                data.Nancy.CachesDisabled = StaticConfiguration.DisableCaches;
                data.Nancy.TracesDisabled = StaticConfiguration.DisableErrorTraces;
                data.Nancy.CaseSensitivity = StaticConfiguration.CaseSensitive ? "Sensitive" : "Insensitive";
                data.Nancy.RootPath = rootPathProvider.GetRootPath();
                data.Nancy.Hosting = this.GetHosting();
                data.Nancy.BootstrapperContainer = this.GetBootstrapperContainer();
                data.Nancy.LocatedBootstrapper = NancyBootstrapperLocator.Bootstrapper.GetType().ToString();
                data.Nancy.LoadedViewEngines = GetViewEngines();

                data.Configuration = new Dictionary<string, object>();
                foreach (var propertyInfo in configuration.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
                {
                    var value =
                        propertyInfo.GetValue(configuration, null);

                    data.Configuration[propertyInfo.Name] = (!typeof(IEnumerable).IsAssignableFrom(value.GetType())) ?
                        new[] { value.ToString() } :
                        ((IEnumerable<object>) value).Select(x => x.ToString());
                }

                return Response.AsJson((object)data);
            };
        }

        private static TinyIoCContainer ConfigureContainer(IEnumerable<IDiagnosticsProvider> providers, IRootPathProvider rootPathProvider, IRequestTracing requestTracing, NancyInternalConfiguration configuration, INancyEnvironment diagnosticsEnvironment)
        {
            var diagContainer = new TinyIoCContainer();

            diagContainer.Register<IInteractiveDiagnostics, InteractiveDiagnostics>();
            diagContainer.Register<IRequestTracing>(requestTracing);
            diagContainer.Register<IRootPathProvider>(rootPathProvider);
            diagContainer.Register<NancyInternalConfiguration>(configuration);
            diagContainer.Register<IModelBinderLocator, DefaultModelBinderLocator>();
            diagContainer.Register<IBinder, DefaultBinder>();
            diagContainer.Register<IFieldNameConverter, DefaultFieldNameConverter>();
            diagContainer.Register<BindingDefaults, BindingDefaults>();
            diagContainer.Register<INancyEnvironment>(diagnosticsEnvironment);
            diagContainer.Register<ISerializer>(new DefaultJsonSerializer(diagnosticsEnvironment));

            foreach (var diagnosticsProvider in providers)
            {
                var key = string.Concat(
                    diagnosticsProvider.GetType().FullName,
                    "_",
                    diagnosticsProvider.DiagnosticObject.GetType().FullName);

                diagContainer.Register<IDiagnosticsProvider>(diagnosticsProvider, key);
            }

            foreach (var moduleType in AppDomainAssemblyTypeScanner.TypesOf<DiagnosticModule>().ToArray())
            {
                diagContainer.Register(typeof(INancyModule), moduleType, moduleType.FullName).AsMultiInstance();
            }

            return diagContainer;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ArticleModule" />.
        /// </summary>
        /// <param name="repository">The article's repository</param>
        public ArticleModule(IApplication application, IArticleRepository articleRepository, IRootPathProvider rootPathProvider)
            : base(application)
        {
            this._ArticleRepository = articleRepository;
            this._RootPathProvider = rootPathProvider;

            // Bind the HTTP GET verb to the ListArticles method
            this.Get["/articles"] = ListArticles;

            // Bind the HTTP GET verb to the ListHomeArticles method
            this.Get["/articles/homeArticles"] = ListHomeArticles;

            // Bind the HTTP GET verb to the ListSliderArticles method
            this.Get["/articles/sliderArticles"] = ListSliderArticles;

            // Define a route for urls "/articles/{seoTitle}" which will returns the article matching the specified slug
            this.Get["/articles/{seoTitle}"] = GetArticle;

            // Define a route for urls "/article/{seoTitle}" which will returns the article matching the specified slug
            this.Get["/article/apercu/{seoTitle}"] = GetArticleBySeoTitle;

            // Define a route for urls "/article/{seoTitle}" which will returns the article matching the specified slug
            this.Get["/article/{seoTitle}"] = GetArticleBySeoTitle;

            // Define a route for urls "/articles/byId" which will returns the article matching the specified id
            this.Get["/articles/articles/byId"] = GetArticlebyId;

            // Bind the HTTP GET verb to the ListEvents method
            this.Get["/actualites/actualites"] = ListPublicArticles;
        }

        public DocsModule(IRootPathProvider rootPathProvider)
            : base("api-docs")
        {
            _rootPathProvider = rootPathProvider;

            Get["/"] = Index;
        }

        public RazorViewEngineFixture()
        {
            this.configuration = A.Fake<IRazorConfiguration>();
            this.engine = new RazorViewEngine(this.configuration);

            var cache = A.Fake<IViewCache>();
            A.CallTo(() => cache.GetOrAdd(A<ViewLocationResult>.Ignored, A<Func<ViewLocationResult, Func<NancyRazorViewBase>>>.Ignored))
                .ReturnsLazily(x =>
                {
                    var result = x.GetArgument<ViewLocationResult>(0);
                    return x.GetArgument<Func<ViewLocationResult, Func<NancyRazorViewBase>>>(1).Invoke(result);
                });

            this.renderContext = A.Fake<IRenderContext>();
            A.CallTo(() => this.renderContext.ViewCache).Returns(cache);
            A.CallTo(() => this.renderContext.LocateView(A<string>.Ignored, A<object>.Ignored))
                .ReturnsLazily(x =>
                {
                    var viewName = x.GetArgument<string>(0);
                    return FindView(viewName); ;
                });

            this.rootPathProvider = A.Fake<IRootPathProvider>();
            A.CallTo(() => this.rootPathProvider.GetRootPath()).Returns(Path.Combine(Environment.CurrentDirectory, "TestViews"));

            this.fileSystemViewLocationProvider = new FileSystemViewLocationProvider(this.rootPathProvider, new DefaultFileSystemReader());
        }

        public FaceModule(IRootPathProvider pathProvider)
        {
            Post["/api/face/upload", true] = async (parameters, ct) =>
            {
                var file = this.Request.Files.FirstOrDefault();

                if (file == null)
                    return HttpStatusCode.BadRequest;

                var faceService = new Pubhack4.Services.Face.FaceService();
                var faces = await faceService.GetFacesFromImage(file.Value);

                return Response.AsJson(faces);
            };

            Post["/api/face/base64", true] = async (parameters, ct) =>
            {
                string x = Context.Request.Form["image"];

                var data = System.Convert.FromBase64String(x.Split(',')[1]);

                if (data == null)
                    return HttpStatusCode.BadRequest;

                var ms = new MemoryStream(data, 0, data.Length);

                var faceService = new Pubhack4.Services.Face.FaceService();
                var faces = await faceService.GetFacesFromImage(ms);

                return Response.AsJson(faces);
            };
        }

 /// <summary>
 /// Creates a new instance of the <see cref="DefaultDiagnostics"/> class.
 /// </summary>
 /// <param name="diagnosticProviders"></param>
 /// <param name="rootPathProvider"></param>
 /// <param name="requestTracing"></param>
 /// <param name="configuration"></param>
 /// <param name="modelBinderLocator"></param>
 /// <param name="responseProcessors"></param>
 /// <param name="routeSegmentConstraints"></param>
 /// <param name="cultureService"></param>
 /// <param name="requestTraceFactory"></param>
 /// <param name="routeMetadataProviders"></param>
 /// <param name="textResource"></param>
 /// <param name="environment"></param>
 /// <param name="typeCatalog"></param>
 public DefaultDiagnostics(
     IEnumerable<IDiagnosticsProvider> diagnosticProviders,
     IRootPathProvider rootPathProvider,
     IRequestTracing requestTracing,
     NancyInternalConfiguration configuration,
     IModelBinderLocator modelBinderLocator,
     IEnumerable<IResponseProcessor> responseProcessors,
     IEnumerable<IRouteSegmentConstraint> routeSegmentConstraints,
     ICultureService cultureService,
     IRequestTraceFactory requestTraceFactory,
     IEnumerable<IRouteMetadataProvider> routeMetadataProviders,
     ITextResource textResource,
     INancyEnvironment environment,
     ITypeCatalog typeCatalog)
 {
     this.diagnosticProviders = diagnosticProviders;
     this.rootPathProvider = rootPathProvider;
     this.requestTracing = requestTracing;
     this.configuration = configuration;
     this.modelBinderLocator = modelBinderLocator;
     this.responseProcessors = responseProcessors;
     this.routeSegmentConstraints = routeSegmentConstraints;
     this.cultureService = cultureService;
     this.requestTraceFactory = requestTraceFactory;
     this.routeMetadataProviders = routeMetadataProviders;
     this.textResource = textResource;
     this.environment = environment;
     this.typeCatalog = typeCatalog;
 }