bruh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 61ba8a98c7f510ce257e743caf74457ad517b7bdaa6ac3b82e7fc2422efdcc0a
+  data.tar.gz: c5cab658a2748857fb15db2cefb89d68410085e0ecba91e8c116022bbab01805
+SHA512:
+  metadata.gz: 9f4b12f569e004394f5c295ce42228e296891c7dce96b5b02c7366888321bac81b3c472235eb6ff05512019b099280fcdba2e51ab067be39cf6b724170f397a8
+  data.tar.gz: ee4004de98bb5799343aa5ea51ac17b405a4a7609d34fd1d3fed28474303f02de7f60de211503420505073f07f48f8593ae29438172afe07a7caeddeda8b858c

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2025-04-05
+
+Initial release of Bruh.
+
+### Added
+- Cabal file parsing and version management
+- Changelog handling for release notes
+- Hackage publishing support with documentation
+- Homebrew formula generation and updates
+- Bottle building and publishing to GitHub
+- Configuration management with TOML
+- Interactive and non-interactive modes
+- CLI interface with Thor
+- Full test coverage
+
+### Features
+- HackagePublisher for authentication and package uploads
+- HomebrewFormula for template-based formula management
+- BottleBuilder for building and uploading bottles
+- CLI interface with Thor
+- ConfigManager for storing settings in TOML
+- ChangelogHandler for release notes

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Fuzz Leonard
+
+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:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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.

data/README.md

