@chriswiegman/hugo-tools 0.2.0 → 0.2.2

package/src/extract-tags.js

@@ -17,218 +17,229 @@ const SNIPPETS_FILE = path.join(process.cwd(), config.vscodeDir, 'markdown.code-
  * Extracts frontmatter from a markdown file
  */
 function extractFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  return match ? match[1] : null;
+	const match = content.match(/^---\n([\s\S]*?)\n---/);
+
+	return match ? match[1] : null;
 }
 
 /**
  * Parses YAML-style list items from frontmatter
  */
 function parseListItems(frontmatter, key) {
-  const items = [];
-  const blockRegex = new RegExp(`^${key}:\\s*\\n((\\s*-\\s*.+\\n)+)`, 'm');
-  const match = frontmatter.match(blockRegex);
-
-  if (match) {
-    const lines = match[1].split('\n');
-    for (const line of lines) {
-      const itemMatch = line.match(/^\s*-\s*(.+)\s*$/);
-      if (itemMatch) {
-        const value = itemMatch[1].trim().replace(/^["']|["']$/g, '');
-        if (value) {
-          items.push(value);
-        }
-      }
-    }
-  }
-
-  return items;
+	const items = [];
+	const blockRegex = new RegExp(`^${key}:\\s*\\n((\\s*-\\s*.+\\n)+)`, 'm');
+	const match = frontmatter.match(blockRegex);
+
+	if (match) {
+		const lines = match[1].split('\n');
+
+		for (const line of lines) {
+			const itemMatch = line.match(/^\s*-\s*(.+)\s*$/);
+
+			if (itemMatch) {
+				const value = itemMatch[1].trim().replace(/^["']|["']$/g, '');
+
+				if (value) {
+					items.push(value);
+				}
+			}
+		}
+	}
+
+	return items;
 }
 
 /**
  * Recursively finds all markdown files
  */
 function findMarkdownFiles(dir) {
-  const files = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...findMarkdownFiles(fullPath));
-    } else if (entry.isFile() && entry.name.endsWith('.md')) {
-      files.push(fullPath);
-    }
-  }
-
-  return files;
+	const files = [];
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+
+		if (entry.isDirectory()) {
+			files.push(...findMarkdownFiles(fullPath));
+		} else if (entry.isFile() && entry.name.endsWith('.md')) {
+			files.push(fullPath);
+		}
+	}
+
+	return files;
 }
 
 /**
  * Main extraction logic
  */
 function extractTagsAndCategories() {
-  const categories = new Set();
-  const tags = new Set();
-  const categoryCount = {};
-  const tagCount = {};
-
-  const files = findMarkdownFiles(CONTENT_DIR);
-  console.log(`Found ${files.length} markdown files`);
-
-  for (const file of files) {
-    const content = fs.readFileSync(file, 'utf8');
-    const frontmatter = extractFrontmatter(content);
-
-    if (!frontmatter) continue;
-
-    // Extract categories
-    const fileCategories = parseListItems(frontmatter, 'categories');
-    for (const cat of fileCategories) {
-      categories.add(cat);
-      categoryCount[cat] = (categoryCount[cat] || 0) + 1;
-    }
-
-    // Extract tags
-    const fileTags = parseListItems(frontmatter, 'tags');
-    for (const tag of fileTags) {
-      tags.add(tag);
-      tagCount[tag] = (tagCount[tag] || 0) + 1;
-    }
-  }
-
-  // Sort by usage count (most used first)
-  const sortedCategories = Array.from(categories).sort((a, b) => {
-    return (categoryCount[b] || 0) - (categoryCount[a] || 0);
-  });
-
-  const sortedTags = Array.from(tags).sort((a, b) => {
-    return (tagCount[b] || 0) - (tagCount[a] || 0);
-  });
-
-  return {
-    categories: sortedCategories,
-    tags: sortedTags,
-    stats: {
-      categoryCount,
-      tagCount,
-      totalCategories: categories.size,
-      totalTags: tags.size,
-      totalFiles: files.length,
-      generatedAt: new Date().toISOString()
-    }
-  };
+	const categories = new Set();
+	const tags = new Set();
+	const categoryCount = {};
+	const tagCount = {};
+
+	const files = findMarkdownFiles(CONTENT_DIR);
+
+	console.log(`Found ${files.length} markdown files`);
+
+	for (const file of files) {
+		const content = fs.readFileSync(file, 'utf8');
+		const frontmatter = extractFrontmatter(content);
+
+		if (!frontmatter) continue;
+
+		// Extract categories
+		const fileCategories = parseListItems(frontmatter, 'categories');
+
+		for (const cat of fileCategories) {
+			categories.add(cat);
+			categoryCount[cat] = (categoryCount[cat] || 0) + 1;
+		}
+
+		// Extract tags
+		const fileTags = parseListItems(frontmatter, 'tags');
+
+		for (const tag of fileTags) {
+			tags.add(tag);
+			tagCount[tag] = (tagCount[tag] || 0) + 1;
+		}
+	}
+
+	// Sort by usage count (most used first)
+	const sortedCategories = Array.from(categories).sort((a, b) => {
+		return (categoryCount[b] || 0) - (categoryCount[a] || 0);
+	});
+
+	const sortedTags = Array.from(tags).sort((a, b) => {
+		return (tagCount[b] || 0) - (tagCount[a] || 0);
+	});
+
+	return {
+		categories: sortedCategories,
+		tags: sortedTags,
+		stats: {
+			categoryCount,
+			tagCount,
+			totalCategories: categories.size,
+			totalTags: tags.size,
+			totalFiles: files.length,
+			generatedAt: new Date().toISOString(),
+		},
+	};
 }
 
 /**
  * Generate snippet prefixes for a tag/category
  */
 function generatePrefixes(name) {
-  const lower = name.toLowerCase();
-  const prefixes = [lower];
-
-  // Add concatenated version for multi-word items (e.g., "Digital Life" -> "digitallife")
-  if (name.includes(' ')) {
-    const concat = lower.replace(/\s+/g, '');
-    if (concat !== lower) {
-      prefixes.push(concat);
-    }
-  }
-
-  // Add common abbreviations
-  const abbrevMap = {
-    'Technology': ['tech'],
-    'Personal': ['pers'],
-    'WordPress': ['wp'],
-    'Infrastructure': ['infra'],
-    'Open Source': ['oss'],
-    'Reflection': ['reflect'],
-    'Web Development': ['webdev', 'web'],
-    'Development': ['dev'],
-    'Digital Life': ['digital'],
-    'Social Media': ['social'],
-    'Education': ['edu'],
-    'Self-hosting': ['selfhost'],
-    'Content Management Systems': ['cms', 'contentmanagement']
-  };
-
-  if (abbrevMap[name]) {
-    prefixes.push(...abbrevMap[name]);
-  }
-
-  // Return single string if only one prefix, otherwise return array
-  return prefixes.length === 1 ? prefixes[0] : prefixes;
+	const lower = name.toLowerCase();
+	const prefixes = [lower];
+
+	// Add concatenated version for multi-word items (e.g., "Digital Life" -> "digitallife")
+	if (name.includes(' ')) {
+		const concat = lower.replace(/\s+/g, '');
+
+		if (concat !== lower) {
+			prefixes.push(concat);
+		}
+	}
+
+	// Add common abbreviations
+	const abbrevMap = {
+		'Technology': ['tech'],
+		'Personal': ['pers'],
+		'WordPress': ['wp'],
+		'Infrastructure': ['infra'],
+		'Open Source': ['oss'],
+		'Reflection': ['reflect'],
+		'Web Development': ['webdev', 'web'],
+		'Development': ['dev'],
+		'Digital Life': ['digital'],
+		'Social Media': ['social'],
+		'Education': ['edu'],
+		'Self-hosting': ['selfhost'],
+		'Content Management Systems': ['cms', 'contentmanagement'],
+	};
+
+	if (abbrevMap[name]) {
+		prefixes.push(...abbrevMap[name]);
+	}
+
+	// Return single string if only one prefix, otherwise return array
+	return prefixes.length === 1 ? prefixes[0] : prefixes;
 }
 
 /**
  * Generate VSCode snippets from tags and categories
  */
 function generateSnippets(data) {
-  const snippets = {};
-
-  // Generate category snippets
-  for (const category of data.categories) {
-    snippets[`Category: ${category}`] = {
-      prefix: generatePrefixes(category),
-      body: category,
-      description: `Category: ${category}`
-    };
-  }
-
-  // Generate tag snippets
-  for (const tag of data.tags) {
-    snippets[`Tag: ${tag}`] = {
-      prefix: generatePrefixes(tag),
-      body: tag,
-      description: `Tag: ${tag}`
-    };
-  }
-
-  return snippets;
+	const snippets = {};
+
+	// Generate category snippets
+	for (const category of data.categories) {
+		snippets[`Category: ${category}`] = {
+			prefix: generatePrefixes(category),
+			body: category,
+			description: `Category: ${category}`,
+		};
+	}
+
+	// Generate tag snippets
+	for (const tag of data.tags) {
+		snippets[`Tag: ${tag}`] = {
+			prefix: generatePrefixes(tag),
+			body: tag,
+			description: `Tag: ${tag}`,
+		};
+	}
+
+	return snippets;
 }
 
 /**
  * Main execution
  */
 function main() {
-  config.requireHugoSite();
-
-  console.log('Extracting tags and categories from published posts...');
-
-  const data = extractTagsAndCategories();
-
-  // Ensure .vscode directory exists
-  const vscodePath = path.dirname(OUTPUT_FILE);
-  if (!fs.existsSync(vscodePath)) {
-    fs.mkdirSync(vscodePath, { recursive: true });
-  }
-
-  // Write JSON data file
-  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(data, null, 2));
-
-  // Generate and write snippets file
-  const snippets = generateSnippets(data);
-  fs.writeFileSync(SNIPPETS_FILE, JSON.stringify(snippets, null, 2));
-
-  console.log('\nResults:');
-  console.log(`  Categories: ${data.stats.totalCategories}`);
-  console.log(`  Tags: ${data.stats.totalTags}`);
-  console.log(`  Files processed: ${data.stats.totalFiles}`);
-  console.log(`\nOutput written to:`);
-  console.log(`  - ${OUTPUT_FILE}`);
-  console.log(`  - ${SNIPPETS_FILE}`);
-  console.log('\nMost used categories:');
-  data.categories.slice(0, 5).forEach(cat => {
-    console.log(`  - ${cat} (${data.stats.categoryCount[cat]} posts)`);
-  });
-  console.log('\nMost used tags:');
-  data.tags.slice(0, 10).forEach(tag => {
-    console.log(`  - ${tag} (${data.stats.tagCount[tag]} posts)`);
-  });
+	config.requireHugoSite();
+
+	console.log('Extracting tags and categories from published posts...');
+
+	const data = extractTagsAndCategories();
+
+	// Ensure .vscode directory exists
+	const vscodePath = path.dirname(OUTPUT_FILE);
+
+	if (!fs.existsSync(vscodePath)) {
+		fs.mkdirSync(vscodePath, { recursive: true });
+	}
+
+	// Write JSON data file
+	fs.writeFileSync(OUTPUT_FILE, JSON.stringify(data, null, 2));
+
+	// Generate and write snippets file
+	const snippets = generateSnippets(data);
+
+	fs.writeFileSync(SNIPPETS_FILE, JSON.stringify(snippets, null, 2));
+
+	console.log('\nResults:');
+	console.log(`  Categories: ${data.stats.totalCategories}`);
+	console.log(`  Tags: ${data.stats.totalTags}`);
+	console.log(`  Files processed: ${data.stats.totalFiles}`);
+	console.log('\nOutput written to:');
+	console.log(`  - ${OUTPUT_FILE}`);
+	console.log(`  - ${SNIPPETS_FILE}`);
+	console.log('\nMost used categories:');
+	data.categories.slice(0, 5).forEach((cat) => {
+		console.log(`  - ${cat} (${data.stats.categoryCount[cat]} posts)`);
+	});
+	console.log('\nMost used tags:');
+	data.tags.slice(0, 10).forEach((tag) => {
+		console.log(`  - ${tag} (${data.stats.tagCount[tag]} posts)`);
+	});
 }
 
 if (require.main === module) {
-  main();
+	main();
 }
 
 module.exports = { extractFrontmatter, parseListItems, generatePrefixes, main };

