Turn a string into IRC upper case.
 @param [String] irc_string An IRC string (nickname, channel, etc)
 @param [Symbol] casemapping An IRC casemapping
 @return [String] An upper case version of the IRC string according to
   the casemapping.
199231
def irc_upcase(irc_string, casemapping = :rfc1459)
      result = irc_string.dup
      irc_upcase!(result, casemapping)
      return result
    end
1007904
def _irc_lower(self, in_string):
        """"""
        conv_string = self._translate(in_string)
        if self._lower_trans is not None:
            conv_string = conv_string.translate(self._lower_trans)
        return str.lower(conv_string)
878883
def _irc_upper(self, in_string):
        """"""
        conv_string = self._translate(in_string)
        if self._upper_trans is not None:
            conv_string = in_string.translate(self._upper_trans)
        return str.upper(conv_string)
668640
def kebab_case(string):
    
    if not string:
        return string
    string = string.replace('_', '-').replace(' ', '-')
    return de_camel(string, '-')
776371
function toCamelCase (str, upper) {
  str = str.toLowerCase().replace(/(?:(^.)|(\s+.)|(-.))/g, function (match) {
    return match.charAt(match.length - 1).toUpperCase()
  })
  if (upper) {
    return str
  }
  return str.charAt(0).toLowerCase() + str.substr(1)
}
914120
def _camel_case(cls, text, first_upper=False):
        
        result = ''
        need_upper = False
        for pos, symbol in enumerate(text):
            if symbol == '_' and pos > 0:
                need_upper = True
            else:
                if need_upper:
                    result += symbol.upper()
                else:
                    result += symbol.lower()
                need_upper = False
        if first_upper:
            result = result[0].upper() + result[1:]
        return result
1241306
private String getCamelCaseFromUnderscoreSeparated(String underScoreSeparatedStr) {

    final StringGrabber underScoreSeparatedSg = new StringGrabber(underScoreSeparatedStr);
    final StringGrabberList wordBlockList = underScoreSeparatedSg.split("_");
    final StringGrabber resultSg = new StringGrabber();

    for (int i = 0; i < wordBlockList.size(); i++) {

      final StringGrabber word = wordBlockList.get(i);

      if (i == 0) {

        // first element not to upper case
        resultSg.append(word.toString());

      } else {
        resultSg.append(word.replaceFirstToUpperCase().toString());
      }
    }
    return resultSg.toString();
  }
203223
def iriref_to_str(self, ref: ShExDocParser.IRIREF) -> str:
        
        rval = ref.getText()[1:-1].encode('utf-8').decode('unicode-escape')
        return rval if ':' in rval or not self.base else self.base.val + rval
871561
def from_irc(self, irc_nickname=None, irc_password=None):
        '''
            
        '''
        if have_bottom:
            from .findall import IrcListener

            # connect and fetch current set of servers who are
            # on #electrum channel at freenode

            bot = IrcListener(irc_nickname=irc_nickname, irc_password=irc_password)
            results = bot.loop.run_until_complete(bot.collect_data())
            bot.loop.close()

            # merge by nick name
            self.update(results)
        else:
            return(False)
82331
def set_uppercase(self, uppercase):
        
        for row in self.rows:
            for key in row.keys:
                if type(key) == VKey:
                    if uppercase:
                        key.value = key.value.upper()
                    else:
                        key.value = key.value.lower()
291553
public static String upperCaseFirstChar(String _str) {
        if (_str == null) {
            return null;
        }
        if (_str.isEmpty()) {
            return _str;
        }
        return _str.substring(0, 1).toUpperCase() + _str.substring(1);
    }
268465
def _get_header_correctly_cased(header_name):
    

    header_name = header_name.capitalize()

    matches = re.findall(_REGEX_FOR_LOWERCASE_HEADERS, header_name)

    for match in matches:
        header_name = (re.sub(match, match.upper(), header_name))

    return header_name
555639
def normalize_underscore_case(name):
    
    normalized = name.lower()
    normalized = re.sub(r'_(\w)',
                        lambda match: ' ' + match.group(1).upper(),
                        normalized)
    return normalized[0].upper() + normalized[1:]
578213
def underscores_to_camelcase(argument):
    '''  '''
    result = ''
    previous_was_underscore = False
    for char in argument:
        if char != '_':
            if previous_was_underscore:
                result += char.upper()
            else:
                result += char
        previous_was_underscore = char == '_'
    return result
34232
def encode_irc!(string, encoding = :irc)
      if encoding == :irc
        # If your text contains only characters that fit inside the CP1252
        # code page (aka Windows Latin-1), the entire line will be sent
        # that way. mIRC users should see it correctly. XChat users who
        # are using UTF-8 will also see it correctly, because it will fail
        # UTF-8 validation and will be assumed to be CP1252, even by older
        # XChat versions.
        #
        # If the text doesn't fit inside the CP1252 code page, (for example if you
        # type Eastern European characters, or Russian) it will be sent as UTF-8. Only
        # UTF-8 capable clients will be able to see these characters correctly
        #
        # (from http://xchat.org/encoding/#hybrid)
        begin
          string.encode!("CP1252")
        rescue ::Encoding::UndefinedConversionError
        end
      else
        string.encode!(encoding, {:invalid => :replace, :undef => :replace}).force_encoding("ASCII-8BIT")
      end

      return string
    end
1248914
function $$core$$toLatinUpperCase (str) {
        var i = str.length;

        while (i--) {
            var ch = str.charAt(i);

            if (ch >= "a" && ch <= "z")
                str = str.slice(0, i) + ch.toUpperCase() + str.slice(i+1);
        }

        return str;
    }
130229
def _to_camelcase(input_string):
    ''' '''
    camel_string = ''
    for i in range(len(input_string)):
        if input_string[i] == '_':
            pass
        elif not camel_string:
            camel_string += input_string[i].upper()
        elif input_string[i-1] == '_':
            camel_string += input_string[i].upper()
        else:
            camel_string += input_string[i]
    return camel_string