readme-builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b59aa8d423852759bfd4f22fcce55150ee3bd486d576212dd4fe00afb7f82102
+  data.tar.gz: bafbb8a2ec5fc9068288e1428f89f2e3694220e6b929065e7b70bb68bc2f58d1
+SHA512:
+  metadata.gz: 85bfde61084e55f3e11cc3f6e4a2309612702c4447394d5db28c28353ffe5fa0519e715729f0a5265d4cc8865dad84e94c4305823183ae37f339432ca599de1d
+  data.tar.gz: 7296779c0b26b03e3be0062060b6b4ec18c80d952ec93ff459a82d4664af84262f931b3bdf5edc0ecdb5c8fead495a02ef7216e654cf605be0cef5a92f0da42a

data/README.md

@@ -0,0 +1,125 @@
+# README Builder
+
+A command-line tool that automatically generates professional README files and licenses for your projects. Simply answer a few questions, and the tool will analyze your project structure, detect programming languages used, and create well-structured documentation.
+
+## Features
+
+- Interactive command-line interface
+- Automatic programming language detection
+- License generation (MIT, Apache 2.0, GPL-3.0)
+- Project structure analysis
+- Build system detection
+- Language statistics
+- Cross-platform support
+
+## Installation
+
+```bash
+gem install readme_builder
+```
+
+### Requirements
+
+- Ruby >= 2.7.0
+- C++17 compatible compiler
+- CMake >= 3.14 (for building from source)
+
+## Usage
+
+1. Navigate to your project directory:
+   ```bash
+   cd /path/to/your/project
+   ```
+
+2. Run the tool:
+   ```bash
+   readme_builder
+   ```
+
+3. Follow the interactive prompts:
+   ```
+   Enter project title: My Awesome Project
+   Enter project description: A fantastic tool that does amazing things
+   Select license type:
+   1. MIT
+   2. Apache 2.0
+   3. GPL-3.0
+   Enter number (1-3): 1
+   ```
+
+The tool will then:
+- Analyze your project directory
+- Detect programming languages used
+- Identify build systems
+- Generate a comprehensive README.md
+- Create a LICENSE file with your chosen license
+
+## Generated Files
+
+### README.md Structure
+- Project title and description
+- Installation instructions (based on detected build system)
+- Usage section
+- Project structure
+- Language statistics
+- License information
+
+### Supported Licenses
+- MIT License
+- Apache License 2.0
+- GNU GPL v3.0
+
+## Example
+
+Here's what happens when you run the tool:
+
+```bash
+$ readme_builder
+Welcome to README Builder!
+
+Enter project title: Weather App
+Enter project description: A command-line weather forecast tool
+Select license type:
+1. MIT
+2. Apache 2.0
+3. GPL-3.0
+Enter number (1-3): 1
+
+Analyzing project structure...
+Detecting languages...
+Found: Python (80%), JavaScript (15%), CSS (5%)
+Generating README.md...
+Generating LICENSE...
+Done! Created:
+ - README.md
+ - LICENSE
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -am 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Create a Pull Request
+
+### Development Setup
+
+```bash
+git clone https://github.com/yourusername/readme_builder
+cd readme_builder
+bundle install
+rake compile  # Compiles native extensions
+rake test     # Runs tests
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Credits
+
+Built with:
+- Ruby for the command-line interface
+- C++ for the core analysis engine
+- Native extensions for seamless integration

data/bin/readme-builder

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "readme_builder"
+ReadmeBuilder::CLI.start

data/ext/readme_generator/binding.cpp

