func AppFilesInDir(dir string) (appFiles []models.AppFileFields, err error) {
	dir, err = filepath.Abs(dir)
	if err != nil {
		return
	}

	err = WalkAppFiles(dir, func(fileName string, fullPath string) (err error) {
		fileInfo, err := os.Lstat(fullPath)
		if err != nil {
			return
		}

		appFile := models.AppFileFields{
			Path: filepath.ToSlash(fileName),
			Size: fileInfo.Size(),
		}

		if fileInfo.IsDir() {
			appFile.Sha1 = "0"
			appFile.Size = 0
		} else {
			hash := sha1.New()
			err = fileutils.CopyPathToWriter(fullPath, hash)
			if err != nil {
				return
			}
			appFile.Sha1 = fmt.Sprintf("%x", hash.Sum(nil))
		}

		appFiles = append(appFiles, appFile)
		return
	})
	return
}

func copyPathToPath(fromPath, toPath string) (err error) {
	srcFileInfo, err := os.Stat(fromPath)
	if err != nil {
		return
	}

	if srcFileInfo.IsDir() {
		err = os.MkdirAll(toPath, srcFileInfo.Mode())
		if err != nil {
			return
		}
	} else {
		var dst *os.File
		dst, err = fileutils.Create(toPath)
		if err != nil {
			return
		}
		defer dst.Close()

		dst.Chmod(srcFileInfo.Mode())

		err = fileutils.CopyPathToWriter(fromPath, dst)
	}
	return err
}

func sha(path string) string {
	hash := sha1.New()
	err := fileutils.CopyPathToWriter(path, hash)
	if err != nil {
		panic("Failed to compute sha1")
	}
	return fmt.Sprintf("%x", hash.Sum(nil))
}

func (b *bloblet) Write(w io.Writer) {
	fileutils.TempDir("bloblet-zipdir", func(zipDir string, err error) {
		cliutil.Check(err)
		zipPath := filepath.Join(zipDir, BlobletFileName)
		cliutil.Check(b.Compress(zipPath))
		cliutil.Check(fileutils.CopyPathToWriter(zipPath, w))
	})
}

func (zipper ApplicationZipper) Zip(dirOrZipFile string, targetFile *os.File) (err error) {
	if zipper.IsZipFile(dirOrZipFile) {
		err = fileutils.CopyPathToWriter(dirOrZipFile, targetFile)
	} else {
		err = writeZipFile(dirOrZipFile, targetFile)
	}
	targetFile.Seek(0, os.SEEK_SET)
	return
}

// New returns a Hash of the contents of the specified file.
func New(filePath string) Hash {
	fileInfo, err := os.Lstat(filePath)
	if err != nil {
		panic(err)
	}

	if fileInfo.IsDir() {
		panic("cannot compute hash of directory")
	} else {
		hash := sha1.New()
		err = fileutils.CopyPathToWriter(filePath, hash)
		if err != nil {
			panic(err)
		}
		return Hash(hash.Sum(nil))
	}
}

func writeZipFile(dir string, targetFile *os.File) error {
	isEmpty, err := fileutils.IsDirEmpty(dir)
	if err != nil {
		return err
	}

	if isEmpty {
		return errors.NewEmptyDirError(dir)
	}

	writer := zip.NewWriter(targetFile)
	defer writer.Close()

	appfiles := ApplicationFiles{}
	return appfiles.WalkAppFiles(dir, func(fileName string, fullPath string) error {
		fileInfo, err := os.Stat(fullPath)
		if err != nil {
			return err
		}

		header, err := zip.FileInfoHeader(fileInfo)
		if err != nil {
			return err
		}

		header.Name = filepath.ToSlash(fileName)

		if fileInfo.IsDir() {
			header.Name += "/"
		}

		zipFilePart, err := writer.CreateHeader(header)
		if err != nil {
			return err
		}

		if fileInfo.IsDir() {
			return nil
		}

		return fileutils.CopyPathToWriter(fullPath, zipFilePart)
	})
}

func (b *bloblet) Compress(path string) error {
	f, err := os.OpenFile(path, os.O_CREATE+os.O_RDWR, 0644)
	if err != nil {
		return err
	}
	defer f.Close()
	zw := zip.NewWriter(f)
	defer zw.Close()

	for filePath, _ := range b.files {
		w, err := zw.Create(filePath)
		if err != nil {
			return err
		}
		err = fileutils.CopyPathToWriter(filePath, w)
		if err != nil {
			return err
		}
	}
	return nil
}

				Expect(fileInfo.Mode()).To(Equal(expectedFileInfo.Mode()))
			})
		})
	})

	Describe("CopyPathToWriter", func() {
		var destPath string

		BeforeEach(func() {
			destFile, err := ioutil.TempFile("", "copy_test")
			Expect(err).NotTo(HaveOccurred())
			defer destFile.Close()

			destPath = destFile.Name()

			err = fileutils.CopyPathToWriter(fixturePath, destFile)
			Expect(err).NotTo(HaveOccurred())
		})

		It("copies the file contents", func() {
			fileBytes, err := ioutil.ReadFile(destPath)
			Expect(err).NotTo(HaveOccurred())

			Expect(fileBytes).To(Equal(fixtureBytes))
		})
	})

	Describe("CopyReaderToPath", func() {
		var destPath = fileutils.TempPath("copy_test")

		BeforeEach(func() {