Rename constraint -> rule globally (#91)

Following the change from protovalidate v0.11.0 onward, the term
"constraint" is now removed in places where it referred to protovalidate
rules, using the following nomenclature:
- ConstraintRule -> ValidationRule
- Constraint -> Rule
etc.

This is an API breaking change, since names of public structures have
changed.

Author: jchadwick-buf

buf/validate/internal/BUILD.bazel

@@ -15,11 +15,11 @@
 package(default_visibility = ["//:__subpackages__"])
 
 cc_library(
-    name = "cel_constraint_rules",
-    srcs = ["cel_constraint_rules.cc"],
-    hdrs = ["cel_constraint_rules.h"],
+    name = "cel_validation_rules",
+    srcs = ["cel_validation_rules.cc"],
+    hdrs = ["cel_validation_rules.h"],
     deps = [
-        ":constraint_rules",
+        ":validation_rules",
         "@com_google_cel_cpp//eval/public:activation",
         "@com_google_cel_cpp//eval/public:cel_expression",
         "@com_google_cel_cpp//eval/public:cel_value",
@@ -43,8 +43,8 @@ cc_library(
 )
 
 cc_library(
-    name = "constraint_rules",
-    hdrs = ["constraint_rules.h"],
+    name = "validation_rules",
+    hdrs = ["validation_rules.h"],
     deps = [
         "@com_github_bufbuild_protovalidate//proto/protovalidate/buf/validate:validate_proto_cc",
         ":proto_field",
@@ -93,18 +93,18 @@ cc_library(
     hdrs = ["field_rules.h"],
     deps = [
         ":cel_rules",
-        ":constraint",
+        ":rules",
         "@com_google_absl//absl/status:statusor",
         "@com_google_protobuf//:protobuf",
     ],
 )
 
 cc_library(
-    name = "constraint",
-    srcs = ["constraints.cc"],
-    hdrs = ["constraints.h"],
+    name = "rules",
+    srcs = ["rules.cc"],
+    hdrs = ["rules.h"],
     deps = [
-        ":cel_constraint_rules",
+        ":cel_validation_rules",
         ":extra_func",
         "@com_github_bufbuild_protovalidate//proto/protovalidate/buf/validate:validate_proto_cc",
         "@com_google_cel_cpp//eval/public:activation",
@@ -119,10 +119,10 @@ cc_library(
 )
 
 cc_test(
-    name = "constraint_test",
-    srcs = ["constraints_test.cc"],
+    name = "rules_test",
+    srcs = ["rules_test.cc"],
     deps = [
-        ":constraint",
+        ":rules",
         "@com_google_cel_cpp//eval/public:activation",
         "@com_google_googletest//:gtest_main",
     ],

buf/validate/internal/cel_rules.h

@@ -15,9 +15,9 @@
 #pragma once
 
 #include "absl/status/status.h"
-#include "buf/validate/internal/cel_constraint_rules.h"
-#include "buf/validate/internal/constraints.h"
+#include "buf/validate/internal/cel_validation_rules.h"
 #include "buf/validate/internal/message_factory.h"
+#include "buf/validate/internal/rules.h"
 #include "buf/validate/validate.pb.h"
 #include "google/protobuf/arena.h"
 #include "google/protobuf/descriptor.h"
@@ -64,8 +64,8 @@ absl::Status BuildCelRules(
     google::protobuf::Arena* arena,
     google::api::expr::runtime::CelExpressionBuilder& builder,
     const R& rules,
-    CelConstraintRules& result) {
-  // Look for constraints on the set fields.
+    CelValidationRules& result) {
+  // Look for rules on the set fields.
   std::vector<const google::protobuf::FieldDescriptor*> fields;
   google::protobuf::Message* reparsedRules{};
   if (messageFactory && rules.unknown_fields().field_count() > 0) {
@@ -81,14 +81,13 @@ absl::Status BuildCelRules(
     if (!allowUnknownFields &&
         !reparsedRules->GetReflection()->GetUnknownFields(*reparsedRules).empty()) {
       return absl::FailedPreconditionError(
-          absl::StrCat("unknown constraints in ", reparsedRules->GetTypeName()));
+          absl::StrCat("unknown rules in ", reparsedRules->GetTypeName()));
     }
     result.setRules(reparsedRules, arena);
     reparsedRules->GetReflection()->ListFields(*reparsedRules, &fields);
   } else {
     if (!allowUnknownFields && !R::GetReflection()->GetUnknownFields(rules).empty()) {
-      return absl::FailedPreconditionError(
-          absl::StrCat("unknown constraints in ", rules.GetTypeName()));
+      return absl::FailedPreconditionError(absl::StrCat("unknown rules in ", rules.GetTypeName()));
     }
     result.setRules(&rules, arena);
     R::GetReflection()->ListFields(rules, &fields);
@@ -102,9 +101,9 @@ absl::Status BuildCelRules(
       continue;
     }
     const auto& fieldLvl = field->options().GetExtension(buf::validate::predefined);
-    for (const auto& constraint : fieldLvl.cel()) {
-      auto status = result.Add(
-          builder, constraint.id(), constraint.message(), constraint.expression(), rulePath, field);
+    for (const auto& rule : fieldLvl.cel()) {
+      auto status =
+          result.Add(builder, rule.id(), rule.message(), rule.expression(), rulePath, field);
       if (!status.ok()) {
         return status;
       }

buf/validate/internal/cel_constraint_rules.cc renamed to buf/validate/internal/cel_validation_rules.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "buf/validate/internal/cel_constraint_rules.h"
+#include "buf/validate/internal/cel_validation_rules.h"
 
 #include "common/values/struct_value.h"
 #include "eval/public/containers/field_access.h"
@@ -26,21 +26,21 @@ namespace cel = google::api::expr;
 
 namespace {
 
-absl::Status ProcessConstraint(
-    ConstraintContext& ctx,
+absl::Status ProcessRule(
+    RuleContext& ctx,
     const google::api::expr::runtime::BaseActivation& activation,
-    const CompiledConstraint& expr) {
-  auto result_or= expr.expr->Evaluate(activation, ctx.arena);
+    const CompiledRule& expr) {
+  auto result_or = expr.expr->Evaluate(activation, ctx.arena);
   if (!result_or.ok()) {
     return result_or.status();
   }
   cel::runtime::CelValue result = std::move(result_or).value();
   if (result.IsBool()) {
     if (!result.BoolOrDie()) {
-      // Add violation with the constraint message.
+      // Add violation with the rule message.
       Violation violation;
-      violation.set_message(expr.constraint.message());
-      violation.set_rule_id(expr.constraint.id());
+      violation.set_message(expr.rule.message());
+      violation.set_rule_id(expr.rule.id());
       if (expr.rulePath.has_value()) {
         *violation.mutable_rule() = *expr.rulePath;
       }
@@ -51,7 +51,7 @@ absl::Status ProcessConstraint(
       // Add violation with custom message.
       Violation violation;
       violation.set_message(std::string(result.StringOrDie().value()));
-      violation.set_rule_id(expr.constraint.id());
+      violation.set_rule_id(expr.rule.id());
       if (expr.rulePath.has_value()) {
         *violation.mutable_rule() = *expr.rulePath;
       }
@@ -87,12 +87,12 @@ cel::runtime::CelValue ProtoFieldToCelValue(
 
 } // namespace
 
-absl::Status CelConstraintRules::Add(
+absl::Status CelValidationRules::Add(
     google::api::expr::runtime::CelExpressionBuilder& builder,
-    Rule constraint,
+    Rule rule,
     absl::optional<FieldPath> rulePath,
-    const google::protobuf::FieldDescriptor* rule) {
-  auto pexpr_or = cel::parser::Parse(constraint.expression());
+    const google::protobuf::FieldDescriptor* ruleField) {
+  auto pexpr_or = cel::parser::Parse(rule.expression());
   if (!pexpr_or.ok()) {
     return pexpr_or.status();
   }
@@ -102,40 +102,40 @@ absl::Status CelConstraintRules::Add(
     return expr_or.status();
   }
   std::unique_ptr<cel::runtime::CelExpression> expr = std::move(expr_or).value();
-  exprs_.emplace_back(CompiledConstraint{std::move(constraint), std::move(expr), std::move(rulePath), rule});
+  exprs_.emplace_back(
+      CompiledRule{std::move(rule), std::move(expr), std::move(rulePath), ruleField});
   return absl::OkStatus();
 }
 
-absl::Status CelConstraintRules::Add(
+absl::Status CelValidationRules::Add(
     google::api::expr::runtime::CelExpressionBuilder& builder,
     std::string_view id,
     std::string_view message,
     std::string_view expression,
     absl::optional<FieldPath> rulePath,
-    const google::protobuf::FieldDescriptor* rule) {
-  Rule constraint;
-  *constraint.mutable_id() = id;
-  *constraint.mutable_message() = message;
-  *constraint.mutable_expression() = expression;
-  return Add(builder, constraint, std::move(rulePath), rule);
+    const google::protobuf::FieldDescriptor* ruleField) {
+  Rule rule;
+  *rule.mutable_id() = id;
+  *rule.mutable_message() = message;
+  *rule.mutable_expression() = expression;
+  return Add(builder, rule, std::move(rulePath), ruleField);
 }
 
-absl::Status CelConstraintRules::ValidateCel(
-    ConstraintContext& ctx,
-    google::api::expr::runtime::Activation& activation) const {
+absl::Status CelValidationRules::ValidateCel(
+    RuleContext& ctx, google::api::expr::runtime::Activation& activation) const {
   activation.InsertValue("rules", rules_);
   activation.InsertValue("now", cel::runtime::CelValue::CreateTimestamp(absl::Now()));
   absl::Status status = absl::OkStatus();
 
   for (const auto& expr : exprs_) {
-    if (rules_.IsMessage() && expr.rule != nullptr) {
+    if (rules_.IsMessage() && expr.ruleField != nullptr) {
       activation.InsertValue(
-          "rule", ProtoFieldToCelValue(rules_.MessageOrDie(), expr.rule, ctx.arena));
+          "rule", ProtoFieldToCelValue(rules_.MessageOrDie(), expr.ruleField, ctx.arena));
     }
     int pos = ctx.violations.size();
-    status = ProcessConstraint(ctx, activation, expr);
-    if (rules_.IsMessage() && expr.rule != nullptr && ctx.violations.size() > pos) {
-      ctx.setRuleValue(ProtoField{rules_.MessageOrDie(), expr.rule}, pos);
+    status = ProcessRule(ctx, activation, expr);
+    if (rules_.IsMessage() && expr.ruleField != nullptr && ctx.violations.size() > pos) {
+      ctx.setRuleValue(ProtoField{rules_.MessageOrDie(), expr.ruleField}, pos);
     }
     if (ctx.shouldReturn(status)) {
       break;
@@ -146,7 +146,7 @@ absl::Status CelConstraintRules::ValidateCel(
   return status;
 }
 
-void CelConstraintRules::setRules(
+void CelValidationRules::setRules(
     const google::protobuf::Message* rules, google::protobuf::Arena* arena) {
   rules_ = cel::runtime::CelProtoWrapper::CreateMessage(rules, arena);
 }

buf/validate/internal/cel_constraint_rules.h renamed to buf/validate/internal/cel_validation_rules.h

@@ -16,53 +16,52 @@
 
 #include <string_view>
 
+#include "buf/validate/internal/validation_rules.h"
 #include "buf/validate/validate.pb.h"
-#include "buf/validate/internal/constraint_rules.h"
 #include "eval/public/activation.h"
 #include "eval/public/cel_expression.h"
 #include "eval/public/cel_value.h"
 
 namespace buf::validate::internal {
 
-// A compiled constraint expression.
-struct CompiledConstraint {
-  buf::validate::Rule constraint;
+// A compiled rule expression.
+struct CompiledRule {
+  buf::validate::Rule rule;
   std::unique_ptr<google::api::expr::runtime::CelExpression> expr;
   const absl::optional<FieldPath> rulePath;
-  const google::protobuf::FieldDescriptor* rule;
+  const google::protobuf::FieldDescriptor* ruleField;
 };
 
-// An abstract base class for constraint with rules that are compiled into CEL expressions.
-class CelConstraintRules : public ConstraintRules {
-  using Base = ConstraintRules;
+// An abstract base class for rules that are compiled into CEL expressions.
+class CelValidationRules : public ValidationRules {
+  using Base = ValidationRules;
 
  public:
   using Base::Base;
 
   absl::Status Add(
       google::api::expr::runtime::CelExpressionBuilder& builder,
-      Rule constraint,
+      Rule rule,
       absl::optional<FieldPath> rulePath,
-      const google::protobuf::FieldDescriptor* rule);
+      const google::protobuf::FieldDescriptor* ruleField);
   absl::Status Add(
       google::api::expr::runtime::CelExpressionBuilder& builder,
       std::string_view id,
       std::string_view message,
       std::string_view expression,
       absl::optional<FieldPath> rulePath,
-      const google::protobuf::FieldDescriptor* rule);
+      const google::protobuf::FieldDescriptor* ruleField);
 
   // Validate all the cel rules given the activation that already has 'this' bound.
   absl::Status ValidateCel(
-      ConstraintContext& ctx,
-      google::api::expr::runtime::Activation& activation) const;
+      RuleContext& ctx, google::api::expr::runtime::Activation& activation) const;
 
   void setRules(google::api::expr::runtime::CelValue rules) { rules_ = rules; }
   void setRules(const google::protobuf::Message* rules, google::protobuf::Arena* arena);
 
  protected:
   google::api::expr::runtime::CelValue rules_;
-  std::vector<CompiledConstraint> exprs_;
+  std::vector<CompiledRule> exprs_;
 };
 
 } // namespace buf::validate::internal