Task 593: .R File Format

thinkmelt@protonmail.com

Nov 13, 2025 • 5 min read

File Format Specifications for the .R File Format

Based on available documentation, the .R file format is primarily associated with R script files used in the R programming language for statistical computing and graphics. It is a plain text format containing R code, with no binary structure, headers, or encoded data. The format follows standard text file conventions, typically encoded in UTF-8 or ASCII, and can include R syntax for functions, variables, loops, and data manipulation. There are no format-specific intrinsic properties beyond those of a general text file, such as line endings (LF or CRLF) and character encoding. Other less common uses of the .R extension include Rebol source code, Mac Resource scripts, and Twist Report scripts, all of which are also text-based.

List of all the properties of this file format intrinsic to its file system:

Inode number (unique identifier in the file system)
Device ID (identifier of the storage device)
Mode (file type and permissions, e.g., read/write/execute for owner/group/others)
Number of hard links (count of links pointing to the inode)
User ID (UID of the file owner)
Group ID (GID of the file's group)
File size (in bytes)
Last access time (atime, timestamp of last read)
Last modification time (mtime, timestamp of last content change)
Last status change time (ctime, timestamp of last metadata change)

These properties are standard file system metadata and not unique to the .R format, but they are intrinsic to how the file is managed in the file system (e.g., in Unix-like systems via the stat structure).

Two direct download links for files of format .R:

Ghost blog embedded HTML JavaScript for drag-and-drop .R file to dump properties:

Here's a self-contained HTML snippet with embedded JavaScript that can be embedded in a Ghost blog post (e.g., via the HTML card in the editor). It creates a drag-and-drop area. Upon dropping a .R file, it displays the available properties. Note: Browser security limits access to full file system metadata (e.g., inode, UID), so only browser-accessible properties (name, size, type, last modified) are shown. For full properties, a server-side tool would be needed.

Drag and drop a .R file here

Python class for handling .R files:

import os
import time

class RFile:
    def __init__(self, path):
        self.path = path
        self.stat = os.stat(path)

    def read(self):
        """Read the content of the .R file."""
        with open(self.path, 'r') as f:
            return f.read()

    def write(self, content):
        """Write content to the .R file."""
        with open(self.path, 'w') as f:
            f.write(content)

    def print_properties(self):
        """Print all file system properties."""
        print(f"Inode number: {self.stat.st_ino}")
        print(f"Device ID: {self.stat.st_dev}")
        print(f"Mode (permissions): {oct(self.stat.st_mode)}")
        print(f"Number of hard links: {self.stat.st_nlink}")
        print(f"User ID (UID): {self.stat.st_uid}")
        print(f"Group ID (GID): {self.stat.st_gid}")
        print(f"File size: {self.stat.st_size} bytes")
        print(f"Last access time: {time.ctime(self.stat.st_atime)}")
        print(f"Last modification time: {time.ctime(self.stat.st_mtime)}")
        print(f"Last status change time: {time.ctime(self.stat.st_ctime)}")

# Example usage:
# rfile = RFile('example.R')
# print(rfile.read())
# rfile.write('print("Hello from R")')
# rfile.print_properties()

Note: "Decode" is not applicable as .R is plain text; read() handles content access. This assumes a Unix-like system for full stat properties.

Java class for handling .R files:

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.util.Date;

public class RFile {
    private final Path path;
    private final PosixFileAttributes attrs;

    public RFile(String pathStr) throws IOException {
        this.path = Paths.get(pathStr);
        this.attrs = Files.readAttributes(this.path, PosixFileAttributes.class);
    }

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

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

    public void printProperties() {
        System.out.println("Inode number: " + attrs.ino());
        System.out.println("Device ID: " + attrs.dev());
        System.out.println("Mode (permissions): " + PosixFilePermissions.toString(attrs.permissions()));
        System.out.println("Number of hard links: " + attrs.nlink());
        System.out.println("User ID (UID): " + attrs.owner().getName());  // Name instead of ID for simplicity
        System.out.println("Group ID (GID): " + attrs.group().getName());  // Name instead of ID
        System.out.println("File size: " + attrs.size() + " bytes");
        System.out.println("Last access time: " + new Date(attrs.lastAccessTime().toMillis()));
        System.out.println("Last modification time: " + new Date(attrs.lastModifiedTime().toMillis()));
        System.out.println("Last status change time: " + new Date(attrs.creationTime().toMillis()));  // Approximation for ctime
    }

    // Example usage:
    // public static void main(String[] args) throws IOException {
    //     RFile rfile = new RFile("example.R");
    //     System.out.println(rfile.read());
    //     rfile.write("print(\"Hello from R\")");
    //     rfile.printProperties();
    // }
}

Note: Uses NIO for attributes; assumes POSIX-compliant system (e.g., Linux). UID/GID shown as names. Creation time approximates ctime in some systems.

JavaScript class (Node.js) for handling .R files:

const fs = require('fs');

class RFile {
  constructor(path) {
    this.path = path;
    this.stat = fs.statSync(path);
  }

  read() {
    return fs.readFileSync(this.path, 'utf8');
  }

  write(content) {
    fs.writeFileSync(this.path, content);
  }

  printProperties() {
    console.log(`Inode number: ${this.stat.ino}`);
    console.log(`Device ID: ${this.stat.dev}`);
    console.log(`Mode (permissions): ${this.stat.mode.toString(8)}`);
    console.log(`Number of hard links: ${this.stat.nlink}`);
    console.log(`User ID (UID): ${this.stat.uid}`);
    console.log(`Group ID (GID): ${this.stat.gid}`);
    console.log(`File size: ${this.stat.size} bytes`);
    console.log(`Last access time: ${new Date(this.stat.atimeMs)}`);
    console.log(`Last modification time: ${new Date(this.stat.mtimeMs)}`);
    console.log(`Last status change time: ${new Date(this.stat.ctimeMs)}`);
  }
}

// Example usage:
// const rfile = new RFile('example.R');
// console.log(rfile.read());
// rfile.write('print("Hello from R")');
// rfile.printProperties();

Note: Requires Node.js for fs module and full stat access. Browser JS is limited, as shown in the drag-drop script.

C class (struct-based) for handling .R files:

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <time.h>
#include <string.h>

typedef struct {
    char *path;
    struct stat statbuf;
} RFile;

RFile* rfile_new(const char *path) {
    RFile *rf = malloc(sizeof(RFile));
    rf->path = strdup(path);
    if (stat(path, &rf->statbuf) != 0) {
        perror("stat");
        free(rf);
        return NULL;
    }
    return rf;
}

void rfile_free(RFile *rf) {
    free(rf->path);
    free(rf);
}

char* rfile_read(RFile *rf) {
    FILE *f = fopen(rf->path, "r");
    if (!f) {
        perror("fopen");
        return NULL;
    }
    fseek(f, 0, SEEK_END);
    long size = ftell(f);
    fseek(f, 0, SEEK_SET);
    char *content = malloc(size + 1);
    fread(content, 1, size, f);
    content[size] = '\0';
    fclose(f);
    return content;
}

void rfile_write(RFile *rf, const char *content) {
    FILE *f = fopen(rf->path, "w");
    if (!f) {
        perror("fopen");
        return;
    }
    fprintf(f, "%s", content);
    fclose(f);
    // Update stat after write
    stat(rf->path, &rf->statbuf);
}

void rfile_print_properties(RFile *rf) {
    printf("Inode number: %ld\n", rf->statbuf.st_ino);
    printf("Device ID: %ld\n", rf->statbuf.st_dev);
    printf("Mode (permissions): %o\n", rf->statbuf.st_mode);
    printf("Number of hard links: %ld\n", rf->statbuf.st_nlink);
    printf("User ID (UID): %d\n", rf->statbuf.st_uid);
    printf("Group ID (GID): %d\n", rf->statbuf.st_gid);
    printf("File size: %ld bytes\n", rf->statbuf.st_size);
    printf("Last access time: %s", ctime(&rf->statbuf.st_atime));
    printf("Last modification time: %s", ctime(&rf->statbuf.st_mtime));
    printf("Last status change time: %s", ctime(&rf->statbuf.st_ctime));
}

// Example usage:
// int main() {
//     RFile *rf = rfile_new("example.R");
//     if (!rf) return 1;
//     char *content = rfile_read(rf);
//     printf("%s\n", content);
//     free(content);
//     rfile_write(rf, "print(\"Hello from R\")\n");
//     rfile_print_properties(rf);
//     rfile_free(rf);
//     return 0;
// }

Note: Assumes Unix-like system for stat. Compile with gcc. "Decode" not applicable for text; read handles content.