readme-builder 0.1.0

data/ext/readme_generator/src/language_detector.cpp

@@ -0,0 +1,199 @@
+/**
+ * @file language_detector.cpp
+ * @brief Programming language detection system
+ * @details Implements a sophisticated system for detecting programming languages
+ *          used in a project by analyzing file extensions and content patterns.
+ *          Supports multiple detection strategies including extension matching
+ *          and content-based analysis.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ *
+ * @note This implementation supports extensibility through custom language
+ *       detection rules and pattern matching.
+ */
+
+
+#include "../include/language_detector.hpp"
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <regex>
+
+
+/**
+ * @brief Constructor initializing supported language mappings
+ * @details Sets up the initial mapping of file extensions to programming languages
+ */
+
+LanguageDetector::LanguageDetector() {
+    // Initialize extension map
+    extensionMap = {
+            {".py", "Python"},
+            {".js", "JavaScript"},
+            {".ts", "TypeScript"},
+            {".cpp", "C++"},
+            {".hpp", "C++"},
+            {".h", "C/C++"},
+            {".c", "C"},
+            {".java", "Java"},
+            {".rs", "Rust"},
+            {".go", "Go"},
+            {".rb", "Ruby"},
+            {".php", "PHP"},
+            {".cs", "C#"},
+            {".swift", "Swift"},
+            {".kt", "Kotlin"},
+            {".r", "R"},
+            {".scala", "Scala"},
+            {".m", "Objective-C"},
+            {".sql", "SQL"},
+            {".sh", "Shell"}
+    };
+}
+
+/**
+ * @brief Analyzes file content to determine the programming language
+ * @details Examines file contents for language-specific patterns such as
+ *          shebangs and syntax patterns when extension-based detection
+ *          is insufficient
+ *
+ * @param filePath Path to the file being analyzed
+ * @return std::string Detected programming language or empty string if unknown
+ */
+
+std::string LanguageDetector::analyzeFileContent(const std::string& filePath) {
+    std::ifstream file(filePath);
+    if (!file.is_open()) return "";
+
+    std::string line;
+    std::vector<std::string> firstLines;
+    int lineCount = 0;
+
+    // Read first 10 lines for analysis
+    while (std::getline(file, line) && lineCount < 10) {
+        firstLines.push_back(line);
+        lineCount++;
+    }
+
+    // Pattern matching for specific languages
+    for (const auto& line : firstLines) {
+        // Python shebang
+        if (std::regex_search(line, std::regex("^#!/usr/bin/env python"))) {
+            return "Python";
+        }
+        // Node.js shebang
+        if (std::regex_search(line, std::regex("^#!/usr/bin/env node"))) {
+            return "JavaScript";
+        }
+        // Ruby shebang
+        if (std::regex_search(line, std::regex("^#!/usr/bin/env ruby"))) {
+            return "Ruby";
+        }
+    }
+
+    return "";
+}
+
+/**
+ * @brief Analyzes all source files in a project
+ * @details Recursively traverses the project's src directory, analyzing each file
+ *          to determine its programming language using both extension-based and
+ *          content-based detection methods
+ *
+ * @param projectPath Root path of the project to analyze
+ */
+
+void LanguageDetector::analyzeProject(const std::string& projectPath) {
+    try {
+        // Only analyze files in the src directory
+        std::filesystem::path srcPath = std::filesystem::path(projectPath) / "src";
+        if (!std::filesystem::exists(srcPath)) {
+            return;
+        }
+
+        for (const auto& entry : std::filesystem::directory_iterator(srcPath)) {
+            if (!entry.is_regular_file()) continue;
+            if (entry.path().filename().string()[0] == '.') continue;
+
+            std::string extension = entry.path().extension().string();
+            std::string detectedLanguage;
+
+            // First try extension-based detection
+            if (extensionMap.find(extension) != extensionMap.end()) {
+                detectedLanguage = extensionMap[extension];
+            } else {
+                // If extension not found, try content analysis
+                detectedLanguage = analyzeFileContent(entry.path().string());
+            }
+
+            if (!detectedLanguage.empty()) {
+                languageStats[detectedLanguage]++;
+            }
+        }
+    } catch (const std::filesystem::filesystem_error& e) {
+        std::cerr << "Error accessing directory: " << e.what() << std::endl;
+    }
+}
+
+/**
+ * @brief Retrieves the current language statistics
+ * @return std::unordered_map<std::string, int> Map of languages to file counts
+ */
+
+std::unordered_map<std::string, int> LanguageDetector::getLanguageStatistics() const {
+    return languageStats;
+}
+
+/**
+ * @brief Resets all language statistics
+ * @details Clears all accumulated language statistics, preparing for a new analysis
+ */
+
+void LanguageDetector::reset() {
+    languageStats.clear();
+}
+
+/**
+ * @brief Adds a custom file extension to language mapping
+ * @details Allows users to extend the language detection capabilities with
+ *          custom file extensions
+ *
+ * @param extension File extension including the dot (e.g., ".custom")
+ * @param language Name of the programming language
+ */
+
+void LanguageDetector::addCustomExtension(const std::string& extension, const std::string& language) {
+    extensionMap[extension] = language;
+}
+
+/**
+ * @brief Gets the total number of analyzed files
+ * @return int Total number of files analyzed
+ */
+
+int LanguageDetector::getTotalFiles() const {
+    int total = 0;
+    for (const auto& stat : languageStats) {
+        total += stat.second;
+    }
+    return total;
+}
+
+/**
+ * @brief Determines the most frequently used programming language
+ * @return std::string Name of the primary programming language
+ */
+std::string LanguageDetector::getPrimaryLanguage() const {
+    std::string primaryLang;
+    int maxCount = 0;
+
+    for (const auto& stat : languageStats) {
+        if (stat.second > maxCount) {
+            maxCount = stat.second;
+            primaryLang = stat.first;
+        }
+    }
+
+    return primaryLang;
+}

