feat: read files

src/lib/path/index.ts

@@ -4,6 +4,7 @@ import {
   PathKind,
   PathMeta,
   PathWalker,
+  TextTransform,
   WalkOptions
 } from "../../types";
 import walker from "../walker";
@@ -19,6 +20,7 @@ import meta from "./meta";
 import parent from "./parent";
 import { constants, pathKind, pathString } from "./parse";
 import prepend from "./prepend";
+import read from "./read";
 import reverse from "./reverse";
 import subDirectories from "./subDirectories";
 import write from "./write";
@@ -69,6 +71,12 @@ export const path = (current: Path): FlexiPath => {
       ? (current as PathMeta)
       : meta(current);
 
+  const readWrapper = ({
+    encoding = "utf8",
+    transform = TextTransform.Plain
+  }: { encoding?: string; transform?: TextTransform } = {}): any =>
+    read(pathMeta, { encoding, transform });
+
   return Object.freeze({
     ...pathMeta,
     ...{
@@ -86,6 +94,7 @@ export const path = (current: Path): FlexiPath => {
       parent: parent(pathMeta.path),
       prepend: (...paths: Path[]) =>
         prepend(pathMeta.path, ...paths.map(x => pathString(x))),
+      read: readWrapper,
       reverse: () => reverse(pathMeta.path),
       subDirectories: subDirectories(pathMeta.path),
       walk: () => pathWalker(pathMeta.path),

src/lib/path/read.ts

@@ -0,0 +1,23 @@
+import { readFileSync } from "fs";
+
+import { PathMeta, PathType, TextTransform } from "../../types";
+
+const read = (
+  path: PathMeta,
+  {
+    encoding = "utf8",
+    transform = TextTransform.Plain
+  }: { encoding?: string; transform?: TextTransform } = {}
+): any => {
+  if (path.type() !== PathType.File) {
+    return "";
+  }
+  const content = readFileSync(path.path, encoding);
+
+  if (transform === TextTransform.JSON) {
+    return JSON.parse(content);
+  }
+  return content;
+};
+
+export default read;

src/types/FlexiPath.ts

@@ -5,6 +5,7 @@ import {
   Path,
   PathMeta,
   SubDirectoryQuery,
+  TextTransform,
   PathWalker
 } from ".";
 
@@ -91,6 +92,7 @@ export interface FlexiPath extends PathMeta {
    */
   except(...paths: Path[]): FlexiPath;
 
+  read(options?: { encoding?: string; transform?: TextTransform }): any;
   walk(): PathWalker;
   /**
    * Writes the current `path` to disk if possible

src/types/PathWalker.ts

@@ -0,0 +1,6 @@
+import { FlexiPath, WalkOptions } from ".";
+
+export interface PathWalker {
+  forward: (options?: WalkOptions) => FlexiPath[];
+  back: (options?: WalkOptions) => FlexiPath;
+}

src/types/TextTransform.ts

@@ -0,0 +1,4 @@
+export enum TextTransform {
+  Plain = 0,
+  JSON = 1
+}

src/types/Walker.ts

@@ -9,8 +9,3 @@ export interface Walker {
     acc?: FlexiPath
   ) => WalkedPath<FlexiPath>;
 }
-
-export interface PathWalker {
-  forward: (options?: WalkOptions) => FlexiPath[];
-  back: (options?: WalkOptions) => FlexiPath;
-}

src/types/index.ts

@@ -5,6 +5,7 @@ export { PathKind } from "./PathKind";
 export { PathMeta } from "./PathMeta";
 export { PathType } from "./PathType";
 export { PathVistor } from "./PathVistor";
+export { PathWalker } from "./PathWalker";
 export { PathWithBasePath } from "./PathWithBasePath";
 export {
   ChildQuery,
@@ -13,9 +14,10 @@ export {
   Query,
   SubDirectoryQuery
 } from "./Query";
+export { TextTransform } from "./TextTransform";
 export { WalkedState } from "./WalkedState";
 export { WalkedPath } from "./WalkedPath";
-export { Walker, PathWalker } from "./Walker";
+export { Walker } from "./Walker";
 export { Walking } from "./Walking";
 export { WalkOptions } from "./WalkOptions";
 export { WalkUntil } from "./WalkUntil";

test/path/read.test.ts

@@ -0,0 +1,34 @@
+import flexi, { TextTransform } from "../../src";
+import { testDir } from "../jest/createTestData";
+
+interface PackageJson {
+  name: string;
+  description: string;
+}
+
+const packageJson = flexi
+  .path(__dirname)
+  .parent(x => x.name === "flexi-path")
+  .append("package.json");
+
+describe("read", () => {
+  it("can read file", () => {
+    expect(packageJson.read()).not.toBeEmpty();
+  });
+
+  it("can read file as json", () => {
+    const json: PackageJson = packageJson.read({
+      transform: TextTransform.JSON
+    });
+
+    expect(json.name).toBe("flexi-path");
+  });
+
+  it("should be empty when path is dir", () => {
+    expect(flexi.path(testDir).read()).toBeEmpty();
+  });
+
+  it("should be empty when path is invalid", () => {
+    expect(flexi.path("invalid").read()).toBeEmpty();
+  });
+});