@@ -0,0 +1,61 @@
+// ext/readme-builder/binding.cpp
+#include <ruby.h>
+#include "readme_builder.hpp"
+#include "license.hpp"
+
+// Wrap our C++ ReadmeBuilder class
+static VALUE rb_readme_builder_init(VALUE self, VALUE rb_name, VALUE rb_desc) {
+    Check_Type(rb_name, T_STRING);
+    Check_Type(rb_desc, T_STRING);
+
+    try {
+        ReadmeBuilder* generator = new ReadmeBuilder(
+                StringValueCStr(rb_name)
+        );
+        generator->setDescription(StringValueCStr(rb_desc));
+        generator->generateWithLanguageDetection();
+        return Qtrue;
+    } catch (const std::exception& e) {
+        rb_raise(rb_eRuntimeError, "%s", e.what());
+        return Qfalse;
+    }
+}
+
+// Wrap our License class
+static VALUE rb_license_add(VALUE self, VALUE rb_type, VALUE rb_holder) {
+    Check_Type(rb_type, T_STRING);
+    Check_Type(rb_holder, T_STRING);
+
+    try {
+        License license;
+        std::string content = license.getLicenseContent(
+                StringValueCStr(rb_type),
+                StringValueCStr(rb_holder)
+        );
+
+        // Write to LICENSE file
+        FILE* file = fopen("LICENSE", "w");
+        if (!file) {
+            rb_raise(rb_eIOError, "Could not create LICENSE file");
+            return Qfalse;
+        }
+        fprintf(file, "%s", content.c_str());
+        fclose(file);
+
+        return Qtrue;
+    } catch (const std::exception& e) {
+        rb_raise(rb_eRuntimeError, "%s", e.what());
+        return Qfalse;
+    }
+}
+
+// Initialize the extension
+extern "C" void Init_readme_builder() {
+    VALUE mReadmeGenerator = rb_define_module("ReadmeBuilder");
+    VALUE cGenerator = rb_define_class_under(ReadmeBuilder, "Native", rb_cObject);
+
+    rb_define_singleton_method(cGenerator, "generate",
+                               RUBY_METHOD_FUNC(rb_readme_builder_init), 2);
+    rb_define_singleton_method(cGenerator, "add_license",
+                               RUBY_METHOD_FUNC(rb_license_add), 2);
+}

data/ext/readme_generator/extconf.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+##
+# Configuration script for compiling the ReadmeBuilder native extension.
+# This script sets up the build environment and creates a Makefile for
+# compiling the C++ code into a Ruby extension.
+#
+# @note Requires C++17 compiler
+# @note Requires CMake >= 3.14
+#
+# @author Your Name
+# @since 0.1.0
+
+require 'mkmf'
+require 'pathname'
+
+##
+# Absolute path to the current extension directory
+CURRENT_DIR = File.expand_path(__dir__)
+
+##
+# Absolute path to the project root directory
+ROOT_DIR = File.expand_path('../..', __dir__)
+
+##
+# Add necessary include paths for C++ headers
+# @note Includes both project root and extension-specific headers
+$INCFLAGS << " -I#{ROOT_DIR}/include"
+$INCFLAGS << " -I#{CURRENT_DIR}/include"
+
+##
+# Set C++17 as the required standard
+# @note This is required for filesystem and other modern C++ features
+$CXXFLAGS << ' -std=c++17'
+
+##
+# List of source files to compile
+# @note Files are listed explicitly to ensure correct build order
+$srcs = [
+  "#{ROOT_DIR}/src/build_detector.cpp",     # Build system detection
+  "#{ROOT_DIR}/src/language_detector.cpp",   # Programming language detection
+  "#{ROOT_DIR}/src/license.cpp",            # License generation
+  "#{ROOT_DIR}/src/main.cpp",               # Main program logic
+  "#{ROOT_DIR}/src/readme_generator.cpp",    # README generation
+  "#{CURRENT_DIR}/binding.cpp"              # Ruby binding code
+]
+
+##
+# Verify all source files exist before attempting to build
+# Provides early warning if any files are missing
+#
+# @note Warns but doesn't fail if files are missing
+$srcs.each do |src|
+  unless File.exist?(src)
+    puts "Warning: Source file not found: #{src}"
+  end
+end
+
+# Create the makefile for building the native extension
+create_makefile('readme_builder/native')

data/ext/readme_generator/include/build_detector.hpp

@@ -0,0 +1,44 @@
+#ifndef BUILD_SYSTEM_DETECTOR_HPP
+#define BUILD_SYSTEM_DETECTOR_HPP
+
+#include <string>
+#include <filesystem>
+
+/**
+ * @class BuildSystemDetector
+ * @brief Detects and processes project build systems
+ * @details Scans project directory for common build system files and generates
+ *          appropriate installation instructions
+ */
+
+class BuildSystemDetector {
+    /**
+     * @brief Constructor initializes detector with project root path
+     * @param root Path to project root directory
+     */
+private:
+    /**
+     * @brief Detect presence of various build system files
+     */
+
+    bool hasCMake;
+    bool hasMakefile;
+    bool hasDockerfile;
+    bool hasPackageJson;
+    bool hasPipfile;
+    bool hasRequirementsTxt;
+    std::string projectRoot;
+
+    void detectBuildSystems();
+
+public:
+    BuildSystemDetector(const std::string& root);
+
+    /**
+    * @brief Generate markdown-formatted installation instructions
+    * @return std::string Installation instructions in markdown format
+    */
+    std::string generateInstallationInstructions() const;
+};
+
+#endif // BUILD_SYSTEM_DETECTOR_HPP

