예제 #1
0
파일: show.go 프로젝트: 9seconds/ah
// Show implements s (show) command.
func Show(slice *slices.Slice, filter *utils.Regexp, env *environments.Environment) {
	var commands []historyentries.HistoryEntry

	if slice.Start >= 0 && slice.Finish >= 0 {
		keeper, err := historyentries.GetCommands(historyentries.GetCommandsRange,
			filter, env, slice.Start, slice.Finish)
		if err != nil {
			return
		}
		commands = keeper.Result().([]historyentries.HistoryEntry)
	} else {
		keeper, err := historyentries.GetCommands(historyentries.GetCommandsAll, filter, env)
		if err != nil {
			return
		}
		toBeRanged := keeper.Result().([]historyentries.HistoryEntry)
		sliceStart := slices.GetSliceIndex(slice.Start, len(toBeRanged))
		sliceFinish := slices.GetSliceIndex(slice.Finish, len(toBeRanged))
		if sliceStart < 0 || sliceFinish < 0 || sliceFinish <= sliceStart {
			return
		}
		commands = toBeRanged[sliceStart:sliceFinish]
	}

	for idx := 0; idx < len(commands); idx++ {
		os.Stdout.WriteString(commands[idx].ToString(env))
		os.Stdout.WriteString("\n")
	}
}
예제 #2
0
파일: list_trace.go 프로젝트: 9seconds/ah
// ListTrace implements l command (list trace).
func ListTrace(argument string, env *environments.Environment) {
	number, err := strconv.Atoi(argument)
	if err != nil || number < 0 {
		utils.Logger.Panicf("Cannot convert argument to a command number: %s", argument)
	}

	commands, err := historyentries.GetCommands(historyentries.GetCommandsPrecise, nil, env, number)
	if err != nil {
		utils.Logger.Panic(err)
	}
	command := commands.Result().(historyentries.HistoryEntry)
	hashFilename := command.GetTraceName()
	filename := env.GetTraceFileName(hashFilename)
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		utils.Logger.Panicf("Output for %s is not exist", argument)
	}

	file := utils.Open(filename)
	defer file.Close()
	ungzippedFile, err := gzip.NewReader(file)
	if err != nil {
		utils.Logger.Panic(err)
	}
	defer ungzippedFile.Close()

	scanner := bufio.NewScanner(ungzippedFile)
	for scanner.Scan() {
		os.Stdout.WriteString(scanner.Text())
		os.Stdout.WriteString("\n")
	}

	if err := scanner.Err(); err != nil {
		utils.Logger.Panic(err)
	}
}
예제 #3
0
파일: execute.go 프로젝트: 9seconds/ah
// ExecuteCommandNumber executes command by its number in history file.
func ExecuteCommandNumber(number int, interactive bool, pseudoTTY bool, env *environments.Environment) {
	if number < 0 {
		utils.Logger.Panic("Cannot find such command")
	}

	commands, err := historyentries.GetCommands(historyentries.GetCommandsPrecise, nil, env, number)
	if err != nil {
		utils.Logger.Panic(err)
	}
	command := commands.Result().(historyentries.HistoryEntry)

	execute(command.GetCommand(), env.Shell, interactive, pseudoTTY)
}
예제 #4
0
파일: tee.go 프로젝트: 9seconds/ah
func getPreciseHash(cmd string, env *environments.Environment) (hash string, err error) {
	commands, err := historyentries.GetCommands(historyentries.GetCommandsAll, nil, env)
	if err != nil {
		err = fmt.Errorf("Cannot fetch commands list: %v", err)
		return
	}
	commandList := commands.Result().([]historyentries.HistoryEntry)

	if len(commandList) == 0 {
		err = errors.New("Command list is empty")
		return
	}

	// Why do I need such complicated logic here? The reason is trivial:
	// one may use substitutions in a command like
	// ah t -- `which python` script $(docker images -a -q)
	// basically it manages these situations as precise as possible.

	// Candidates here just means that several command may be executed
	// simultaneously (e.g. with tmuxinator) so timestamp is not precise
	// identifier here.

	candidates, err := getCandidates(commandList)
	if err != nil {
		err = fmt.Errorf("Cannot detect proper command: %v", err)
		return
	}

	if len(candidates) == 1 {
		hash = candidates[0].GetTraceName()
		return
	}

	suitable := getSuitable(candidates, cmd)
	hash = (*suitable).GetTraceName()

	return
}
예제 #5
0
파일: bookmark.go 프로젝트: 9seconds/ah
// Bookmark implements "b" (bookmark) command.
func Bookmark(commandNumber int, bookmarkAs string, env *environments.Environment) {
	if commandNumber < 0 {
		utils.Logger.Panic("Command number should be >= 0")
	}

	commandsKeeper, err := historyentries.GetCommands(historyentries.GetCommandsAll, nil, env)
	if err != nil {
		utils.Logger.Panic(err)
	}
	commands := commandsKeeper.Result().([]historyentries.HistoryEntry)
	if len(commands) <= commandNumber {
		utils.Logger.Panic("Command number does not exist")
	}
	command := commands[commandNumber-1]

	filename := env.GetBookmarkFileName(bookmarkAs)
	file, err := os.Create(filename)
	if err != nil {
		utils.Logger.Panicf("Cannot create bookmark %s: %v", filename, err)
	}
	defer file.Close()

	file.WriteString(command.GetCommand())
}