Switching some more things over to the new Repository type

  );

  eleventyConfig.addFilter("getDirectoryContents", (repo, branch, dirPath) => {
    return reposData.find(current => current.name === repo).branches[branch].fileList.filter(file => file.startsWith(dirPath) && file !== dirPath)
  })

  eleventyConfig.addFilter("getRelativePath", (currentDir, fullFilePath) => {

    return lineNumbers
  })

  eleventyConfig.addFilter("highlightCode", (code: string, language: string) => {
    const highlighter = eleventyConfig?.javascript?.functions?.highlight
    if (highlighter) {
      return highlighter(language, code)

    return repoOperations[config._type].getFileLastTouchInfo(repo, branch, filename, location)
  })

  eleventyConfig.addFilter("isDirectory", (filename: string, repoName: string, branchName: string) => {
    const repo = reposData.find(repo => repo.name === repoName)
    const files = repo.branches.find(branch => branch.name === branchName).fileList
    const isDirectory = files.some((testFile) => {
        return testFile.startsWith(filename + '/') && (testFile !== filename)
      })
    return isDirectory
  })

  eleventyConfig.addAsyncFilter("getFileContents", async (repo: string, branch: string, filename: string) => {
    const location = getLocation(reposConfiguration, branch, repo)
⁣
    const command = `git show ${branch}:${filename}`
    const res = await exec(`(cd ${location} && ${command})`)
    return res.stdout

  eleventyConfig.addAsyncFilter("getReadMe", async (repoName, branchName) => {
    const location = getLocation(reposConfiguration, branchName, repoName)
⁣
    const command = `git show ${branchName}:README.md`
    try {
      const res = await exec(`(cd ${location} && ${command})`)

        nav: {
          repoName: (data) => data.branchInfo.repoName,
          branchName: (data) => data.branchInfo.branchName,
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.branchInfo.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.branchInfo.repoName
        }).branches.find(branch => {
          return branch.name === data.branchInfo.branchName
        })
      },
      navTab: "files",
    }

        nav: {
          repoName: (data) => data.branch.repoName,
          branchName: (data) => data.branch.branchName,
        },
        currentRepo: (data) => reposData.find(repo => {
          return repo.name === data.branch.repoName
        }),
        currentBranch: (data) => reposData.find(repo => {
          return repo.name === data.branch.repoName
        }).branches.find(branch => {
          return branch.name === data.branch.branchName
        }),
      },
      navTab: "landing",
    }

  // PATCH.NJK
  const patchTemplate = fsImport.readFileSync(`${import.meta.dirname}/templates/patch.njk`).toString()
  const flatPatchesData = await flatPatches(reposData)
  eleventyConfig.addTemplate(
    `repos/patch.njk`,
    topLayoutPartial + patchTemplate + bottomLayoutPartial,

  // htmlBaseUrl is a function defined by the 11ty RSS plugin.
  // Skip this virtual template if the 11ty RSS plugin is not being used.
  let rssAvailable = false
  // if (eleventyConfig?.javascript?.functions?.htmlBaseUrl) {
  //   rssAvailable = true
  //   const feedTemplate = fsImport.readFileSync(`${import.meta.dirname}/templates/feed.njk`).toString()
  //   eleventyConfig.addTemplate(
  //     `repos/feed.njk`,
  //     feedTemplate,
  //     {
  //       pagination: {
  //         data: "branches",
  //         size: 1,
  //         alias: "branch",
  //       },
  //       permalink: (data) => {
  //         const repoName = data.branch.repoName
  //         const branchName = data.branch.branchName
  //         return `${reposPath}/${eleventyConfig.getFilter("slugify")(repoName)}/branches/${eleventyConfig.getFilter("slugify")(branchName)}/patches.xml`
  //       },
  //       eleventyComputed: {
  //         currentRepo: (data) => reposData.find(repo => {
  //           return repo.name === data.branch.repoName
  //         }),
  //         currentBranch: (data) => reposData.find(repo => {
  //           return repo.name === data.branch.repoName
  //         }).branches.find(branch => {
  //           return branch.name === data.branch.branchName
  //         }),
  //       },
  //       eleventyExcludeFromCollections: true,
  //     }
  //   )
  // }

  // This is used to show/hide the RSS feed link on the landing page.
  eleventyConfig.addGlobalData('rssAvailable', rssAvailable)

                    <div class="input-group input-group-sm">
                      <span class="input-group-text">Branch</span>
                      <select class="form-select" onchange="selectBranch(this)" aria-label="Repository branch selector">
⁣
                        {% for branch in repos[nav.repoName].branches %}
                        <option value="{{branch.repoName | slugify}},{{branch.branchName | slugify}},{{nav.path}}" {% if branch.branchName == nav.branchName %}selected{% endif %}>{{branch.branchName}}</option>
⁣
                        {% endfor %}
                      </select>
                    </div>

        },
        "branchesToPull": {
          "items": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "additionalProperties": false,
                "properties": {
                  "max": {
                    "type": "number"
                  },
                  "regex": {
                    "type": "string"
                  }
                },
                "required": [
                  "regex",
                  "max"
                ],
                "type": "object"
              }
            ]
          },
          "type": "array"
        },

        },
        "location": {
          "type": "string"
        },
        "tags": {
          "items": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "additionalProperties": false,
                "properties": {
                  "max": {
                    "type": "number"
                  },
                  "regex": {
                    "type": "string"
                  }
                },
                "required": [
                  "regex",
                  "max"
                ],
                "type": "object"
              }
            ]
          },
          "type": "array"
        }
      },
      "required": [

import { type Repository } from "./dataTypes.ts"

let cachedBranches = null

export default (repos: Array<Repository>) => {
  if (cachedBranches !== null) { return cachedBranches }

  cachedBranches = repos.flatMap((repo) => {
    return repo.branches.map((branch) => {
      return {
        branchName: branch.name,
        repoName: repo.name,
      }
    })
  })

  location: string,
  description?: string,
  defaultBranch: string,
  branchesToPull: Array<string | {regex: string, max: number}>,
  tags?: Array<string | {regex: string, max: number}>,
  languageExtensions?: {
    [fileExtension: string]: string
  },

  defaultBranch: string,
  branches: Array<{
    name: string,
    head: string,
    fileList: Array<string>,
  }>,
  tags: Array<{
    name: string,
    sha: string,
    fileList: Array<string>,
  }>,
  commits: Map<string, {
    hash: string,
    message: string,
    author: string,
    date: Date,

    }>
  }>,
⁣
⁣
⁣
⁣
⁣
}

