Performs camelcase translation.
511514
private static String computeJsExtensionName(FieldDescriptor field) {
    String name = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, field.getName());
    return field.isRepeated() ? name + "List" : name;
  }
330151
def _to_camel_case(string):
        
        components = string.split('_')
        return '%s%s' % (
            components[0],
            ''.join(c.title() for c in components[1:]),
        )
1370627
def format_camel_case(text):
    
    text = text.strip()
    if len(text) == 0:  # if empty string, return it
        raise ValueError("can not be empty string!")
    else:
        text = text.lower()  # lower all char
        # delete redundant empty space
        words = list()
        word = list()
        for char in text:
            if char in ALPHA_DIGITS:
                word.append(char)
            else:
                if len(word):
                    words.append("".join(word))
                    word = list()
        if len(word):
            words.append("".join(word))

        words = [word[0].upper() + word[1:] for word in words]
        return "".join(words)
74469
function camelCase(str, next) {
    let output = '';
    for (const c of str) {
        if (c === '_') {
            next = true;
            continue;
        }
        output += next ? c.toUpperCase() : c;
        next = false;
    }
    return output;
}
806366
public static String camelCaseToUnderscore(final String camelCaseString) {

        final StringBuilder sb = new StringBuilder();
        for (final String camelPart : camelCaseString.split("(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])")) {
            if (sb.length() > 0) {
                sb.append(CASE_SEPARATOR);
            }
            sb.append(camelPart.toUpperCase(Locale.getDefault()));
        }
        return sb.toString();
    }
949661
def camel_case_from_underscores(string):
    """"""
    components = string.split('_')
    string = ''
    for component in components:
        string += component[0].upper() + component[1:]
    return string
158866
function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
    return index === 0 ? letter.toLowerCase() : letter.toUpperCase()
  }).replace(/[\s\-_]+/g, '')
}
58502
function camelCase(s) {
  return s.toLowerCase().replace(/-(.)/g, function(m, g) {
    return g.toUpperCase()
  })
}
757309
function _camelcase(flag) {
  return flag.split('-').reduce(function (str, word) {
    return str + word[0].toUpperCase() + word.slice(1);
  });
}
1069477
def camelize(string, lower = false)
      string = string.to_s.gsub(/(?:^|_)(.)/) { Regexp.last_match(1).upcase }
      string = string[0].chr.downcase + string[1..-1] if lower
      string
    end
46974
def to_camel_case(s):
    

    def to_upper(match):
        return match.group(0)[-1].upper()

    return re.sub('(^|[_\W])+[a-zA-Z]', to_upper, s)
937844
function (input) {
        function camelCaseSingle(input) {
        return String(input).toLowerCase().replace(/[-|\s](.)/g, function (match, group1) {
            return group1.toUpperCase();
        });
        }

        if(typeof input == 'string')
            return camelCaseSingle(input);
        else
            return input.map(camelCaseSingle);
    }
761543
public function camelize() {
        $encoding = $this->encoding;
        $stringy = self::create($this->str, $this->encoding);

        $camelCase = preg_replace_callback(
                '/[-_\s]+(.)?/u', function ($match) use (&$encoding) {
            return $match[1] ? mb_strtoupper($match[1], $encoding) : "";
        }, $stringy->trim()->lowerCaseFirst()->str
        );

        $stringy->str = preg_replace_callback(
                '/[\d]+(.)?/u', function ($match) use (&$encoding) {
            return mb_strtoupper($match[0], $encoding);
        }, $camelCase
        );

        return $stringy;
    }
688050
def camel_case_to_underscore(name):
    """"""
    res = RE_TOKEN1.sub(r'\1_\2', name)
    res = RE_TOKEN2.sub(r'\1_\2', res)
    return res.lower()
1296107
private static String translate(String word, List<Replacer> replacers){
        // Scan uncountables and leave alone
        for(String uncountable: uncountables){
            if(uncountable.equals(word))
                return word;
        }

        // Scan our patterns for a match and return the correct replacement
        for(Replacer replacer: replacers){
            Matcher matcher = replacer.pattern.matcher(word);

            if(matcher.matches()){
                StringBuffer sb = new StringBuffer();
                boolean group = false;
                for(int i=0; i<replacer.rule.length(); i++){
                    char ch = replacer.rule.charAt(i);
                    if(group){
                        sb.append(matcher.group(Character.digit(ch, 10)));
                        group = false;
                    }else if(ch=='\\')
                        group=true;
                    else
                        sb.append(ch);
                }
                return sb.toString();
            }
        }

        // Return the original string unchanged
        return word;
    }
959491
private StringGrabber replaceCaseTo(int startPos, int endPos, ECase toCase) {

		StringBuilder sbRange = new StringBuilder();

		try {
			for (int i = startPos; i < endPos; i++) {
				sbRange.append(String.valueOf(sb.charAt(i)));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		final String caseConvertedRangeStr;

		if (ECase.LOWER == toCase) {
			caseConvertedRangeStr = sbRange.toString().toLowerCase();
		} else {
			caseConvertedRangeStr = sbRange.toString().toUpperCase();
		}
		try {
			sb.replace(startPos, endPos, caseConvertedRangeStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return StringGrabber.this;
	}
289292
def snake_to_camel_case(name):
    
    name = name.replace("-", "_")
    return "".join(word.capitalize() for word in name.split("_"))