responseData.setResponseBody(new byte[0]);
        final Rule rule = ruleManager.getRule(responseData);
        assertNotNull(rule);
        assertEquals("fileRule", rule.getRuleId());
        CloseableUtil.closeQuietly(responseData);
    }

    public void test_checkRule() {
        final Rule rule = ruleManager.getRule(new ResponseData());
        assertNotNull(rule);

				rbacv1helpers.NewRule("create").Groups(coordinationGroup).Resources("leases").RuleOrDie(),
				rbacv1helpers.NewRule("get", "update").Groups(coordinationGroup).Resources("leases").Names("kube-controller-manager").RuleOrDie(),
				// Fundamental resources.
				rbacv1helpers.NewRule("create").Groups(legacyGroup).Resources("secrets", "serviceaccounts").RuleOrDie(),

			Rules: []rbacv1.PolicyRule{
				rbacv1helpers.NewRule("list", "watch").Groups(legacyGroup).Resources("persistentvolumes", "persistentvolumeclaims").RuleOrDie(),
				rbacv1helpers.NewRule("get", "list", "watch").Groups(legacyGroup).Resources("nodes").RuleOrDie(),
				rbacv1helpers.NewRule("patch", "update").Groups(legacyGroup).Resources("nodes/status").RuleOrDie(),
				rbacv1helpers.NewRule("list", "watch").Groups(legacyGroup).Resources("pods").RuleOrDie(),

		}

		src, err := os.ReadFile(a.genfile)
		if err != nil {
			log.Fatalf("can't read %s: %v", a.genfile, err)
		}
		seen := make(map[string]bool, len(a.ops))
		for _, m := range rxOp.FindAllSubmatch(src, -1) {
			seen[string(m[1])] = true
		}
		for _, op := range a.ops {
			if !seen[op.name] {
				log.Fatalf("Op%s%s has no code generation in %s", a.name, op.name, a.genfile)
			}
		}
	}
}

    protected final List<Rule> ruleList = new ArrayList<>();

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.rule.RuleManager#getRule(org.codelibs.fess.crawler.entity.ResponseData)
     */
    @Override
    public Rule getRule(final ResponseData responseData) {
        for (final Rule rule : ruleList) {
            if (rule.match(responseData)) {
                return rule;
            }

        warnAboutReservedName();
        ConfigurationInternal internalConf = (ConfigurationInternal) conf;

        if (!getRole().isUsageConsistentWithRole(conf)) {
            warnAboutNeedToMutateUsage(internalConf);
            if (internalConf.usageCanBeMutated()) {
                internalConf.setAllowedUsageFromRole(getRole());
            } else {
                failOnInabilityToMutateUsage();
            }
        }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.api.admin.role;

import static org.codelibs.fess.app.web.admin.role.AdminRoleAction.getRole;

import java.util.List;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

            if (form instanceof EditForm) {
                return ComponentUtil.getComponent(RoleService.class).getRole(((EditForm) form).id);
            }
            break;
        default:
            break;
        }
        return OptionalEntity.empty();
    }

    public static OptionalEntity<Role> getRole(final CreateForm form) {
        return getEntity(form).map(entity -> {

		for _, fc := range parsed.filterChains {
			for _, rbacHTTP := range fc.rbacHTTP {
				action := rbacHTTP.GetRules().GetAction()
				for name := range rbacHTTP.GetRules().GetPolicies() {
					nameOfPolicy, indexOfRule := extractName(name)
					addPolicy(action, nameOfPolicy, indexOfRule)
				}
				if len(rbacHTTP.GetRules().GetPolicies()) == 0 {
					addPolicy(action, anonymousName, "0")
				}
			}

 */
package org.codelibs.fess.crawler.rule;

import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * @author shinsuke
 *
 */
public interface RuleManager {

    Rule getRule(ResponseData responseData);

    void addRule(Rule rule);

    void addRule(int index, Rule rule);

    boolean removeRule(Rule rule);

    boolean hasRule(Rule rule);