Same as #proxy_message_chain but using an array of symbols as
 message_chain instead of a dot separated string
169645
def proxy_message_chain_a(messages, &last_proxy_setup_block)
      first_message = messages.first
      return last_proxy_setup_block.call(receive(first_message)) if messages.size == 1

      receive(first_message).and_wrap_original do |m, *args, &original_block|
        result = m.call(*args, &original_block)
        allow(result).to proxy_message_chain_a(messages.drop(1), &last_proxy_setup_block)
        result
      end
    end
451544
function template(string, data) {
  var proxyRegEx = /\{\{([^\}]+)?\}\}/g;
  return string.replace(proxyRegEx, function(_, key) {
    var keyParts = key.split('.');
    var value = data;
    for (var i = 0; i < keyParts.length; i++) {
      value = value[keyParts[i]];
    }
    return value || '';
  });
}
26107
function implodeArray(tokens) {
	var message = "", i, l;
	l = tokens.length;
	for (i = 0; i < l; i++) {
		message += (i > 0 ? globals.SEP : "") + tokens[i];
	}
	return message;
}
109980
def regular_generic_msg(hostname, result, oneline, caption):
    '''  '''

    if not oneline:
        return "%s | %s >> %s\n" % (hostname, caption, utils.jsonify(result,format=True))
    else:
        return "%s | %s >> %s\n" % (hostname, caption, utils.jsonify(result))
345562
function encodeAttachmentMessage(buffer, offset, message) {
    if (message == undefined)
        throw Error('Specify message');
    offset += encodeString(buffer, message, offset);
    return offset;
}
290942
def _ReformatMessageString(self, message_string):
    
    def _PlaceHolderSpecifierReplacer(match_object):
      """Replaces message string place holders into Python format() style."""
      expanded_groups = []
      for group in match_object.groups():
        try:
          place_holder_number = int(group, 10) - 1
          expanded_group = '{{{0:d}:s}}'.format(place_holder_number)
        except ValueError:
          expanded_group = group

        expanded_groups.append(expanded_group)

      return ''.join(expanded_groups)

    if not message_string:
      return None

    message_string = self._WHITE_SPACE_SPECIFIER_RE.sub(r'', message_string)
    message_string = self._TEXT_SPECIFIER_RE.sub(r'\\\1', message_string)
    message_string = self._CURLY_BRACKETS.sub(r'\1\1', message_string)
    return self._PLACE_HOLDER_SPECIFIER_RE.sub(
        _PlaceHolderSpecifierReplacer, message_string)
592930
def block str
      return str unless self.class.const_defined?(:BLOCK_TAGS)
      result = str.dup
      self.class::BLOCK_TAGS.each { |tag, value|
        result.gsub!(/(#{tag})(.*?)(?:#{tag}|\Z)/m) { |m|
          %Q{

#{$1} #{Base64.encode64($2).carriage(false).bowl}

}
        }
      }
      result
    end
598707
function formatMsg(){

        return Array.prototype.slice.call( arguments ) .concat([ " (at ", linen, ":", linec, ")." ]) .join( "" );
    }
771127
function (str) {
    str = str.split('Blockly.Msg.')[1].split(' ');
    return {
        key: str[0],
        value: str
            .splice(2, str.length)
            .join(' ')
            .slice(1, -2) // strip off initial ', and ending ';
            .replace(/\\'/g, "'")
    };
}
915964
private void addMsgs(VarTensor[] msgs, Tensor t, int tf) {
        assert msgs[0].getAlgebra().equals(t.getAlgebra());
        EdgeScores es = EdgeScores.tensorToEdgeScores(t);
        for (VarTensor msg : msgs) {
            LinkVar link = (LinkVar) msg.getVars().get(0);
            double val = es.getScore(link.getParent(), link.getChild());
            msg.addValue(tf, val);
        }
    }
1338717
function getProxyListString(proxies) {
      // Older versions of Chrome would set these values as strings, whereas
      // newer
      // logs use arrays.
      // TODO(eroman): This behavior changed in M27. Support for older logs can
      //               safely be removed circa M29.
      if (Array.isArray(proxies)) {
        const listString = proxies.join(', ');
        if (proxies.length > 1) {
          return '[' + listString + ']';
        }
        return listString;
      }
      return proxies;
    }
1331202
def message_list
      list = []
      each do |k, v|
        list.concat(v.message_list)
      end
      list
    end
74743
function(allMessages) {
            allMessages = allMessages || [];
            
            for(var i = 0; i < allMessages.length; i++) {
                var message = allMessages[i];
                var type = message["type"];
                var text = message["text"];
                var msg = '[SPLUNKD] ' + text;
                switch (type) {
                    case 'HTTP':
                    case 'FATAL':
                    case 'ERROR':
                        this.error(msg);
                        break;
                    case 'WARN':
                        this.warn(msg);
                        break;
                    case 'INFO':
                        this.info(msg);
                        break;
                    case 'HTTP':
                        this.error(msg);
                        break;
                    default:
                        this.info(msg);
                        break;
                }
            }  
        }
1052232
def convert_message_to_string(self, message):
        """"""
        final_message = ''
        for submessage in message:
            final_message += '* {submessage}\n'.format(submessage=submessage)
        return final_message
225484
def as_symbols(self):
        
        out = set()
        for name in self.types:
            out.add(('type', name))
        for name in self.enums:
            out.add(('enum', name))
        for name in self.commands:
            out.add(('command', name))
        return out
1124156
public static void displayChains(TraceComponent logger, List<?> lchain,
                                     String message, String prefix) {
        if (logger.isDebugEnabled()) {
            chTrace.traceChains(logger, lchain, message, prefix);
        }
    }
1252633
function applicableMessages(messages, options) {
  var length = messages.length
  var index = -1
  var result = []

  if (options.silent) {
    while (++index < length) {
      if (messages[index].fatal) {
        result.push(messages[index])
      }
    }
  } else {
    result = messages.concat()
  }

  return result
}