pkg.go

Documentation: cuelang.org/go/pkg/path

     1  // Copyright 2020 CUE Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package path
    16  
    17  import (
    18  	"cuelang.org/go/internal/core/adt"
    19  	"cuelang.org/go/internal/pkg"
    20  )
    21  
    22  func init() {
    23  	pkg.Register("path", p)
    24  }
    25  
    26  var _ = adt.TopKind // in case the adt package isn't used
    27  
    28  var (
    29  	osRequired = &adt.Disjunction{
    30  		Values: allOS,
    31  	}
    32  
    33  	unixDefault = &adt.Disjunction{
    34  		NumDefaults: 1,
    35  		Values:      allOS,
    36  	}
    37  
    38  	// windowsDefault is the default for VolumeName.
    39  	windowsDefault = &adt.Disjunction{
    40  		NumDefaults: 1,
    41  		Values: append([]adt.Value{
    42  			newStr("windows"),
    43  			newStr("unix"),
    44  			newStr("plan9")}, unixOS...),
    45  	}
    46  
    47  	allOS = append([]adt.Value{
    48  		newStr("unix"),
    49  		newStr("windows"),
    50  		newStr("plan9"),
    51  	}, unixOS...)
    52  
    53  	// These all fall back to unix
    54  	unixOS = []adt.Value{
    55  		newStr("aix"),
    56  		newStr("android"),
    57  		newStr("darwin"),
    58  		newStr("dragonfly"),
    59  		newStr("freebsd"),
    60  		newStr("hurd"),
    61  		newStr("illumos"),
    62  		newStr("ios"),
    63  		newStr("js"),
    64  		newStr("linux"),
    65  		newStr("nacl"),
    66  		newStr("netbsd"),
    67  		newStr("openbsd"),
    68  		newStr("solaris"),
    69  		newStr("zos"),
    70  	}
    71  )
    72  
    73  func newStr(s string) adt.Value {
    74  	return &adt.String{Str: s}
    75  }
    76  
    77  var p = &pkg.Package{
    78  	CUE: `{
    79  		Unix:    "unix"
    80  		Windows: "windows"
    81  		Plan9:   "plan9"
    82  	}`,
    83  	Native: []*pkg.Builtin{{
    84  		Name: "Split",
    85  		Params: []pkg.Param{
    86  			{Kind: adt.StringKind},
    87  			{Kind: adt.StringKind, Value: unixDefault},
    88  		},
    89  		Result: adt.ListKind,
    90  		Func: func(c *pkg.CallCtxt) {
    91  			path, os := c.String(0), c.String(1)
    92  			if c.Do() {
    93  				c.Ret = Split(path, OS(os))
    94  			}
    95  		},
    96  	}, {
    97  		Name: "SplitList",
    98  		Params: []pkg.Param{
    99  			{Kind: adt.StringKind},
   100  			{Kind: adt.StringKind, Value: osRequired},
   101  		},
   102  		Result: adt.ListKind,
   103  		Func: func(c *pkg.CallCtxt) {
   104  			path, os := c.String(0), c.String(1)
   105  			if c.Do() {
   106  				c.Ret = SplitList(path, OS(os))
   107  			}
   108  		},
   109  	}, {
   110  		Name: "Join",
   111  		Params: []pkg.Param{
   112  			{Kind: adt.ListKind},
   113  			{Kind: adt.StringKind, Value: unixDefault},
   114  		},
   115  		Result: adt.StringKind,
   116  		Func: func(c *pkg.CallCtxt) {
   117  			list, os := c.StringList(0), c.String(1)
   118  			if c.Do() {
   119  				c.Ret = Join(list, OS(os))
   120  			}
   121  		},
   122  	}, {
   123  		Name: "Match",
   124  		Params: []pkg.Param{
   125  			{Kind: adt.StringKind},
   126  			{Kind: adt.StringKind, Value: unixDefault},
   127  		},
   128  		Result: adt.BoolKind,
   129  		Func: func(c *pkg.CallCtxt) {
   130  			pattern, name, os := c.String(0), c.String(1), c.String(2)
   131  			if c.Do() {
   132  				c.Ret, c.Err = Match(pattern, name, OS(os))
   133  			}
   134  		},
   135  	}, {
   136  		Name: "Clean",
   137  		Params: []pkg.Param{
   138  			{Kind: adt.StringKind},
   139  			{Kind: adt.StringKind, Value: unixDefault},
   140  		},
   141  		Result: adt.StringKind,
   142  		Func: func(c *pkg.CallCtxt) {
   143  			path, os := c.String(0), c.String(1)
   144  			if c.Do() {
   145  				c.Ret = Clean(path, OS(os))
   146  			}
   147  		},
   148  	}, {
   149  		Name: "ToSlash",
   150  		Params: []pkg.Param{
   151  			{Kind: adt.StringKind},
   152  			{Kind: adt.StringKind, Value: osRequired},
   153  		},
   154  		Result: adt.StringKind,
   155  		Func: func(c *pkg.CallCtxt) {
   156  			path, os := c.String(0), c.String(1)
   157  			if c.Do() {
   158  				c.Ret = ToSlash(path, OS(os))
   159  			}
   160  		},
   161  	}, {
   162  		Name: "FromSlash",
   163  		Params: []pkg.Param{
   164  			{Kind: adt.StringKind},
   165  			{Kind: adt.StringKind, Value: osRequired},
   166  		},
   167  		Result: adt.StringKind,
   168  		Func: func(c *pkg.CallCtxt) {
   169  			path, os := c.String(0), c.String(1)
   170  			if c.Do() {
   171  				c.Ret = FromSlash(path, OS(os))
   172  			}
   173  		},
   174  	}, {
   175  		Name: "Ext",
   176  		Params: []pkg.Param{
   177  			{Kind: adt.StringKind},
   178  			{Kind: adt.StringKind, Value: unixDefault},
   179  		},
   180  		Result: adt.StringKind,
   181  		Func: func(c *pkg.CallCtxt) {
   182  			path, os := c.String(0), c.String(1)
   183  			if c.Do() {
   184  				c.Ret = Ext(path, OS(os))
   185  			}
   186  		},
   187  	}, {
   188  		Name: "Resolve",
   189  		Params: []pkg.Param{
   190  			{Kind: adt.StringKind},
   191  			{Kind: adt.StringKind},
   192  			{Kind: adt.StringKind, Value: unixDefault},
   193  		},
   194  		Result: adt.StringKind,
   195  		Func: func(c *pkg.CallCtxt) {
   196  			dir, sub, os := c.String(0), c.String(1), c.String(2)
   197  			if c.Do() {
   198  				c.Ret = Resolve(dir, sub, OS(os))
   199  			}
   200  		},
   201  	}, {
   202  		Name: "Rel",
   203  		Params: []pkg.Param{
   204  			{Kind: adt.StringKind},
   205  			{Kind: adt.StringKind},
   206  			{Kind: adt.StringKind, Value: unixDefault},
   207  		},
   208  		Result: adt.StringKind,
   209  		Func: func(c *pkg.CallCtxt) {
   210  			base, target, os := c.String(0), c.String(1), c.String(2)
   211  			if c.Do() {
   212  				c.Ret, c.Err = Rel(base, target, OS(os))
   213  			}
   214  		},
   215  	}, {
   216  		Name: "Base",
   217  		Params: []pkg.Param{
   218  			{Kind: adt.StringKind},
   219  			{Kind: adt.StringKind, Value: unixDefault},
   220  		},
   221  		Result: adt.StringKind,
   222  		Func: func(c *pkg.CallCtxt) {
   223  			path, os := c.String(0), c.String(1)
   224  			if c.Do() {
   225  				c.Ret = Base(path, OS(os))
   226  			}
   227  		},
   228  	}, {
   229  		Name: "Dir",
   230  		Params: []pkg.Param{
   231  			{Kind: adt.StringKind},
   232  			{Kind: adt.StringKind, Value: unixDefault},
   233  		},
   234  		Result: adt.StringKind,
   235  		Func: func(c *pkg.CallCtxt) {
   236  			path, os := c.String(0), c.String(1)
   237  			if c.Do() {
   238  				c.Ret = Dir(path, OS(os))
   239  			}
   240  		},
   241  	}, {
   242  		Name: "IsAbs",
   243  		Params: []pkg.Param{
   244  			{Kind: adt.StringKind},
   245  			{Kind: adt.StringKind, Value: unixDefault},
   246  		},
   247  		Result: adt.BoolKind,
   248  		Func: func(c *pkg.CallCtxt) {
   249  			path, os := c.String(0), c.String(1)
   250  			if c.Do() {
   251  				c.Ret = IsAbs(path, OS(os))
   252  			}
   253  		},
   254  	}, {
   255  		Name: "VolumeName",
   256  		Params: []pkg.Param{
   257  			{Kind: adt.StringKind},
   258  			{Kind: adt.StringKind, Value: windowsDefault},
   259  		},
   260  		Result: adt.StringKind,
   261  		Func: func(c *pkg.CallCtxt) {
   262  			path, os := c.String(0), c.String(1)
   263  			if c.Do() {
   264  				c.Ret = VolumeName(path, OS(os))
   265  			}
   266  		},
   267  	}},
   268  }
   269
View as plain text