Task 350: .LATEX File Format

The .LATEX file format is associated with LaTeX source documents, which are plain text files containing markup for typesetting. The standard extension for LaTeX source files is .tex, though .latex is occasionally recognized or used in some systems. The format is text-based, with no binary structure or fixed headers; it follows the LaTeX markup language specification, which defines syntax for document structure, commands, and environments.

The properties of this file format intrinsic to its file system are the metadata attributes maintained by the operating system's file system for any file, including those with the .LATEX extension. These include:

• Mode (permissions and file type indicator)
• Inode number
• Device ID
• Number of hard links
• User ID of the owner
• Group ID of the owner
• File size in bytes
• Last access time
• Last modification time
• Creation time (or metadata change time, depending on the system)

Files with the exact .LATEX extension are uncommon in public repositories, as LaTeX source files are predominantly saved with the .tex extension while sharing the same format and content structure. Below are two direct download links to example LaTeX source files (with .tex extension) that can be renamed to .latex if needed, as the content is identical in format:

• https://www3.nd.edu/~powers/ame.20231/sample.tex
• https://dondi.lmu.build/fall2012/cmsi370/latex-sample.tex

Below is the HTML code with embedded JavaScript suitable for embedding in a Ghost blog post (or similar platform). It creates a drop zone where a user can drag and drop a .LATEX file. Upon drop, it validates the extension, retrieves available file system properties accessible in a browser environment (limited to name, size, type, and last modification time), and displays them on the screen. Note that browser security restrictions limit access to full file system metadata; for complete properties, a server-side implementation would be required.

1. Below is a Python class that can open a file with the .LATEX extension, decode its content (assuming UTF-8 encoding), read the content, write new content, and print the file system properties to the console.

import os
import time

class LatexFile:
    def __init__(self, filepath):
        if not filepath.lower().endswith('.latex'):
            raise ValueError("The file must have a .LATEX extension.")
        self.filepath = filepath
        self.stat = os.stat(filepath)

    def print_properties(self):
        print("Mode:", oct(self.stat.st_mode))
        print("Inode Number:", self.stat.st_ino)
        print("Device ID:", self.stat.st_dev)
        print("Number of Hard Links:", self.stat.st_nlink)
        print("User ID of Owner:", self.stat.st_uid)
        print("Group ID of Owner:", self.stat.st_gid)
        print("File Size (bytes):", self.stat.st_size)
        print("Last Access Time:", time.ctime(self.stat.st_atime))
        print("Last Modification Time:", time.ctime(self.stat.st_mtime))
        print("Creation Time:", time.ctime(self.stat.st_ctime))

    def read(self):
        with open(self.filepath, 'r', encoding='utf-8') as f:
            return f.read()

    def write(self, content):
        with open(self.filepath, 'w', encoding='utf-8') as f:
            f.write(content)

1. Below is a Java class that can open a file with the .LATEX extension, read its content (decoding as UTF-8), write new content, and print the file system properties to the console. It uses java.nio.file for metadata access.

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.time.Instant;

public class LatexFile {
    private final Path path;
    private final BasicFileAttributes attrs;

    public LatexFile(String filepath) throws IOException {
        this.path = Paths.get(filepath);
        if (!filepath.toLowerCase().endsWith(".latex")) {
            throw new IllegalArgumentException("The file must have a .LATEX extension.");
        }
        this.attrs = Files.readAttributes(path, BasicFileAttributes.class);
    }

    public void printProperties() {
        System.out.println("File Key: " + attrs.fileKey());
        System.out.println("Is Directory: " + attrs.isDirectory());
        System.out.println("Is Regular File: " + attrs.isRegularFile());
        System.out.println("Is Symbolic Link: " + attrs.isSymbolicLink());
        System.out.println("File Size (bytes): " + attrs.size());
        System.out.println("Last Access Time: " + Instant.ofEpochMilli(attrs.lastAccessTime().toMillis()));
        System.out.println("Last Modification Time: " + Instant.ofEpochMilli(attrs.lastModifiedTime().toMillis()));
        System.out.println("Creation Time: " + Instant.ofEpochMilli(attrs.creationTime().toMillis()));
    }