data/ext/readme_generator/include/language_detector.hpp

@@ -0,0 +1,47 @@
+#ifndef LANGUAGE_DETECTOR_HPP
+#define LANGUAGE_DETECTOR_HPP
+
+#include <string>
+#include <unordered_map>
+#include <filesystem>
+
+class LanguageDetector {
+    /**
+ * @class LanguageDetector
+ * @brief Detects programming languages in project files
+ * @details Analyzes file extensions and content to determine programming
+ *          languages used in a project
+ */
+private:
+    std::unordered_map<std::string, std::string> extensionMap;
+    std::unordered_map<std::string, int> languageStats;
+    /**
+    * @brief Analyze content of a single file
+    * @param filePath Path to the file to analyze
+    * @return std::string Detected programming language or empty string if unknown
+    */
+    std::string analyzeFileContent(const std::string& filePath);
+
+public:
+    /**
+     * @brief Constructor initializes language detection rules
+     */
+
+    LanguageDetector();
+    /**
+    * @brief Analyze all files in a project directory
+    * @param projectPath Path to the project root
+    */
+    void analyzeProject(const std::string& projectPath);
+    /**
+     * @brief Get statistics of detected languages
+     * @return std::unordered_map<std::string, int> Map of language names to file counts
+     */
+    std::unordered_map<std::string, int> getLanguageStatistics() const;
+    void reset();
+    void addCustomExtension(const std::string& extension, const std::string& language);
+    std::string getPrimaryLanguage() const;
+    int getTotalFiles() const;
+};
+
+#endif // LANGUAGE_DETECTOR_HPP

data/ext/readme_generator/include/license.hpp

@@ -0,0 +1,61 @@
+// license.hpp
+#ifndef LICENSE_HPP
+#define LICENSE_HPP
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+class License {
+    /**
+     * @brief Constructor initializes license templates and current year
+     */
+private:
+    struct LicenseInfo {
+        std::string name;
+        std::string content;
+        std::string description;
+    };
+
+    std::unordered_map<std::string, LicenseInfo> licenses;
+    std::string currentYear;
+
+    /**
+     * @brief Initialize the license templates
+     */
+    void initializeLicenses();
+    /**
+     * @brief Get the current year as string
+     * @return std::string Current year
+     */
+    std::string getCurrentYear() const;
+
+public:
+    License();
+
+    /**
+    * @brief Get a list of all available license types
+    * @return std::vector<std::string> List of supported license identifiers
+    */
+    std::vector<std::string> getAvailableLicenses() const;
+
+    /**
+     * @brief Generate license content with copyright information
+     * @param licenseType The type of license (e.g., "MIT", "Apache-2.0", "GPL-3.0")
+     * @param copyrightHolder Name of the copyright holder
+     * @return std::string Complete license text with copyright information
+     * @throws std::runtime_error if license type is invalid
+     */
+    std::string getLicenseContent(const std::string& licenseType,
+                                  const std::string& copyrightHolder) const;
+
+    /**
+      * @brief Get description of a specific license
+      * @param licenseType The type of license to get description for
+      * @return std::string Description of the license
+      * @throws std::runtime_error if license type is invalid
+      */
+    std::string getLicenseDescription(const std::string& licenseType) const;
+};
+
+#endif // LICENSE_HPP

data/ext/readme_generator/include/readme_builder.hpp

