public TextResultWriter (IRunner runner, string fileName)
			: base (runner, fileName)
		{
			if ((fileName == null) || (fileName.Length == 0)) {
				writer = System.Console.Out;

				string color_override = Environment.GetEnvironmentVariable ("GENDARME_COLOR") ?? "dark";
				switch (color_override.ToLowerInvariant ()) {
				case "none":
					color_scheme = ColorScheme.None;
					break;
				case "light":
					color_scheme = ColorScheme.Light;
					break;
				case "dark":
				default:
					color_scheme = ColorScheme.Dark;
					break;
				}
			} else {
				color_scheme = ColorScheme.None;
				writer = new StreamWriter (fileName);
				need_closing = true;
			}
		}

		public XmlResultWriter (IRunner runner, string fileName)
			: base (runner, fileName)
		{
			writer = XmlWriter.Create (
				CreateWriterFor (fileName),
				new XmlWriterSettings { Indent = true, CloseOutput = true, CheckCharacters = false });
		}

 public ScoresController(IDbContext context, ICompiler compiler, IRunner runner, Participant participant = null)
 {
     _context = context;
     _compiler = compiler;
     _runner = runner;
     _participant = participant ?? GetCurrentParticipant();
 }

		public IgnoreFileList (IRunner runner, string fileName)
			: base (runner)
		{
			if (!String.IsNullOrEmpty (fileName) && File.Exists (fileName)) {
				Parse (fileName);
			}
		}

 public RunController(IDbContext context, ICompiler compiler, IRunner runner, Participant participant = null)
 {
     _context = context;
     _compiler = compiler;
     _runner = runner;
     _participant = participant == null ? GetCurrentParticipant() : participant;
 }

        private static void FillSectionMap(IRunner runner)
        {
            SectionMap = new Dictionary<string, Section>();

            // We may later read the current directory for dlls to load
            // 3rd party section handler modules but right now
            // there is not such a requirement

            // get types inherited from Section
            var types =
                typeof(Section).Assembly.
                GetTypes().
                Where(t => typeof(Section).IsAssignableFrom(t)).
                ToArray();

            foreach (var type in types)
            {
                var heading = type.GetCustomAttributes(
                        typeof(SectionHeaderAttribute),
                        inherit: false).
                    OfType<SectionHeaderAttribute>().
                    FirstOrDefault();

                // only accept Sections types which have SectionHeader attribute
                if (heading != null)
                {
                    var instance = Activator.CreateInstance(type) as Section;
                    instance.Runner = runner;
                    // cache the concrete section handler
                    SectionMap.Add("[" + heading.Header.ToLower() + "]", instance);
                }
            }
        }

		public XmlResultWriter (IRunner runner, string fileName)
			: base (runner, fileName)
		{
			if ((fileName == null) || (fileName.Length == 0))
				writer = new XmlTextWriter (System.Console.Out);
			else
				writer = new XmlTextWriter (fileName, Encoding.UTF8);
		}

 public RunnerFactory(ICategoryFinderService categoryFinderService,
     IResultsParser resultsParser,
     IRunner runner)
 {
     _categoryFinderService = categoryFinderService;
     _resultsParser = resultsParser;
     _runner = runner;
 }

 /// <summary>
 /// Constructor for the updater
 /// </summary>
 /// <param name="index"></param>
 /// <param name="createDate"></param>
 /// <param name="description"></param>
 /// <param name="createBy"></param>
 /// <param name="runner"></param>
 public UpdatesMetadata(double index, string createDate, string description, string createBy, IRunner runner)
 {
     _index = index;
     _createDate = createDate;
     _description = description;
     _createBy = createBy;
     _runner = runner;
 }

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);

			// avoid checking all methods unless the type has some properties
			Runner.AnalyzeType += delegate (object o, RunnerEventArgs e) {
				Active = e.CurrentType.HasProperties;
			};
		}

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);

			// Nullable cannot be used if the assembly target runtime is earlier than 2.0
			Runner.AnalyzeModule += delegate (object o, RunnerEventArgs e) {
				Active = (e.CurrentModule.Runtime >= TargetRuntime.Net_2_0);
			};
		}

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);

			Runner.AnalyzeModule += (object o, RunnerEventArgs e) => {
				Active = (e.CurrentAssembly.Name.Name == "mscorlib" ||
				e.CurrentModule.HasTypeReference ("System.ArgIterator"));
			};
		}

		internal PausableTask(IEnumerator enumerator, IRunner runner)
		{
            if (enumerator is SingleTask || enumerator is PausableTask || enumerator is AsyncTask)
				throw new ArgumentException("Use of incompatible Enumerator, cannot be SingleTask/PausableTask/AsyncTask");

            _enumerator = enumerator;
			
			_runner = runner;
		}

        public PausableTask(IEnumerator enumerator, IRunner runner)
        {
            if (enumerator is SingleTask || enumerator is PausableTask || enumerator is AsyncTask)
                throw new ArgumentException("Internal task used outside the framework scope");

            _enumerator = enumerator;

            _runner = runner;
        }

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);

			Runner.AnalyzeType += (object sender, RunnerEventArgs e) =>
			{
				Active = e.CurrentType.Implements ("Gendarme.Framework", "IRule");
			};
		}

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);

			//check if this is a Boo assembly using macros
			Runner.AnalyzeAssembly += delegate (object o, RunnerEventArgs e) {
				IsBooAssemblyUsingMacro = (e.CurrentAssembly.MainModule.HasTypeReference (BooMacroStatement));
			};
		}

 public Profile(IRunner runner)
 {
     _runner = runner;
     _home = Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%");
     if (string.IsNullOrEmpty(_home)) return;
     _profile = Path.Combine(_home, RcFile);
     var fi = new FileInfo(_profile);
     Exists = fi.Exists;
 }

        public ServiceRunner(ISettingsRunnable settings, IRunner runner, string threadName, bool autoStart = false)
        {
            _settings = settings;
            _runnableObject = runner;
            _threadName = threadName;

            if (autoStart)
                Start();
        }

		public override void Initialize (IRunner runner)
		{
			base.Initialize (runner);
			// extension methods are only available in FX3.5
			// check runtime >= NET2_0 (fast) then check if [ExtensionAttribute] is referenced
			Runner.AnalyzeModule += (object o, RunnerEventArgs e) => {
				Active = e.CurrentModule.Runtime >= TargetRuntime.Net_2_0 &&
					e.CurrentModule.HasTypeReference ("System.Runtime.CompilerServices.ExtensionAttribute");
			};
		}

        private string GetSubject(Mapping map, BuildData build, IRunner runner)
        {
            string errorMessage = "Success: ";
            if (runner.ErrorOccured)
            {
                errorMessage = "Failed: ";
            }

            return string.Format("{0} TfsDeployer Ran Script {1} on Machine {2} for {3}/{4}/{5}",errorMessage, map.Script, map.Computer, build.TeamProject, build.BuildType, build.BuildNumber);
        }