github.com/lmorg/murex@v0.0.0-20240217211045-e081c89cd4ef/builtins/core/modules/cmd.go (about)

     1  package modules
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"os"
     7  	"strings"
     8  
     9  	"github.com/lmorg/murex/config/profile"
    10  	"github.com/lmorg/murex/lang"
    11  	"github.com/lmorg/murex/lang/types"
    12  	"github.com/lmorg/murex/utils/ansi"
    13  	"github.com/lmorg/murex/utils/cd"
    14  )
    15  
    16  const usage = `
    17  Usage: murex-package install         uri
    18                       remove          package
    19                       update
    20                       reload
    21                       enable|disable  package[/module]
    22                       import          [uri|local path]packages.json
    23                       status
    24                       list            loaded|not-loaded|enabled|disabled|packages`
    25  
    26  func init() {
    27  	lang.DefineFunction("murex-package", cmdModuleAdmin, types.Json)
    28  }
    29  
    30  func cmdModuleAdmin(p *lang.Process) error {
    31  	method, _ := p.Parameters.String(0)
    32  	switch method {
    33  	case "install":
    34  		return getModule(p)
    35  
    36  	case "remove":
    37  		return removePackage(p)
    38  
    39  	case "update":
    40  		return updateModules(p)
    41  
    42  	case "reload":
    43  		return reloadModules(p)
    44  
    45  	case "import":
    46  		return importModules(p)
    47  
    48  	case "enable":
    49  		return enableModules(p)
    50  
    51  	case "disable":
    52  		return disableModules(p)
    53  
    54  	case "status":
    55  		return statusModules(p)
    56  
    57  	case "list":
    58  		return listModules(p)
    59  
    60  	case "new":
    61  		return newPackage(p)
    62  
    63  	case "cd":
    64  		return cdPackage(p)
    65  
    66  	case "git":
    67  		return gitPackage(p)
    68  
    69  	default:
    70  		return errors.New("missing or invalid parameters." + usage)
    71  	}
    72  }
    73  
    74  func detectProtocol(uri string) (string, error) {
    75  	switch {
    76  	case strings.HasPrefix(uri, "http://"):
    77  		return "", errors.New("for security reasons, downloading packages is not allowed over plain text http. Please use `https://` instead")
    78  
    79  	case strings.HasSuffix(uri, ".git"):
    80  		return "git", nil
    81  
    82  	case strings.HasPrefix(uri, "https://"):
    83  		return "https", nil
    84  
    85  	default:
    86  		return "", errors.New("unable to get package: Unable to auto-detect a suitable protocol for transferring the package")
    87  	}
    88  }
    89  
    90  func cdPackage(p *lang.Process) error {
    91  	modulePath := profile.ModulePath()
    92  
    93  	path, err := p.Parameters.String(1)
    94  	if err != nil {
    95  		return err
    96  	}
    97  
    98  	f, err := os.Stat(modulePath + path)
    99  	if err != nil {
   100  		var err2 error
   101  		f, err2 = os.Stat(modulePath + path + profile.IgnoredExt)
   102  		if err2 != nil {
   103  			return fmt.Errorf("unable to cd to package: %s: %s", err, err2)
   104  		}
   105  	}
   106  
   107  	if !f.IsDir() {
   108  		return fmt.Errorf("`%s` is not a directory", f.Name())
   109  	}
   110  
   111  	return cd.Chdir(p, modulePath+f.Name())
   112  }
   113  
   114  func updateModules(p *lang.Process) error {
   115  	db, err := readPackagesFile(profile.ModulePath() + profile.PackagesFile)
   116  	if err != nil {
   117  		return err
   118  	}
   119  
   120  	for i := range db {
   121  		if err := packageDirExists(profile.ModulePath() + "/" + db[i].Package); err == nil {
   122  			write(p, "{BLUE}Skipping package '{BOLD}%s{RESET}{BLUE}'....{RESET}", db[i].Package)
   123  			continue
   124  		}
   125  
   126  		write(p, "Updating package '{BOLD}%s{RESET}'....", db[i].Package)
   127  
   128  		switch db[i].Protocol {
   129  		case "git":
   130  			err = gitUpdate(p, &db[i])
   131  			if err != nil {
   132  				write(p, "{RED}Unable to update package '{BOLD}%s{RESET}{RED}': %s{RESET}", db[i].Package, err.Error())
   133  			}
   134  
   135  		default:
   136  			write(p, "{RED}Unable to update package '{BOLD}%s{RESET}{RED}': Unknown protocol '%s'{RESET}", db[i].Package, db[i].Protocol)
   137  		}
   138  	}
   139  
   140  	return nil
   141  }
   142  
   143  func reloadModules(p *lang.Process) error {
   144  	profile.Execute(profile.F_MODULES)
   145  	return nil
   146  }
   147  
   148  func write(p *lang.Process, format string, v ...any) {
   149  	message := fmt.Sprintf("* "+ansi.ExpandConsts(format), v...)
   150  	p.Stdout.Writeln([]byte(message))
   151  }