ScriptCSSession( IScriptEngine engine, ScriptPackSession scriptPackSession, CurrentCmdletScriptPack currentCmdletScriptPack, CurrentLogger logger)
 {
     _engine = engine;
     _scriptPackSession = scriptPackSession;
     _currentCmdletScriptPack = currentCmdletScriptPack;
     _logger = logger;
 }

        public Camera(IScriptEngine scriptEngine, IApplicationContext context)
        {
            _scriptEngine = scriptEngine;
            _context = context;

            Size = 200;
        }

        public FileSystem(IScriptEngine scriptEngine, IApplicationContext io)
        {
            _scriptEngine = scriptEngine;
            _io = io;

            ReadFsLog();
        }

 private CalamariResult ExecuteScript(IScriptEngine psse, string scriptName, CalamariVariableDictionary variables)
 {
     var capture = new CaptureCommandOutput();
     var runner = new CommandLineRunner(capture);
     var result = psse.Execute(scriptName, variables, runner);
     return new CalamariResult(result.ExitCode, capture);
 }

 public ScriptServices(
     IFileSystem fileSystem,
     IPackageAssemblyResolver packageAssemblyResolver, 
     IScriptExecutor executor,
     IScriptEngine engine,
     IFilePreProcessor filePreProcessor,
     IReplCommandService replCommandService,
     IScriptPackResolver scriptPackResolver, 
     IPackageInstaller packageInstaller,
     ILog logger,
     IAssemblyResolver assemblyResolver,
     IConsole console = null,
     IInstallationProvider installationProvider = null 
     )
 {
     FileSystem = fileSystem;
     PackageAssemblyResolver = packageAssemblyResolver;
     Executor = executor;
     Engine = engine;
     FilePreProcessor = filePreProcessor;
     ReplCommandService = replCommandService;
     ScriptPackResolver = scriptPackResolver;
     PackageInstaller = packageInstaller;
     Logger = logger;
     Console = console;
     AssemblyResolver = assemblyResolver;
     InstallationProvider = installationProvider;
 }

        public Web(IScriptEngine engine, IWebProvider provider)
        {
            Assert.IsNotNull(engine); Assert.IsNotNull(provider);

            _scriptEngine = engine;
            _provider = provider;
        }

        public Gallery(IApplicationContext context, IScriptEngine engine)
        {
            _context = context;
            _scriptEngine = engine;

            Size = 200;
        }

        public ScriptExecutor(
            IFileSystem fileSystem,
            IFilePreProcessor filePreProcessor,
            IScriptEngine scriptEngine,
            ILogProvider logProvider,
            IScriptLibraryComposer composer)
        {
            Guard.AgainstNullArgument("fileSystem", fileSystem);
            Guard.AgainstNullArgumentProperty("fileSystem", "BinFolder", fileSystem.BinFolder);
            Guard.AgainstNullArgumentProperty("fileSystem", "DllCacheFolder", fileSystem.DllCacheFolder);
            Guard.AgainstNullArgument("filePreProcessor", filePreProcessor);
            Guard.AgainstNullArgument("scriptEngine", scriptEngine);
            Guard.AgainstNullArgument("logProvider", logProvider);
            Guard.AgainstNullArgument("composer", composer);

            References = new AssemblyReferences(DefaultReferences);
            Namespaces = new Collection<string>();
            ImportNamespaces(DefaultNamespaces);
            FileSystem = fileSystem;
            FilePreProcessor = filePreProcessor;
            ScriptEngine = scriptEngine;
            _log = logProvider.ForCurrentType();
#pragma warning disable 618
            Logger = new ScriptCsLogger(_log);
#pragma warning restore 618
            ScriptLibraryComposer = composer;
        }

 public ScriptServices(
     IFileSystem fileSystem,
     IPackageAssemblyResolver packageAssemblyResolver,
     IScriptExecutor executor,
     IRepl repl,
     IScriptEngine engine,
     IFilePreProcessor filePreProcessor,
     IScriptPackResolver scriptPackResolver,
     IPackageInstaller packageInstaller,
     IObjectSerializer objectSerializer,
     ILog logger,
     IAssemblyResolver assemblyResolver,
     IEnumerable<IReplCommand> replCommands,
     IConsole console = null,
     IInstallationProvider installationProvider = null)
 {
     FileSystem = fileSystem;
     PackageAssemblyResolver = packageAssemblyResolver;
     Executor = executor;
     Repl = repl;
     Engine = engine;
     FilePreProcessor = filePreProcessor;
     ScriptPackResolver = scriptPackResolver;
     PackageInstaller = packageInstaller;
     ObjectSerializer = objectSerializer;
     Logger = logger;
     Console = console;
     AssemblyResolver = assemblyResolver;
     InstallationProvider = installationProvider;
     ReplCommands = replCommands;
 }

 public ExecuteReplCommand(
     string scriptName,
     string[] scriptArgs,
     IFileSystem fileSystem,
     IScriptPackResolver scriptPackResolver,
     IScriptEngine scriptEngine,
     IFilePreProcessor filePreProcessor,
     IObjectSerializer serializer,
     ILog logger,
     IConsole console,
     IAssemblyResolver assemblyResolver,
     IEnumerable<IReplCommand> replCommands)
 {
     _scriptName = scriptName;
     _scriptArgs = scriptArgs;
     _fileSystem = fileSystem;
     _scriptPackResolver = scriptPackResolver;
     _scriptEngine = scriptEngine;
     _filePreProcessor = filePreProcessor;
     _serializer = serializer;
     _logger = logger;
     _console = console;
     _assemblyResolver = assemblyResolver;
     _replCommands = replCommands;
 }

        /// <summary>
        /// Executes the comand line - depending upon the options provided we will
        /// either run a single file, a single command, or enter the interactive loop.
        /// </summary>
        public int Run(IScriptEngine engine, IConsole console, ConsoleOptions options) {
            Contract.RequiresNotNull(engine, "engine");
            Contract.RequiresNotNull(console, "console");
            Contract.RequiresNotNull(options, "options");

            _engine = engine;
            _options = options;
            _console = console;

            Initialize();
            
            try {
                return Run();

#if !SILVERLIGHT // ThreadAbortException.ExceptionState
            } catch (System.Threading.ThreadAbortException tae) {
                if (tae.ExceptionState is KeyboardInterruptException) {
                    Thread.ResetAbort();
                }
                return -1;
#endif
            } finally {
                Shutdown(engine);
            }
        }

 public ScriptExecutor(IFileSystem fileSystem, IFilePreProcessor filePreProcessor, IScriptEngine scriptEngine, ILog logger)
 {
     FileSystem = fileSystem;
     FilePreProcessor = filePreProcessor;
     ScriptEngine = scriptEngine;
     Logger = logger;
 }

 public PackagedScriptConvention(string scriptFilePrefix, ICalamariFileSystem fileSystem, IScriptEngine scriptEngine, ICommandLineRunner commandLineRunner)
 {
     this.scriptFilePrefix = scriptFilePrefix;
     this.fileSystem = fileSystem;
     this.scriptEngine = scriptEngine;
     this.commandLineRunner = commandLineRunner;
 }

 public DeployAzureCloudServicePackageConvention(ICalamariFileSystem fileSystem, ICalamariEmbeddedResources embeddedResources, 
     IScriptEngine scriptEngine, ICommandLineRunner commandLineRunner)
 {
     this.fileSystem = fileSystem;
     this.embeddedResources = embeddedResources;
     this.scriptEngine = scriptEngine;
     this.commandLineRunner = commandLineRunner;
 }

 private RShipCore CreateCore(IScriptEngine engine)
 {
     var modulesPath = Path.Combine(PathHelpers.GetAssemblyDirectory(), "ship_modules");
     var pathResolver = new ModulePathResolver(modulesPath, new[] { ".ship", ".js", ".json", ".dll" }, "lib");
     var loaderFactory = new ModuleLoaderFactory();
     var core = new RShipCore(engine, pathResolver, loaderFactory);
     return core;
 }

        /// <summary>
        /// Binary file with a default encoding. The actual encoding of the file is determined by first 
        /// bytes of the file in a language specific way.
        /// </summary>
        public SourceFileContentProvider(string path, Encoding defaultEncoding, IScriptEngine engine)
        {
            Contract.RequiresNotNull(defaultEncoding, "defaultEncoding");

            _path = path;
            _defaultEncoding = defaultEncoding;
            _engine = engine;
        }

 public Repl(IFileSystem fileSystem, IScriptEngine scriptEngine, ILog logger, IConsole console, IFilePreProcessor filePreProcessor)
 {
     FileSystem = fileSystem;
     ScriptEngine = scriptEngine;
     FilePreProcessor = filePreProcessor;
     Logger = logger;
     Console = console;
 }

 public ConfiguredScriptConvention(string deploymentStage, IScriptEngine scriptEngine,
     ICalamariFileSystem fileSystem, ICommandLineRunner commandLineRunner)
 {
     this.deploymentStage = deploymentStage;
     this.scriptEngine = scriptEngine;
     this.fileSystem = fileSystem;
     this.commandLineRunner = commandLineRunner;
 }

 public void ShouldLoadScriptPacksIfScriptNameIsSet(IConsole console, TestLogProvider logProvider, IScriptEngine engine)
 {
     var builder = new ScriptServicesBuilder(console, logProvider);
     builder.Overrides[typeof(IScriptEngine)] = engine.GetType();
     builder.ScriptName("");
     builder.Build();
     var runtimeServices = (RuntimeServices)builder.RuntimeServices;
     runtimeServices.InitDirectoryCatalog.ShouldBeTrue();
 }

 public FeatureScriptConvention(string deploymentStage, ICalamariFileSystem fileSystem, ICalamariEmbeddedResources embeddedResources, 
     IScriptEngine scriptEngine, ICommandLineRunner commandLineRunner)
 {
     this.deploymentStage = deploymentStage;
     this.fileSystem = fileSystem;
     this.embeddedResources = embeddedResources;
     this.scriptEngine = scriptEngine;
     this.commandLineRunner = commandLineRunner;
 }