// NewHelper ...
func NewHelper(destinationDir, remoteURI string, resetRepository bool) (Helper, error) {
if destinationDir == "" {
return Helper{}, errors.New("destination dir path is empty")
}
if remoteURI == "" {
return Helper{}, errors.New("remote URI is empty")
}
// Expand destination dir
fullDestinationDir, err := pathutil.AbsPath(destinationDir)
if err != nil {
return Helper{}, err
}
helper := Helper{
destinationDir: fullDestinationDir,
remoteURI: remoteURI,
}
// Check if .git exist
gitDirPth := filepath.Join(fullDestinationDir, ".git")
if exist, err := pathutil.IsDirExists(gitDirPth); err != nil {
return Helper{}, err
} else if exist {
if remotes, err := helper.RemoteList(); err != nil {
return Helper{}, err
} else {
if !strings.Contains(remotes, remoteURI) {
return Helper{}, fmt.Errorf(".git folder already exists in the destination dir: %s, using a different remote", fullDestinationDir)
} else {
if resetRepository {
if err = helper.Clean(); err != nil {
return Helper{}, err
}
}
helper.originPresent = true
}
}
}
// Create destination dir if not exist
if exist, err := pathutil.IsDirExists(fullDestinationDir); err != nil {
return Helper{}, err
} else if !exist {
if err := os.MkdirAll(fullDestinationDir, 0777); err != nil {
return Helper{}, err
}
}
return helper, nil
}
func saveAttachements(projectPath, scheme string) error {
projectName := filepath.Base(projectPath)
projectExt := filepath.Ext(projectName)
projectName = strings.TrimSuffix(projectName, projectExt)
userHome := pathutil.UserHomeDir()
deviedDataDir := filepath.Join(userHome, "Library/Developer/Xcode/DerivedData")
projectDerivedDataDirPattern := filepath.Join(deviedDataDir, fmt.Sprintf("%s-*", projectName))
projectDerivedDataDirs, err := filepath.Glob(projectDerivedDataDirPattern)
if err != nil {
return err
}
if len(projectDerivedDataDirs) > 1 {
return fmt.Errorf("more than 1 project derived data dir found: %v, with pattern: %s", projectDerivedDataDirs, projectDerivedDataDirPattern)
} else if len(projectDerivedDataDirs) == 0 {
return fmt.Errorf("no project derived data dir found with pattern: %s", projectDerivedDataDirPattern)
}
projectDerivedDataDir := projectDerivedDataDirs[0]
testLogDir := filepath.Join(projectDerivedDataDir, "Logs", "Test")
if exist, err := pathutil.IsDirExists(testLogDir); err != nil {
return err
} else if !exist {
return fmt.Errorf("no test logs found at: %s", projectDerivedDataDir)
}
testLogAttachmentsDir := filepath.Join(testLogDir, "Attachments")
if exist, err := pathutil.IsDirExists(testLogAttachmentsDir); err != nil {
return err
} else if !exist {
return fmt.Errorf("no test attachments found at: %s", testLogAttachmentsDir)
}
deployDir := os.Getenv("BITRISE_DEPLOY_DIR")
if deployDir == "" {
return errors.New("No BITRISE_DEPLOY_DIR found")
}
zipedTestsDerivedDataPath := filepath.Join(deployDir, fmt.Sprintf("%s-xc-test-Attachments.zip", scheme))
if err := cmd.Zip(testLogDir, "Attachments", zipedTestsDerivedDataPath); err != nil {
return err
}
if err := cmd.ExportEnvironmentWithEnvman("BITRISE_XCODE_TEST_ATTACHMENTS_PATH", zipedTestsDerivedDataPath); err != nil {
log.Warn("Failed to export: BITRISE_XCODE_TEST_ATTACHMENTS_PATH, error: %s", err)
}
return nil
}
func TestNewHelper(t *testing.T) {
t.Log("it fails if destinationDir empty")
{
helper, err := NewHelper("", "https://github.com/bitrise-samples/git-clone-test.git", false)
require.Error(t, err)
require.Equal(t, "", helper.destinationDir)
require.Equal(t, "", helper.remoteURI)
}
t.Log("it fails if remote URI empty")
{
helper, err := NewHelper("./", "", false)
require.Error(t, err)
require.Equal(t, "", helper.destinationDir)
require.Equal(t, "", helper.remoteURI)
}
t.Log("it fails if remote URI empty")
{
helper, err := NewHelper("./", "", false)
require.Error(t, err)
require.Equal(t, "", helper.destinationDir)
require.Equal(t, "", helper.remoteURI)
}
t.Log("it creates destination dir if not exist")
{
tmpDir, err := pathutil.NormalizedOSTempDirPath("__test__")
require.NoError(t, err)
destinationDir := filepath.Join(tmpDir, "dst")
exist, err := pathutil.IsDirExists(destinationDir)
require.NoError(t, err)
require.Equal(t, false, exist)
helper, err := NewHelper(destinationDir, "https://github.com/bitrise-samples/git-clone-test.git", false)
require.NoError(t, err)
require.Equal(t, destinationDir, helper.destinationDir)
require.Equal(t, "https://github.com/bitrise-samples/git-clone-test.git", helper.remoteURI)
exist, err = pathutil.IsDirExists(destinationDir)
require.NoError(t, err)
require.Equal(t, true, exist)
require.NoError(t, os.RemoveAll(tmpDir))
}
}
func ensureEnvmanConfigDirExists() error {
confDirPth := getEnvmanConfigsDirPath()
isExists, err := pathutil.IsDirExists(confDirPth)
if !isExists || err != nil {
if err := os.MkdirAll(confDirPth, 0777); err != nil {
return err
}
}
return nil
}
// CleanAll ...
func (builder Model) CleanAll(callback ClearCommandCallback) error {
whitelistedProjects := builder.whitelistedProjects()
for _, proj := range whitelistedProjects {
projectDir := filepath.Dir(proj.Pth)
{
binPth := filepath.Join(projectDir, "bin")
if exist, err := pathutil.IsDirExists(binPth); err != nil {
return err
} else if exist {
if callback != nil {
callback(proj, binPth)
}
if err := os.RemoveAll(binPth); err != nil {
return err
}
}
}
{
objPth := filepath.Join(projectDir, "obj")
if exist, err := pathutil.IsDirExists(objPth); err != nil {
return err
} else if exist {
if callback != nil {
callback(proj, objPth)
}
if err := os.RemoveAll(objPth); err != nil {
return err
}
}
}
}
return nil
}
// DeletePlugin ...
func DeletePlugin(name string) error {
pluginDir := GetPluginDir(name)
if exists, err := pathutil.IsDirExists(pluginDir); err != nil {
return err
} else if !exists {
return fmt.Errorf("Plugin (%s) not installed", name)
}
if err := os.RemoveAll(pluginDir); err != nil {
return fmt.Errorf("failed to delete dir (%s)", pluginDir)
}
return DeletePluginRoute(name)
}
func initExportOutputDir() (string, error) {
absExportOutputDirPath, err := pathutil.AbsPath(confExportOutputDirPath)
log.Debugf("absExportOutputDirPath: %s", absExportOutputDirPath)
if err != nil {
return absExportOutputDirPath, fmt.Errorf("Failed to determin Absolute path of export dir: %s", confExportOutputDirPath)
}
if exist, err := pathutil.IsDirExists(absExportOutputDirPath); err != nil {
return absExportOutputDirPath, fmt.Errorf("Failed to determin whether the export directory already exists: %s", err)
} else if !exist {
if err := os.Mkdir(absExportOutputDirPath, 0777); err != nil {
return absExportOutputDirPath, fmt.Errorf("Failed to create export output directory at path: %s | error: %s", absExportOutputDirPath, err)
}
} else {
log.Infof("Export output dir already exists at path: %s", absExportOutputDirPath)
}
return absExportOutputDirPath, nil
}
// LoadPlugin ...
func LoadPlugin(name string) (Plugin, bool, error) {
pluginDir := GetPluginDir(name)
if exists, err := pathutil.IsDirExists(pluginDir); err != nil {
return Plugin{}, false, fmt.Errorf("Failed to check dir (%s), err: %s", pluginDir, err)
} else if !exists {
return Plugin{}, false, nil
}
pluginYMLPath := GetPluginYMLPath(name)
plugin, err := NewPluginFromYML(pluginYMLPath)
if err != nil {
return Plugin{}, true, err
}
return plugin, true, nil
}
func convert(c *cli.Context) {
// Input validation
src := c.String(SourceKey)
if src == "" {
log.Fatal("Missing source")
}
sources := []string{}
srcSlice := strings.Split(src, ",")
if len(srcSlice) > 1 {
// Comma separated sources
log.Info("Converting workflows at:", srcSlice)
fmt.Println()
sources = srcSlice
} else {
isDir, err := pathutil.IsDirExists(src)
if err != nil {
log.Fatal("Failed to check path:", err)
}
if isDir {
// Converting workflows in directory
log.Info("Converting workflows in dir:", src)
fmt.Println()
if err := filepath.Walk(src, func(path string, f os.FileInfo, err error) error {
if filepath.Ext(path) == ".yml" {
sources = append(sources, path)
}
return nil
}); err != nil {
log.Fatal("Faild to collect workflow pathes")
}
log.Info("Converting workflows at:", sources)
fmt.Println()
} else {
// Converting single workflow
log.Info("Converting single workflows at:", src)
fmt.Println()
sources = append(sources, src)
}
}
dstPth := c.String(DestinationKey)
if dstPth == "" {
log.Fatal("Missing destination")
}
// Read old workflow
oldWorkflowMap := map[string]oldModels.WorkflowModel{}
for _, srcPth := range sources {
log.Infoln("Converting workflow at:", srcPth)
fmt.Println()
oldWorkflow, err := utils.ReadOldWorkflowModel(srcPth)
if err != nil {
log.Fatal("Failed to read old workflow:", err)
}
oldWorkflowID := getWorkflowNameFromPath(srcPth)
log.Debugln("Old workflow:")
log.Debugf("%#v", oldWorkflow)
oldWorkflowMap[oldWorkflowID] = oldWorkflow
}
// Convert workflow
newConfig, err := converter.ConvertOldWorkfowModels(oldWorkflowMap)
if err != nil {
log.Fatal("Failed to convert old workflow:", err)
}
log.Debugln("New workflow:")
log.Debugf("%#v", newConfig)
// Write new wokrflow to file
if err := utils.WriteNewWorkflowModel(dstPth, newConfig); err != nil {
if err != nil {
log.Fatal("Failed to write new workflow:", err)
}
}
log.Infoln("Converted workflow path:", dstPth)
fmt.Println()
}
func export(c *cli.Context) error {
// Input validation
steplibURI := c.String("steplib")
outputPth := c.String("output")
exportTypeStr := c.String("export-type")
if steplibURI == "" {
return fmt.Errorf("Missing required input: steplib")
}
if outputPth == "" {
return fmt.Errorf("Missing required input: output")
}
exportType := exportTypeFull
if exportTypeStr != "" {
var err error
exportType, err = parseExportType(exportTypeStr)
if err != nil {
return err
}
}
log.Infof("Exporting StepLib (%s) spec, export-type: %s, output: %s", steplibURI, exportTypeStr, outputPth)
// Setup StepLib
if exist, err := stepman.RootExistForCollection(steplibURI); err != nil {
return fmt.Errorf("Failed to check if setup was done for StepLib, error: %s", err)
} else if !exist {
log.Infof("StepLib does not exist, setup...")
if err := setupSteplib(steplibURI, false); err != nil {
return fmt.Errorf("Failed to setup StepLib, error: %s", err)
}
}
// Prepare spec
stepLibSpec, err := stepman.ReadStepSpec(steplibURI)
if err != nil {
log.Fatalln("Failed to read StepLib spec, error: %s", err)
}
switch exportType {
case exportTypeMinimal:
stepLibSpec = convertToMinimalSpec(stepLibSpec)
case exportTypeLatest:
stepLibSpec = convertToLatestSpec(stepLibSpec)
}
stepLibSpecBytes, err := json.Marshal(stepLibSpec)
if err != nil {
return fmt.Errorf("Failed to marshal StepLib, error: %s", err)
}
// Export spec
outputDir := filepath.Dir(outputPth)
exist, err := pathutil.IsDirExists(outputDir)
if err != nil {
return fmt.Errorf("Failed to check if dir (%s) exist, error: %s", outputDir, err)
}
if !exist {
if err := os.MkdirAll(outputDir, 0777); err != nil {
return fmt.Errorf("Failed to create dir (%s), error: %s", outputDir, err)
}
}
if err := fileutil.WriteBytesToFile(outputPth, stepLibSpecBytes); err != nil {
return fmt.Errorf("Failed to write StepLib spec to: %s, error: %s", outputPth, err)
}
log.Infof("StepLib spec exported to: %s", outputPth)
return nil
}