data/ext/readme_generator/src/license.cpp

@@ -0,0 +1,197 @@
+/**
+ * @file license.cpp
+ * @brief License management and generation system
+ * @details Implements a comprehensive system for managing and generating software
+ *          licenses. This system supports multiple common open source licenses
+ *          including MIT, Apache 2.0, and GPL-3.0. Each license is stored with
+ *          its full text, title, and a brief description explaining its key
+ *          characteristics and use cases.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ *
+ * @note This implementation follows the official license texts from their
+ *       respective sources and automatically handles the insertion of
+ *       copyright year and holder information.
+ */
+
+#include "license.hpp"
+#include <ctime>
+#include <stdexcept>
+
+/**
+ * @brief Constructs a new License manager
+ * @details Initializes the license management system by:
+ *          1. Getting the current year for copyright notices
+ *          2. Setting up the license template database
+ *
+ * The constructor prepares all supported license templates with their
+ * official texts and descriptions for later use.
+ */
+
+License::License() {
+    currentYear = getCurrentYear();
+    initializeLicenses();
+}
+
+/**
+ * @brief Initializes the database of supported licenses
+ * @details Sets up the internal storage of license templates, including:
+ *          - Full license text with placeholders
+ *          - License titles
+ *          - Descriptions explaining license characteristics
+ *
+ * Currently supports:
+ *          - MIT License
+ *          - Apache License 2.0
+ *          - GNU General Public License v3.0
+ *
+ * Each license is stored with placeholders for dynamic content
+ * (year and copyright holder) that get replaced during generation.
+ */
+
+void License::initializeLicenses() {
+    licenses["MIT"] = {
+            "MIT License",
+            "MIT License\n\n"
+            "Copyright (c) [year] [fullname]\n\n"
+            "Permission is hereby granted, free of charge, to any person obtaining a copy "
+            "of this software and associated documentation files (the \"Software\"), to deal "
+            "in the Software without restriction, including without limitation the rights "
+            "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell "
+            "copies of the Software, and to permit persons to whom the Software is "
+            "furnished to do so, subject to the following conditions:\n\n"
+            "The above copyright notice and this permission notice shall be included in all "
+            "copies or substantial portions of the Software.\n\n"
+            "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR "
+            "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, "
+            "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE "
+            "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER "
+            "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, "
+            "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE "
+            "SOFTWARE.",
+            "A permissive license that lets people do anything with your code with proper attribution and without warranty."
+    };
+
+    licenses["Apache-2.0"] = {
+            "Apache License 2.0",
+            "                                 Apache License\n"
+            "                           Version 2.0, January 2004\n"
+            "                        http://www.apache.org/licenses/\n\n"
+            "Copyright [year] [fullname]\n\n"
+            "Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+            "you may not use this file except in compliance with the License.\n"
+            "You may obtain a copy of the License at\n\n"
+            "    http://www.apache.org/licenses/LICENSE-2.0\n\n"
+            "Unless required by applicable law or agreed to in writing, software\n"
+            "distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+            "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+            "See the License for the specific language governing permissions and\n"
+            "limitations under the License.",
+            "A permissive license that also provides an express grant of patent rights from contributors to users."
+    };
+
+    licenses["GPL-3.0"] = {
+            "GNU General Public License v3.0",
+            "Copyright (C) [year] [fullname]\n\n"
+            "This program is free software: you can redistribute it and/or modify "
+            "it under the terms of the GNU General Public License as published by "
+            "the Free Software Foundation, either version 3 of the License, or "
+            "(at your option) any later version.\n\n"
+            "This program is distributed in the hope that it will be useful, "
+            "but WITHOUT ANY WARRANTY; without even the implied warranty of "
+            "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
+            "GNU General Public License for more details.\n\n"
+            "You should have received a copy of the GNU General Public License "
+            "along with this program. If not, see <https://www.gnu.org/licenses/>.",
+            "A copyleft license that requires anyone who distributes your code or a derivative work to make the source available under the same terms."
+    };
+}
+
+/**
+ * @brief Gets the current year for copyright notices
+ * @details Retrieves the current year from the system clock for use
+ *          in license copyright statements. The year is formatted as
+ *          a string to maintain consistency with license templates.
+ *
+ * @return std::string The current year as a string
+ */
+
+std::string License::getCurrentYear() const {
+    time_t now = time(0);
+    tm* ltm = localtime(&now);
+    return std::to_string(1900 + ltm->tm_year);
+}
+
+/**
+ * @brief Lists all available license types
+ * @details Returns a vector of supported license identifiers (e.g., "MIT",
+ *          "Apache-2.0", "GPL-3.0") that can be used with getLicenseContent().
+ *
+ * @return std::vector<std::string> List of available license identifiers
+ */
+
+std::vector<std::string> License::getAvailableLicenses() const {
+    std::vector<std::string> available;
+    for (const auto& [key, value] : licenses) {
+        available.push_back(key);
+    }
+    return available;
+}
+
+/**
+ * @brief Generates a complete license text for a specific license type
+ * @details Creates a fully formatted license text by:
+ *          1. Retrieving the appropriate license template
+ *          2. Replacing [year] placeholder with current year
+ *          3. Replacing [fullname] placeholder with copyright holder
+ *
+ * @param licenseType The type of license to generate (e.g., "MIT")
+ * @param copyrightHolder The name of the copyright holder
+ * @return std::string Complete license text with all placeholders replaced
+ *
+ * @throws std::runtime_error If the requested license type is not supported
+ *
+ * @see getAvailableLicenses() For a list of supported license types
+ */
+
+std::string License::getLicenseContent(const std::string& licenseType,
+                                       const std::string& copyrightHolder) const {
+    if (licenses.find(licenseType) == licenses.end()) {
+        throw std::runtime_error("Invalid license type");
+    }
+
+    std::string content = licenses.at(licenseType).content;
+
+    // Replace placeholders
+    size_t yearPos = content.find("[year]");
+    if (yearPos != std::string::npos) {
+        content.replace(yearPos, 6, currentYear);
+    }
+
+    size_t namePos = content.find("[fullname]");
+    if (namePos != std::string::npos) {
+        content.replace(namePos, 10, copyrightHolder);
+    }
+
+    return content;
+}
+
+/**
+ * @brief Retrieves the description of a specific license
+ * @details Returns a human-readable description of the license's key
+ *          characteristics, including its permissions, conditions, and
+ *          limitations.
+ *
+ * @param licenseType The type of license to describe (e.g., "MIT")
+ * @return std::string Description of the license
+ *
+ * @throws std::runtime_error If the requested license type is not supported
+ */
+
+std::string License::getLicenseDescription(const std::string& licenseType) const {
+    if (licenses.find(licenseType) == licenses.end()) {
+        throw std::runtime_error("Invalid license type");
+    }
+    return licenses.at(licenseType).description;
+}

