internal /*for testing purposes*/ bool TryUpdateExistingProjectRuleSet(string solutionRuleSetPath, string projectRuleSetRootFolder, string currentRuleSet, out string existingRuleSetPath, out RuleSet existingRuleSet)
        {
            existingRuleSetPath = null;
            existingRuleSet = null;

            if (ShouldIgnoreConfigureRuleSetValue(currentRuleSet))
            {
                return false;
            }

            existingRuleSetPath = PathHelper.ResolveRelativePath(currentRuleSet, projectRuleSetRootFolder);
            if (!PathHelper.IsPathRootedUnderRoot(existingRuleSetPath, projectRuleSetRootFolder))
            {
                // Not our file (i.e. absolute path to some other ruleset)
                existingRuleSetPath = null;
                return false;
            }

            if (this.AlreadyUpdatedExistingRuleSetPaths.TryGetValue(existingRuleSetPath, out existingRuleSet))
            {
                return true;
            }

            existingRuleSet = this.ruleSetSerializer.LoadRuleSet(existingRuleSetPath);
            if (existingRuleSet == null)
            {
                existingRuleSetPath = null;
                return false;
            }

            RuleSetHelper.UpdateExistingProjectRuleSet(existingRuleSet, solutionRuleSetPath);
            this.AlreadyUpdatedExistingRuleSetPaths.Add(existingRuleSetPath, existingRuleSet);
            return true;
        }

        private string GetSelectorNameInternal(RuleSet ruleSet)
        {
            var currentSelectorName = base.GetSelectorName(ruleSet).Trim();
            var currentSet = ruleSet;
            var currentBlock = ruleSet.Parent as LessRuleBlock;

            while (currentSet != null && currentBlock != null)
            {
                currentSet = currentBlock.Parent as RuleSet;

                if (currentSet != null)
                {
                    currentSelectorName = base.GetSelectorName(currentSet).Trim() + " " + currentSelectorName;
                    currentBlock = currentSet.Parent as LessRuleBlock;
                }
            }

            var name = currentSelectorName.Replace(" &", "");
            var oldName = name;

            while (oldName != (name = name.Replace(" >", ">").Replace("> ", ">")))
            {
                oldName = name;
            }

            return oldName.Replace(">", " > ");
        }

        public static IEnumerable<string> GetSelectorNames(RuleSet ruleSet, LessMixinAction mixinAction)
        {
            if (ruleSet.Selectors.Any(s => s.SimpleSelectors.Any(ss => ss.SubSelectors.Any(sss => sss is LessMixinDeclaration))))
            {
                switch (mixinAction)
                {
                    case LessMixinAction.Skip:
                        return Enumerable.Empty<string>();
                    case LessMixinAction.Literal:
                        break;
                    case LessMixinAction.NestedOnly:
                        var mixinDecl = ruleSet.Selectors.SelectMany(s => s.SimpleSelectors.SelectMany(ss => ss.SubSelectors.OfType<LessMixinDeclaration>())).First();
                        return Enumerable.Repeat("«mixin " + mixinDecl.MixinName.Name + "»", 1);
                }
            }

            var parentBlock = ruleSet.FindType<LessRuleBlock>();

            if (parentBlock == null)
                return ruleSet.Selectors.Select(CssExtensions.SelectorText);

            var parentSet = parentBlock.FindType<RuleSet>();

            if (parentSet == null)
                return ruleSet.Selectors.Select(CssExtensions.SelectorText);

            // Cache the computed parents to avoid re-computing them
            // for every child permutation.
            var parentSelectors = GetSelectorNames(parentSet, mixinAction).ToList();

            return ruleSet.Selectors.SelectMany(child =>
                CombineSelectors(parentSelectors, child.SelectorText())
            );
        }

        private string FindRuleSetInFile(IEnumerable<string> extensions, string className, out RuleSet rule)
        {
            string root = ProjectHelpers.GetProjectFolder(peekableItem._textbuffer.GetFileName());
            string result = null;
            bool isLow = false, isMedium = false;
            rule = null;

            foreach (string ext in extensions)
            {
                ICssParser parser = CssParserLocator.FindComponent(Mef.GetContentType(ext.Trim('.'))).CreateParser();

                foreach (string file in Directory.EnumerateFiles(root, "*" + ext, SearchOption.AllDirectories))
                {
                    if (file.EndsWith(".min" + ext, StringComparison.OrdinalIgnoreCase) ||
                        file.Contains("node_modules") ||
                        file.Contains("bower_components"))
                        continue;

                    string text = FileHelpers.ReadAllTextRetry(file).ConfigureAwait(false).GetAwaiter().GetResult();
                    int index = text.IndexOf("." + className, StringComparison.Ordinal);

                    if (index == -1)
                        continue;

                    var css = parser.Parse(text, true);
                    var visitor = new CssItemCollector<ClassSelector>(false);
                    css.Accept(visitor);

                    var selectors = visitor.Items.Where(c => c.ClassName.Text == className);
                    var high = selectors.FirstOrDefault(c => c.FindType<AtDirective>() == null && (c.Parent.NextSibling == null || c.Parent.NextSibling.Text == ","));

                    if (high != null)
                    {
                        rule = high.FindType<RuleSet>();
                        return file;
                    }

                    var medium = selectors.FirstOrDefault(c => c.Parent.NextSibling == null || c.Parent.NextSibling.Text == ",");

                    if (medium != null && !isMedium)
                    {
                        rule = medium.FindType<RuleSet>();
                        result = file;
                        isMedium = true;
                        continue;
                    }

                    var low = selectors.FirstOrDefault();

                    if (low != null && !isLow && !isMedium)
                    {
                        rule = low.FindType<RuleSet>();
                        result = file;
                        isLow = true;
                    }
                }
            }

            return result;
        }

        public RuleSetDialog(Activity activity, RuleSet ruleSet)
        {
            if (activity == null)
                throw (new ArgumentNullException("activity"));

            InitializeDialog(ruleSet);

            ITypeProvider typeProvider;
            this.serviceProvider = activity.Site;
            if (this.serviceProvider != null)
            {
                typeProvider = (ITypeProvider)this.serviceProvider.GetService(typeof(ITypeProvider));
                if (typeProvider == null)
                {
                    string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ITypeProvider).FullName);
                    throw new InvalidOperationException(message);
                }

                WorkflowDesignerLoader loader = this.serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
                if (loader != null)
                    loader.Flush();

            }
            else
            {
                // no service provider, so make a TypeProvider that has all loaded Assemblies
                TypeProvider newProvider = new TypeProvider(null);
                foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
                    newProvider.AddAssembly(a);
                typeProvider = newProvider;
            }

            RuleValidation validation = new RuleValidation(activity, typeProvider, false);
            this.ruleParser = new Parser(validation);
        }

        public static IEnumerable<string> GetSelectorNames(RuleSet ruleSet, ScssMixinAction mixinAction)
        {
            if (ruleSet.Block.Directives.Any(d => d is ScssMixinDirective))
            {
                switch (mixinAction)
                {
                    case ScssMixinAction.Skip:
                        return Enumerable.Empty<string>();
                    case ScssMixinAction.Literal:
                        break;
                }
            }

            var parentBlock = ruleSet.FindType<ScssRuleBlock>();

            if (parentBlock == null)
                return ruleSet.Selectors.Select(CssExtensions.SelectorText);

            var parentSet = parentBlock.FindType<RuleSet>();

            if (parentSet == null)
                return ruleSet.Selectors.Select(CssExtensions.SelectorText);

            // Cache the computed parents to avoid re-computing them
            // for every child permutation.
            var parentSelectors = GetSelectorNames(parentSet, mixinAction).ToList();

            return ruleSet.Selectors.SelectMany(child =>
                CombineSelectors(parentSelectors, child.SelectorText())
            );
        }

        internal static string GetScssSelectorName(RuleSet ruleSet, bool includeShellSelectors = true)
        {
            if (!includeShellSelectors)
            {
                var block = ruleSet.Block as ScssRuleBlock;

                if (block == null || ruleSet.Block.Declarations.Count == 0 && ruleSet.Block.Directives.Count == 0 && block.RuleSets.Any())
                {
                    //If we got here, the element won't be included in the output but has children that might be
                    return null;
                }
            }

            string name = string.Join(",\r\n", GetSelectorNames(ruleSet, ScssMixinAction.Skip));

            if (name.Length == 0)
                return null;

            var oldName = name;

            while (oldName != (name = name.Replace(" >", ">").Replace("> ", ">")))
            {
                oldName = name;
            }

            return oldName.Replace(">", " > ");
        }

        private CssRule(string sourceFile, string fileText, RuleSet ruleSet, string selectorName)
        {
            SelectorName = selectorName;
            CleansedSelectorName = RuleRegistry.StandardizeSelector(SelectorName);
            DisplaySelectorName = SelectorName.Replace('\r', '\n').Replace("\n", "").Trim();

            string oldDisplaySelectorName = null;

            while (DisplaySelectorName != oldDisplaySelectorName)
            {
                oldDisplaySelectorName = DisplaySelectorName;
                DisplaySelectorName = DisplaySelectorName.Replace("  ", " ");
            }

            File = sourceFile;

            int line, column;

            CalculateLineAndColumn(fileText, ruleSet, out line, out column);
            Line = line;
            Column = column;
            Offset = ruleSet.Range.Start;
            Length = ruleSet.Range.Length;

            var lastSelector = ruleSet.Selectors[ruleSet.Selectors.Count - 1];

            SelectorLength = lastSelector.Length + lastSelector.Start - ruleSet.Selectors[0].Start;
            _ruleSet = ruleSet;
        }

        public string Fire(Unit target)
        {
            string result = string.Empty;

            RuleSet idealHitRules = new RuleSet();
            idealHitRules.Add(new UnderMaximumIdealRangeRule(this, target));
            idealHitRules.Add(new OverMinimumIdealRangeRule(this, target));

            RuleSet regularHitRules = new RuleSet();
            regularHitRules.Add(new UnderMaximumRangeRule(this, target));
            regularHitRules.Add(new OverMinimumRangeRule(this, target));

            //Fire!
            if (idealHitRules.Validate())
            {
                result = "Ideal hit!";
            }
            else if (regularHitRules.Validate())
            {
                result = "Hit.";
            }
            else
            {
                result = regularHitRules.FailureMessages[0];
            }

            return result;
        }

        public void Verifies_SimpleTrueRules()
        {
            var propertiesForObject = new Dictionary<object, object> { { "phrase_count", 2 }, { "length", 10 } };

            var ruleSet = new RuleSet(new Rule[] { new GreaterThan("phrase_count", 1), new LessThan("length", 15) });

            Assert.That(ruleSet.VerifiedBy(propertiesForObject), Is.True);
        }

        public void Verifies_SimpleFalseRule()
        {
            var propertiesForObject = new Dictionary<object, object> { { "phrase_count", 1 } };

            var ruleSet = new RuleSet (new[]{new GreaterThan("phrase_count", 3)});

            Assert.That(ruleSet.VerifiedBy(propertiesForObject), Is.False);
        }

        public void EmptyRuleSet_AlwaysTrue()
        {
            var ruleSet = new RuleSet(new Rule[0]);

            var propertiesForObject = new Dictionary<object, object> { { "phrase_count", 2 }, { "length", 10 } };

            Assert.That(ruleSet.VerifiedBy(propertiesForObject));
        }

        public void CanUsePrintCommand()
        {
            var rs = new RuleSet();
            var c = Setup( rs, new[] { ">fire", ">water", "energy", "?fire" } );
            c.Cook();

            Assert.AreEqual( 3, rs.FoundElements.Length );
        }

		public void TestFirstReturnsDefaultResultWhereNoConditionIsMet()
		{
			var ruleSet = new RuleSet<object,object,string>("default");

			ruleSet.When(equal).Then("equal");

			Assert.That(ruleSet.First("foo", "bar"), Is.EqualTo("default"));
		}

		public void TestPassingGenericTypeToWhenInsteadOfFunc()
		{
			var ruleSet = new RuleSet<int, string>();

			ruleSet.When(1).Then("one");

			Assert.That(ruleSet.First(1), Is.EqualTo("one"));
		}

        public void Equality_True()
        {
            var ruleSet = new RuleSet(new[] { new EqualTo("ciao", 1) });

            var propertiesForObject = new Dictionary<object, object> { { "ciao", 1 }, { "length", 10 } };

            Assert.That(ruleSet.VerifiedBy(propertiesForObject), Is.True);
        }

        public void AlchemyControllerRecommendsNullIfNoElements()
        {
            var rs = new RuleSet();
            var controller = new AlchemyController( rs );

            var rule = controller.RecommendNewRule();

            Assert.IsNull( rule );
        }

		public void TestFirstReturnsFirstResultWhereTheConditionIsMet()
		{
			var ruleSet = new RuleSet<object,object,string>();

			ruleSet.When(equal).Then("equal");
			ruleSet.When(equal).Then("definitely equal");

			Assert.That(ruleSet.First("foo", "foo"), Is.EqualTo("equal"));
		}

        public void AssertRuleSetsAreEqual(string ruleSetPath, RuleSet expectedRuleSet)
        {
            this.AssertRuleSetExists(ruleSetPath);

            RuleSet actualRuleSet = this.savedRuleSets[ruleSetPath];

            Assert.IsNotNull(actualRuleSet, "Expected rule set to be written");
            RuleSetAssert.AreEqual(expectedRuleSet, actualRuleSet);
        }

 public static RuleSet CreateTestRuleSetWithRuleIds(IEnumerable<string> ids, string analyzerId = "TestId", string ruleNamespace = "TestNamespace", RuleSet existingRuleSet = null)
 {
     var ruleSet = existingRuleSet ?? new RuleSet("Test Rule Set");
     foreach (var id in ids)
     {
         ruleSet.Rules.Add(new RuleReference(analyzerId, ruleNamespace, id, RuleAction.Warning));
     }
     return ruleSet;
 }