Example #1
0
// ConvertToMP3 converts given file into .mp3 file
// Example: ConvertToMP3("oldAudio", "newAudio")
// Result: newAudio.mp3
// If only one argument is passed, than result will have the same name
func ConvertToMP3(filenames ...string) error {
	var toFilename string
	var fromFilename string = filenames[0]
	switch len(filenames) {
	case 1:
		toFilename = cutExtension(filenames[0])
		break
	case 0:
		return errors.New("error: no arguements passed")
	default:
		toFilename = cutExtension(filenames[1])
	}
	os.Remove(toFilename + ".mp3")
	// Convert to MP3
	switch path.Ext(fromFilename) {
	case ".amr":
		comm := exec.Command("ffmpeg", "-i", fromFilename, "-ar", AudioSamplingRateMP3, toFilename+".mp3")
		if err := comm.Run(); err != nil {
			return ConvertError
		}
	default:
		return fmt.Errorf("Unsupported format: %v", path.Ext(fromFilename))
	}
	return nil
}
// When a test is skipped or fails, runtime.Goexit() is called which destroys the callstack.
// This means the name of the test case is lost, so we need to grab a copy of pc before.
func Report(t testing.TB) {
	// If the goroutine panics, Fatal()s, or Skip()s, the function name is at the 3rd callstack
	// layer.  On success, its at 1st.  Since it's hard to check which happened, just try both.
	pcs := make([]uintptr, 10)
	total := runtime.Callers(1, pcs)
	var name string
	for _, pc := range pcs[:total] {
		fn := runtime.FuncForPC(pc)
		fullName := fn.Name()
		if strings.HasPrefix(path.Ext(fullName), ".Test") {
			// Skip the leading .
			name = string([]byte(path.Ext(fullName))[1:])
			break
		}
	}
	if name == "" {
		return
	}

	allCaseInfos.lock.Lock()
	defer allCaseInfos.lock.Unlock()
	allCaseInfos.Cases = append(allCaseInfos.Cases, &caseInfo{
		Name:    name,
		Passed:  !t.Failed() && !t.Skipped(),
		Skipped: t.Skipped(),
		Fatal:   t.Failed() && !strings.HasPrefix(name, "TestSoon"),
	})
}
Example #3
0
func (this *SunnyEndPoint) GetRequestedEndPoint(r *http.Request, upath []string, data []string) *RequestedEndPoint {
	handlers := this.Handlers()
	if h, exists := handlers[r.Method]; exists && h != nil {
		var pdata = make(map[string]string)
		for i, value := range data {
			if this.varnames[i] != "_" {
				pdata[this.varnames[i]] = value
			}
		}

		ext := ""
		lastele := len(upath) - 1

		if lastele >= 0 && strings.Contains(upath[lastele], ".") {
			ext = path.Ext(upath[lastele])
			upath[lastele] = strings.TrimSuffix(upath[lastele], ext)
		} else {
			ext = path.Ext(strings.TrimRight(r.URL.Path, "/"))
		}

		return &RequestedEndPoint{
			Ext:      ext,
			UPath:    web.UPath(upath),
			PData:    web.PData(pdata),
			Method:   r.Method,
			Handler:  h,
			EndPoint: this,
		}
	}

	return nil
}
Example #4
0
// Reads an array from a file.
func ReadFile(fname string) *host.Array {
	readFunc, ok := inputFormats[path.Ext(fname)]
	if !ok {
		panic(InputErrF("Can not load file with extension ", path.Ext(fname)))
	}
	return readFunc(fname)
}
Example #5
0
// AddFile saves to Response.Files preparing for Pipeline
func (self *Response) AddFile(name ...string) {
	file := map[string]interface{}{
		"Body": self.Response.Body,
	}

	_, s := path.Split(self.GetUrl())
	n := strings.Split(s, "?")[0]

	// 初始化
	baseName := strings.Split(n, ".")[0]
	ext := path.Ext(n)

	if len(name) > 0 {
		_, n = path.Split(name[0])
		if baseName2 := strings.Split(n, ".")[0]; baseName2 != "" {
			baseName = baseName2
		}
		if ext == "" {
			ext = path.Ext(n)
		}
	}

	if ext == "" {
		ext = ".html"
	}

	file["Name"] = baseName + ext

	self.files = append(self.files, file)
}
Example #6
0
func (fs *gopherJSFS) openSource(path string) (http.File, error) {
	f, err := fs.source.Open(path)
	if err != nil {
		return nil, err
	}

	fi, err := f.Stat()
	if err != nil {
		f.Close()
		return nil, err
	}

	switch {
	// Files with .go and ".inc.js" extensions are consumed and no longer exist
	// in output filesystem.
	case !fi.IsDir() && pathpkg.Ext(fi.Name()) == ".go":
		fallthrough
	case !fi.IsDir() && strings.HasSuffix(fi.Name(), ".inc.js"):
		f.Close()
		return nil, &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
	case !fi.IsDir():
		return f, nil
	}
	defer f.Close()

	fis, err := f.Readdir(0)
	if err != nil {
		return nil, err
	}

	// Include all subfolders, non-.go files.
	var entries []os.FileInfo
	var haveGo []os.FileInfo
	for _, fi := range fis {
		switch {
		case !fi.IsDir() && pathpkg.Ext(fi.Name()) == ".go":
			haveGo = append(haveGo, fi)
		case !fi.IsDir() && strings.HasSuffix(fi.Name(), ".inc.js"):
			// TODO: Handle ".inc.js" files correctly.
			entries = append(entries, fi)
		default:
			entries = append(entries, fi)
		}
	}

	// If it has any .go files, present the Go package compiled with GopherJS as an additional virtual file.
	if len(haveGo) > 0 {
		entries = append(entries, &file{
			name:    fi.Name() + ".js",
			size:    0,           // TODO.
			modTime: time.Time{}, // TODO.
		})
	}

	return &dir{
		name:    fi.Name(),
		entries: entries,
		modTime: fi.ModTime(),
	}, nil
}
Example #7
0
// ConvertToM4A converts given file into .m4a file
// Example: ConvertToM4A("oldAudio", "newAudio")
// Result: newAudio.M4A
// If only one argument is passed, than result will have the same name
func ConvertToM4A(fromFilename string, length string) error {
	toFilename := cutExtension(fromFilename)
	fmt.Println(fromFilename, toFilename, length)

	os.Remove(toFilename + ".m4a")
	// Convert to M4A
	switch path.Ext(fromFilename) {
	case ".amr":
		// fileSize (in bytes) / bit-rate (bits/secs)*8
		// ffmpeg -t 2 -i test.amr -ar 8k test1.m4a
		var comm *exec.Cmd
		if length != "" {
			fmt.Println("ffmpeg", "-t", length, "-i", fromFilename, toFilename+".m4a")
			comm = exec.Command("ffmpeg", "-t", length, "-i", fromFilename, toFilename+".m4a")
		} else {
			comm = exec.Command("ffmpeg", "-i", fromFilename, toFilename+".m4a")
		}

		if err := comm.Run(); err != nil {
			return ConvertError
		}
	default:
		return fmt.Errorf("Unsupported format: %v", path.Ext(fromFilename))
	}
	return nil
}
Example #8
0
File: main.go Project: yahoo/coname
// This getKey interprets key IDs as paths, and loads private keys from the
// specified file
func getKey(keyid string) (crypto.PrivateKey, error) {
	fileContents, err := ioutil.ReadFile(keyid)
	if err != nil {
		return nil, err
	}
	if path.Ext(keyid) == ".ed25519secret" {
		if got, want := len(fileContents), ed25519.PrivateKeySize; got != want {
			return nil, fmt.Errorf("ed25519 private key %s has wrong size %d (want %d)", keyid, got, want)
		}
		var keyArray [ed25519.PrivateKeySize]uint8
		copy(keyArray[:], fileContents)
		return &keyArray, nil
	} else if path.Ext(keyid) == ".vrfsecret" {
		if got, want := len(fileContents), vrf.SecretKeySize; got != want {
			return nil, fmt.Errorf("VRF private key %s has wrong size %d (want %d)", keyid, got, want)
		}
		var keyArray [vrf.SecretKeySize]uint8
		copy(keyArray[:], fileContents)
		return &keyArray, nil
	} else {
		keyPEM := fileContents
		var keyDER *pem.Block
		for {
			keyDER, keyPEM = pem.Decode(keyPEM)
			if keyDER == nil {
				return nil, fmt.Errorf("failed to parse key PEM in %s", keyid)
			}
			if keyDER.Type == "PRIVATE KEY" || strings.HasSuffix(keyDER.Type, " PRIVATE KEY") {
				break
			}
		}
		return parsePrivateKey(keyDER.Bytes)
	}
}
Example #9
0
func (s *processedAsset) requiredPaths(rx *regexp.Regexp) ([]string, error) {
	f, err := os.Open(s.static.pathname)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	buf := bufio.NewReader(f)
	paths := make([]string, 0)
	for {
		line, err := buf.ReadString('\n')
		if err == io.EOF {
			break
		} else if err != nil {
			return nil, err
		}
		if strings.TrimSpace(line) != "" && !strings.HasPrefix(line, "//") {
			break
		}
		matches := rx.FindStringSubmatch(line)
		if len(matches) > 1 {
			match := matches[1]
			if path.Ext(match) == "" {
				match += path.Ext(s.static.logical)
			}
			paths = append(paths, match)
		}
	}
	return paths, nil
}
Example #10
0
// TypeByExtension returns the MIME type associated with the file extension ext.
// 获取文件类型,选项ContentType使用
func TypeByExtension(filePath string) string {
	typ := mime.TypeByExtension(path.Ext(filePath))
	if typ == "" {
		typ = extToMimeType[strings.ToLower(path.Ext(filePath))]
	}
	return typ
}
Example #11
0
func main() {
	argsWithoutProg := os.Args[1:]
	if len(argsWithoutProg) <= 0 {
		fmt.Println("Please enter a directory or file path.\r\[email protected]")
		return
	}
	target, err := os.Stat(argsWithoutProg[0])
	if os.IsNotExist(err) {
		fmt.Printf("No such file or directory: %s", argsWithoutProg[0])
		return
	}

	//process directory
	if target.IsDir() {
		files, _ := ioutil.ReadDir(argsWithoutProg[0])
		for _, file := range files {
			if file.IsDir() {
				continue
			} else {
				filePath := path.Join(argsWithoutProg[0], file.Name())
				if path.Ext(filePath) == FILE_EXT {
					PatchFile(filePath)
				}
			}
		}
	} else {
		if path.Ext(argsWithoutProg[0]) == FILE_EXT {
			PatchFile(argsWithoutProg[0])
		}
	}
}
Example #12
0
func getTemplates() (*template.Template, error) {
	t := template.New("")
	root := "app/tpl"
	err := filepath.Walk(root, func(p string, info os.FileInfo, err error) error {
		if info.IsDir() {
			return nil
		}

		if path.Ext(p) != ".tpl" {
			return nil
		}

		if err != nil {
			return err
		}

		contents, err := ioutil.ReadFile(p)
		if err != nil {
			return err
		}

		nm := strings.Replace(p, "\\", "/", -1)
		nm = nm[len(root):]
		nm = nm[:len(nm)-len(path.Ext(nm))]

		child := t.New(nm)
		_, err = child.Parse(string(contents))

		return err
	})
	return t, err
}
Example #13
0
func (r *Response) detectContentType() (sure bool) {
	if r.CertainType {
		return true
	}
	defer func() { r.CertainType = sure }()

	if t := r.Header.Get("Content-Type"); t != "" {
		r.ContentType = t
		return true
	}
	if r.NewURL != nil || r.ContentLocation != nil {
		var pth, ext string
		if r.NewURL != nil {
			pth = r.NewURL.Path
			ext = path.Ext(pth)
		}
		if ext == "" && r.ContentLocation != nil {
			pth = r.ContentLocation.Path
			ext = path.Ext(pth)
		}
		if ext != "" {
			if t := mime.TypeByExtension(ext); t != "" {
				r.ContentType = t
				return true
			}
		} else if strings.HasSuffix(pth, "/") {
			r.ContentType = "text/html"
			return false
		}
	}
	r.ContentType = string(media.UNKNOWN)
	return false
}
Example #14
0
func isYaml(filename string) bool {
	if path.Ext(filename) == ".yml" || path.Ext(filename) == ".yaml" {
		return true
	}

	return false
}
Example #15
0
func Handler(nc *blobserv.Client, w http.ResponseWriter, r *http.Request) {
	defer util.DeferWrite(w)
	c = nc

	tmpl := template.Must(template.ParseFiles(appserv.Static("pics/index.tmpl")))

	if picIndex == nil {
		loadPicIndex()
	}
	updateIndex()

	pth := strings.Trim(r.URL.Path, "/")
	if pth == "pics" {
		links := picLinks(picIndex.Newest(10))
		err := tmpl.Execute(w, links)
		util.Check(err)
	} else if strings.HasPrefix(pth, "pics/ref/") {
		ref := path.Base(pth)
		ref = ref[:len(ref)-len(path.Ext(ref))]

		fblob, err := c.ObjectTip(ref)
		util.Check(err)

		m, data, err := c.ReconstituteFile(fblob.Ref())
		util.Check(err)

		ext := path.Ext(m.Name)
		w.Header().Set("Content-Type", mime.TypeByExtension(ext))
		w.Write(data)
	} else {
		err := util.LoadStatic(appserv.Static(pth), w)
		util.Check(err)
	}
}
Example #16
0
func (c *appContext) uploadPic(a *multipart.FileHeader) (string, string) {
	log.Println("In upload pic territory")

	bucket := c.bucket

	file, err := a.Open()
	defer file.Close()
	if err != nil {
		panic(err.Error())
	}

	if err != nil {
		panic(err)
	}

	buf, _ := ioutil.ReadAll(file)

	fn := uuid.New()
	fname := "places/" + fn + path.Ext(a.Filename)
	thumbname := "placesthumb/" + fn + path.Ext(a.Filename)
	log.Println(fname)

	b := "http://s3-us-west-2.amazonaws.com/" + c.bucket.Name + "/" + fname
	d := "http://s3-us-west-2.amazonaws.com/" + c.bucket.Name + "/" + thumbname

	filetype := http.DetectContentType(buf)

	err = bucket.Put(fname, buf, filetype, s3.PublicRead)

	if err != nil {
		log.Println("bucket put error for main image")
		panic(err.Error())

	}
	log.Print("added a full image")
	img, err := jpeg.Decode(bytes.NewReader(buf))

	if err != nil {
		log.Println(err.Error())
	}

	m := resize.Resize(200, 200, img, resize.Lanczos2)

	buf2 := new(bytes.Buffer)
	err = jpeg.Encode(buf2, m, nil)
	if err != nil {
		fmt.Println(err.Error())
	}
	thumb := buf2.Bytes()
	filetype2 := http.DetectContentType(thumb)
	err = bucket.Put(thumbname, thumb, filetype2, s3.PublicRead)

	if err != nil {
		log.Println("bucket put error for thumbnail")
		panic(err.Error())
	}
	log.Println("uploaded one thumb image")
	return b, d

}
Example #17
0
// 输出文件。
// name指定文件名,为空时默认保持原文件名不变。
func (self *Context) FileOutput(name ...string) {
	_, s := path.Split(self.GetUrl())
	n := strings.Split(s, "?")[0]

	// 初始化
	baseName := strings.Split(n, ".")[0]
	ext := path.Ext(n)

	if len(name) > 0 {
		p, n := path.Split(name[0])
		if baseName2 := strings.Split(n, ".")[0]; baseName2 != "" {
			baseName = p + baseName2
		}
		if ext == "" {
			ext = path.Ext(n)
		}
	}

	if ext == "" {
		ext = ".html"
	}
	self.Lock()
	self.files = append(self.files, data.GetFileCell(self.GetRuleName(), baseName+ext, self.Response.Body))
	self.Unlock()
}
Example #18
0
// 输出文件。
// name指定文件名,为空时默认保持原文件名不变。
func (self *Context) FileOutput(name ...string) {
	// 读取完整文件流
	bytes, err := ioutil.ReadAll(self.Response.Body)
	self.Response.Body.Close()
	if err != nil {
		panic(err.Error())
		return
	}

	// 智能设置完整文件名
	_, s := path.Split(self.GetUrl())
	n := strings.Split(s, "?")[0]

	baseName := strings.Split(n, ".")[0]

	var ext string
	if len(name) > 0 {
		p, n := path.Split(name[0])
		if baseName2 := strings.Split(n, ".")[0]; baseName2 != "" {
			baseName = p + baseName2
		}
		ext = path.Ext(n)
	}
	if ext == "" {
		ext = path.Ext(n)
	}
	if ext == "" {
		ext = ".html"
	}

	// 保存到文件临时队列
	self.Lock()
	self.files = append(self.files, data.GetFileCell(self.GetRuleName(), baseName+ext, bytes))
	self.Unlock()
}
Example #19
0
// AddFont takes a font filename and compiles it into Report.FontCompiledPath
// with the encoding specified. It strips the filename extension and replaces
// it with .json automatically. The extension-less string becomes the name of
// the font family to use with Report.AddStyle(). For example:
//
//   r.AddFont("OpenSans-Bold.ttf", "cp1252")
//   r.AddStyle("header", "OpenSans-Bold", "", 64, AlignmentTop | AlignmentLeft)
//
// The following encodings are supported:
//
//	 cp1250
// 	 cp1251
// 	 cp1252
// 	 cp1253
// 	 cp1254
// 	 cp1255
// 	 cp1257
// 	 cp1258
// 	 cp874
// 	 iso-8859-1
// 	 iso-8859-11
// 	 iso-8859-15
// 	 iso-8859-16
// 	 iso-8859-2
// 	 iso-8859-4
// 	 iso-8859-5
// 	 iso-8859-7
// 	 iso-8859-9
// 	 koi8-r
// 	 koi8-u
func (r *Report) AddFont(filename, encoding string) error {
	var err error
	err = r.PrepareFontCompiledPath()
	if err != nil {
		return err
	}

	ext := path.Ext(filename)
	familyName := filename[:len(filename)-len(ext)]

	// auto compiles
	if path.Ext(filename) == ".json" {
		if r.IsCompiledFile(filename) {
			r.Pdf.AddFont(familyName, "", filename)
		} else {
			return fmt.Errorf("Cache font file not found: %s", filename)
		}
	} else {
		if r.IsSourcedFont(filename) {
			compiledFilename, err := r.CompileFont(filename, encoding)
			if err != nil {
				return fmt.Errorf("Could not compile font: %v", err)
			}
			r.Pdf.AddFont(familyName, "", compiledFilename)
		} else {
			return fmt.Errorf("Source font file not found: %s", filename)
		}
	}
	return nil
}
Example #20
0
// ConvertToAMR converts given file into .amr file
// Example: ConvertToMP3("oldAudio", "newAudio")
// Result: newAudio.amr
// If only one argument is passed, than result will have the same name
func ConvertToAMR(fromFilename string, length string) error {
	toFilename := cutExtension(fromFilename)

	_ = length
	os.Remove(toFilename + ".amr")
	switch path.Ext(fromFilename) {
	case ".mp3", ".m4a":
		// Convert to WAV
		comm := exec.Command("ffmpeg", "-i", fromFilename, "-f", "wav", toFilename+".wav")
		if err := comm.Run(); err != nil {
			return ConvertError
		}
		// Convert to AMR
		comm = exec.Command("ffmpeg", "-i", toFilename+".wav", "-ab", AudioBitRate, "-ac", NumberOfAudioChannels, "-ar", AudioSamplingRateAMR, toFilename+".amr")
		if err := comm.Run(); err != nil {
			return ConvertError
		}
		// Delete tmp file
		if err := os.Remove(toFilename + ".wav"); err != nil {
			log.Println(err)
		}
	default:
		return fmt.Errorf("Unsupported format: %v", path.Ext(fromFilename))
	}
	return nil
}
Example #21
0
func main() {
	flag.Parse()
	if flag.NArg() == 0 {
		log.Fatal("missing file name")
	}
	name := flag.Args()[0]

	f, err := os.Open(name)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	var r io.Reader
	if path.Ext(name) == ".gz" {
		gz, err := gzip.NewReader(f)
		if err != nil {
			log.Fatal(err)
		}
		name = strings.TrimSuffix(name, ".gz")
		r = gz
	} else {
		r = f
	}

	var aDok *sparse.DOK
	switch path.Ext(name) {
	case ".mtx":
		aDok, err = readMatrixMarket(r)
	case ".rsa":
		log.Fatal("reading of Harwell-Boeing format not yet implemented")
	default:
		log.Fatal("unknown file extension")
	}
	if err != nil {
		log.Fatal(err)
	}

	a := sparse.NewCSR(aDok)
	n, _ := a.Dims()
	x := make([]float64, n)
	for i := range x {
		x[i] = 1
	}
	b := make([]float64, n)
	sparse.MulMatVec(1, false, a, x, 1, 0, b, 1)
	for i := range x {
		x[i] = 0
	}
	result, err := iterative.Solve(a, b, x, nil, &iterative.CG{})
	if err != nil {
		log.Fatal(err)
	}
	if len(result.X) > 10 {
		fmt.Println("Solution[:10]:", result.X[:10])
	} else {
		fmt.Println("Solution:", result.X)
	}
}
Example #22
0
// Checks whether the incoming request has the same expected type as an
// over-ride specification.
func matchTypes(spec string, req string) bool {
	smime := _getType(path.Ext(spec))
	rmime := _getType(path.Ext(req))
	if smime == rmime {
		return true
	}
	return false
}
Example #23
0
func compile(cmd *cobra.Command, args []string) {
	if len(args) < 1 {
		log.Fatal("You need to specify a level directory to compile!")
	}
	levelDir = args[0]
	if levelFile == "" {
		levelFile = path.Base(levelDir) + ".lvl"
	}
	log.Println("will compile to", levelFile)

	lvlMan := &data.Level{}
	buf, err := ioutil.ReadFile(levelDir + "/Manifest.json")
	if err != nil {
		log.Fatal("Error reading file: ", err)
	}

	err = json.Unmarshal(buf, lvlMan)
	if err != nil {
		log.Fatal("Error reading level manifest: ", err)
	}

	fmt.Println(lvlMan)

	for k, _ := range lvlMan.Layers {
		log.Println("Processing layer: ", k)
		dirlist, derr := ioutil.ReadDir(levelDir + "/" + k)
		if derr != nil {
			log.Println("Layer directory error: ", derr)
		} else {
			lvlMan.Layers[k].Frames = make(map[int]([][]rune))
			for _, fi := range dirlist {
				if path.Ext(fi.Name()) == ".frame" {
					log.Println(fi.Name())
					fdata, derr := ioutil.ReadFile(levelDir + "/" + k + "/" + fi.Name())
					if derr != nil {
						log.Println("Error reading frame: ", derr)
					} else {
						rdata := make([][]rune, 0, 25)
						for _, line := range strings.Split(string(fdata), "\n") {
							rdata = append(rdata, []rune(line))
						}
						idx, ierr := strconv.Atoi(strings.TrimSuffix(fi.Name(), path.Ext(fi.Name())))
						if ierr != nil {
							log.Printf("Invalid Index in Filename: ", ierr)
						} else {
							lvlMan.Layers[k].Frames[idx] = rdata
						}
					}
				}
			}
		}
	}
	obuf := &bytes.Buffer{}
	enc := gob.NewEncoder(obuf)
	enc.Encode(&lvlMan)
	ioutil.WriteFile(levelFile, obuf.Bytes(), 0644)
	log.Println("done.")
}
Example #24
0
// FromArg gets the json/yaml file from args
func (f *File) FromArg(read bool) error {
	// (length - 1)
	arg := os.Args[len(os.Args)-1:][0]

	// get extension
	ext := path.Ext(arg)
	if len(ext) > 1 {
		ext = ext[1:] // remove dot
	}

	// when json/yaml file isn't found on last arg
	// it searches for a ".json" or ".yaml" string in all args
	if ext != "json" && ext != "yaml" {
		// loop through args
		for _, a := range os.Args {
			// get extension
			ext := path.Ext(a)

			// check for valid extensions
			if ext == ".json" || ext == ".yaml" {
				f.Mode = ext[1:] // remove dot
				ext = f.Mode
				arg = a
				break
			}
		}
	} else {
		f.Mode = ext
	}

	// check if extension is json or yaml
	// then get it's absolute path
	if ext == "json" || ext == "yaml" {
		abs := filepath.IsAbs(arg)
		if !abs {
			dir, err := utils.GetCurrentDir()
			if err != nil {
				return err
			}

			arg = filepath.Clean(dir + "/" + arg)
		}

		f.FilePath = arg

		// so we can test without reading a file
		if read {
			if !utils.Exists(f.FilePath) {
				return errors.New("Error: I Can't find the config file at [" + f.FilePath + "]")
			}
		}
	} else {
		return errors.New("Error: You must specify a json or yaml file")
	}

	return nil
}
Example #25
0
func (p *JSMin) ProcessedFileName(fileName string) (string, bool) {
	ext := path.Ext(fileName)
	baseName := fileName[:len(fileName)-len(ext)]
	ext2 := path.Ext(baseName)
	if ext == ".js" && ext2 != ".min" {
		return baseName + ".min.js", true
	}
	return fileName, false
}
Example #26
0
func (p *JSMin) ReverseFileName(fileName string) (string, bool) {
	ext := path.Ext(fileName)
	baseName := fileName[:len(fileName)-len(ext)]
	ext2 := path.Ext(baseName)
	baseName = baseName[:len(baseName)-len(ext2)]
	if ext == ".js" && ext2 == ".min" {
		return baseName + ".js", true
	}
	return fileName, false
}
Example #27
0
func ReadAssetsFunc(filePath, assetUrl string, found func(filePath string, content string)) (filePaths []string, err error) {
	fileExt := path.Ext(filePath)
	fileExtPattern := patternExt(fileExt)
	var cacheKey string
	if cacheKey, err = generateCacheKey(filePath); err != nil {
		err = errors.New("Asset Not Found: " + assetUrl)
		return
	}

	requiredAssetUrls, content, hit := readFromCache(cacheKey)
	if !hit {
		content, err = ReadRawAsset(filePath, assetUrl)
		if err != nil {
			return
		}
		header := FindDirectivesHeader(&content, fileExtPattern)
		content, err = ReadRawAndCompileAsset(filePath, assetUrl)
		content = hotFixSASSCommentLines(content, fileExt)
		if len(header) != 0 {
			content = strings.Replace(content, header, "", 1)

			for _, line := range strings.Split(header, "\n") {
				if !patterns[fileExtPattern]["require"].Match([]byte(line)) {
					continue
				}

				requiredAssetUrl := string(patterns[fileExtPattern]["require"].ReplaceAll([]byte(line), []byte("")))
				if len(requiredAssetUrl) == 0 {
					continue
				}

				requiredAssetUrls = append(requiredAssetUrls, requiredAssetUrl)
			}
		}
		writeToCache(cacheKey, requiredAssetUrls, content)
	}

	for _, requiredAssetUrl := range requiredAssetUrls {
		var paths []string
		requiredFilePath := ResolvePath(requiredAssetUrl + fileExt)
		requiredFileExt := path.Ext(requiredFilePath)
		paths, err = ReadAssetsFunc(requiredFilePath, requiredAssetUrl+requiredFileExt, found)
		if err != nil {
			err = errors.New(fmt.Sprintf("%s\n--- required by %s", err.Error(), assetUrl))
			return
		}

		filePaths = append(filePaths, paths...)
	}

	found(filePath, content)
	filePaths = append(filePaths, filePath)
	return
}
Example #28
0
func fetchAndRenderDoc(user, repo, ref, doc string) (string, error) {
	template := make(chan string)
	templateName := "template"
	templateRecv := false
	defer func() {
		if !templateRecv {
			<-template
		}
	}()

	if doc == "index.md" {
		templateName = "home"
	}

	go fetchTemplate(template, user, repo, ref, templateName)

	// https://github.com/github/markup/blob/master/lib/github/markups.rb#L1
	mdExts := markdownExtensions()
	if ok, _ := mdExts[path.Ext(doc)]; !ok {
		doc += ".md"
	}

	bodyStr, err := fetchDoc(user, repo, ref, "docs/"+doc)
	if err != nil {
		return "", err
	}

	resp, err := http.Post("https://api.github.com/markdown/raw?access_token="+os.Getenv("ACCESS_TOKEN"), "text/x-markdown", strings.NewReader(bodyStr))
	if err != nil {
		return "", err
	}
	body, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()
	if err != nil {
		return "", err
	}

	pagesClass := strings.Replace(doc, "/", "-", -1)
	pagesClass = pagesClass[:len(pagesClass)-len(path.Ext(pagesClass))]

	output := strings.Replace(<-template, "{{CONTENT}}", string(body), 1)
	templateRecv = true
	output = strings.Replace(output, "{{NAME}}", repo, -1)
	output = strings.Replace(output, "{{USER}}", user, -1)
	output = strings.Replace(output, "{{PAGE_CLASS}}", pagesClass, -1)

	// Fix relative links
	output, err = fixRelativeLinks(doc, repo, ref, output)
	if err != nil {
		return "", err
	}

	return output, nil
}
Example #29
0
func (app *App) importAssets(included *includedApp) error {
	im := included.app.assetsManager
	if !app.shouldImportAssets() {
		im.SetPrefix(included.prefix + im.Prefix())
		return nil
	}
	m := app.assetsManager
	prefix := strings.ToLower(included.name)
	renames := make(map[string]string)
	err := vfs.Walk(im.VFS(), "/", func(fs vfs.VFS, p string, info os.FileInfo, err error) error {
		if err != nil || info.IsDir() {
			return err
		}
		if p != "" && p[0] == '/' {
			p = p[1:]
		}
		log.Debugf("will import asset %v from app %s", p, included.name)
		src, err := im.Load(p)
		if err != nil {
			return err
		}
		defer src.Close()
		seeker, err := assets.Seeker(src)
		if err != nil {
			return err
		}
		sum := hashutil.Fnv32a(seeker)
		nonExt := p[:len(p)-len(path.Ext(p))]
		dest := path.Join(prefix, nonExt+".gen."+sum+path.Ext(p))
		renames[p] = dest
		log.Debugf("importing asset %q as %q", p, dest)
		if m.Has(dest) {
			return nil
		}
		f, err := m.Create(dest, true)
		if err != nil {
			return err
		}
		defer f.Close()
		if _, err := seeker.Seek(0, os.SEEK_SET); err != nil {
			return err
		}
		if _, err := io.Copy(f, seeker); err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		return err
	}
	included.renames = renames
	return nil
}
Example #30
0
// IsDuplicate returns true if the date isn't unique.
func (rename *Rename) IsDuplicate(renames []*Rename) bool {
	var i int
	for _, r := range renames {
		if r.date == rename.date && path.Ext(r.origPath) == path.Ext(rename.origPath) {
			i++
		}
		if i == 2 {
			return true
		}
	}
	return false
}