data/ext/readme_generator/src/main.cpp

@@ -0,0 +1,40 @@
+/**
+ * @file main.cpp
+ * @brief Main entry point for the README generation system
+ * @details This file contains the main function that orchestrates the README
+ *          generation process, including project analysis and user input collection.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ */
+
+#include "../include/readme_builder.hpp"
+#include <iostream>
+
+/**
+ * @brief Program entry point
+ * @details Initializes the README generator, collects user input, and generates
+ *          a comprehensive README.md file with project statistics and structure.
+ *
+ * @return int Exit code (0 for success, 1 for error)
+ *
+ * @throws std::exception Various exceptions from the README generation process
+ */
+
+int main() {
+    try {
+        ReadmeBuilder generator;
+
+        // First get user input for project name and description
+        generator.run();
+
+        // Then analyze the project for language statistics
+        generator.generateWithLanguageDetection();
+
+        std::cout << "README.md has been generated successfully with project structure and language statistics!" << std::endl;
+    } catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
+        return 1;
+    }
+    return 0;
+}

data/ext/readme_generator/src/readme_builder.cpp

@@ -0,0 +1,226 @@
+/**
+ * @file readme_builder.cpp
+ * @brief README generation system
+ * @details Implements a comprehensive README generator that analyzes project structure,
+ *          detects programming languages used, and creates well-structured documentation.
+ *          The system automatically detects project characteristics and generates
+ *          appropriate installation instructions based on the build system used.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ *
+ * @note This implementation focuses on generating standardized, informative README
+ *       files that follow best practices in project documentation.
+ */
+
+
+#include "../include/readme_builder.hpp"
+#include "../include/language_detector.hpp"
+#include "../include/build_detector.hpp"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iomanip>
+#include <ctime>
+
+/**
+ * @brief Locates the root directory of the project
+ * @details Searches upward from the given path until it finds common project markers
+ *          such as .git directory, src directory, or CMakeLists.txt
+ *
+ * @param startPath The path to start searching from
+ * @return std::string The absolute path to the project root
+ */
+
+std::string ReadmeBuilder::findProjectRoot(const std::string& startPath) const {
+    std::filesystem::path current(startPath);
+
+    while (current.has_parent_path()) {
+        bool hasGit = std::filesystem::exists(current / ".git");
+        bool hasSrc = std::filesystem::exists(current / "src");
+        bool hasCMake = std::filesystem::exists(current / "CMakeLists.txt");
+
+        if (hasGit || hasSrc || hasCMake) {
+            return current.string();
+        }
+
+        current = current.parent_path();
+    }
+
+    return startPath;
+}
+
+/**
+ * @brief Gets the current date in YYYY-MM-DD format
+ * @return std::string Formatted current date
+ */
+
+std::string ReadmeBuilder::getCurrentDate() const {
+    time_t now = time(0);
+    tm* ltm = localtime(&now);
+    std::string date = std::to_string(1900 + ltm->tm_year) + "-" +
+                       std::to_string(1 + ltm->tm_mon) + "-" +
+                       std::to_string(ltm->tm_mday);
+    return date;
+}
+
+/**
+ * @brief Generates the language statistics section of the README
+ * @details Creates a formatted section showing the percentage and count of files
+ *          for each programming language detected in the project
+ *
+ * @return std::string Markdown-formatted language statistics
+ */
+
+std::string ReadmeBuilder::generateLanguageSection() const {
+    std::stringstream ss;
+    ss << "## Languages Used\n\n";
+
+    for (const auto& [language, count] : languageStats) {
+        double percentage = (static_cast<double>(count) / totalFiles) * 100;
+        ss << "- " << language << ": " << count << " files ("
+           << std::fixed << std::setprecision(1) << percentage << "%)\n";
+    }
+
+    return ss.str();
+}
+
+/**
+ * @brief Generates a tree-like structure of project source files
+ * @details Recursively traverses the project directory and creates a formatted
+ *          listing of source files, focusing on the src directory
+ *
+ * @param path The directory path to analyze
+ * @param depth Current recursion depth
+ * @return std::string Markdown-formatted project structure
+ */
+
+std::string ReadmeBuilder::generateProjectStructure(const std::string& path, int depth) const {
+    std::stringstream ss;
+
+    if (depth == 0) {
+        ss << "\n## Source Files\n\n";
+    }
+
+    // Only process src directory
+    std::filesystem::path srcPath = std::filesystem::path(path) / "src";
+    if (!std::filesystem::exists(srcPath)) {
+        return ss.str();
+    }
+
+    for (const auto& entry : std::filesystem::directory_iterator(srcPath)) {
+        if (!entry.is_regular_file()) continue;
+        if (entry.path().filename().string()[0] == '.') continue;
+
+        ss << "- " << entry.path().filename().string() << "\n";
+    }
+
+    return ss.str();
+}
+
+/**
+ * @brief Generates the README.md file
+ * @details Combines all gathered information and user input to create a comprehensive
+ *          README.md file in the project root directory
+ *
+ * @throws std::runtime_error If unable to create or write to README.md
+ */
+
+void ReadmeBuilder::generateFile() {
+    std::filesystem::path readmePath = std::filesystem::path(projectRoot) / "README.md";
+    std::ofstream readme(readmePath);
+    if (!readme.is_open()) {
+        throw std::runtime_error("Could not create README.md file in project root");
+    }
+
+    readme << "# " << projectName << "\n\n"
+           << description << "\n\n"
+           << "Last updated: " << getCurrentDate() << "\n\n";
+
+    if (totalFiles > 0) {
+        readme << "## Project Overview\n\n"
+               << "This project is primarily written in " << primaryLanguage
+               << " and contains " << totalFiles << " source files.\n\n"
+               << generateLanguageSection()
+               << generateProjectStructure(projectRoot);
+    }
+
+    // Use the build system detector to generate installation instructions
+    BuildSystemDetector detector(projectRoot);
+    readme << detector.generateInstallationInstructions();
+
+    readme << "## Usage\n\n"
+           << "Add instructions on how to use your project.\n\n"
+           << "## Contributing\n\n"
+           << "Instructions for how to contribute to the project.\n\n"
+           << "## License\n\n"
+           << "Specify your project license here.\n";
+
+    readme.close();
+    std::cout << "README.md has been generated successfully in project root!" << std::endl;
+}
+
+/**
+ * @brief Constructor for ReadmeBuilder with pre-analyzed statistics
+ * @details Initializes the README builder with pre-computed language statistics
+ *
+ * @param name Project name
+ * @param stats Map of language statistics
+ * @param primary Primary programming language used
+ * @param total Total number of source files
+ */
+
+ReadmeBuilder::ReadmeBuilder(const std::string& name,
+                                 const std::unordered_map<std::string, int>& stats,
+                                 const std::string& primary,
+                                 int total)
+        : projectName(name), languageStats(stats), primaryLanguage(primary), totalFiles(total) {
+    projectRoot = findProjectRoot(std::filesystem::current_path().string());
+}
+
+/**
+ * @brief Interactively collects project information from user
+ * @details Prompts the user for project title and description
+ *
+ * @throws std::runtime_error If required information is not provided
+ */
+
+void ReadmeBuilder::run() {
+    std::cout << "Enter project title: ";
+    std::getline(std::cin, projectName);
+
+    if (projectName.empty()) {
+        throw std::runtime_error("Project title cannot be empty");
+    }
+
+    std::cout << "Enter project description: ";
+    std::getline(std::cin, description);
+
+    if (description.empty()) {
+        throw std::runtime_error("Project description cannot be empty");
+    }
+
+    generateFile();
+}
+
+/**
+ * @brief Analyzes project and generates README with language statistics
+ * @details Uses LanguageDetector to analyze the project structure and
+ *          automatically generate language statistics
+ */
+
+void ReadmeBuilder::generateWithLanguageDetection() {
+    LanguageDetector detector;
+    detector.analyzeProject(projectRoot);
+
+    languageStats = detector.getLanguageStatistics();
+    primaryLanguage = detector.getPrimaryLanguage();
+    totalFiles = detector.getTotalFiles();
+
+    if (projectName.empty()) {
+        projectName = std::filesystem::path(projectRoot).filename().string();
+    }
+
+    generateFile();
+}
+

data/lib/readme_builder/version.rb

@@ -0,0 +1,4 @@
+# lib/readme_builder/version.rb
+module ReadmeBuilder
+  VERSION = "0.1.0"
+end

data/lib/readme_builder.rb

@@ -0,0 +1,31 @@
+# lib/readme_builder.rb
+
+##
+# The ReadmeBuilder module provides functionality to automatically generate
+# README and LICENSE files for software projects through a command-line interface.
+#
+# @example Using from command line
+#   $ readme_builder
+#   Enter project name: My Project
+#   Enter description: A great tool
+#   Select license: MIT
+#
+# @author Your Name
+# @since 0.1.0
+module ReadmeBuilder
+  ##
+  # Custom error class for ReadmeBuilder-specific exceptions.
+  # Used to distinguish errors from this gem from standard Ruby errors.
+  #
+  # @example Handling specific errors
+  #   begin
+  #     # Some readme_builder operation
+  #   rescue ReadmeBuilder::Error => e
+  #     puts "ReadmeBuilder error: #{e.message}"
+  #   end
+  class Error < StandardError; end
+end
+
+# Load version and native extension
+require 'readme_builder/version'
+require 'readme_builder/native'  # Load the compiled C++ extension