import { type Repository } from "./dataTypes.ts"

let cachedFlatFiles = null

export default (repos: Array<Repository>) => {
  if (cachedFlatFiles !== null) { return cachedFlatFiles }

  cachedFlatFiles = repos.flatMap((repo) => {
    return repo.branches.flatMap((branch) => {
      return branch.fileList.map((file) => {
        return {
          file,
          branchName: branch.name,
          repoName: repo.name,
        }
      })
    })

import { type Repository } from "./dataTypes.ts"

let cachedFlatPatches = null

export default async (repos: Array<Repository>) => {
  if (cachedFlatPatches !== null) { return cachedFlatPatches }

  cachedFlatPatches = repos.flatMap((repo) => {
    return repo.branches.flatMap((branch) => {
⁣
      return [] // todo implement this with new commits format
⁣
⁣
⁣
⁣
⁣
    })
  })

import {
  type ReposConfiguration,
  type GitConfig,
} from './configTypes.ts'
import { type Repository} from './dataTypes.ts'

⁣
import { addBranchToCommitsMap } from './vcses/git/operations.ts'
import { getLocation} from './helpers.ts'

⁣
⁣
const getBranchNames = (repoConfig: GitConfig): Array<string> => {
⁣
⁣
  return repoConfig.branchesToPull.map((branch) => {
⁣
    if (typeof branch === "string") {
      return branch
⁣
    }
    else {
⁣
      return "" // todo
    }
  })
}

let cachedRepos = null

const repos: (reposConfig: ReposConfiguration) => Promise<Array<Repository>> = async (reposConfig) => {
  if (cachedRepos !== null) { return cachedRepos }

  const repoNames = Object.keys(reposConfig.repos)
  const repos: Array<Repository> = []

  for (const repoName of repoNames) {
⁣
    const branchNames = getBranchNames(reposConfig.repos[repoName])
    const commits: Repository['commits'] = new Map()
    for (const branchName of branchNames) {
      const repoLocation = getLocation(reposConfig, branchName, repoName)
⁣
      await addBranchToCommitsMap(branchName, repoLocation, commits)
⁣
⁣
⁣
⁣
    }

⁣
    repos.push({
⁣
⁣
      name: repoName,
⁣
⁣
      branches: branchNames.map((branchName) => {
        return {
          name: branchName,
          head: "", // todo
          fileList: [], //todo
        }
      }),
      cloneUrl: "",
      defaultBranch: "main",
      tags: [],
      commits,
    })
  }

⁣
  return repos
}

export default repos

  return Array.from(fileSet)
}

⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
export const addBranchToCommitsMap = async(branchName: string, repoLocation: string, commits: Repository['commits']): Promise<void> => {
⁣
  const totalPatchesCountRes = await exec(`(cd ${repoLocation} && git rev-list --count ${branchName})`)
  const totalPatchesCount = parseInt(totalPatchesCountRes.stdout)
  for (let i = 0; i < totalPatchesCount; i = i + 10) {

      gitLogSubset = gitLogSubset.slice(nextPatchStart)

      const hash = currentPatch[0].replace("commit ", "").trim()

      // exit early if the commits map already includes this hash
      if (commits.has(hash)) {
        break
      }

      let author: string, date: string
      [1, 2, 3].forEach((lineNumber) => {
        if (currentPatch[lineNumber].startsWith("Author")) {

        return line.startsWith("diff ")
      })
      // Git log is indent four spaces by default -- remove those.
⁣
⁣
      const commitMessage = currentPatch.slice(4, diffStart).map(str => str.replace("    ", "")).filter((line) => {
        // git log --porcelain output adds these "Ignore-this:" lines and I'm not sure what they are
        return !line.startsWith('Ignore-this: ')
      }).join("\n").trim()

      const diffs = getGitDiffsFromPatchText(currentPatch.slice(diffStart).join("\n"))
      commits.set(hash, {
        hash,
        message: commitMessage,
        author,
        date: new Date(date),
                  diffs,
                  parent: "todo",
      })
    } while (gitLogSubset.length > 1)
  }
⁣
⁣
}

export const getFileLastTouchInfo = async (repo: string, branch: string, filename: string, repoLocation: string) => {
  const regex = RegExp(".* [0-9]+ [0-9]+")
  const command = `git blame --porcelain ${branch} ${filename}`
  const res = await exec(`(cd ${repoLocation} && ${command})`)

  getFileList as getGitFileList,
  getFileLastTouchInfo as getGitFileLastTouchInfo,
} from './git/operations.ts'

⁣
type RepoOperationsType = {
  [vcs: string]: {
    getFileList: (repoName: string, branchName: string, repoLocation: string) => Promise<Array<string>>,
    getFileLastTouchInfo: (repoName: string, branchName: string, filename: string, repoLocation: string) => Promise<Array<{sha: string, author: string}>>,
  }
}

<div class="row">
  <div class="col">
    <ul class="list-group">
    {% set files = currentBranch.fileList | topLevelFilesOnly('') %}
    {% for file in files %}
      <li class="list-group-item">
        {% if file.isDirectory %}

<ul>
{% for repo in repos %}
  <li><a href="{{reposPath}}/{{repo.name | slugify}}/branches/{{reposConfig.repos[repo.name].defaultBranch}}">{{repo.name}}</a></li>
{% endfor %}
</ul>

            </div>
          {% endif %}
        </div>
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
⁣
      </div>
    </div>
  </div>