@featurevisor/core 1.35.3 → 2.0.1

package/lib/datasource/filesystemAdapter.js

@@ -1,102 +1,47 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilesystemAdapter = void 0;
 exports.getExistingStateFilePath = getExistingStateFilePath;
 exports.getRevisionFilePath = getRevisionFilePath;
 exports.getAllEntityFilePathsRecursively = getAllEntityFilePathsRecursively;
-var fs = require("fs");
-var path = require("path");
-var child_process_1 = require("child_process");
-var mkdirp = require("mkdirp");
-var adapter_1 = require("./adapter");
-var git_1 = require("../utils/git");
-var commitRegex = /^commit (\w+)\nAuthor: (.+) <(.+)>\nDate:   (.+)\n\n(.+)/gm;
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const adapter_1 = require("./adapter");
+const git_1 = require("../utils/git");
 function getExistingStateFilePath(projectConfig, environment) {
-    var fileName = environment ? "existing-state-".concat(environment, ".json") : "existing-state.json";
+    const fileName = environment ? `existing-state-${environment}.json` : `existing-state.json`;
     return path.join(projectConfig.stateDirectoryPath, fileName);
 }
 function getRevisionFilePath(projectConfig) {
-    return path.join(projectConfig.stateDirectoryPath, "REVISION");
+    return path.join(projectConfig.stateDirectoryPath, `REVISION`);
 }
 function getAllEntityFilePathsRecursively(directoryPath, extension) {
-    var entities = [];
+    let entities = [];
     if (!fs.existsSync(directoryPath)) {
         return entities;
     }
-    var files = fs.readdirSync(directoryPath);
-    for (var i = 0; i < files.length; i++) {
-        var file = files[i];
-        var filePath = path.join(directoryPath, file);
+    const files = fs.readdirSync(directoryPath);
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const filePath = path.join(directoryPath, file);
         if (fs.statSync(filePath).isDirectory()) {
             entities = entities.concat(getAllEntityFilePathsRecursively(filePath, extension));
         }
-        else if (file.endsWith(".".concat(extension))) {
+        else if (file.endsWith(`.${extension}`)) {
             entities.push(filePath);
         }
     }
     return entities;
 }
-var FilesystemAdapter = /** @class */ (function (_super) {
-    __extends(FilesystemAdapter, _super);
-    function FilesystemAdapter(config, rootDirectoryPath) {
-        var _this = _super.call(this) || this;
-        _this.config = config;
-        _this.rootDirectoryPath = rootDirectoryPath;
-        _this.parser = config.parser;
-        return _this;
+class FilesystemAdapter extends adapter_1.Adapter {
+    constructor(config, rootDirectoryPath) {
+        super();
+        this.config = config;
+        this.rootDirectoryPath = rootDirectoryPath;
+        this.parser = config.parser;
     }
-    FilesystemAdapter.prototype.getEntityDirectoryPath = function (entityType) {
+    getEntityDirectoryPath(entityType) {
         if (entityType === "feature") {
             return this.config.featuresDirectoryPath;
         }
@@ -110,226 +55,161 @@ var FilesystemAdapter = /** @class */ (function (_super) {
             return this.config.testsDirectoryPath;
         }
         return this.config.attributesDirectoryPath;
-    };
-    FilesystemAdapter.prototype.getEntityPath = function (entityType, entityKey) {
-        var basePath = this.getEntityDirectoryPath(entityType);
+    }
+    getEntityPath(entityType, entityKey) {
+        const basePath = this.getEntityDirectoryPath(entityType);
         // taking care of windows paths
-        var relativeEntityPath = entityKey.replace(/\//g, path.sep);
-        return path.join(basePath, "".concat(relativeEntityPath, ".").concat(this.parser.extension));
-    };
-    FilesystemAdapter.prototype.listEntities = function (entityType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var directoryPath, filePaths;
-            var _this = this;
-            return __generator(this, function (_a) {
-                directoryPath = this.getEntityDirectoryPath(entityType);
-                filePaths = getAllEntityFilePathsRecursively(directoryPath, this.parser.extension);
-                return [2 /*return*/, (filePaths
-                        // keep only the files with the right extension
-                        .filter(function (filterPath) { return filterPath.endsWith(".".concat(_this.parser.extension)); })
-                        // remove the entity directory path from beginning
-                        .map(function (filePath) { return filePath.replace(directoryPath + path.sep, ""); })
-                        // remove the extension from the end
-                        .map(function (filterPath) { return filterPath.replace(".".concat(_this.parser.extension), ""); })
-                        // take care of windows paths
-                        .map(function (filterPath) { return filterPath.replace(/\\/g, "/"); }))];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.entityExists = function (entityType, entityKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var entityPath;
-            return __generator(this, function (_a) {
-                entityPath = this.getEntityPath(entityType, entityKey);
-                return [2 /*return*/, fs.existsSync(entityPath)];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.readEntity = function (entityType, entityKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath, entityContent;
-            return __generator(this, function (_a) {
-                filePath = this.getEntityPath(entityType, entityKey);
-                entityContent = fs.readFileSync(filePath, "utf8");
-                return [2 /*return*/, this.parser.parse(entityContent, filePath)];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.writeEntity = function (entityType, entityKey, entity) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath;
-            return __generator(this, function (_a) {
-                filePath = this.getEntityPath(entityType, entityKey);
-                if (!fs.existsSync(this.getEntityDirectoryPath(entityType))) {
-                    mkdirp.sync(this.getEntityDirectoryPath(entityType));
-                }
-                fs.writeFileSync(filePath, this.parser.stringify(entity));
-                return [2 /*return*/, entity];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.deleteEntity = function (entityType, entityKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath;
-            return __generator(this, function (_a) {
-                filePath = this.getEntityPath(entityType, entityKey);
-                if (!fs.existsSync(filePath)) {
-                    return [2 /*return*/];
-                }
-                fs.unlinkSync(filePath);
-                return [2 /*return*/];
-            });
-        });
-    };
+        const relativeEntityPath = entityKey.replace(/\//g, path.sep);
+        return path.join(basePath, `${relativeEntityPath}.${this.parser.extension}`);
+    }
+    async listEntities(entityType) {
+        const directoryPath = this.getEntityDirectoryPath(entityType);
+        const filePaths = getAllEntityFilePathsRecursively(directoryPath, this.parser.extension);
+        return (filePaths
+            // keep only the files with the right extension
+            .filter((filterPath) => filterPath.endsWith(`.${this.parser.extension}`))
+            // remove the entity directory path from beginning
+            .map((filePath) => filePath.replace(directoryPath + path.sep, ""))
+            // remove the extension from the end
+            .map((filterPath) => filterPath.replace(`.${this.parser.extension}`, ""))
+            // take care of windows paths
+            .map((filterPath) => filterPath.replace(/\\/g, "/")));
+    }
+    async entityExists(entityType, entityKey) {
+        const entityPath = this.getEntityPath(entityType, entityKey);
+        return fs.existsSync(entityPath);
+    }
+    async readEntity(entityType, entityKey) {
+        const filePath = this.getEntityPath(entityType, entityKey);
+        const entityContent = fs.readFileSync(filePath, "utf8");
+        return this.parser.parse(entityContent, filePath);
+    }
+    async writeEntity(entityType, entityKey, entity) {
+        const filePath = this.getEntityPath(entityType, entityKey);
+        if (!fs.existsSync(this.getEntityDirectoryPath(entityType))) {
+            fs.mkdirSync(this.getEntityDirectoryPath(entityType), { recursive: true });
+        }
+        fs.writeFileSync(filePath, this.parser.stringify(entity));
+        return entity;
+    }
+    async deleteEntity(entityType, entityKey) {
+        const filePath = this.getEntityPath(entityType, entityKey);
+        if (!fs.existsSync(filePath)) {
+            return;
+        }
+        fs.unlinkSync(filePath);
+    }
     /**
      * State
      */
-    FilesystemAdapter.prototype.readState = function (environment) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath;
-            return __generator(this, function (_a) {
-                filePath = getExistingStateFilePath(this.config, environment);
-                if (!fs.existsSync(filePath)) {
-                    return [2 /*return*/, {
-                            features: {},
-                        }];
-                }
-                return [2 /*return*/, require(filePath)];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.writeState = function (environment, existingState) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath;
-            return __generator(this, function (_a) {
-                filePath = getExistingStateFilePath(this.config, environment);
-                if (!fs.existsSync(this.config.stateDirectoryPath)) {
-                    mkdirp.sync(this.config.stateDirectoryPath);
-                }
-                fs.writeFileSync(filePath, this.config.prettyState
-                    ? JSON.stringify(existingState, null, 2)
-                    : JSON.stringify(existingState));
-                fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
-                return [2 /*return*/];
-            });
-        });
-    };
+    async readState(environment) {
+        const filePath = getExistingStateFilePath(this.config, environment);
+        if (!fs.existsSync(filePath)) {
+            return {
+                features: {},
+            };
+        }
+        return require(filePath);
+    }
+    async writeState(environment, existingState) {
+        const filePath = getExistingStateFilePath(this.config, environment);
+        if (!fs.existsSync(this.config.stateDirectoryPath)) {
+            fs.mkdirSync(this.config.stateDirectoryPath, { recursive: true });
+        }
+        fs.writeFileSync(filePath, this.config.prettyState
+            ? JSON.stringify(existingState, null, 2)
+            : JSON.stringify(existingState));
+        fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+    }
     /**
      * Revision
      */
-    FilesystemAdapter.prototype.readRevision = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath, pkg, pkgVersion;
-            return __generator(this, function (_a) {
-                filePath = getRevisionFilePath(this.config);
-                if (fs.existsSync(filePath)) {
-                    return [2 /*return*/, fs.readFileSync(filePath, "utf8")];
-                }
-                // maintain backwards compatibility
-                try {
-                    pkg = require(path.join(this.rootDirectoryPath, "package.json"));
-                    pkgVersion = pkg.version;
-                    if (pkgVersion) {
-                        return [2 /*return*/, pkgVersion];
-                    }
-                    return [2 /*return*/, "0"];
-                }
-                catch (e) {
-                    return [2 /*return*/, "0"];
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.writeRevision = function (revision) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath;
-            return __generator(this, function (_a) {
-                filePath = getRevisionFilePath(this.config);
-                if (!fs.existsSync(this.config.stateDirectoryPath)) {
-                    mkdirp.sync(this.config.stateDirectoryPath);
-                }
-                fs.writeFileSync(filePath, revision);
-                return [2 /*return*/];
-            });
-        });
-    };
+    async readRevision() {
+        const filePath = getRevisionFilePath(this.config);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, "utf8");
+        }
+        // maintain backwards compatibility
+        try {
+            const pkg = require(path.join(this.rootDirectoryPath, "package.json"));
+            const pkgVersion = pkg.version;
+            if (pkgVersion) {
+                return pkgVersion;
+            }
+            return "0";
+            // eslint-disable-next-line
+        }
+        catch (e) {
+            return "0";
+        }
+    }
+    async writeRevision(revision) {
+        const filePath = getRevisionFilePath(this.config);
+        if (!fs.existsSync(this.config.stateDirectoryPath)) {
+            fs.mkdirSync(this.config.stateDirectoryPath, { recursive: true });
+        }
+        fs.writeFileSync(filePath, revision);
+    }
     /**
      * Datafile
      */
-    FilesystemAdapter.prototype.getDatafilePath = function (options) {
-        var fileName = "datafile-tag-".concat(options.tag, ".json");
-        var dir = options.datafilesDir || this.config.outputDirectoryPath;
+    getDatafilePath(options) {
+        const pattern = this.config.datafileNamePattern || "featurevisor-%s.json";
+        const fileName = pattern.replace("%s", `tag-${options.tag}`);
+        const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
         if (options.environment) {
             return path.join(dir, options.environment, fileName);
         }
         return path.join(dir, fileName);
-    };
-    FilesystemAdapter.prototype.readDatafile = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var filePath, content, datafileContent;
-            return __generator(this, function (_a) {
-                filePath = this.getDatafilePath(options);
-                content = fs.readFileSync(filePath, "utf8");
-                datafileContent = JSON.parse(content);
-                return [2 /*return*/, datafileContent];
-            });
-        });
-    };
-    FilesystemAdapter.prototype.writeDatafile = function (datafileContent, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dir, outputEnvironmentDirPath, outputFilePath, root, shortPath;
-            return __generator(this, function (_a) {
-                dir = options.datafilesDir || this.config.outputDirectoryPath;
-                outputEnvironmentDirPath = options.environment
-                    ? path.join(dir, options.environment)
-                    : dir;
-                mkdirp.sync(outputEnvironmentDirPath);
-                outputFilePath = this.getDatafilePath(options);
-                fs.writeFileSync(outputFilePath, this.config.prettyDatafile
-                    ? JSON.stringify(datafileContent, null, 2)
-                    : JSON.stringify(datafileContent));
-                root = path.resolve(dir, "..");
-                shortPath = outputFilePath.replace(root + path.sep, "");
-                console.log("     Datafile generated: ".concat(shortPath));
-                return [2 /*return*/];
-            });
-        });
-    };
+    }
+    async readDatafile(options) {
+        const filePath = this.getDatafilePath(options);
+        const content = fs.readFileSync(filePath, "utf8");
+        const datafileContent = JSON.parse(content);
+        return datafileContent;
+    }
+    async writeDatafile(datafileContent, options) {
+        const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
+        const outputEnvironmentDirPath = options.environment
+            ? path.join(dir, options.environment)
+            : dir;
+        fs.mkdirSync(outputEnvironmentDirPath, { recursive: true });
+        const outputFilePath = this.getDatafilePath(options);
+        fs.writeFileSync(outputFilePath, this.config.prettyDatafile
+            ? JSON.stringify(datafileContent, null, 2)
+            : JSON.stringify(datafileContent));
+        const root = path.resolve(dir, "..");
+        const shortPath = outputFilePath.replace(root + path.sep, "");
+        console.log(`     Datafile generated: ${shortPath}`);
+    }
     /**
      * History
      */
-    FilesystemAdapter.prototype.getRawHistory = function (pathPatterns) {
-        return __awaiter(this, void 0, void 0, function () {
-            var gitPaths, logCommand, fullCommand;
-            return __generator(this, function (_a) {
-                gitPaths = pathPatterns.join(" ");
-                logCommand = "git log --name-only --pretty=format:\"%h|%an|%aI\" --relative --no-merges -- ".concat(gitPaths);
-                fullCommand = "(cd ".concat(this.rootDirectoryPath, " && ").concat(logCommand, ")");
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var child = (0, child_process_1.spawn)(fullCommand, { shell: true });
-                        var result = "";
-                        child.stdout.on("data", function (data) {
-                            result += data.toString();
-                        });
-                        child.stderr.on("data", function (data) {
-                            console.error(data.toString());
-                        });
-                        child.on("close", function (code) {
-                            if (code === 0) {
-                                resolve(result);
-                            }
-                            else {
-                                reject(code);
-                            }
-                        });
-                    })];
+    async getRawHistory(pathPatterns) {
+        const gitPaths = pathPatterns.join(" ");
+        const logCommand = `git log --name-only --pretty=format:"%h|%an|%aI" --relative --no-merges -- ${gitPaths}`;
+        const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+        return new Promise(function (resolve, reject) {
+            const child = (0, child_process_1.spawn)(fullCommand, { shell: true });
+            let result = "";
+            child.stdout.on("data", function (data) {
+                result += data.toString();
+            });
+            child.stderr.on("data", function (data) {
+                console.error(data.toString());
+            });
+            child.on("close", function (code) {
+                if (code === 0) {
+                    resolve(result);
+                }
+                else {
+                    reject(code);
+                }
             });
         });
-    };
-    FilesystemAdapter.prototype.getPathPatterns = function (entityType, entityKey) {
-        var _this = this;
-        var pathPatterns = [];
+    }
+    getPathPatterns(entityType, entityKey) {
+        let pathPatterns = [];
         if (entityType && entityKey) {
             pathPatterns = [this.getEntityPath(entityType, entityKey)];
         }
@@ -359,93 +239,77 @@ var FilesystemAdapter = /** @class */ (function (_super) {
                 this.config.testsDirectoryPath,
             ];
         }
-        return pathPatterns.map(function (p) { return p.replace(_this.rootDirectoryPath + path.sep, ""); });
-    };
-    FilesystemAdapter.prototype.listHistoryEntries = function (entityType, entityKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pathPatterns, rawHistory, fullHistory, blocks, i, block, lines, commitLine, _a, commitHash, author, timestamp, entities, filePathLines, j, relativePath, absolutePath, fileName, relativeDir, key, type;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        pathPatterns = this.getPathPatterns(entityType, entityKey);
-                        return [4 /*yield*/, this.getRawHistory(pathPatterns)];
-                    case 1:
-                        rawHistory = _b.sent();
-                        fullHistory = [];
-                        blocks = rawHistory.split("\n\n");
-                        for (i = 0; i < blocks.length; i++) {
-                            block = blocks[i];
-                            if (block.length === 0) {
-                                continue;
-                            }
-                            lines = block.split("\n");
-                            commitLine = lines[0];
-                            _a = commitLine.split("|"), commitHash = _a[0], author = _a[1], timestamp = _a[2];
-                            entities = [];
-                            filePathLines = lines.slice(1);
-                            for (j = 0; j < filePathLines.length; j++) {
-                                relativePath = filePathLines[j];
-                                absolutePath = path.join(this.rootDirectoryPath, relativePath);
-                                fileName = absolutePath.split(path.sep).pop();
-                                relativeDir = path.dirname(absolutePath);
-                                key = fileName.replace("." + this.parser.extension, "");
-                                type = "attribute";
-                                if (relativeDir === this.config.attributesDirectoryPath) {
-                                    type = "attribute";
-                                }
-                                else if (relativeDir === this.config.segmentsDirectoryPath) {
-                                    type = "segment";
-                                }
-                                else if (relativeDir === this.config.featuresDirectoryPath) {
-                                    type = "feature";
-                                }
-                                else if (relativeDir === this.config.groupsDirectoryPath) {
-                                    type = "group";
-                                }
-                                else if (relativeDir === this.config.testsDirectoryPath) {
-                                    type = "test";
-                                }
-                                else {
-                                    continue;
-                                }
-                                entities.push({
-                                    type: type,
-                                    key: key,
-                                });
-                            }
-                            if (entities.length === 0) {
-                                continue;
-                            }
-                            fullHistory.push({
-                                commit: commitHash,
-                                author: author,
-                                timestamp: timestamp,
-                                entities: entities,
-                            });
-                        }
-                        return [2 /*return*/, fullHistory];
+        return pathPatterns.map((p) => p.replace(this.rootDirectoryPath + path.sep, ""));
+    }
+    async listHistoryEntries(entityType, entityKey) {
+        const pathPatterns = this.getPathPatterns(entityType, entityKey);
+        const rawHistory = await this.getRawHistory(pathPatterns);
+        const fullHistory = [];
+        const blocks = rawHistory.split("\n\n");
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            if (block.length === 0) {
+                continue;
+            }
+            const lines = block.split("\n");
+            const commitLine = lines[0];
+            const [commitHash, author, timestamp] = commitLine.split("|");
+            const entities = [];
+            const filePathLines = lines.slice(1);
+            for (let j = 0; j < filePathLines.length; j++) {
+                const relativePath = filePathLines[j];
+                const absolutePath = path.join(this.rootDirectoryPath, relativePath);
+                const fileName = absolutePath.split(path.sep).pop();
+                const relativeDir = path.dirname(absolutePath);
+                const key = fileName.replace("." + this.parser.extension, "");
+                let type = "attribute";
+                if (relativeDir === this.config.attributesDirectoryPath) {
+                    type = "attribute";
                 }
-            });
-        });
-    };
-    FilesystemAdapter.prototype.readCommit = function (commitHash, entityType, entityKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pathPatterns, gitPaths, logCommand, fullCommand, gitShowOutput, commit;
-            return __generator(this, function (_a) {
-                pathPatterns = this.getPathPatterns(entityType, entityKey);
-                gitPaths = pathPatterns.join(" ");
-                logCommand = "git show ".concat(commitHash, " --relative -- ").concat(gitPaths);
-                fullCommand = "(cd ".concat(this.rootDirectoryPath, " && ").concat(logCommand, ")");
-                gitShowOutput = (0, child_process_1.execSync)(fullCommand, { encoding: "utf8" }).toString();
-                commit = (0, git_1.getCommit)(gitShowOutput, {
-                    rootDirectoryPath: this.rootDirectoryPath,
-                    projectConfig: this.config,
+                else if (relativeDir === this.config.segmentsDirectoryPath) {
+                    type = "segment";
+                }
+                else if (relativeDir === this.config.featuresDirectoryPath) {
+                    type = "feature";
+                }
+                else if (relativeDir === this.config.groupsDirectoryPath) {
+                    type = "group";
+                }
+                else if (relativeDir === this.config.testsDirectoryPath) {
+                    type = "test";
+                }
+                else {
+                    continue;
+                }
+                entities.push({
+                    type,
+                    key,
                 });
-                return [2 /*return*/, commit];
+            }
+            if (entities.length === 0) {
+                continue;
+            }
+            fullHistory.push({
+                commit: commitHash,
+                author,
+                timestamp,
+                entities,
             });
+        }
+        return fullHistory;
+    }
+    async readCommit(commitHash, entityType, entityKey) {
+        const pathPatterns = this.getPathPatterns(entityType, entityKey);
+        const gitPaths = pathPatterns.join(" ");
+        const logCommand = `git show ${commitHash} --relative -- ${gitPaths}`;
+        const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+        const gitShowOutput = (0, child_process_1.execSync)(fullCommand, { encoding: "utf8" }).toString();
+        const commit = (0, git_1.getCommit)(gitShowOutput, {
+            rootDirectoryPath: this.rootDirectoryPath,
+            projectConfig: this.config,
         });
-    };
-    return FilesystemAdapter;
-}(adapter_1.Adapter));
+        return commit;
+    }
+}
 exports.FilesystemAdapter = FilesystemAdapter;
 //# sourceMappingURL=filesystemAdapter.js.map