replace attribution placeholders with their values from toplevel provider attribution, recursively
778459
function (attr) {
				if (attr.indexOf('{attribution.') === -1) {
					return attr;
				}
				return attr.replace(/\{attribution.(\w*)\}/,
					function (match, attributionName) {
						return attributionReplacer(providers[attributionName].options.attribution);
					}
				);
			}
627903
def remove_attribution_layer(self):
        
        if self.attribution_layer is not None:
            this_node = self.attribution_layer.get_node()
            self.root.remove(this_node)
            self.attribution_layer = None

        if self.header is not None:
            self.header.remove_lp('attribution')
252782
def transform(self, attrs):
        """"""
        self.collect(attrs)
        self.add_missing_implementations()
        self.fill_attrs(attrs)
151946
def do_fileplaceholder(parser, token):
    
    name, params = parse_placeholder(parser, token)
    return FilePlaceholderNode(name, **params)
1223490
function transformTemplateElement (node) {
    const originalValue = node.value.value.raw
    if (rootPathWithDotRegex.test(originalValue)) {
      node.value.value.raw = node.value.value.raw.replace(
        rootPathWithDotRegex,
        '$$$1'
      )
    }
  }
1153309
function replacePatterns(token, replacements, measureThreshold) {
    var result = attemptReplacePatterns(token, replacements, measureThreshold);
    token = result == null ? token : result;
    
    return token;
}
679712
function replace(translation, replacements) {
    // check if the object has a replace property
    if (!translation.replace) {
      return translation;
    }

    return translation.replace(matcher, function (placeholder) {
      // remove the identifiers (can be set on the module level)
      var key = placeholder.replace(identifiers[0], '').replace(identifiers[1], '');

      if (replacements[key] !== undefined) {
        return replacements[key];
      } // warn user that the placeholder has not been found


      if (warnings) {
        console.group ? console.group('i18n: Not all placeholders found') : console.warn('i18n: Not all placeholders found');
        console.warn('Text:', translation);
        console.warn('Placeholder:', placeholder);

        if (console.groupEnd) {
          console.groupEnd();
        }
      } // return the original placeholder


      return placeholder;
    });
  }
829746
private CompletableFuture<Revision> replacePermissionAtPointer(Author author,
                                                                   String projectName, JsonPointer path,
                                                                   Collection<Permission> permission,
                                                                   String commitSummary) {
        final Change<JsonNode> change =
                Change.ofJsonPatch(METADATA_JSON,
                                   new ReplaceOperation(path, Jackson.valueToTree(permission)).toJsonNode());
        return metadataRepo.push(projectName, Project.REPO_DOGMA, author, commitSummary, change);
    }
253593
function parsePullDownPlaceHolders( str ) {
	log( "Pong-PullDown",  "parsePullDownPlaceHolders: "+ str );
	for (var key in sessionInfo) {
		if ( str.indexOf( '${'+key+'}' ) >=0 ) {
			str = str.replace( '${'+key+'}', $.i18n( sessionInfo[key] ) );
		}
	}
	log( "Pong-PullDown", "Processed value: "+ str );
	return str;
}
352864
def do_markdownlaceholder(parser, token):
    
    name, params = parse_placeholder(parser, token)
    return MarkdownPlaceholderNode(name, **params)
809985
public static void extractPlaceholders(ClassNode node, Map<String, GenericsType> map) {
        if (node == null) return;

        if (node.isArray()) {
            extractPlaceholders(node.getComponentType(), map);
            return;
        }

        if (!node.isUsingGenerics() || !node.isRedirectNode()) return;
        GenericsType[] parameterized = node.getGenericsTypes();
        if (parameterized == null || parameterized.length == 0) return;
        GenericsType[] redirectGenericsTypes = node.redirect().getGenericsTypes();
        if (redirectGenericsTypes==null) redirectGenericsTypes = parameterized;
        for (int i = 0; i < redirectGenericsTypes.length; i++) {
            GenericsType redirectType = redirectGenericsTypes[i];
            if (redirectType.isPlaceholder()) {
                String name = redirectType.getName();
                if (!map.containsKey(name)) {
                    GenericsType value = parameterized[i];
                    map.put(name, value);
                    if (value.isWildcard()) {
                        ClassNode lowerBound = value.getLowerBound();
                        if (lowerBound!=null) {
                            extractPlaceholders(lowerBound, map);
                        }
                        ClassNode[] upperBounds = value.getUpperBounds();
                        if (upperBounds!=null) {
                            for (ClassNode upperBound : upperBounds) {
                                extractPlaceholders(upperBound, map);
                            }
                        }
                    } else if (!value.isPlaceholder()) {
                        extractPlaceholders(value.getType(), map);
                    }
                }
            }
        }
    }
63684
public static String replacePlaceHoldersInTemplate(final String template, final Map<String, String> replacementMap) {

		List<String> toReplace = new ArrayList<>();
		List<String> replaceBy = new ArrayList<>();

		for (Entry<String, String> property : replacementMap.entrySet()) {

			toReplace.add(property.getKey());
			replaceBy.add(property.getValue());

		}

		return StringUtils.replaceEachRepeatedly(template, toReplace.toArray(new String[toReplace.size()]), replaceBy.toArray(new String[replaceBy.size()]));

	}
1201407
public function replacePlaceholders($string, $values, $quoteIfNecessary = true)
    {
        foreach ($values as $placeholder => $value) {
            $replacement = $quoteIfNecessary ? $this->quoteIfNecessary($value) : $value;
            $string = str_replace(":{$placeholder}", $replacement, $string);
        }

        return $string;
    }
138089
public static function replaceTpl($content, array $placeholders = null, Template $template)
    {
        $template = clone $template;
        $template->removeAllPlaceholders();

        return $template->replace($content, $placeholders);
    }
1259096
function extractPlaceholderToIds(messageBundle) {
	      var messageMap = messageBundle.getMessageMap();
	      var placeholderToIds = {};
	      Object.keys(messageMap).forEach(function (msgId) {
	          placeholderToIds[msgId] = messageMap[msgId].placeholderToMsgIds;
	      });
	      return placeholderToIds;
	  }
498783
def substitute_vars(template, replacements):
    
    result = template
    for (key, value) in replacements:
        result = result.replace('${' + key + '}' , value)
    if '${' in result:
        logging.warning("A variable was not replaced in '%s'.", result)
    return result
754878
private Map<String, String> maybeReplaceFormatterInSettings(Map<String, String> individualSettings) {

        if (individualSettings == null) {
            return null;
        } else if (m_customReplacements == null) {
            return individualSettings;
        } else {
            LinkedHashMap<String, String> result = new LinkedHashMap<String, String>();
            for (Map.Entry<String, String> entry : individualSettings.entrySet()) {
                String value = entry.getValue();
                if (CmsUUID.isValidUUID(value)) {
                    CmsUUID valueId = new CmsUUID(value);
                    if (m_customReplacements.containsKey(valueId)) {
                        value = "" + m_customReplacements.get(valueId);
                    }
                }
                result.put(entry.getKey(), value);
            }
            return result;
        }
    }