コード例 #1
0
ファイル: flagenv.go プロジェクト: plimble/flagenv
func camelCase(src string) string {
	byteSrc := []byte(src)
	chunks := camelingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		if idx > 0 {
			chunks[idx] = bytes.Title(val)
		}
	}

	return string(bytes.Title(bytes.Join(chunks, nil)))
}
コード例 #2
0
ファイル: parser.go プロジェクト: lfkeitel/inca-tool
func normalizeKeyToField(k []byte) string {
	k = bytes.ToLower(k)
	k = bytes.Title(k)
	k = bytes.Replace(k, []byte(" "), []byte(""), -1)
	k = bytes.TrimSpace(k)
	return string(k)
}
コード例 #3
0
ファイル: case.go プロジェクト: rif/golang-stuff
func main() {
	quickBrownFox := []byte("The quick brown fox jumped over the lazy dog")

	title := bytes.Title(quickBrownFox)
	log.Printf("Title turned %q into %q", quickBrownFox, title)

	allTitle := bytes.ToTitle(quickBrownFox)
	log.Printf("ToTitle turned %q to %q", quickBrownFox, allTitle)

	allTitleTurkish := bytes.ToTitleSpecial(unicode.TurkishCase, quickBrownFox)
	log.Printf("ToTitleSpecial turned %q into %q using the Turkish case rules", quickBrownFox, allTitleTurkish)

	lower := bytes.ToLower(title)
	log.Printf("ToLower turned %q into %q", title, lower)

	turkishCapitalI := []byte("İ")
	turkishLowerI := bytes.ToLowerSpecial(unicode.TurkishCase, turkishCapitalI)
	log.Printf("ToLowerSpecial turned %q into %q using the Turkish case rules", turkishCapitalI, turkishLowerI)

	upper := bytes.ToUpper(quickBrownFox)
	log.Printf("ToUpper turned %q to %q", quickBrownFox, upper)

	upperSpecial := bytes.ToUpperSpecial(unicode.TurkishCase, quickBrownFox)
	log.Printf("ToUpperSpecial turned %q into %q using the Turkish case rules", quickBrownFox, upperSpecial)
}
コード例 #4
0
ファイル: template.go プロジェクト: philipsoutham/cqlc
func snakeToCamel(src string) string {
	byteSrc := []byte(src)
	chunks := camelRegex.FindAll(byteSrc, -1)
	for i, val := range chunks {
		chunks[i] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #5
0
ファイル: util.go プロジェクト: magiccreater/cx
func pascalCase(src string, sep string) string {
	byteSrc := []byte(src)
	chunks := camelingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		chunks[idx] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, []byte(sep)))
}
コード例 #6
0
ファイル: name.go プロジェクト: ngdinhtoan/hari
// ToCamelCase convert string to CamelCase, the first char also in upper case.
func ToCamelCase(s string) string {
	chunks := alphaNumRegex.FindAll([]byte(s), -1)
	for i, val := range chunks {
		chunks[i] = bytes.Title(val)
	}

	return string(bytes.Join(chunks, nil))
}
コード例 #7
0
func titleCase(src string) string {
	byteSrc := []byte(src)
	chunks := titlingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		chunks[idx] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #8
0
ファイル: parser.go プロジェクト: gkalabin/uap-go
func GetExportedName(src string) string {
	byteSrc := []byte(src)
	chunks := exportedNameRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		chunks[idx] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #9
0
ファイル: parser.go プロジェクト: lfkeitel/inca-tool
func (p *Parser) parseCommandBlockStart(cmd, opts []byte) error {
	if p.task.Commands == nil {
		p.task.Commands = make(map[string]*CommandBlock)
	}

	pieces := bytes.Split(opts, []byte(" "))
	name := ""
	settingsStartIndex := 0

	if !bytes.Contains(pieces[0], []byte("=")) {
		name = string(pieces[0])
		settingsStartIndex = 1
	}

	_, set := p.task.Commands[name]
	if set {
		return fmt.Errorf("%s block with name '%s' already exists. Line %d", cmd, opts, p.currentLine)
	}

	p.task.Commands[name] = &CommandBlock{
		Name: name,
	}

	if len(pieces) > 0 {
		for _, setting := range pieces[settingsStartIndex:] {
			parts := bytes.SplitN(setting, []byte("="), 2)
			if len(parts) < 2 {
				continue
			}

			taskReflect := reflect.ValueOf(p.task.Commands[name])
			// struct
			s := taskReflect.Elem()
			// exported field
			f := s.FieldByName(string(bytes.Title(parts[0])))
			if f.IsValid() {
				// A Value can be changed only if it is
				// addressable and was not obtained by
				// the use of unexported struct fields.
				if f.CanSet() {
					// change value of N
					if f.Kind() == reflect.String {
						if f.String() != "" {
							return fmt.Errorf("Cannot redeclare setting '%s'. Line %d", parts[0], p.currentLine)
						}
						f.SetString(string(parts[1]))
					}
				}
			} else {
				return fmt.Errorf("Invalid block setting \"%s\". Line %d", parts[0], p.currentLine)
			}
		}
	}
	p.task.currentBlock = name
	p.runningMode = modeCommand
	return nil
}
コード例 #10
0
ファイル: compiler.go プロジェクト: stealnetwork/gosp
func camelCase(src string) string {
	camelingRegex := regexp.MustCompile("[0-9A-Za-z]+")
	byteSrc := []byte(src)
	chunks := camelingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		chunks[idx] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #11
0
func UpperCamelCase(src string) string {
	byteSrc := []byte(src)
	chunks := camelingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		if idx > 0 {
			chunks[idx] = bytes.Title(val)
		}
	}
	camel := string(bytes.Join(chunks, nil))
	return strings.ToUpper(string(camel[0])) + camel[1:]
}
コード例 #12
0
ファイル: vimdoc.go プロジェクト: FooSoft/md2vim
func (v *vimDoc) buildHelpTag(text []byte) []byte {
	if v.flags&flagPascal == 0 {
		text = bytes.ToLower(text)
		text = bytes.Replace(text, []byte{' '}, []byte{'_'}, -1)
	} else {
		text = bytes.Title(text)
		text = bytes.Replace(text, []byte{' '}, []byte{}, -1)
	}

	return []byte(fmt.Sprintf("%s-%s", v.title, text))
}
コード例 #13
0
ファイル: game_event.go プロジェクト: BenLubar/manta
func camelCase(src string, export bool) string {
	re := regexp.MustCompile("[0-9A-Za-z]+")
	byteSrc := []byte(src)
	chunks := re.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		if idx > 0 || export {
			chunks[idx] = bytes.Title(val)
		}
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #14
0
ファイル: jaegerh.go プロジェクト: gitmonster/jaeger
func camelKey(src string) string {
	// From: https://github.com/etgryphon/stringUp

	var camelingRegex = regexp.MustCompile("[0-9A-Za-z]+")

	byteSrc := []byte(src)
	chunks := camelingRegex.FindAll(byteSrc, -1)
	for idx, val := range chunks {
		chunks[idx] = bytes.Title(val)
	}
	return string(bytes.Join(chunks, nil))
}
コード例 #15
0
ファイル: helper.go プロジェクト: ciarant/gcli
// camelCase transform string to CamelCase
func camelCase(s string) string {
	b := []byte(s)
	matched := reg.FindAll(b, -1)
	for i, m := range matched {
		if i == 0 {
			continue
		}
		matched[i] = bytes.Title(m)
	}

	return string(bytes.Join(matched, nil))
}
コード例 #16
0
ファイル: info.go プロジェクト: tgulacsi/aostor
func CanonicalHeaderKey(key []byte) []byte {
	return bytes.Title(key)
}
コード例 #17
0
ファイル: view.go プロジェクト: pombredanne/vigo
func (v *view) onVcommand(c viewCommand) {
	lastClass := v.lastCommand.Cmd.class()
	if c.Cmd.class() != lastClass || lastClass == vCommandClassMisc {
		v.buf.FinalizeActionGroup()
	}

	count := c.Count
	if count == 0 {
		count = 1
	}

	for i := 0; i < count; i++ {
		switch c.Cmd {
		case vCommandMoveCursorForward:
			v.moveCursorForward()

		case vCommandMoveCursorBackward:
			v.moveCursorBackward()

		case vCommandMoveCursorWordForward:
			v.moveCursorWordFoward()

		case vCommandMoveCursorWordEnd:
			v.moveCursorWordEnd()

		case vCommandMoveCursorWordBackward:
			v.moveCursorWordBackward()

		case vCommandMoveCursorNextLine:
			v.moveCursorNextLine()

		case vCommandMoveCursorPrevLine:
			v.moveCursorPrevLine()

		case vCommandMoveCursorBeginningOfLine:
			v.moveCursorBeginningOfLine()

		case vCommandMoveCursorEndOfLine:
			v.moveCursorEndOfLine()

		case vCommandMoveCursorBeginningOfFile:
			v.moveCursorBeginningOfFile()

		case vCommandMoveCursorEndOfFile:
			v.moveCursorEndOfFile()
			/*
				case vCommandMoveCursorToLine:
					v.MoveCursorToLine(int(arg))
			*/

		case vCommandMoveViewHalfForward:
			v.maybeMoveViewNlines(v.height() / 2)
		case vCommandMoveViewHalfBackward:
			v.moveViewNlines(-v.height() / 2)
		case vCommandInsertRune:
			v.buf.InsertRune(v.cursor, c.Rune)
		case vCommandYank:
			v.yank()
		case vCommandDeleteRuneBackward:
			v.buf.DeleteRuneBackward(v.cursor)
		case vCommandDeleteRune:
			v.buf.DeleteRune(v.cursor)
		case vCommandKillLine:
			v.killLine()
		case vCommandKillWord:
			v.killWord()
		case vCommandKillWordBackward:
			v.killWordBackward()
		case vCommandUndo:
			v.buf.Undo()
		case vCommandRedo:
			v.buf.Redo()
		case vCommandWordToUpper:
			v.wordTo(bytes.ToUpper)
		case vCommandWordToTitle:
			v.wordTo(func(s []byte) []byte {
				return bytes.Title(bytes.ToLower(s))
			})
		case vCommandWordToLower:
			v.wordTo(bytes.ToLower)
		}
	}

	v.lastCommand = c
}
コード例 #18
0
ファイル: example_test.go プロジェクト: achanda/go
func ExampleTitle() {
	fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
	// Output: Her Royal Highness
}
コード例 #19
0
ファイル: Title.go プロジェクト: cwen-coder/study-gopkg
func main() {
	s := []byte("hello, world!")
	fmt.Println(string(bytes.Title(s)))
	fmt.Println(string(s))
}
コード例 #20
0
ファイル: view.go プロジェクト: tv42/godit
func (v *view) on_vcommand(cmd vcommand, arg rune) {
	last_class := v.last_vcommand.class()
	if cmd.class() != last_class || last_class == vcommand_class_misc {
		v.finalize_action_group()
	}

	switch cmd {
	case vcommand_move_cursor_forward:
		v.move_cursor_forward()
	case vcommand_move_cursor_backward:
		v.move_cursor_backward()
	case vcommand_move_cursor_word_forward:
		v.move_cursor_word_forward()
	case vcommand_move_cursor_word_backward:
		v.move_cursor_word_backward()
	case vcommand_move_cursor_next_line:
		v.move_cursor_next_line()
	case vcommand_move_cursor_prev_line:
		v.move_cursor_prev_line()
	case vcommand_move_cursor_beginning_of_line:
		v.move_cursor_beginning_of_line()
	case vcommand_move_cursor_end_of_line:
		v.move_cursor_end_of_line()
	case vcommand_move_cursor_beginning_of_file:
		v.move_cursor_beginning_of_file()
	case vcommand_move_cursor_end_of_file:
		v.move_cursor_end_of_file()
	case vcommand_move_cursor_to_line:
		v.move_cursor_to_line(int(arg))
	case vcommand_move_view_half_forward:
		v.maybe_move_view_n_lines(v.height() / 2)
	case vcommand_move_view_half_backward:
		v.move_view_n_lines(-v.height() / 2)
	case vcommand_set_mark:
		v.set_mark()
	case vcommand_swap_cursor_and_mark:
		v.swap_cursor_and_mark()
	case vcommand_insert_rune:
		v.insert_rune(arg)
	case vcommand_yank:
		v.yank()
	case vcommand_delete_rune_backward:
		v.delete_rune_backward()
	case vcommand_delete_rune:
		v.delete_rune()
	case vcommand_kill_line:
		v.kill_line()
	case vcommand_kill_word:
		v.kill_word()
	case vcommand_kill_word_backward:
		v.kill_word_backward()
	case vcommand_kill_region:
		v.kill_region()
	case vcommand_copy_region:
		v.copy_region()
	case vcommand_undo:
		v.undo()
	case vcommand_redo:
		v.redo()
	case vcommand_autocompl_init:
		v.init_autocompl()
	case vcommand_autocompl_finalize:
		v.ac.finalize(v)
		v.ac = nil
	case vcommand_autocompl_move_cursor_up:
		v.ac.move_cursor_up()
	case vcommand_autocompl_move_cursor_down:
		v.ac.move_cursor_down()
	case vcommand_indent_region:
		v.indent_region()
	case vcommand_deindent_region:
		v.deindent_region()
	case vcommand_region_to_upper:
		v.region_to(bytes.ToUpper)
	case vcommand_region_to_lower:
		v.region_to(bytes.ToLower)
	case vcommand_word_to_upper:
		v.word_to(bytes.ToUpper)
	case vcommand_word_to_title:
		v.word_to(func(s []byte) []byte {
			return bytes.Title(bytes.ToLower(s))
		})
	case vcommand_word_to_lower:
		v.word_to(bytes.ToLower)
	}

	v.last_vcommand = cmd
}