private static TextReader ReadAsReader(PSObject sourceObject, out InputFileInfo sourceInfo)
{
sourceInfo = null;
if (sourceObject.BaseObject is string)
{
return(new StringReader(sourceObject.BaseObject.ToString()));
}
else if (sourceObject.BaseObject is InputFileInfo inputFileInfo)
{
sourceInfo = inputFileInfo;
return(new StreamReader(inputFileInfo.FullName));
}
else if (sourceObject.BaseObject is FileInfo fileInfo)
{
sourceInfo = new InputFileInfo(PSDocumentOption.GetRootedBasePath(""), fileInfo.FullName);
return(new StreamReader(fileInfo.FullName));
}
else
{
var uri = sourceObject.BaseObject as Uri;
sourceInfo = new InputFileInfo(null, uri.ToString());
using (var webClient = new WebClient())
{
return(new StringReader(webClient.DownloadString(uri)));
}
}
}
protected override void ProcessInputFile(ArcArchive archive, InputFileInfo fileInfo, IProgress?progress)
{
if (archive.TryGetEntry(fileInfo.EntryName, out var entry))
{
if (entry.LastWriteTime < fileInfo.LastWriteTime)
{
{
using var entryStream = entry.OpenWrite();
CopyFileToStream(fileInfo.FileName, entryStream, progress);
}
entry.LastWriteTime = fileInfo.LastWriteTime;
// TODO: Console.Out.WriteLine("Added: " + inputFileInfo.EntryName);
}
}
else
{
entry = archive.CreateEntry(fileInfo.EntryName);
{
using var entryStream = entry.OpenWrite();
CopyFileToStream(fileInfo.FileName, entryStream, progress);
}
entry.LastWriteTime = fileInfo.LastWriteTime;
// TODO: Console.Out.WriteLine("Added: " + inputFileInfo.EntryName);
}
}
public async void TestExport(string dataFile, ExportType type)
{
var fileInfo = new InputFileInfo
{
FilePath = Path.Combine(Environment.CurrentDirectory, dataFile)
};
fileInfo.Type.Should().NotBe(ImportType.Unknown);
var importer = GetImporter(fileInfo.Type);
importer.Should().NotBeNull();
var cancellationToken = new CancellationToken();
var pointSets = await importer.ImportAsync(fileInfo.FilePath, cancellationToken);
pointSets.Should().NotBeNull();
var outInfo = GetExportConfig();
outInfo.Should().NotBeNull();
outInfo.OutputFile.FilePath = fileInfo.FilePath;
outInfo.OutputFile.Type = type;
outInfo.OutputFile.FileNameWithoutExtension = $"{outInfo.OutputFile.FileNameWithoutExtension}-processed";
var exporter = GetExporter(type);
exporter.Should().NotBeNull();
(await exporter.ExportAsync(pointSets ![0], 0, cancellationToken)).Should().BeTrue();
protected override void ProcessInputFile(ArcArchive archive, InputFileInfo fileInfo, IProgress?progress)
{
if (archive.Exists(fileInfo.EntryName))
{
_entryNamesToKeep.Add(fileInfo.EntryName);
}
}
private static void NoteSource(TargetObject value, InputFileInfo source)
{
if (value == null || source == null)
{
return;
}
value.SetSourceInfo(source);
}
public virtual IFileObject SaveFile(IFileSystem fs, InputFileInfo inputFile)
{
var originalFileName = Path.GetFileName(inputFile.FileName);
var fileName = Path.Combine(inputFile.Folder, originalFileName);
log.Write(LogEvent.Debug, "Saving file: {0}", fileName);
var uploadFile = fs.ResolveFile(fileName);
if (uploadFile.Exists())
{
if (inputFile.Overwrite)
{
uploadFile.Delete();
}
else
{
uploadFile = GetUniqueFile(fs, fileName);
}
}
// special handling for images
if (inputFile.ForceImageFormat != null || inputFile.ImageMaxWidth > 0 || inputFile.ImageMaxHeight > 0)
{
var imgFormat = String.IsNullOrEmpty(inputFile.ForceImageFormat)?
ImageFormat.Png : ImageUtils.ResolveImageFormat(inputFile.ForceImageFormat);
var imgFormatExt = ImageUtils.GetImageFormatExtension(imgFormat);
if (imgFormatExt != (Path.GetExtension(uploadFile.Name) ?? String.Empty).ToLower())
{
uploadFile = GetUniqueFile(fs,
Path.Combine(inputFile.Folder, Path.GetFileNameWithoutExtension(originalFileName) + imgFormatExt));
}
uploadFile.CreateFile();
using (var outputStream = uploadFile.Content.GetStream(FileAccess.Write)) {
ImageUtils.ResizeImage(
inputFile.InputStream, outputStream,
imgFormat,
inputFile.ImageMaxWidth,
inputFile.ImageMaxHeight,
true
);
}
}
else
{
uploadFile.CopyFrom(inputFile.InputStream);
}
return(uploadFile);
}
public async void TestImport(string dataFile)
{
var fileInfo = new InputFileInfo
{
FilePath = Path.Combine(Environment.CurrentDirectory, dataFile)
};
fileInfo.Type.Should().NotBe(ImportType.Unknown);
var importer = GetImporter(fileInfo.Type);
importer.Should().NotBeNull();
var cancellationToken = new CancellationToken();
var pointSets = await importer.ImportAsync(fileInfo.FilePath, cancellationToken);
pointSets.Should().NotBeNull();
}
private static IEnumerable <TargetObject> VisitItem(PSObject value, InputFileInfo sourceInfo, VisitTargetObject next)
{
if (value == null)
{
return(EmptyArray);
}
var items = next(new TargetObject(value));
if (items == null)
{
return(EmptyArray);
}
foreach (var i in items)
{
NoteSource(i, sourceInfo);
}
return(items);
}
public int Run()
{
Check.True(InputPaths.Count > 0);
var archiveOptions = new ArcArchiveOptions
{
// Mode
Format = Format,
CompressionLevel = CompressionLevel,
SafeWrite = SafeWrite,
HeaderAreaLength = HeaderAreaSize,
ChunkLength = ChunkSize,
// TODO: UseLibDeflate = setup from global option
};
var archiveExist = File.Exists(ArchivePath);
archiveOptions.Mode = archiveExist ? ArcArchiveMode.Update : ArcArchiveMode.Create;
long totalInputLength = 0;
var inputFileInfos = new List <InputFileInfo>();
{
using var progressBar = CreateProgressBar();
progressBar.Title = "Gathering input files...";
var inputs = GetAllInputs();
foreach (var inputFile in inputs)
{
progressBar.Message = inputFile;
var fileInfo = new FileInfo(inputFile);
totalInputLength += fileInfo.Length;
var info = new InputFileInfo
{
FileName = inputFile,
EntryName = CreateEntryName(inputFile),
LastWriteTime = new DateTimeOffset(fileInfo.LastWriteTimeUtc),
};
inputFileInfos.Add(info);
}
if (!PreserveCase)
{
var hashSet = new HashSet <string>(StringComparer.Ordinal);
foreach (var x in inputFileInfos)
{
if (!hashSet.Add(x.EntryName))
{
throw Error.InvalidOperation("Invalid casing. Final entry names must be unique.");
}
}
}
// Validate Entry Names
foreach (var x in inputFileInfos)
{
EntryNameUtilities.Validate(x.EntryName);
}
}
{
using var progressBar = CreateProgressBar();
progressBar.Title = GetProcessInputFilesTitle();
using var archive = ArcArchive.Open(ArchivePath, archiveOptions);
progressBar.SetMaxValue(totalInputLength);
foreach (var inputFileInfo in inputFileInfos)
{
progressBar.Message = inputFileInfo.FileName;
ProcessInputFile(archive, inputFileInfo, progressBar);
}
PostProcessArchive(archive, progressBar);
}
return(0);
}
protected abstract void ProcessInputFile(ArcArchive archive, InputFileInfo fileInfo, IProgress?progress);
internal void SetSourceInfo(InputFileInfo sourceInfo)
{
Source = sourceInfo;
}
private static IEnumerable <TargetObject> VisitItems(IEnumerable <PSObject> value, InputFileInfo sourceInfo, VisitTargetObject next)
{
if (value == null)
{
return(EmptyArray);
}
var result = new List <TargetObject>();
foreach (var item in value)
{
result.AddRange(VisitItem(item, sourceInfo, next));
}
return(result.Count == 0 ? EmptyArray : result.ToArray());
}
public IEnumerable<WithSource<string>> Characterize(InputFileInfo inputFile) {
var codepoints = StringToCodePoints(inputFile.data);
var graphemes = GetGraphemes(codepoints);
var charsWithSource = GetCharactersWithSourceLocation(graphemes, inputFile.name);
return charsWithSource;
}
