public static bool IsFunctionAvailable(string localName, string nsUri)
{
if (XPathBuilder.IsFunctionAvailable(localName, nsUri))
{
return(true);
}
if (nsUri.Length == 0)
{
return(FunctionTable.ContainsKey(localName) && localName != "unparsed-entity-uri");
}
if (nsUri == XmlReservedNs.NsMsxsl)
{
return(
localName == "node-set" ||
localName == "format-date" ||
localName == "format-time" ||
localName == "local-name" ||
localName == "namespace-uri" ||
localName == "number" ||
localName == "string-compare" ||
localName == "utc"
);
}
if (nsUri == XmlReservedNs.NsExsltCommon)
{
return(localName == "node-set" || localName == "object-type");
}
return(false);
}
public void HelloWorldTest_CyclesThroughWholeProgram()
{
new HeavyTestRunner(_logger).RunServerAndBrowserAndExecute(
MagicsForTests.ClientSideFlows.HelloWorld, (assertX, server, browser) => {
assertX.DialogIsVisibleInBrowser("Hello there");
browser
.FindElementByXPath(XPathBuilder.Dialog("Hello there").InBody("/input[@type='text']"))
.SendKeys(someName);
assertX.NoServiceCallsMadeOnServer();
browser
.FindElementByXPath(XPathBuilder.Dialog("Hello there").HasEnabledButtonAction("OK"))
.Click();
assertX.DialogIsVisibleInBrowser("Server reply");
assertX.InvocationsMadeOnServerAre(x => x.ResType == ResourceType.RegularPostService, () => {
var onBefore = FilterInvocation.OfMethod((IHelloWorldService x) => x.SayHello(someName));
var actualCall = ServiceCall.OfMethod((IHelloWorldService x) => x.SayHello(someName));
var onAfter = FilterInvocation.ExpectOnConnectionAfterFor(onBefore);
return(new CsChoice <ServiceCall, FilterInvocation>[] { onBefore, actualCall, onAfter });
});
assertX.MatchesXPathInBrowser(
XPathBuilder
.Dialog("Server reply")
.HasReadOnlyLabel($"Hello {someName}. How are you?"));
});
}
public Scss Concat(Scss scss2)
{
string resultXpath = XPathBuilder.Concat(this.Xpath, scss2.Xpath);
var resultCss = string.IsNullOrEmpty(this.Css) || string.IsNullOrEmpty(scss2.Css)
? string.Empty
: CssBuilder.Concat(this.Css, scss2.Css);
return(new Scss(resultXpath, resultCss));
}
public XPathPatternBuilder(IXPathEnvironment environment) {
Debug.Assert(environment != null);
this.environment = environment;
this.f = environment.Factory;
this.predicateEnvironment = new XPathPredicateEnvironment(environment);
this.predicateBuilder = new XPathBuilder(predicateEnvironment);
this.fixupNode = f.Unknown(T.NodeNotRtfS);
}
public XPathPatternBuilder(IXPathEnvironment environment)
{
Debug.Assert(environment != null);
_environment = environment;
_f = environment.Factory;
_predicateEnvironment = new XPathPredicateEnvironment(environment);
_predicateBuilder = new XPathBuilder(_predicateEnvironment);
_fixupNode = _f.Unknown(T.NodeNotRtfS);
}
//The structure of result is a Filter, variable is current node, body is the match condition.
//Previous predicate build logic in XPathPatternBuilder is match from right to left, which have 2^n complexiy when have lots of position predicates. TFS #368771
//Now change the logic to: If predicates contains position/last predicates, given the current node, filter out all the nodes that match the predicates,
//and then check if current node is in the result set.
public QilNode BuildPredicates(QilNode nodeset, List <QilNode> predicates)
{
//convert predicates to boolean type
List <QilNode> convertedPredicates = new List <QilNode>(predicates.Count);
foreach (var predicate in predicates)
{
convertedPredicates.Add(XPathBuilder.PredicateToBoolean(predicate, _f, _predicateEnvironment));
}
QilLoop nodeFilter = (QilLoop)nodeset;
QilIterator current = nodeFilter.Variable;
//If no last() and position() in predicates, use nodeFilter.Variable to fixup current
//because all the predicates only based on the input variable, no matter what other predicates are.
if (_predicateEnvironment.numFixupLast == 0 && _predicateEnvironment.numFixupPosition == 0)
{
foreach (var predicate in convertedPredicates)
{
nodeFilter.Body = _f.And(nodeFilter.Body, predicate);
}
nodeFilter.Body = _predicateEnvironment.fixupVisitor.Fixup(nodeFilter.Body, current, null);
}
//If any preidcate contains last() or position() node, then the current node is based on previous predicates,
//for instance, a[...][2] is match second node after filter 'a[...]' instead of second 'a'.
else
{
//filter out the siblings
QilIterator parentIter = _f.For(_f.Parent(current));
QilNode sibling = _f.Content(parentIter);
//generate filter based on input filter
QilLoop siblingFilter = (QilLoop)nodeset.DeepClone(_f.BaseFactory);
siblingFilter.Variable.Binding = sibling;
siblingFilter = (QilLoop)_f.Loop(parentIter, siblingFilter);
//build predicates from left to right to get all the matching nodes
QilNode matchingSet = siblingFilter;
foreach (var predicate in convertedPredicates)
{
matchingSet = XPathBuilder.BuildOnePredicate(matchingSet, predicate, /*isReverseStep*/ false,
_f, _predicateEnvironment.fixupVisitor,
ref _predicateEnvironment.numFixupCurrent, ref _predicateEnvironment.numFixupPosition, ref _predicateEnvironment.numFixupLast);
}
//check if the matching nodes contains the current node
QilIterator matchNodeIter = _f.For(matchingSet);
QilNode filterCurrent = _f.Filter(matchNodeIter, _f.Is(matchNodeIter, current));
nodeFilter.Body = _f.Not(_f.IsEmpty(filterCurrent));
//for passing type check, explicit say the result is target type
nodeFilter.Body = _f.And(_f.IsType(current, nodeFilter.XmlType), nodeFilter.Body);
}
SetPriority(nodeset, 0.5);
return(nodeset);
}
public XmlGridView()
{
InitializeComponent();
_xmlGridView.MouseDown += (sender, args) => { _contextMenuAtPos = args.Location; };
_xmlGridView.ContextMenu = new ContextMenu(
new[]
{
new MenuItem("Refresh", (sender, evt) => load()),
new MenuItem("Expand all", (sender, evt) => _xmlGridView.FullExpand()),
new MenuItem("-"),
new MenuItem("Copy", (sender, evt) =>
{
Rectangle rect = new Rectangle();
GridCell cell = _xmlGridView.FindCellByPoint(_contextMenuAtPos, ref rect);
cell.CopyToClipboard();
}),
new MenuItem("Copy XPath", (sender, evt) =>
{
Rectangle rect = new Rectangle();
GridCell cell = _xmlGridView.FindCellByPoint(_contextMenuAtPos, ref rect);
XmlNode node;
if (cell is XmlLabelCell)
{
node = ((XmlLabelCell)cell).Node;
}
else if (cell is XmlValueCell)
{
node = ((XmlValueCell)cell).Node;
}
else if (cell is XmlDeclarationCell)
{
node = ((XmlDeclarationCell)cell).Node;
}
else if (cell is XmlGroupCell)
{
node = ((XmlGroupCell)cell).Node;
}
else
{
MessageBox.Show("Selected cell is not a XML node. Can't copy XPath", "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (node != null)
{
var xpath = XPathBuilder.GetXPathToNode(node);
Clipboard.SetText(xpath);
}
}),
});
}
// public static By CreateBy(string scssSelector, params object[] args)
// {
// scssSelector = string.Format(scssSelector, args);
// return Create(scssSelector).By;
// }
public static Scss Create(string scssSelector)
{
if (string.IsNullOrWhiteSpace(scssSelector))
{
return(null);
}
var combineWithRoot = false;
if (scssSelector.StartsWith(ROOT_PREFIX))
{
combineWithRoot = true;
scssSelector = scssSelector.Remove(0, ROOT_PREFIX.Length).Trim();
}
var xpath = string.Empty;
string css = null;
try
{
var isTrueCss = true;
var parts = SplitIgnoringConditions(scssSelector, true, ',');
foreach (var partScssSelector in parts)
{
bool partScssIsTrueCss;
var xpathPart = ScssPartToXpath(partScssSelector, out partScssIsTrueCss);
xpath += "//" + RemoveDescendantAxis(xpathPart) + "|";
isTrueCss &= partScssIsTrueCss;
}
xpath = xpath.Substring(0, xpath.Length - 1);
if (isTrueCss)
{
css = scssSelector;
}
}
catch (InvalidScssException e)
{
// Это не scss, возможно это xpath
if (XPathBuilder.IsXPath(scssSelector))
{
xpath = scssSelector;
}
else
{
throw new InvalidScssException($"Invalid scss: {scssSelector}.", e);
}
}
return(new Scss(xpath, css, combineWithRoot));
}
public XPathBuilder_GetAttributePart_Tests()
{
_xPathValidator = new XPathValidator();
_xPathValidatorMock = Substitute.For <IXPathValidator>();
_xPathValidatorMock.IsReservedFunctionName(Arg.Any <string>())
.Returns(x => _xPathValidator.IsReservedFunctionName(x.Arg <string>()));
_xPathValidatorMock.When(x => x.ValidateQName(Arg.Any <string>(), Arg.Any <string>()))
.Do(x => _xPathValidator.ValidateQName(x.ArgAt <string>(0), x.ArgAt <string>(1)));
_xPathValidatorMock.When(x => x.ValidateNCName(Arg.Any <string>(), Arg.Any <string>()))
.Do(x => _xPathValidator.ValidateNCName(x.ArgAt <string>(0), x.ArgAt <string>(1)));
_cssValidatorMock = Substitute.For <ICssValidator>();
_builder = new XPathBuilder(_xPathValidatorMock, _cssValidatorMock);
}
private static Scss CreateFromXpath(string scssSelector, bool combineWithRoot)
{
string xpath;
// Это не scss, возможно это xpath
if (XPathBuilder.IsXPath(scssSelector))
{
xpath = scssSelector;
}
else
{
// TODO: what should we do in this case?
throw new InvalidScssException($"Invalid scss: {scssSelector}.");
}
return(new Scss(xpath, null, combineWithRoot));
}
public static Scss Create(string scssSelector)
{
if (string.IsNullOrEmpty(scssSelector))
{
return(new Scss(string.Empty, string.Empty));
}
var xpath = string.Empty;
string css = null;
try
{
var isTrueCss = true;
var parts = SplitIgnoringConditions(scssSelector, true, ',');
foreach (var partScssSelector in parts)
{
bool partScssIsTrueCss;
var xpathPart = ScssPartToXpath(partScssSelector, out partScssIsTrueCss);
xpath += "//" + RemoveDescendantAxis(xpathPart) + "|";
isTrueCss &= partScssIsTrueCss;
}
xpath = xpath.Substring(0, xpath.Length - 1);
if (isTrueCss)
{
css = scssSelector;
}
}
catch (InvalidScssException e)
{
// Это не scss, возможно это xpath
if (XPathBuilder.IsXPath(scssSelector))
{
xpath = scssSelector;
}
else
{
throw e;
}
}
return(new Scss(xpath, css));
}
private static QilLoop BuildAxisFilter(QilPatternFactory f, QilIterator itr, XPathAxis xpathAxis, XPathNodeType nodeType, string name, string nsUri)
{
QilNode nameTest = (
name != null && nsUri != null ? f.Eq(f.NameOf(itr), f.QName(name, nsUri)) : // ns:bar || bar
nsUri != null ? f.Eq(f.NamespaceUriOf(itr), f.String(nsUri)) : // ns:*
name != null ? f.Eq(f.LocalNameOf(itr), f.String(name)) : // *:foo
/*name == nsUri == null*/ f.True() // *
);
XmlNodeKindFlags intersection = XPathBuilder.AxisTypeMask(itr.XmlType.NodeKinds, nodeType, xpathAxis);
QilNode typeTest = (
intersection == 0 ? f.False() : // input & required doesn't intersect
intersection == itr.XmlType.NodeKinds ? f.True() : // input is subset of required
/*else*/ f.IsType(itr, T.NodeChoice(intersection))
);
QilLoop filter = f.BaseFactory.Filter(itr, f.And(typeTest, nameTest));
filter.XmlType = T.PrimeProduct(T.NodeChoice(intersection), filter.XmlType.Cardinality);
return(filter);
}
public void BuilderTest()
{
const string xml = @"
<root>
<foo />
<foo>
<bar attr='value'/>
<bar other='va' />
</foo>
<foo><bar /></foo>
</root>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode node = doc.SelectSingleNode("//@attr");
string xpath = XPathBuilder.GetXPathToNode(node);
Assert.AreEqual("/node()[1]/node()[2]/node()[1]/@attr", xpath);
Console.WriteLine(xpath);
Assert.AreEqual(node, doc.SelectSingleNode(xpath));
}
private QilGenerator(bool debug)
{
_scope = new CompilerScopeManager<QilIterator>();
_outputScope = new OutputScopeManager();
_prefixesInUse = new HybridDictionary();
_f = new XsltQilFactory(new QilFactory(), debug);
_xpathBuilder = new XPathBuilder((IXPathEnvironment)this);
_xpathParser = new XPathParser<QilNode>();
_ptrnBuilder = new XPathPatternBuilder((IXPathEnvironment)this);
_ptrnParser = new XPathPatternParser();
_refReplacer = new ReferenceReplacer(_f.BaseFactory);
_invkGen = new InvokeGenerator(_f, debug);
_matcherBuilder = new MatcherBuilder(_f, _refReplacer, _invkGen);
_singlFocus = new SingletonFocus(_f);
_funcFocus = new FunctionFocus();
_curLoop = new LoopFocus(_f);
_strConcat = new QilStrConcatenator(_f);
_varHelper = new VariableHelper(_f);
_elementOrDocumentType = T.DocumentOrElement;
_textOrAttributeType = T.NodeChoice(XmlNodeKindFlags.Text | XmlNodeKindFlags.Attribute);
_nameCurrent = _f.QName("current", XmlReservedNs.NsXslDebug);
_namePosition = _f.QName("position", XmlReservedNs.NsXslDebug);
_nameLast = _f.QName("last", XmlReservedNs.NsXslDebug);
_nameNamespaces = _f.QName("namespaces", XmlReservedNs.NsXslDebug);
_nameInit = _f.QName("init", XmlReservedNs.NsXslDebug);
_formatterCnt = 0;
}
public XPathBuilder_GetCssClassPart_Tests()
{
_xPathValidator = Substitute.For <IXPathValidator>();
_cssValidator = Substitute.For <ICssValidator>();
_builder = new XPathBuilder(_xPathValidator, _cssValidator);
}
