Skip to content
This repository has been archived by the owner on May 12, 2020. It is now read-only.

Commit

Permalink
linter fixes / cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@pes10k
pes10k committed Feb 25, 2019
1 parent d4a9635 commit 76bdb66
Show file tree
Hide file tree
Showing 13 changed files with 75 additions and 75 deletions.
10 changes: 5 additions & 5 deletions etld/domain.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,14 +9,14 @@

namespace brave_etld {

Domain::Domain(const Domain &domain) :
Domain::Domain(const Domain& domain) :
labels_(domain.labels_) {}

Domain::Domain(const std::vector<Label> &labels) :
Domain::Domain(const std::vector<Label>& labels) :
labels_(labels) {}

Domain::Domain(const std::string &string) {
std::size_t current, previous = 0;
Domain::Domain(const std::string& string) {
size_t current, previous = 0;
current = string.find(".");
if (current == std::string::npos) {
labels_.push_back(string);
Expand All @@ -34,7 +34,7 @@ Domain::Domain(const std::string &string) {
}
}

bool Domain::Equals(const Domain &domain) {
bool Domain::Equals(const Domain& domain) {
const size_t local_length = Length();
if (local_length != domain.Length()) {
return false;
Expand Down
6 changes: 3 additions & 3 deletions etld/domain.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,9 +14,9 @@ namespace brave_etld {

class Domain {
public:
explicit Domain(const Domain &domain);
explicit Domain(const std::string &domain);
explicit Domain(const std::vector<Label> &labels);
explicit Domain(const Domain& domain);
explicit Domain(const std::string& domain);
explicit Domain(const std::vector<Label>& labels);

bool Equals(const Domain &domain);

Expand Down
15 changes: 7 additions & 8 deletions etld/internal/parser.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ namespace internal {
PublicSuffixParseResult::PublicSuffixParseResult() {}

PublicSuffixParseResult::PublicSuffixParseResult(
const PublicSuffixParseResult &results) :
const PublicSuffixParseResult& results) :
num_whitespace_lines_(results.num_whitespace_lines_),
num_comment_lines_(results.num_comment_lines_),
num_invalid_rules_(results.num_invalid_rules_),
Expand All @@ -28,7 +28,7 @@ const std::vector<PublicSuffixRule>& PublicSuffixParseResult::Rules() const {
}

void PublicSuffixParseResult::ConsumeParseResult(
const PublicSuffixTextLineParseResult &result) {
const PublicSuffixTextLineParseResult& result) {
switch (result.type) {
case PublicSuffixTextLineTypeRule:
rules_.push_back(*(result.rule));
Expand All @@ -52,17 +52,17 @@ void PublicSuffixParseResult::ConsumeParseResult(
}
}

PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file) {
std::string line;
PublicSuffixParseResult results;
while (std::getline(rule_file, line)) {
while (std::getline(*rule_file, line)) {
results.ConsumeParseResult(parse_rule_line(line));
}

return results;
}

PublicSuffixParseResult parse_rule_text(const std::string &text) {
PublicSuffixParseResult parse_rule_text(const std::string& text) {
std::istringstream stream(text);
std::string line;
PublicSuffixParseResult results;
Expand All @@ -73,7 +73,7 @@ PublicSuffixParseResult parse_rule_text(const std::string &text) {
return results;
}

PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
PublicSuffixTextLineParseResult parse_rule_line(const std::string& line) {
// Check to see if this is a comment line. If so, process no further.
if (line.find("//") == 0) {
return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeComment);
Expand All @@ -88,8 +88,7 @@ PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
try {
return PublicSuffixTextLineParseResult(
PublicSuffixTextLineTypeRule,
new PublicSuffixRule(line)
);
new PublicSuffixRule(line));
} catch (PublicSuffixRuleInputException error) {
return PublicSuffixTextLineParseResult(PublicSuffixTextLineTypeInvalidRule);
}
Expand Down
12 changes: 6 additions & 6 deletions etld/internal/parser.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,7 @@ enum PublicSuffixTextLineType {
struct PublicSuffixTextLineParseResult {
PublicSuffixTextLineParseResult(
PublicSuffixTextLineType type = PublicSuffixTextLineTypeNone,
const PublicSuffixRule * rule = nullptr) :
const PublicSuffixRule* rule = nullptr) :
type(type),
rule(rule) {}
const PublicSuffixTextLineType type;
Expand All @@ -36,10 +36,10 @@ struct PublicSuffixTextLineParseResult {
class PublicSuffixParseResult {
public:
PublicSuffixParseResult();
PublicSuffixParseResult(const PublicSuffixParseResult &results);
PublicSuffixParseResult(const PublicSuffixParseResult& results);

const std::vector<PublicSuffixRule>& Rules() const;
void ConsumeParseResult(const PublicSuffixTextLineParseResult &result);
void ConsumeParseResult(const PublicSuffixTextLineParseResult& result);

int NumWhitespaceLines() const {
return num_whitespace_lines_;
Expand All @@ -62,9 +62,9 @@ class PublicSuffixParseResult {

// This attempts to implement the algorithm described here:
// https://www.publicsuffix.org/list/
PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
PublicSuffixParseResult parse_rule_file(std::ifstream* rule_file);
PublicSuffixParseResult parse_rule_text(const std::string& rule_text);
PublicSuffixTextLineParseResult parse_rule_line(const std::string& line);

} // namespace internal
} // namespace brave_etld
Expand Down
20 changes: 10 additions & 10 deletions etld/internal/public_suffix_rule.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,9 +16,9 @@
namespace brave_etld {
namespace internal {

const PublicSuffixRule * PublicSuffixRule::root_rule = new PublicSuffixRule("*");
const PublicSuffixRule* PublicSuffixRule::root_rule = new PublicSuffixRule("*");

std::vector<Label> parse_labels(const std::string &label_text) {
std::vector<Label> parse_labels(const std::string& label_text) {
std::vector<Label> labels;
size_t previous = 0;
size_t current = label_text.find(".");
Expand Down Expand Up @@ -61,12 +61,12 @@ std::string trim_to_whitespace(std::string const& str) {

PublicSuffixRule::PublicSuffixRule() {}

PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule &rule) :
PublicSuffixRule::PublicSuffixRule(const PublicSuffixRule& rule) :
labels_(rule.labels_),
is_exception_(rule.IsException()),
is_wildcard_(rule.IsWildcard()) {}

PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
PublicSuffixRule::PublicSuffixRule(const std::string& rule_text) {
std::string trimmed_rule_text(trim_to_whitespace(rule_text));
if (trimmed_rule_text.length() == 0) {
throw PublicSuffixRuleInputException(
Expand Down Expand Up @@ -97,7 +97,7 @@ PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
labels_ = parse_labels(labels_view);
}

PublicSuffixRule::PublicSuffixRule(const std::vector<Label> &labels,
PublicSuffixRule::PublicSuffixRule(const std::vector<Label>& labels,
bool is_exception, bool is_wildcard) :
labels_(labels),
is_exception_(is_exception),
Expand Down Expand Up @@ -129,7 +129,7 @@ SerializationResult PublicSuffixRule::Serialize() const {
};
}

bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
bool PublicSuffixRule::Equals(const PublicSuffixRule& rule) const {
return (
labels_ == rule.labels_ &&
is_exception_ == rule.IsException() &&
Expand All @@ -138,7 +138,7 @@ bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {

// Implements matching algoritms described here
// https://publicsuffix.org/list/
bool PublicSuffixRule::Matches(const Domain &domain) const {
bool PublicSuffixRule::Matches(const Domain& domain) const {
// When the domain and rule are split into corresponding labels, that the
// domain contains as many or more labels than the rule.
const size_t num_rule_labels = labels_.size();
Expand Down Expand Up @@ -166,8 +166,8 @@ bool PublicSuffixRule::Matches(const Domain &domain) const {
return true;
}

DomainInfo PublicSuffixRule::Apply(const Domain &domain) const {
auto domain_len = domain.Length();
DomainInfo PublicSuffixRule::Apply(const Domain& domain) const {
const auto domain_len = domain.Length();
auto rule_len = Length();
if (IsException()) {
rule_len -= 1;
Expand Down Expand Up @@ -249,7 +249,7 @@ std::string PublicSuffixRule::ToString() const {
return as_string.str();
}

PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer) {
PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer) {
const SerializedBufferInfo info = extract_buffer_info(buffer);
const std::string body_str = buffer.substr(info.body_start, info.body_len);
bool is_exception = body_str[0] == 't';
Expand Down
20 changes: 10 additions & 10 deletions etld/internal/public_suffix_rule.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ namespace internal {

class PublicSuffixRuleInputException : public std::exception {
public:
explicit PublicSuffixRuleInputException(const char * message) :
explicit PublicSuffixRuleInputException(const char* message) :
msg_(message) {}
explicit PublicSuffixRuleInputException(const std::string &message) :
msg_(message) {}
Expand All @@ -32,20 +32,20 @@ class PublicSuffixRuleInputException : public std::exception {

class PublicSuffixRule {
public:
static const PublicSuffixRule * root_rule;
static const PublicSuffixRule* root_rule;
PublicSuffixRule();
PublicSuffixRule(const PublicSuffixRule &rule);
explicit PublicSuffixRule(const std::string &rule_text);
PublicSuffixRule(const PublicSuffixRule& rule);
explicit PublicSuffixRule(const std::string& rule_text);
PublicSuffixRule(
const std::vector<Label> &labels,
const std::vector<Label>& labels,
bool is_exception = false,
bool is_wildcard = false);

SerializationResult Serialize() const;

bool Equals(const PublicSuffixRule &rule) const;
bool Matches(const Domain &domain) const;
DomainInfo Apply(const Domain &domain) const;
bool Equals(const PublicSuffixRule& rule) const;
bool Matches(const Domain& domain) const;
DomainInfo Apply(const Domain& domain) const;
std::string ToString() const;
std::string DomainString() const;

Expand All @@ -68,8 +68,8 @@ class PublicSuffixRule {
bool is_wildcard_ = false;
};

PublicSuffixRule rule_from_serialization(const SerializedBuffer &buffer);
std::vector<Label> parse_labels(const std::string &label_text);
PublicSuffixRule rule_from_serialization(const SerializedBuffer& buffer);
std::vector<Label> parse_labels(const std::string& label_text);

} // namespace internal
} // namespace brave_etld
Expand Down
10 changes: 6 additions & 4 deletions etld/internal/public_suffix_rule_set.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -118,7 +118,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
if (label_result != node->children->end()) {
PublicSuffixRuleMapNode* child_node = node->children->at(current_label);
if (child_node->rule != nullptr) {
if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
if (*match == nullptr ||
child_node->rule->Length() > (*match)->Length()) {
*match = child_node->rule;
}
}
Expand All @@ -131,7 +132,8 @@ void PublicSuffixRuleSet::MatchRecursions(const Domain& domain,
if (wildcard_result != node->children->end()) {
PublicSuffixRuleMapNode* child_node = node->children->at("*");
if (child_node->rule != nullptr) {
if (*match == nullptr || child_node->rule->Length() > (*match)->Length()) {
if (*match == nullptr ||
child_node->rule->Length() > (*match)->Length()) {
*match = child_node->rule;
}
}
Expand Down Expand Up @@ -168,12 +170,12 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule& rule,
rules_.push_back(new_rule);
return;
}

AddRule(rule, label_index - 1, child_node);
}

PublicSuffixRuleSet rule_set_from_serialization(
const SerializedBuffer &buffer) {
const SerializedBuffer& buffer) {
std::vector<PublicSuffixRule> rules;
for (auto &elm : deserialize_buffer(buffer)) {
rules.push_back(rule_from_serialization(elm));
Expand Down
23 changes: 11 additions & 12 deletions etld/matcher.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,28 +18,28 @@ using brave_etld::internal::SerializedChildBuffers;
namespace brave_etld {

DomainInfo build_domain_info(const internal::PublicSuffixRule* rule,
const Domain &domain) {
const Domain& domain) {
return rule->Apply(domain);
}

Matcher::Matcher(std::ifstream &rule_file) {
Matcher::Matcher(std::ifstream* rule_file) {
ConsumeParseResult(internal::parse_rule_file(rule_file));
}

Matcher::Matcher(const std::string &rule_text) {
Matcher::Matcher(const std::string& rule_text) {
ConsumeParseResult(internal::parse_rule_text(rule_text));
}

Matcher::Matcher(const PublicSuffixParseResult &rules) {
Matcher::Matcher(const PublicSuffixParseResult& rules) {
ConsumeParseResult(rules);
}

Matcher::Matcher(const Matcher &matcher) :
Matcher::Matcher(const Matcher& matcher) :
rules_(matcher.rules_),
exception_rules_(matcher.exception_rules_) {}

Matcher::Matcher(const internal::PublicSuffixRuleSet &rules,
const internal::PublicSuffixRuleSet &exception_rules) :
Matcher::Matcher(const internal::PublicSuffixRuleSet& rules,
const internal::PublicSuffixRuleSet& exception_rules) :
rules_(rules),
exception_rules_(exception_rules) {}

Expand Down Expand Up @@ -70,14 +70,14 @@ SerializationResult Matcher::Serialize() const {
};
}

bool Matcher::Equal(const Matcher &matcher) const {
bool Matcher::Equal(const Matcher& matcher) const {
return (rules_.Equal(matcher.rules_) &&
exception_rules_.Equal(matcher.exception_rules_));
}

// Attempts to implement the algoritms described here:
// https://publicsuffix.org/list/
DomainInfo Matcher::Match(const Domain &domain) const {
DomainInfo Matcher::Match(const Domain& domain) const {
PublicSuffixRuleSetMatchResult except_match = exception_rules_.Match(domain);
if (except_match.found_match) {
return build_domain_info(except_match.rule, domain);
Expand All @@ -91,8 +91,7 @@ DomainInfo Matcher::Match(const Domain &domain) const {
return build_domain_info(internal::PublicSuffixRule::root_rule, domain);
}


void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
void Matcher::ConsumeParseResult(const PublicSuffixParseResult& result) {
for (auto &elm : result.Rules()) {
if (elm.IsException()) {
exception_rules_.AddRule(elm);
Expand All @@ -102,7 +101,7 @@ void Matcher::ConsumeParseResult(const PublicSuffixParseResult &result) {
}
}

Matcher matcher_from_serialization(const SerializedBuffer &buffer) {
Matcher matcher_from_serialization(const SerializedBuffer& buffer) {
SerializedChildBuffers child_buffers = internal::deserialize_buffer(buffer);
return {
internal::rule_set_from_serialization(child_buffers[0]),
Expand Down
20 changes: 10 additions & 10 deletions etld/matcher.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,24 +22,24 @@ class Matcher {
public:
Matcher() {}
Matcher(const Matcher &matcher);
explicit Matcher(std::ifstream &rule_file);
explicit Matcher(const std::string &rule_text);
explicit Matcher(const internal::PublicSuffixParseResult &rules);
Matcher(const internal::PublicSuffixRuleSet &rules,
const internal::PublicSuffixRuleSet &exception_rules);
explicit Matcher(std::ifstream* rule_file);
explicit Matcher(const std::string& rule_text);
explicit Matcher(const internal::PublicSuffixParseResult& rules);
Matcher(const internal::PublicSuffixRuleSet& rules,
const internal::PublicSuffixRuleSet& exception_rules);

SerializationResult Serialize() const;

bool Equal(const Matcher &matcher) const;
DomainInfo Match(const Domain &domain) const;
bool Equal(const Matcher& matcher) const;
DomainInfo Match(const Domain& domain) const;

private:
void ConsumeParseResult(const internal::PublicSuffixParseResult &result);
void ConsumeParseResult(const internal::PublicSuffixParseResult& result);
internal::PublicSuffixRuleSet rules_;
internal::PublicSuffixRuleSet exception_rules_;
};

Matcher matcher_from_serialization(const SerializedBuffer &buffer);
Matcher matcher_from_serialization(const SerializedBuffer& buffer);

} // namespace brave_etld

Expand Down
Loading

0 comments on commit 76bdb66

Please sign in to comment.