github.com/AiRISTAFlowInc/fs-cli@v0.2.6/api/imports.go (about)

     1  package api
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"os/exec"
     7  	"path/filepath"
     8  	"strings"
     9  
    10  	"github.com/AiRISTAFlowInc/fs-cli/common"
    11  	"github.com/AiRISTAFlowInc/fs-cli/util"
    12  	"github.com/AiRISTAFlowInc/fs-core/app"
    13  )
    14  
    15  func ListProjectImports(project common.AppProject) error {
    16  	appImports, err := util.GetAppImports(filepath.Join(project.Dir(), fileFlogoJson), project.DepManager(), false)
    17  	if err != nil {
    18  		return err
    19  	}
    20  
    21  	for _, imp := range appImports.GetAllImports() {
    22  
    23  		fmt.Fprintf(os.Stdout, "  %s\n", imp)
    24  	}
    25  
    26  	return nil
    27  }
    28  
    29  func SyncProjectImports(project common.AppProject) error {
    30  	appImports, err := util.GetAppImports(filepath.Join(project.Dir(), fileFlogoJson), project.DepManager(), false)
    31  	if err != nil {
    32  		return err
    33  	}
    34  	appImportsMap := make(map[string]util.Import)
    35  	for _, imp := range appImports.GetAllImports() {
    36  		appImportsMap[imp.GoImportPath()] = imp
    37  	}
    38  
    39  	goImports, err := project.GetGoImports(false)
    40  	if err != nil {
    41  		return err
    42  	}
    43  	goImportsMap := make(map[string]util.Import)
    44  	for _, imp := range goImports {
    45  		goImportsMap[imp.GoImportPath()] = imp
    46  	}
    47  
    48  	var toAdd []util.Import
    49  	for goPath, imp := range appImportsMap {
    50  		if _, ok := goImportsMap[goPath]; !ok {
    51  			toAdd = append(toAdd, imp)
    52  			if Verbose() {
    53  				fmt.Println("Adding missing Go import: ", goPath)
    54  			}
    55  		}
    56  	}
    57  
    58  	if util.FileExists(filepath.Join(project.Dir(), fileEngineJson)) {
    59  		engineImports, err := util.GetEngineImports(filepath.Join(project.Dir(), fileEngineJson), project.DepManager())
    60  		if err != nil {
    61  			return err
    62  		}
    63  
    64  		engImportsMap := make(map[string]util.Import)
    65  		for _, imp := range engineImports.GetAllImports() {
    66  			engImportsMap[imp.GoImportPath()] = imp
    67  		}
    68  
    69  		for goPath, imp := range engImportsMap {
    70  			if _, ok := goImportsMap[goPath]; !ok {
    71  				toAdd = append(toAdd, imp)
    72  				if Verbose() {
    73  					fmt.Println("Adding missing Go import: ", goPath)
    74  				}
    75  			}
    76  		}
    77  	}
    78  
    79  	var toRemove []string
    80  	for goPath := range goImportsMap {
    81  		if _, ok := appImportsMap[goPath]; !ok {
    82  			toRemove = append(toRemove, goPath)
    83  			if Verbose() {
    84  				fmt.Println("Removing extraneous Go import: ", goPath)
    85  			}
    86  		}
    87  	}
    88  
    89  	err = project.RemoveImports(toRemove...)
    90  	if err != nil {
    91  		return err
    92  	}
    93  
    94  	err = project.AddImports(false, false, toAdd...)
    95  	if err != nil {
    96  		return err
    97  	}
    98  
    99  	err = util.ExecCmd(exec.Command("go", "mod", "tidy"), project.SrcDir())
   100  	if err != nil {
   101  		fmt.Println("[err]", err)
   102  	}
   103  
   104  	return nil
   105  }
   106  
   107  func ResolveProjectImports(project common.AppProject) error {
   108  	if Verbose() {
   109  		fmt.Fprintln(os.Stdout, "Synchronizing project imports")
   110  	}
   111  	err := SyncProjectImports(project)
   112  	if err != nil {
   113  		return err
   114  	}
   115  
   116  	if Verbose() {
   117  		fmt.Fprintln(os.Stdout, "Reading flogo.json")
   118  	}
   119  	appDescriptor, err := readAppDescriptor(project)
   120  	if err != nil {
   121  		return err
   122  	}
   123  
   124  	if Verbose() {
   125  		fmt.Fprintln(os.Stdout, "Updating flogo.json import versions")
   126  	}
   127  	err = updateDescriptorImportVersions(project, appDescriptor)
   128  	if err != nil {
   129  		return err
   130  	}
   131  
   132  	if Verbose() {
   133  		fmt.Fprintln(os.Stdout, "Saving updated flogo.json")
   134  	}
   135  	err = writeAppDescriptor(project, appDescriptor)
   136  	if err != nil {
   137  		return err
   138  	}
   139  
   140  	return nil
   141  }
   142  
   143  func updateDescriptorImportVersions(project common.AppProject, appDescriptor *app.Config) error {
   144  	goModImports, err := project.DepManager().GetAllImports()
   145  	if err != nil {
   146  		return err
   147  	}
   148  
   149  	appImports, err := util.ParseImports(appDescriptor.Imports)
   150  	if err != nil {
   151  		return err
   152  	}
   153  
   154  	var result []string
   155  
   156  	for _, appImport := range appImports {
   157  
   158  		if goModImport, ok := goModImports[appImport.ModulePath()]; ok {
   159  			updatedImp := util.NewFlogoImportWithVersion(appImport, goModImport.Version())
   160  			result = append(result, updatedImp.CanonicalImport())
   161  		} else {
   162  			//not found, look for import of parent package
   163  			for pkg, goModImport := range goModImports {
   164  				if strings.Contains(appImport.ModulePath(), pkg) {
   165  					updatedImp := util.NewFlogoImportWithVersion(appImport, goModImport.Version())
   166  					result = append(result, updatedImp.CanonicalImport())
   167  				}
   168  			}
   169  		}
   170  	}
   171  
   172  	appDescriptor.Imports = result
   173  
   174  	return nil
   175  }