Ejemplo n.º 1
0
func runManifest(cmd *Command, w io.Writer, args []string) {
	openRepository(args)
	rs := getRevisionSpec()
	b := revlog.NewFileBuilder()
	c, err := getChangeset(rs, b)
	if err != nil {
		fatalf("%s", err)
	}
	mm, err := getManifest(int(c.Linkrev), c.ManifestNode, b)
	if err != nil {
		fatalf("%s", err)
	}
	for i := range mm {
		fmt.Fprintln(w, mm[i].FileName)
	}
}
Ejemplo n.º 2
0
func runRevlog(cmd *Command, w io.Writer, args []string) {
	if len(args) == 0 {
		fatalf("missing argument: revlog index file")
	}
	index, err := revlog.Open(storeName(args[0]))
	if err != nil {
		fatalf("%s", err)
	}

	if *revlogR == -1 {
		index.Dump(w)
		return
	}

	r, err := revlog.FileRevSpec(*revlogR).Lookup(index)
	if err != nil {
		fatalf("%s", err)
	}
	if !*revlogBuild {
		dh := &dataHelper{}
		d, err := r.GetData(dh)
		if dh.file != nil {
			dh.file.Close()
		}
		if err != nil {
			fatalf("%s", err)
		}
		if r.IsBase() {
			w.Write(d)
		} else {
			hunks, err := patch.Parse(d)
			if err != nil {
				fatalf("%s", err)
			}
			for _, h := range hunks {
				h.Dump(w)
			}
		}
	} else {
		fb := revlog.NewFileBuilder()
		err = fb.BuildWrite(w, r)
		if err != nil {
			fatalf("%s", err)
		}
	}
}
Ejemplo n.º 3
0
Archivo: tags.go Proyecto: knieriem/hgo
// Parse tags, and return one Tags structure containing only
// global tags, another one containing both global and local tags.
func (r *Repository) Tags() (tGlobal, tAll *Tags) {
	tGlobal, tAll = newTags(), newTags()

	st := r.NewStore()
	index, err := st.OpenRevlog(".hgtags")
	if err == nil {
		fb := revlog.NewFileBuilder()
		if err := fb.BuildWrite(nil, index.Tip()); err == nil {
			tAll.parseFile(bytes.NewReader(fb.Bytes()))
		}
	}

	f, err := r.open(".hg/localtags")
	if err == nil {
		tGlobal.copy(tAll)
		err = tAll.parseFile(f)
		f.Close()
	} else {
		tGlobal = tAll
	}
	return
}
Ejemplo n.º 4
0
func runCat(cmd *Command, w io.Writer, args []string) {
	openRepository(args)
	rs := getRevisionSpec()
	fileArg := getFileArg(args)
	st := repo.NewStore()

	fileLog, err := st.OpenRevlog(fileArg)
	if err != nil {
		fatalf("%s", err)
	}

	ra := repoAccess{
		fb: revlog.NewFileBuilder(),
		st: st,
	}
	localId, ok := rs.(revlog.FileRevSpec)
	if !ok {
		localId, err = ra.localChangesetId(rs)
		if err != nil {
			return
		}
	}

	link := revlog.NewLinkRevSpec(int(localId))
	link.FindPresent = func(rlist []*revlog.Rec) (index int, err error) {
		if len(rlist) > 1 {
			// Does link.Rev refer to a changelog revision that is a
			// descendant of one of the revisions in rlist?
			for i, r := range rlist {
				cr, err1 := ra.clRec(revlog.FileRevSpec(r.Linkrev))
				if err1 != nil {
					err = err1
					return
				}
				if cr.IsDescendant(link.Rev) {
					index = i
					goto found
				}
			}
			err = fmt.Errorf("internal error: none of the given records is an ancestor of rev %v", link.Rev)
			return

		found:
			if !rlist[index].IsLeaf() {
				return
			}
		}

		// Check for the file's existence using the manifest.
		ent, err := ra.manifestEntry(link.Rev, fileArg)
		if err == nil {
			index, err = findPresentByNodeId(ent, rlist)
		}
		return
	}
	r, err := link.Lookup(fileLog)
	if err != nil {
		fatalf("%s", err)
	}

	fb := revlog.NewFileBuilder()
	err = fb.BuildWrite(w, r)
	if err != nil {
		fatalf("%s", err)
	}
}
Ejemplo n.º 5
0
func printChangelog(w io.Writer, rFrom, rTo *revlog.Rec, logIndex *revlog.Index, tags map[string][]string, wantDirPrefix, wantFile string) (err error) {
	var clr *revlog.Rec

	match := func([]string) bool { return true }
	if wantFile != "" {
		match = func(files []string) (ok bool) {
			for _, f := range files {
				if f == wantFile {
					ok = true
					return
				}
			}
			return
		}
	} else if wantDirPrefix != "" {
		match = func(files []string) (ok bool) {
			for _, f := range files {
				if strings.HasPrefix(f, wantDirPrefix) {
					ok = true
					return
				}
			}
			return
		}
	}

	fb := revlog.NewFileBuilder()
	fb.SetDataCache(&dc)
	fb.KeepDataOpen()
	defer fb.CloseData()
	t, err := setupLogTemplate(logTemplate, tags)
	if err != nil {
		return
	}
	ch := make(chan *changelog.Entry, 16)
	errch := make(chan error, 0)
	go func() {
		errch <- t.Execute(w, ch)
	}()
	r := rFrom
	target := rTo.FileRev()
	var next func()
	if rFrom.FileRev() > target {
		next = func() { r = r.Prev() }
	} else {
		next = func() { r = r.Next() }
	}
	i := 0
	for {
		if logIndex == nil {
			clr = r
		} else {
			clr, err = revlog.FileRevSpec(r.Linkrev).Lookup(logIndex)
			if err != nil {
				return
			}
		}
		c, err1 := changelog.BuildEntry(clr, fb)
		if err1 != nil {
			err = err1
			return
		}
		c.Rec = clr

		if match(c.Files) {
			select {
			case ch <- c:
				i++
			case err = <-errch:
				return
			}
		}
		if r.FileRev() == target {
			break
		}
		next()
		if r.FileRev() == -1 {
			break
		}
		if *logL != 0 && i == *logL {
			break
		}
	}
	close(ch)
	err = <-errch
	return
}
Ejemplo n.º 6
0
func runArchive(cmd *Command, w io.Writer, args []string) {
	openRepository(args)
	rs := getRevisionSpec()
	b := revlog.NewFileBuilder()
	c, err := getChangeset(rs, b)
	if err != nil {
		fatalf("%s", err)
	}

	var ent *store.ManifestEnt
	link := revlog.NewLinkRevSpec(int(c.Linkrev))
	link.FindPresent = func(rlist []*revlog.Rec) (index int, err error) {
		index, err = findPresentByNodeId(ent, rlist)
		return
	}

	mm, err := getManifest(link.Rev, c.ManifestNode, b)
	if err != nil {
		fatalf("%s", err)
	}
	st := repo.NewStore()

	fileArg := getFileArg(args)

	newArchive, ok := amap[*archiveType]
	if !ok {
		fatalf("unknown archive type: %s", *archiveType)
	}
	a, pathPfx, err := newArchive(fileArg)
	if err != nil {
		fatalf("%s", err)
	}

	err = createArchivalTxt(a, pathPfx, c)
	if err != nil {
		fatalf("%s", err)
	}
	pathPfx += "/"

	for i := range mm {
		ent = &mm[i]

		f, err := st.OpenRevlog(ent.FileName)
		if err != nil {
			fatalf("%s", err)
		}
		r, err := link.Lookup(f)
		if err != nil {
			fatalf("%s", err)
		}

		name := pathPfx + ent.FileName
		if ent.IsLink() {
			buf, err := b.Build(r)
			if err != nil {
				fatalf("%s", err)
			}
			err = a.symlink(name, string(buf), c.Date)
			if err != nil {
				fatalf("%s", err)
			}
		} else {
			var mode int
			if ent.IsExecutable() {
				mode = 0755
			} else {
				mode = 0644
			}
			p, err := b.PreparePatch(r)
			if err != nil {
				fatalf("%s", err)
			}

			w, err := a.createFile(name, mode, int64(r.FileLength)-int64(len(p.MetaData)), c.Date)
			if err != nil {
				fatalf("%s", err)
			}
			err = p.Apply(w)
			if err != nil {
				fatalf("%s", err)
			}
		}
	}
	err = a.Close()
	if err != nil {
		fatalf("%s", err)
	}
}