@@ -0,0 +1,62 @@
+#ifndef README_BUILDER_HPP
+#define README_BUILDER_HPP
+
+#include <string>
+#include <unordered_map>
+#include <filesystem>
+
+/**
+ * @class ReadmeBuilder
+ * @brief Builds comprehensive README files for projects
+ * @details Generates README.md files with project information, language statistics,
+ *          and installation instructions
+ */
+
+class ReadmeBuilder {
+private:
+    std::string projectName;
+    std::string description;
+    std::unordered_map<std::string, int> languageStats;
+    std::string primaryLanguage;
+    int totalFiles;
+    std::string projectRoot;
+
+    /**
+    * @brief Generate the language statistics section
+    * @return std::string Markdown-formatted language statistics
+    */
+
+    std::string generateLanguageSection() const;
+    std::string generateProjectStructure(const std::string& path, int depth = 0) const;
+    std::string getCurrentDate() const;
+    std::string findProjectRoot(const std::string& startPath) const;  // Added helper method
+    void generateFile();
+
+public:
+    /**
+     * @brief Constructor initializes builder with project information
+     * @param name Project name
+     * @param stats Language statistics
+     * @param primary Primary programming language
+     * @param total Total number of files
+     */
+    ReadmeBuilder(const std::string& name = "",
+                    const std::unordered_map<std::string, int>& stats = {},
+                    const std::string& primary = "",
+                    int total = 0);
+
+    /**
+    * @brief Interactive README generation process
+    * @throws std::runtime_error if required information is missing
+    */
+
+    void run();
+
+    /**
+   * @brief Generate README with automatic language detection
+   */
+
+    void generateWithLanguageDetection();
+};
+
+#endif // README_BUILDER_HPP

data/ext/readme_generator/src/build_detector.cpp

