ui/accessibility/platform/inspect/ax_property_node.cc - chromium/src - Git at Google

 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ui/accessibility/platform/inspect/ax_property_node.h"

 #include <optional>

 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "ui/accessibility/platform/inspect/ax_inspect.h"

 namespace ui {

 // static
 AXPropertyNode AXPropertyNode::From(
     const std::string& property,
     const std::vector<std::string>& line_indexes) {
   std::string::const_iterator lvalue_end(property.end()),
       rvalue_begin(property.end());

   // Find rvalue start if any. For example, in a statement
   // textarea.AXSelectedTextMarkerRange = textarea_range, textarea_range will be
   // rvalue. Do not confuse it with variable assignment ':=', for example,
   // textarea_range:= textarea.AXTextMarkerRangeForUIElement(textarea) which is
   // stored as a labelled lvalue.
   size_t index = property.find_last_of('=');
   if (index > 0 && index != std::string::npos) {
     if (property[index - 1] != ':') {
       lvalue_end = property.begin() + index - 1;
       index = property.find_first_not_of("= ", index);
       rvalue_begin = index == std::string::npos ? property.end()
                                                 : property.begin() + index;
     }
   }

   // lvalue
   AXPropertyNode lvalue_root;
   Parse(&lvalue_root, property.begin(), lvalue_end);
   if (lvalue_root.arguments.size() == 0)  // Empty AXPropertyNode.
     return lvalue_root;

   AXPropertyNode* lvalue = &lvalue_root.arguments[0];
   lvalue->original_property = std::string(property.begin(), lvalue_end);
   lvalue->line_indexes = line_indexes;

   // rvalue if any
   if (lvalue_end != property.end()) {
     AXPropertyNode rvalue_root;
     Parse(&rvalue_root, rvalue_begin, property.end());

     // Connect rvalue to the latest lvalue in a chain.
     AXPropertyNode* last_in_chain = lvalue;
     for (; last_in_chain->next; last_in_chain = last_in_chain->next.get())
       ;

     // Use {std::make_unique_for_overwrite} once we allow C++20.
     last_in_chain->rvalue = std::unique_ptr<AXPropertyNode>(new AXPropertyNode);
     *(last_in_chain->rvalue) = std::move(rvalue_root.arguments[0]);
   }

   return std::move(*lvalue);
 }

 // static
 AXPropertyNode AXPropertyNode::From(const AXPropertyFilter& filter) {
   // Expel an optional trailing wildcard which is used in tree formatter output
   // filtering.
   std::string property =
       filter.property_str.substr(0, filter.property_str.find_last_of('*'));

   // Line indexes filter: filter_str expected format is
   // :line_num_1, ... :line_num_N, a comma separated list of line indexes
   // the property should be queried for. For example, ":1,:5,:7" indicates that
   // the property should called for objects placed on 1, 5 and 7 lines only.
   return From(property, base::SplitString(
                             filter.filter_str, std::string(1, ','),
                             base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY));
 }

 AXPropertyNode::AXPropertyNode() = default;
 AXPropertyNode::AXPropertyNode(AXPropertyNode&& o) = default;
 AXPropertyNode::~AXPropertyNode() = default;
 AXPropertyNode& AXPropertyNode::operator=(AXPropertyNode&& o) = default;

 AXPropertyNode::operator bool() const {
   return !name_or_value.empty();
 }

 bool AXPropertyNode::IsMatching(const std::string& pattern) const {
   // Looking for exact property match. Expel a trailing whildcard from
   // the property filter to handle filters like AXRole*.
   return name_or_value.compare(0, name_or_value.find_last_of('*'), pattern) ==
          0;
 }

 bool AXPropertyNode::IsArray() const {
   return name_or_value == "[]";
 }

 bool AXPropertyNode::IsDict() const {
   return name_or_value == "{}";
 }

 std::optional<int> AXPropertyNode::AsInt() const {
   int value = 0;
   if (!base::StringToInt(name_or_value, &value)) {
     return std::nullopt;
   }
   return value;
 }

 std::string AXPropertyNode::AsString() const {
   if (name_or_value.size() > 1 && name_or_value[0] == '\'' &&
       name_or_value[name_or_value.size() - 1] == '\'') {
     return name_or_value.substr(1, name_or_value.size() - 2);
   }
   return name_or_value;
 }

 const AXPropertyNode* AXPropertyNode::FindKey(const char* refkey) const {
   for (const auto& param : arguments) {
     if (param.key == refkey) {
       return &param;
     }
   }
   return nullptr;
 }

 std::optional<std::string> AXPropertyNode::FindStringKey(
     const char* refkey) const {
   for (const auto& param : arguments) {
     if (param.key == refkey) {
       return param.name_or_value;
     }
   }
   return std::nullopt;
 }

 std::optional<int> AXPropertyNode::FindIntKey(const char* refkey) const {
   for (const auto& param : arguments) {
     if (param.key == refkey) {
       return param.AsInt();
     }
   }
   return std::nullopt;
 }

 std::string AXPropertyNode::ToString() const {
   if (key.empty())
     return original_property;
   return key;
 }

 std::string AXPropertyNode::ToFlatString() const {
   std::string out;
   for (const auto& index : line_indexes) {
     if (!out.empty()) {
       out += ',';
     }
     out += index;
   }
   if (!out.empty()) {
     out += ';';
   }

   // Format a dictionary key or a variable.
   if (!key.empty()) {
     out += key + ": ";
   }

   out += name_or_value;
   if (arguments.size()) {
     out += '(';
     for (size_t i = 0; i < arguments.size(); i++) {
       if (i != 0) {
         out += ", ";
       }
       out += arguments[i].ToFlatString();
     }
     out += ')';
   }

   // Chains.
   if (next) {
     out += "." + next->ToFlatString();
   }

   // Rvalue.
   if (rvalue) {
     out += "=" + rvalue->ToFlatString();
   }

   return out;
 }

 std::string AXPropertyNode::ToTreeString(const std::string& indent) const {
   std::string out = indent;
   if (!key.empty()) {  // Key.
     out += key + ':';
   }
   out += name_or_value;    // Name or value.
   if (arguments.size()) {  // Arguments.
     out += "(\n";
     for (size_t i = 0; i < arguments.size(); i++) {
       if (i != 0) {
         out += ",\n";
       }
       out += arguments[i].ToTreeString(indent + "  ");
     }
     out += '\n' + indent + ')';
   }
   if (next) {  // Chains.
     out += ".\n" + next->ToTreeString(indent);
   }
   if (rvalue) {  // Rvalue.
     out += "=\n" + rvalue->ToTreeString(indent);
   }
   return out;
 }

 // private
 AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator key_begin,
                                AXPropertyNode::iterator key_end,
                                const std::string& name_or_value)
     : key(key_begin, key_end), name_or_value(name_or_value) {}
 AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator begin,
                                AXPropertyNode::iterator end)
     : name_or_value(begin, end) {}
 AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator key_begin,
                                AXPropertyNode::iterator key_end,
                                AXPropertyNode::iterator value_begin,
                                AXPropertyNode::iterator value_end)
     : key(key_begin, key_end), name_or_value(value_begin, value_end) {
 }

 // private static
 AXPropertyNode::iterator AXPropertyNode::Parse(AXPropertyNode* node,
                                                AXPropertyNode::iterator begin,
                                                AXPropertyNode::iterator end) {
   auto iter = begin;
   auto key_begin = end, key_end = end, maybe_key_end = end;
   ParseState state = kArgument;
   while (iter != end) {
     // Subnode begins: create a new node, record its name and parse its
     // arguments.
     if (*iter == '(') {
       AXPropertyNode* child_node =
           node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);

       key_begin = key_end = end;
       begin = iter = Parse(child_node, ++iter, end);
       continue;
     }

     // Subnode begins: a special case for arrays, which have [arg1, ..., argN]
     // form.
     if (*iter == '[') {
       // If a node ends by an array operator[], then chain them, for example,
       // AXChildren[0].
       if (begin != iter) {
         node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
         key_begin = key_end = end;
         state = kChain;
       }
       AXPropertyNode* child_node =
           node->ConnectTo(state & kChain, key_begin, key_end, "[]");
       key_begin = key_end = end;
       begin = iter = Parse(child_node, ++iter, end);
       continue;
     }

     // Subnode begins: a special case for dictionaries of {key1: value1, ...,
     // key2: value2} form.
     if (*iter == '{') {
       AXPropertyNode* child_node =
           node->AppendToArguments(key_begin, key_end, "{}");
       key_begin = key_end = end;
       begin = iter = Parse(child_node, ++iter, end);
       continue;
     }

     // Subnode ends.
     if (*iter == ')' || *iter == ']' || *iter == '}') {
       if (begin != iter) {
         node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
         key_begin = key_end = end;
       }
       state = kChain;
       return ++iter;
     }

     // Possible dictionary key or variable assignment end.
     if (*iter == ':') {
       maybe_key_end = iter++;
       continue;
     }

     // Possible variable assignment, move next.
     if (*iter == '=') {
       iter++;
       continue;
     }

     // Dictionary key or variable. If so, get a key and adjust a new node start.
     if (*iter == ' ') {
       if (maybe_key_end != end) {
         key_begin = begin;
         key_end = maybe_key_end;
         maybe_key_end = end;
       }
       begin = ++iter;
       continue;
     }

     // Not a dictionary key or a variable.
     maybe_key_end = end;

     // Call chains.
     if (*iter == '.') {
       if (begin != iter) {
         node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
         key_begin = key_end = end;
       }
       begin = ++iter;
       state = kChain;
       continue;
     }

     // Subsequent literal case.
     if (*iter == ',') {
       if (begin != iter) {
         node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
         key_begin = key_end = end;
       }
       state = kArgument;
       begin = ++iter;
       continue;
     }

     iter++;
   }

   // Single scalar param case.
   if (begin != iter) {
     node->ConnectTo(state & kChain, begin, iter);
   }
   return iter;
 }

 }  // namespace ui
	// Copyright 2019 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ui/accessibility/platform/inspect/ax_property_node.h"

	#include <optional>

	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_split.h"
	#include "ui/accessibility/platform/inspect/ax_inspect.h"

	namespace ui {

	// static
	AXPropertyNode AXPropertyNode::From(
	const std::string& property,
	const std::vector<std::string>& line_indexes) {
	std::string::const_iterator lvalue_end(property.end()),
	rvalue_begin(property.end());

	// Find rvalue start if any. For example, in a statement
	// textarea.AXSelectedTextMarkerRange = textarea_range, textarea_range will be
	// rvalue. Do not confuse it with variable assignment ':=', for example,
	// textarea_range:= textarea.AXTextMarkerRangeForUIElement(textarea) which is
	// stored as a labelled lvalue.
	size_t index = property.find_last_of('=');
	if (index > 0 && index != std::string::npos) {
	if (property[index - 1] != ':') {
	lvalue_end = property.begin() + index - 1;
	index = property.find_first_not_of("= ", index);
	rvalue_begin = index == std::string::npos ? property.end()
	: property.begin() + index;
	}
	}

	// lvalue
	AXPropertyNode lvalue_root;
	Parse(&lvalue_root, property.begin(), lvalue_end);
	if (lvalue_root.arguments.size() == 0) // Empty AXPropertyNode.
	return lvalue_root;

	AXPropertyNode* lvalue = &lvalue_root.arguments[0];
	lvalue->original_property = std::string(property.begin(), lvalue_end);
	lvalue->line_indexes = line_indexes;

	// rvalue if any
	if (lvalue_end != property.end()) {
	AXPropertyNode rvalue_root;
	Parse(&rvalue_root, rvalue_begin, property.end());

	// Connect rvalue to the latest lvalue in a chain.
	AXPropertyNode* last_in_chain = lvalue;
	for (; last_in_chain->next; last_in_chain = last_in_chain->next.get())
	;

	// Use {std::make_unique_for_overwrite} once we allow C++20.
	last_in_chain->rvalue = std::unique_ptr<AXPropertyNode>(new AXPropertyNode);
	*(last_in_chain->rvalue) = std::move(rvalue_root.arguments[0]);
	}

	return std::move(*lvalue);
	}

	// static
	AXPropertyNode AXPropertyNode::From(const AXPropertyFilter& filter) {
	// Expel an optional trailing wildcard which is used in tree formatter output
	// filtering.
	std::string property =
	filter.property_str.substr(0, filter.property_str.find_last_of('*'));

	// Line indexes filter: filter_str expected format is
	// :line_num_1, ... :line_num_N, a comma separated list of line indexes
	// the property should be queried for. For example, ":1,:5,:7" indicates that
	// the property should called for objects placed on 1, 5 and 7 lines only.
	return From(property, base::SplitString(
	filter.filter_str, std::string(1, ','),
	base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY));
	}

	AXPropertyNode::AXPropertyNode() = default;
	AXPropertyNode::AXPropertyNode(AXPropertyNode&& o) = default;
	AXPropertyNode::~AXPropertyNode() = default;
	AXPropertyNode& AXPropertyNode::operator=(AXPropertyNode&& o) = default;

	AXPropertyNode::operator bool() const {
	return !name_or_value.empty();
	}

	bool AXPropertyNode::IsMatching(const std::string& pattern) const {
	// Looking for exact property match. Expel a trailing whildcard from
	// the property filter to handle filters like AXRole*.
	return name_or_value.compare(0, name_or_value.find_last_of('*'), pattern) ==
	0;
	}

	bool AXPropertyNode::IsArray() const {
	return name_or_value == "[]";
	}

	bool AXPropertyNode::IsDict() const {
	return name_or_value == "{}";
	}

	std::optional<int> AXPropertyNode::AsInt() const {
	int value = 0;
	if (!base::StringToInt(name_or_value, &value)) {
	return std::nullopt;
	}
	return value;
	}

	std::string AXPropertyNode::AsString() const {
	if (name_or_value.size() > 1 && name_or_value[0] == '\'' &&
	name_or_value[name_or_value.size() - 1] == '\'') {
	return name_or_value.substr(1, name_or_value.size() - 2);
	}
	return name_or_value;
	}

	const AXPropertyNode* AXPropertyNode::FindKey(const char* refkey) const {
	for (const auto& param : arguments) {
	if (param.key == refkey) {
	return &param;
	}
	}
	return nullptr;
	}

	std::optional<std::string> AXPropertyNode::FindStringKey(
	const char* refkey) const {
	for (const auto& param : arguments) {
	if (param.key == refkey) {
	return param.name_or_value;
	}
	}
	return std::nullopt;
	}

	std::optional<int> AXPropertyNode::FindIntKey(const char* refkey) const {
	for (const auto& param : arguments) {
	if (param.key == refkey) {
	return param.AsInt();
	}
	}
	return std::nullopt;
	}

	std::string AXPropertyNode::ToString() const {
	if (key.empty())
	return original_property;
	return key;
	}

	std::string AXPropertyNode::ToFlatString() const {
	std::string out;
	for (const auto& index : line_indexes) {
	if (!out.empty()) {
	out += ',';
	}
	out += index;
	}
	if (!out.empty()) {
	out += ';';
	}

	// Format a dictionary key or a variable.
	if (!key.empty()) {
	out += key + ": ";
	}

	out += name_or_value;
	if (arguments.size()) {
	out += '(';
	for (size_t i = 0; i < arguments.size(); i++) {
	if (i != 0) {
	out += ", ";
	}
	out += arguments[i].ToFlatString();
	}
	out += ')';
	}

	// Chains.
	if (next) {
	out += "." + next->ToFlatString();
	}

	// Rvalue.
	if (rvalue) {
	out += "=" + rvalue->ToFlatString();
	}

	return out;
	}

	std::string AXPropertyNode::ToTreeString(const std::string& indent) const {
	std::string out = indent;
	if (!key.empty()) { // Key.
	out += key + ':';
	}
	out += name_or_value; // Name or value.
	if (arguments.size()) { // Arguments.
	out += "(\n";
	for (size_t i = 0; i < arguments.size(); i++) {
	if (i != 0) {
	out += ",\n";
	}
	out += arguments[i].ToTreeString(indent + " ");
	}
	out += '\n' + indent + ')';
	}
	if (next) { // Chains.
	out += ".\n" + next->ToTreeString(indent);
	}
	if (rvalue) { // Rvalue.
	out += "=\n" + rvalue->ToTreeString(indent);
	}
	return out;
	}

	// private
	AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator key_begin,
	AXPropertyNode::iterator key_end,
	const std::string& name_or_value)
	: key(key_begin, key_end), name_or_value(name_or_value) {}
	AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator begin,
	AXPropertyNode::iterator end)
	: name_or_value(begin, end) {}
	AXPropertyNode::AXPropertyNode(AXPropertyNode::iterator key_begin,
	AXPropertyNode::iterator key_end,
	AXPropertyNode::iterator value_begin,
	AXPropertyNode::iterator value_end)
	: key(key_begin, key_end), name_or_value(value_begin, value_end) {
	}

	// private static
	AXPropertyNode::iterator AXPropertyNode::Parse(AXPropertyNode* node,
	AXPropertyNode::iterator begin,
	AXPropertyNode::iterator end) {
	auto iter = begin;
	auto key_begin = end, key_end = end, maybe_key_end = end;
	ParseState state = kArgument;
	while (iter != end) {
	// Subnode begins: create a new node, record its name and parse its
	// arguments.
	if (*iter == '(') {
	AXPropertyNode* child_node =
	node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);

	key_begin = key_end = end;
	begin = iter = Parse(child_node, ++iter, end);
	continue;
	}

	// Subnode begins: a special case for arrays, which have [arg1, ..., argN]
	// form.
	if (*iter == '[') {
	// If a node ends by an array operator[], then chain them, for example,
	// AXChildren[0].
	if (begin != iter) {
	node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
	key_begin = key_end = end;
	state = kChain;
	}
	AXPropertyNode* child_node =
	node->ConnectTo(state & kChain, key_begin, key_end, "[]");
	key_begin = key_end = end;
	begin = iter = Parse(child_node, ++iter, end);
	continue;
	}

	// Subnode begins: a special case for dictionaries of {key1: value1, ...,
	// key2: value2} form.
	if (*iter == '{') {
	AXPropertyNode* child_node =
	node->AppendToArguments(key_begin, key_end, "{}");
	key_begin = key_end = end;
	begin = iter = Parse(child_node, ++iter, end);
	continue;
	}

	// Subnode ends.
	if (iter == ')' \|\| iter == ']' \|\| *iter == '}') {
	if (begin != iter) {
	node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
	key_begin = key_end = end;
	}
	state = kChain;
	return ++iter;
	}

	// Possible dictionary key or variable assignment end.
	if (*iter == ':') {
	maybe_key_end = iter++;
	continue;
	}

	// Possible variable assignment, move next.
	if (*iter == '=') {
	iter++;
	continue;
	}

	// Dictionary key or variable. If so, get a key and adjust a new node start.
	if (*iter == ' ') {
	if (maybe_key_end != end) {
	key_begin = begin;
	key_end = maybe_key_end;
	maybe_key_end = end;
	}
	begin = ++iter;
	continue;
	}

	// Not a dictionary key or a variable.
	maybe_key_end = end;

	// Call chains.
	if (*iter == '.') {
	if (begin != iter) {
	node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
	key_begin = key_end = end;
	}
	begin = ++iter;
	state = kChain;
	continue;
	}

	// Subsequent literal case.
	if (*iter == ',') {
	if (begin != iter) {
	node->ConnectTo(state & kChain, key_begin, key_end, begin, iter);
	key_begin = key_end = end;
	}
	state = kArgument;
	begin = ++iter;
	continue;
	}

	iter++;
	}

	// Single scalar param case.
	if (begin != iter) {
	node->ConnectTo(state & kChain, begin, iter);
	}
	return iter;
	}

	} // namespace ui