package/src/extract-tags.test.mjs

@@ -10,32 +10,35 @@ const { extractFrontmatter, parseListItems, generatePrefixes } = require('./extr
 // ---------------------------------------------------------------------------
 
 test('extractFrontmatter: returns frontmatter content between --- delimiters', () => {
-  const content = '---\ntitle: My Post\ndraft: true\n---\nBody text here.';
-  assert.equal(extractFrontmatter(content), 'title: My Post\ndraft: true');
+	const content = '---\ntitle: My Post\ndraft: true\n---\nBody text here.';
+
+	assert.equal(extractFrontmatter(content), 'title: My Post\ndraft: true');
 });
 
 test('extractFrontmatter: returns null when no frontmatter', () => {
-  assert.equal(extractFrontmatter('Just body text with no delimiters.'), null);
+	assert.equal(extractFrontmatter('Just body text with no delimiters.'), null);
 });
 
 test('extractFrontmatter: returns null when only one --- delimiter', () => {
-  assert.equal(extractFrontmatter('---\ntitle: foo\nno closing delimiter'), null);
+	assert.equal(extractFrontmatter('---\ntitle: foo\nno closing delimiter'), null);
 });
 
 test('extractFrontmatter: handles empty frontmatter block', () => {
-  assert.equal(extractFrontmatter('---\n\n---\nBody.'), '');
+	assert.equal(extractFrontmatter('---\n\n---\nBody.'), '');
 });
 
 test('extractFrontmatter: does not include body content', () => {
-  const content = '---\ntitle: foo\n---\nThis body should not appear.';
-  const result = extractFrontmatter(content);
-  assert.ok(!result.includes('This body'));
+	const content = '---\ntitle: foo\n---\nThis body should not appear.';
+	const result = extractFrontmatter(content);
+
+	assert.ok(!result.includes('This body'));
 });
 
 test('extractFrontmatter: handles --- appearing in body without confusion', () => {
-  const content = '---\ntitle: foo\n---\nBody line.\n---\nAnother section.';
-  const result = extractFrontmatter(content);
-  assert.equal(result, 'title: foo');
+	const content = '---\ntitle: foo\n---\nBody line.\n---\nAnother section.';
+	const result = extractFrontmatter(content);
+
+	assert.equal(result, 'title: foo');
 });
 
 // ---------------------------------------------------------------------------
@@ -43,42 +46,48 @@ test('extractFrontmatter: handles --- appearing in body without confusion', () =
 // ---------------------------------------------------------------------------
 
 test('parseListItems: parses a simple list', () => {
-  const fm = 'tags:\n  - JavaScript\n  - Go\n';
-  assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript', 'Go']);
+	const fm = 'tags:\n  - JavaScript\n  - Go\n';
+
+	assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript', 'Go']);
 });
 
 test('parseListItems: strips double quotes from values', () => {
-  const fm = 'categories:\n  - "Technology"\n  - "Open Source"\n';
-  assert.deepEqual(parseListItems(fm, 'categories'), ['Technology', 'Open Source']);
+	const fm = 'categories:\n  - "Technology"\n  - "Open Source"\n';
+
+	assert.deepEqual(parseListItems(fm, 'categories'), ['Technology', 'Open Source']);
 });
 
 test('parseListItems: strips single quotes from values', () => {
-  const fm = "tags:\n  - 'JavaScript'\n";
-  assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript']);
+	const fm = 'tags:\n  - \'JavaScript\'\n';
+
+	assert.deepEqual(parseListItems(fm, 'tags'), ['JavaScript']);
 });
 
 test('parseListItems: returns empty array when key is not present', () => {
-  assert.deepEqual(parseListItems('title: My Post\n', 'tags'), []);
+	assert.deepEqual(parseListItems('title: My Post\n', 'tags'), []);
 });
 
 test('parseListItems: returns empty array for empty file', () => {
-  assert.deepEqual(parseListItems('', 'tags'), []);
+	assert.deepEqual(parseListItems('', 'tags'), []);
 });
 
 test('parseListItems: handles multiple spaces before list items', () => {
-  const fm = 'tags:\n    - foo\n    - bar\n';
-  assert.deepEqual(parseListItems(fm, 'tags'), ['foo', 'bar']);
+	const fm = 'tags:\n    - foo\n    - bar\n';
+
+	assert.deepEqual(parseListItems(fm, 'tags'), ['foo', 'bar']);
 });
 
 test('parseListItems: does not confuse tags and categories', () => {
-  const fm = 'categories:\n  - Tech\ntags:\n  - Go\n';
-  assert.deepEqual(parseListItems(fm, 'tags'), ['Go']);
-  assert.deepEqual(parseListItems(fm, 'categories'), ['Tech']);
+	const fm = 'categories:\n  - Tech\ntags:\n  - Go\n';
+
+	assert.deepEqual(parseListItems(fm, 'tags'), ['Go']);
+	assert.deepEqual(parseListItems(fm, 'categories'), ['Tech']);
 });
 
 test('parseListItems: single item list', () => {
-  const fm = 'tags:\n  - solo\n';
-  assert.deepEqual(parseListItems(fm, 'tags'), ['solo']);
+	const fm = 'tags:\n  - solo\n';
+
+	assert.deepEqual(parseListItems(fm, 'tags'), ['solo']);
 });
 
 // ---------------------------------------------------------------------------
@@ -86,36 +95,40 @@ test('parseListItems: single item list', () => {
 // ---------------------------------------------------------------------------
 
 test('generatePrefixes: single word returns a string', () => {
-  assert.equal(generatePrefixes('Go'), 'go');
+	assert.equal(generatePrefixes('Go'), 'go');
 });
 
 test('generatePrefixes: single word with no abbreviation returns lowercase string', () => {
-  assert.equal(generatePrefixes('JavaScript'), 'javascript');
+	assert.equal(generatePrefixes('JavaScript'), 'javascript');
 });
 
 test('generatePrefixes: multi-word returns array including concatenated form', () => {
-  const result = generatePrefixes('Open Source');
-  assert.ok(Array.isArray(result));
-  assert.ok(result.includes('open source'));
-  assert.ok(result.includes('opensource'));
+	const result = generatePrefixes('Open Source');
+
+	assert.ok(Array.isArray(result));
+	assert.ok(result.includes('open source'));
+	assert.ok(result.includes('opensource'));
 });
 
 test('generatePrefixes: known abbreviation is included', () => {
-  const result = generatePrefixes('Technology');
-  assert.ok(Array.isArray(result));
-  assert.ok(result.includes('technology'));
-  assert.ok(result.includes('tech'));
+	const result = generatePrefixes('Technology');
+
+	assert.ok(Array.isArray(result));
+	assert.ok(result.includes('technology'));
+	assert.ok(result.includes('tech'));
 });
 
 test('generatePrefixes: multi-word with abbreviation includes all forms', () => {
-  const result = generatePrefixes('Web Development');
-  assert.ok(result.includes('web development'));
-  assert.ok(result.includes('webdevelopment'));
-  assert.ok(result.includes('webdev'));
-  assert.ok(result.includes('web'));
+	const result = generatePrefixes('Web Development');
+
+	assert.ok(result.includes('web development'));
+	assert.ok(result.includes('webdevelopment'));
+	assert.ok(result.includes('webdev'));
+	assert.ok(result.includes('web'));
 });
 
 test('generatePrefixes: Open Source includes oss abbreviation', () => {
-  const result = generatePrefixes('Open Source');
-  assert.ok(result.includes('oss'));
+	const result = generatePrefixes('Open Source');
+
+	assert.ok(result.includes('oss'));
 });