    public String read() throws IOException {
        return new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
    }

    public void write(String content) throws IOException {
        Files.write(path, content.getBytes(StandardCharsets.UTF_8));
    }
}

1. Below is a JavaScript class (designed for a Node.js environment, as browser JavaScript has limited file system access) that can open a file with the .LATEX extension, decode its content (as UTF-8), read the content, write new content, and print the file system properties to the console.

const fs = require('fs');
const path = require('path');

class LatexFile {
  constructor(filepath) {
    if (!filepath.toLowerCase().endsWith('.latex')) {
      throw new Error('The file must have a .LATEX extension.');
    }
    this.filepath = filepath;
    this.stat = fs.statSync(filepath);
  }

  printProperties() {
    console.log('Mode:', this.stat.mode.toString(8));
    console.log('Inode Number:', this.stat.ino);
    console.log('Device ID:', this.stat.dev);
    console.log('Number of Hard Links:', this.stat.nlink);
    console.log('User ID of Owner:', this.stat.uid);
    console.log('Group ID of Owner:', this.stat.gid);
    console.log('File Size (bytes):', this.stat.size);
    console.log('Last Access Time:', new Date(this.stat.atimeMs).toLocaleString());
    console.log('Last Modification Time:', new Date(this.stat.mtimeMs).toLocaleString());
    console.log('Creation Time:', new Date(this.stat.birthtimeMs).toLocaleString());
  }

  read() {
    return fs.readFileSync(this.filepath, 'utf-8');
  }

  write(content) {
    fs.writeFileSync(this.filepath, content, 'utf-8');
  }
}

1. Below is a C++ class that can open a file with the .LATEX extension, decode its content (assuming UTF-8), read the content, write new content, and print the file system properties to the console. It uses <sys/stat.h> for metadata.

#include <iostream>
#include <fstream>
#include <string>
#include <sys/stat.h>
#include <ctime>
#include <stdexcept>
#include <cstring>

class LatexFile {
private:
    std::string filepath;
    struct stat fileStat;

public:
    LatexFile(const std::string& fp) : filepath(fp) {
        if (filepath.length() < 6 || strcasecmp(filepath.substr(filepath.length() - 6).c_str(), ".latex") != 0) {
            throw std::invalid_argument("The file must have a .LATEX extension.");
        }
        if (stat(filepath.c_str(), &fileStat) != 0) {
            throw std::runtime_error("Failed to get file stats.");
        }
    }

    void printProperties() const {
        std::cout << "Mode: " << std::oct << fileStat.st_mode << std::dec << std::endl;
        std::cout << "Inode Number: " << fileStat.st_ino << std::endl;
        std::cout << "Device ID: " << fileStat.st_dev << std::endl;
        std::cout << "Number of Hard Links: " << fileStat.st_nlink << std::endl;
        std::cout << "User ID of Owner: " << fileStat.st_uid << std::endl;
        std::cout << "Group ID of Owner: " << fileStat.st_gid << std::endl;
        std::cout << "File Size (bytes): " << fileStat.st_size << std::endl;
        std::cout << "Last Access Time: " << std::ctime(&fileStat.st_atime);
        std::cout << "Last Modification Time: " << std::ctime(&fileStat.st_mtime);
        std::cout << "Creation Time: " << std::ctime(&fileStat.st_ctime);
    }

    std::string read() const {
        std::ifstream file(filepath, std::ios::in | std::ios::binary);
        if (!file) {
            throw std::runtime_error("Failed to open file for reading.");
        }
        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        return content;
    }

    void write(const std::string& content) const {
        std::ofstream file(filepath, std::ios::out | std::ios::binary);
        if (!file) {
            throw std::runtime_error("Failed to open file for writing.");
        }
        file << content;
    }
};