@@ -0,0 +1,210 @@
+/**
+ * @file build_detector.cpp
+ * @brief Build system detection and installation instruction generation
+ * @details This system automatically detects various build systems and package managers
+ *          present in a project, including CMake, Make, Docker, npm, and Python package
+ *          managers. It then generates appropriate installation and build instructions
+ *          tailored to the detected build environment. The system supports multiple
+ *          build systems coexisting in the same project, which is common in modern
+ *          polyglot applications.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ *
+ * @note This implementation prioritizes the most commonly used build steps when
+ *       multiple build systems are present, ensuring clear and practical installation
+ *       instructions for end users.
+ */
+
+#include "../include/build_detector.hpp"
+#include <sstream>
+
+
+file's purpose in one line
+Detailed information (@details) that explains the full scope and functionality
+Author and date information for tracking
+        Additional notes (@note) about implementation specifics or important considerations
+Function Documentation: Each function is documented with:
+A clear purpose statement (@brief)
+Detailed explanation of its operation (@details)
+Parameter descriptions (@param) when present
+Return value documentation (@return) for functions that return values
+        Exception information (@throws) when exceptions might be thrown
+        Cross-references (@see) to related functions or classes
+        Implementation Context: The documentation provides context about why certain decisions were made, such as:
+Why certain build systems are detected in a specific order
+How license templates are structured and why
+The reasoning behind file analysis approaches
+User Guidance: The documentation includes helpful information for users:
+Examples of how to use complex functions
+        Explanations of expected inputs and outputs
+Clear error conditions and how to handle them
+        References to related functionality
+        Maintainability: The documentation supports future maintenance by:
+Explaining the relationship between different components
+Documenting internal data structures and their purpose
+Providing context for implementation choices
+Noting any assumptions or dependencies
+        Would you like me to explain any specific aspect of the documentation in more detail? Or would you like to see documentation for any specific functions or components?
+
+Copy
+        Retry
+
+
+Claude can make mistakes. Please double-check responses.
+
+
+
+No file chosen
+
+3.5 Sonnet
+
+        Explanatory
+
+Documented build_detector.cpp
+
+/**
+ * @file build_detector.cpp
+ * @brief Build system detection and installation instruction generation
+ * @details This system automatically detects various build systems and package managers
+ *          present in a project, including CMake, Make, Docker, npm, and Python package
+ *          managers. It then generates appropriate installation and build instructions
+ *          tailored to the detected build environment. The system supports multiple
+ *          build systems coexisting in the same project, which is common in modern
+ *          polyglot applications.
+ *
+ * @author Generated by README Builder
+ * @date 2025-02-17
+ *
+ * @note This implementation prioritizes the most commonly used build steps when
+ *       multiple build systems are present, ensuring clear and practical installation
+ *       instructions for end users.
+ */
+
+#include "../include/build_detector.hpp"
+#include <sstream>
+
+/**
+ * @brief Constructs a BuildSystemDetector for a specific project
+ * @details Initializes the detector with a project root path and performs
+ *          initial detection of all supported build systems. The constructor
+ *          automatically scans for common build system files like CMakeLists.txt,
+ *          Makefile, package.json, etc.
+ *
+ * @param root The root directory path of the project to analyze
+ *
+ * @see detectBuildSystems() For the actual detection logic
+ */
+
+
+BuildSystemDetector::BuildSystemDetector(const std::string& root)
+        : projectRoot(root), hasCMake(false), hasMakefile(false),
+          hasDockerfile(false), hasPackageJson(false),
+          hasPipfile(false), hasRequirementsTxt(false) {
+    detectBuildSystems();
+}
+
+
+/**
+ * @brief Detects all build systems present in the project
+ * @details Scans the project root directory for the presence of various build
+ *          system configuration files. This method checks for:
+ *          - CMake (CMakeLists.txt)
+ *          - Make (Makefile)
+ *          - Docker (Dockerfile)
+ *          - Node.js (package.json)
+ *          - Python (Pipfile, requirements.txt)
+ *
+ * The detection results are stored in member variables for later use in
+ * generating installation instructions.
+ */
+
+void BuildSystemDetector::detectBuildSystems() {
+    namespace fs = std::filesystem;
+    hasCMake = fs::exists(fs::path(projectRoot) / "CMakeLists.txt");
+    hasMakefile = fs::exists(fs::path(projectRoot) / "Makefile");
+    hasDockerfile = fs::exists(fs::path(projectRoot) / "Dockerfile");
+    hasPackageJson = fs::exists(fs::path(projectRoot) / "package.json");
+    hasPipfile = fs::exists(fs::path(projectRoot) / "Pipfile");
+    hasRequirementsTxt = fs::exists(fs::path(projectRoot) / "requirements.txt");
+}
+
+/**
+ * @brief Generates comprehensive installation instructions
+ * @details Creates a markdown-formatted string containing step-by-step
+ *          installation instructions based on the detected build systems.
+ *          The instructions are organized in a logical order:
+ *          1. Repository cloning
+ *          2. Dependencies installation (Node.js, Python)
+ *          3. Build steps (CMake, Make)
+ *          4. Docker instructions (if applicable)
+ *
+ * The method intelligently handles multiple build systems by providing
+ * appropriate instructions for each detected system while maintaining
+ * a clear and organized structure.
+ *
+ * @return std::string Markdown-formatted installation instructions
+ *
+ * @note The instructions are designed to be beginner-friendly while still
+ *       providing all necessary information for successful installation
+ */
+
+std::string BuildSystemDetector::generateInstallationInstructions() const {
+    std::stringstream ss;
+    ss << "### Installation\n\n";
+
+    // Clone repository section
+    ss << "1. Clone the repository\n"
+       << "   ```bash\n"
+       << "   git clone [repository-url]\n"
+       << "   cd " << std::filesystem::path(projectRoot).filename().string() << "\n"
+       << "   ```\n\n";
+
+    // Dependencies section
+    if (hasPackageJson) {
+        ss << "2. Install Node.js dependencies\n"
+           << "   ```bash\n"
+           << "   npm install\n"
+           << "   ```\n\n";
+    }
+
+    if (hasPipfile) {
+        ss << "2. Install Python dependencies using Pipenv\n"
+           << "   ```bash\n"
+           << "   pipenv install\n"
+           << "   ```\n\n";
+    } else if (hasRequirementsTxt) {
+        ss << "2. Install Python dependencies\n"
+           << "   ```bash\n"
+           << "   pip install -r requirements.txt\n"
+           << "   ```\n\n";
+    }
+
+    // Build section
+    if (hasCMake) {
+        ss << "3. Build the project using CMake\n"
+           << "   ```bash\n"
+           << "   mkdir build\n"
+           << "   cd build\n"
+           << "   cmake ..\n"
+           << "   cmake --build .\n"
+           << "   ```\n\n";
+    } else if (hasMakefile) {
+        ss << "3. Build the project\n"
+           << "   ```bash\n"
+           << "   make\n"
+           << "   ```\n\n";
+    }
+
+    // Docker section
+    if (hasDockerfile) {
+        ss << "### Docker Installation\n\n"
+           << "Alternatively, you can build and run using Docker:\n\n"
+           << "```bash\n"
+           << "docker build -t " << std::filesystem::path(projectRoot).filename().string() << " .\n"
+           << "docker run " << std::filesystem::path(projectRoot).filename().string() << "\n"
+           << "```\n\n";
+    }
+
+    return ss.str();
+}