logger.debug("Resolving plugin prefix {} from {}", request.getPrefix(), request.getPluginGroups());

        PluginPrefixResult result = resolveFromProject(request);

        if (result == null) {
            result = resolveFromRepository(request);

            if (result == null) {
                throw new NoPluginFoundForPrefixException(
                        request.getPrefix(),
                        request.getPluginGroups(),

func (r Rule) validateNoncurrentTransition() error {
	return r.NoncurrentVersionTransition.Validate()
}

// GetPrefix - a rule can either have prefix under <rule></rule>, <filter></filter>
// or under <filter><and></and></filter>. This method returns the prefix from the
// location where it is available.
func (r Rule) GetPrefix() string {
	if p := r.Prefix.String(); p != "" {
		return p
	}
	if p := r.Filter.Prefix.String(); p != "" {

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String field = getSearchField(context.getDefaultField(), prefixQuery.getField());
        final String text = prefixQuery.getPrefix().text();

        if (Constants.DEFAULT_FIELD.equals(field)) {
            context.addFieldLog(field, text + "*");
            context.addHighlightedQuery(text);

            LinkedHashMap<String, Plugin> mergedPlugins = new LinkedHashMap<>();
            recessivePlugins.forEach(p -> mergedPlugins.put(p.getPrefix(), p));
            plugins.forEach(p -> mergedPlugins.put(p.getPrefix(), p));
            metadata = metadata.withPlugins(mergedPlugins.values());
        }
        // just carry-on as-is
        if (recessive.getVersioning() != null) {

            Plugin plugin = i.next();
            if (plugin.getPrefix().equals(goalPrefix)) {
                found = true;
            }
        }
        if (!found) {
            Plugin plugin = new Plugin();
            plugin.setPrefix(goalPrefix);
            plugin.setArtifactId(artifactId);
            plugin.setName(name);

        {
            boolean found = false;

            for ( Plugin preExisting : getPlugins() )
            {
                if ( preExisting.getPrefix().equals( plugin.getPrefix() ) )
                {
                    found = true;
                    break;
                }
            }

            if ( !found )
            {

            setPom(project.getModel());
        }

        setPluginGroups(session.getPluginGroups());
    }

    public String getPrefix() {
        return prefix;
    }

    public DefaultPluginPrefixRequest setPrefix(String prefix) {
        this.prefix = prefix;

        return this;
    }

    public List<String> getPluginGroups() {
        return pluginGroups;
    }

	}
	for _, rule := range lc.Rules {
		if rule.Status == Disabled {
			continue
		}

		if len(prefix) > 0 && len(rule.GetPrefix()) > 0 {
			// we can skip this rule if it doesn't match the tested
			// prefix.
			if !strings.HasPrefix(prefix, rule.GetPrefix()) && !strings.HasPrefix(rule.GetPrefix(), prefix) {
				continue
			}
		}

		if rule.NoncurrentVersionExpiration.NoncurrentDays > 0 {
			return true
		}

  @Test
  fun alwaysBuilds() {
    Platform()
  }

  /** Guard against the default value changing by accident.  */
  @Test
  fun defaultPrefix() {
    assertThat(Platform().getPrefix()).isEqualTo("OkHttp")
  }

  @Test
  fun testToStringIsClassname() {
    assertThat(Platform().toString()).isEqualTo("Platform")
  }

  @Test
  fun testNotAndroid() {
    platform.assumeNotAndroid()

     * Gets the prefix of the plugin.
     *
     * @return The prefix of the plugin.
     */
    String getPrefix();

    /**
     * Sets the prefix of the plugin.
     *
     * @param prefix The prefix of the plugin.
     * @return This request, never {@code null}.
     */
    PluginPrefixRequest setPrefix(String prefix);

    /**
     * Gets the list of group ids to scan for the plugin prefix.
     *