@@ -0,0 +1,98 @@
+# Bruh
+
+Bruh is a Ruby gem that automates the release process for Haskell packages to
+both Hackage and Homebrew. It streamlines the workflow of releasing Haskell
+packages by handling version updates, changelog management, Hackage publishing,
+and Homebrew formula updates.
+
+## Features
+
+- **Cabal Integration**: Parse and update Cabal files with version bumps
+- **Changelog Management**: Auto-update CHANGELOG.md with new version entries
+- **Hackage Publishing**: Publish packages to Hackage with documentation
+- **Homebrew Formula Generation**: Update Homebrew formulas with new versions and SHAs
+- **Bottle Building**: Build and publish Homebrew bottles to GitHub
+- **Non-interactive Mode**: Support for CI/CD pipelines and automated testing
+
+## Installation
+
+Install the gem by executing:
+
+```bash
+gem install bruh
+```
+
+## Usage
+
+### Command Line Interface
+
+The primary interface is through the `bruh` command:
+
+```bash
+# Interactive release process
+bruh release
+
+# Non-interactive release with specific version
+bruh release --non-interactive --version 0.1.2
+
+# Skip specific steps
+bruh release --skip-hackage --skip-bottles
+
+# Show version
+bruh version
+```
+
+### Non-interactive Release Script
+
+For CI/CD pipelines, you can use the included release script:
+
+```bash
+# Basic usage
+bin/release --version 0.1.2
+
+# Skip specific steps
+bin/release --version 0.1.2 --skip-hackage --skip-bottles
+
+# Run in interactive mode
+bin/release --interactive
+```
+
+### Configuration
+
+Bruh stores configuration in `~/.config/bruh/config.toml`. For non-interactive usage, you should set up your Hackage credentials:
+
+```bash
+# Setup credentials
+bruh config setup
+
+# Manually set credentials
+bruh config set hackage_username "your-username"
+bruh config set hackage_password "your-password"
+bruh config set github_token "your-token"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+### Running Tests
+
+```bash
+# Run all tests
+bundle exec rake test
+
+# Run a specific test
+bundle exec ruby -I lib:test test/test_cabal.rb -n test_name
+```
+
+## 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 new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/haskbrew

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bruh'
+require 'bruh/cli'
+
+Bruh::CLI.start(ARGV)

data/lib/bruh/bottle.rb

@@ -0,0 +1,209 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'sorbet-runtime'
+
+module Bruh
+  # Builds and manages Homebrew bottles
+  class Bottle
+    extend T::Sig
+
+    sig { params(interactive: T::Boolean).void }
+    def initialize(interactive: true)
+      @interactive = interactive
+      @tap_dir = T.let(find_homebrew_tap, T.nilable(String))
+    end
+
+    sig { params(version: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    def build(version)
+      return nil unless @tap_dir
+
+      return nil if @interactive && !yes_no_prompt('Do you want to build a Homebrew bottle for this release?')
+
+      puts "Building bottle for #{package_name} formula..."
+
+      Dir.chdir(@tap_dir) do
+        # Clean environment - uninstall any existing version
+        system("brew uninstall --force #{package_name} 2>/dev/null || true")
+
+        # Ensure tap is properly set up
+        tap_name = "#{repo_owner}/tap"
+        system("brew untap #{tap_name} 2>/dev/null || true")
+        system("brew tap #{tap_name} \"$(pwd)\"")
+
+        # Install with build-bottle flag
+        unless system("brew install --build-bottle #{tap_name}/#{package_name}")
+          puts 'Failed to install formula with --build-bottle flag'
+          return nil
+        end
+
+        # Create bottle with JSON output
+        bottle_cmd = 'brew bottle --json '
+        bottle_cmd += "--root-url=\"https://github.com/#{repo_owner}/#{repo_name}/releases/download/v#{version}\" "
+        bottle_cmd += "#{tap_name}/#{package_name}"
+        unless system(bottle_cmd)
+          puts 'Failed to create bottle'
+          return nil
+        end
+
+        # Find the JSON file created by brew bottle
+        bottle_json = Dir['*.json'].max_by { |f| File.mtime(f) }
+
+        unless bottle_json && File.exist?(bottle_json)
+          puts 'Could not find bottle JSON file'
+          return nil
+        end
+
+        # Parse the JSON file
+        bottle_data = JSON.parse(File.read(bottle_json))
+
+        # Extract filenames and other data
+        first_entry = bottle_data.values.first
+        first_tag = first_entry['bottle']['tags'].values.first
+
+        bottle_info = {
+          version: version,
+          expected_filename: first_tag['filename'],
+          local_filename: first_tag['local_filename'],
+          sha256: first_tag['sha256'],
+          macos_version: first_entry['bottle']['tags'].keys.first.to_s.split('_')[1]
+        }
+
+        # Extract rebuild number from filename if present
+        bottle_info[:rebuild] = ::Regexp.last_match(1).to_i if bottle_info[:local_filename] =~ /bottle\.(\d+)/
+
+        # Verify the bottle file exists
+        unless File.exist?(bottle_info[:local_filename])
+          puts "Bottle file not found: #{bottle_info[:local_filename]}"
+          return nil
+        end
+
+        # Create bottles directory and move the file
+        FileUtils.mkdir_p('bottles')
+        FileUtils.mv(bottle_info[:local_filename], 'bottles/')
+
+        puts "Bottle created successfully: bottles/#{bottle_info[:local_filename]}"
+        bottle_info
+      end
+    end
+
+    sig { params(version: String, bottle_info: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+    def upload_to_github(version, bottle_info)
+      # Check for GitHub CLI
+      unless system('which gh > /dev/null 2>&1')
+        puts 'GitHub CLI (gh) not found. Please install it to automate bottle uploads.'
+        return false
+      end
+
+      return false if @interactive && !yes_no_prompt('Do you want to upload bottle to GitHub?')
+
+      # Remember current directory
+      original_dir = Dir.pwd
+
+      # Change to the tap directory
+      Dir.chdir(T.must(@tap_dir)) do
+        # Check if release exists
+        release_exists = system("gh release view \"v#{version}\" &>/dev/null")
+
+        unless release_exists
+          puts "Release v#{version} doesn't exist. Creating it now..."
+          release_cmd = "gh release create \"v#{version}\" --title \"Release v#{version}\" "
+          release_cmd += "--notes \"Release v#{version} with Homebrew bottle support.\""
+          unless system(release_cmd)
+            puts 'Failed to create GitHub release'
+            return false
+          end
+        end
+
+        # Rename the bottle file to expected filename
+        bottle_src = File.join('bottles', bottle_info[:local_filename])
+        bottle_dst = File.join('bottles', bottle_info[:expected_filename])
+
+        FileUtils.mv(bottle_src, bottle_dst) unless bottle_src == bottle_dst
+
+        # Upload to GitHub release
+        puts "Uploading bottle to GitHub release v#{version}..."
+        unless system("gh release upload \"v#{version}\" \"#{bottle_dst}\" --clobber")
+          puts 'Failed to upload bottle to GitHub'
+          Dir.chdir(original_dir)
+          return false
+        end
+
+        puts 'Bottle uploaded successfully to GitHub release!'
+      end
+
+      # Change back to original directory
+      Dir.chdir(original_dir)
+      true
+    end
+
+    private
+
+    sig { returns(T.nilable(String)) }
+    def find_homebrew_tap
+      # Try common locations
+      potential_paths = [
+        '../homebrew-tap',
+        '~/homebrew-tap',
+        '~/Projects/homebrew-tap'
+      ]
+
+      potential_paths.each do |path|
+        expanded = File.expand_path(path)
+        return expanded if Dir.exist?(expanded)
+      end
+
+      if @interactive
+        puts 'Homebrew tap directory not found in common locations.'
+        puts 'Please enter the path to your Homebrew tap directory:'
+        tap_dir = gets.chomp.strip
+        return tap_dir if !tap_dir.empty? && Dir.exist?(tap_dir)
+      end
+
+      nil
+    end
+
+    sig { returns(String) }
+    def package_name
+      # Extract package name from current directory
+      File.basename(Dir.pwd)
+    end
+
+    sig { returns(T::Array[String]) }
+    def repo_info
+      # Extract owner and repo from git remote
+      remote = `git remote get-url origin`.chomp
+      if remote =~ %r{github\.com[:/]([^/]+)/([^/]+)\.git}
+        owner = T.let(T.must(::Regexp.last_match(1)), String)
+        repo = T.let(T.must(::Regexp.last_match(2)), String)
+        return [owner, repo]
+      end
+
+      %w[user repo]
+    end
+
+    sig { returns(String) }
+    def repo_owner
+      T.must(repo_info[0])
+    end
+
+    sig { returns(String) }
+    def repo_name
+      T.must(repo_info[1])
+    end
+
+    sig { params(message: String, default_no: T::Boolean).returns(T::Boolean) }
+    def yes_no_prompt(message, default_no: true)
+      return true unless @interactive
+
+      default = default_no ? '[y/N]' : '[Y/n]'
+      print "#{message} #{default} "
+      response = gets.chomp.downcase
+      return response.start_with?('y') if default_no
+
+      !response.start_with?('n')
+    end
+  end
+end

data/lib/bruh/cabal.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Bruh
+  # Minimal Cabal file handler for version management
+  class Cabal
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :version
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { returns(String) }
+    attr_reader :file_path
+
+    sig { params(file_path: String).void }
+    def initialize(file_path)
+      @file_path = file_path
+      @content = T.let(File.read(file_path), String)
+
+      # Extract name and version with specific regexes
+      @name = T.let(extract_field('name'), String)
+      @version = T.let(extract_field('version'), String)
+    end
+
+    sig { params(new_version: String).returns(String) }
+    def update_version(new_version)
+      # Update the version field in the file content
+      updated_content = @content.sub(/^version:\s*[0-9.]+/, "version: #{new_version}")
+
+      # Only write if something actually changed
+      if updated_content != @content
+        File.write(@file_path, updated_content)
+        # These variables are already declared in initialize, so we don't use T.let again
+        @content = updated_content
+        @version = new_version
+      end
+
+      new_version
+    end
+
+    # Get essential dependencies for version calculations
+    sig { returns(T::Array[String]) }
+    def dependencies
+      # Extract all build-depends lines
+      deps = []
+
+      @content.scan(/build-depends:.*?(?=\n\S|\Z)/m).each do |match|
+        # Extract package names without version constraints
+        match_str = T.cast(match, String)
+        match_str.scan(/\b([a-zA-Z][a-zA-Z0-9-]*)[,\s<>=]/).each do |dep_arr|
+          # dep_arr is an array where the first element is the capture group
+          deps << dep_arr[0]
+        end
+      end
+
+      deps.uniq
+    end
+
+    private
+
+    sig { params(field: String).returns(String) }
+    def extract_field(field)
+      # Use a specific regex targeting the field at the beginning of a line
+      # followed by colon and whitespace
+      if @content =~ /^#{field}:\s*([^\n]+)/
+        T.must(::Regexp.last_match(1)).strip
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/bruh/changelog.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'date'
+require 'sorbet-runtime'
+
+module Bruh
+  # Manages changelog updates and version entries
+  class Changelog
+    extend T::Sig
+
+    sig { params(version: String, project_root: String, interactive: T::Boolean).returns(T::Boolean) }
+    def self.update(version, project_root, interactive: true)
+      changelog_path = File.join(project_root, 'CHANGELOG.md')
+      today = Date.today.strftime('%Y-%m-%d')
+
+      # Create file if it doesn't exist
+      File.write(changelog_path, "# Changelog\n\n") unless File.exist?(changelog_path)
+
+      content = File.read(changelog_path)
+
+      # Check if this version already exists in changelog
+      return true if content.include?("## [#{version}]")
+
+      # Insert new version entry after the header
+      new_content = content.sub(/^# Changelog/,
+                                "# Changelog\n\n## [#{version}] - #{today}\n\n- Add your changes here\n\n")
+
+      File.write(changelog_path, new_content)
+
+      # Open editor for user to edit changelog if in interactive mode
+      if interactive
+        editor = ENV['EDITOR'] || 'nano'
+        puts 'Opening CHANGELOG.md for editing. Please add your release notes.'
+        system("#{editor} #{changelog_path}")
+        puts 'Press Enter to continue with the release process...'
+        gets
+      end
+
+      true
+    end
+
+    sig { params(project_root: String).returns(T::Hash[String, String]) }
+    def self.generate_release_notes(project_root)
+      changelog_path = File.join(project_root, 'CHANGELOG.md')
+
+      return { version: 'unknown', notes: 'No changelog found' } unless File.exist?(changelog_path)
+
+      content = File.read(changelog_path)
+
+      # Extract the latest version entry
+      if content =~ /## \[([^\]]+)\][^\n]*\n\n(.*?)(?=\n## |\Z)/m
+        version = ::Regexp.last_match(1)
+        notes = T.must(::Regexp.last_match(2)).strip
+
+        return { version: version, notes: notes }
+      end
+
+      { version: 'unknown', notes: 'Could not extract release notes' }
+    end
+  end
+end