gembrew 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46aaf0e8b85829162de73512e6c9fe6c892a7dc646513a6cd6d6d9265c06124b
-  data.tar.gz: 90de5846e5cc45f8e0458d0c0dcf6368ea4071595b152b72279cff91b4e349f1
+  metadata.gz: fe9b9cc5e9535cca862d2adf23aa7887bf0608fa14104d8aa7c3db046358ac61
+  data.tar.gz: 7242264cbf2fa6c438445dd180ec73fec06c37513a5d67889ac47dddb748985b
 SHA512:
-  metadata.gz: 40a61361c893f96bc402ef4c4514236cb7ec4313386f3378e1dfcf026a4726a2fbfec786f6ccdd8120495d7c80adfe240f3b182e79d3890e5b2e6bfa2bff57ca
-  data.tar.gz: edf9bd6364b9c2409b43d1777739b9591d02adaee91475b72203b64dbfdd5c75f566aab6d632aa1998318f745120ccfb5102ad7f937b6f9be323817521e575e4
+  metadata.gz: 412fd3b8bc7d1d92ae3358902eacb1e89d6d5a1c2eee5fbb21512b6ea549d1035e438d45855ee8091eda01b9f92f22603c8a089324e82485bafcb124afe4723c
+  data.tar.gz: 5fdb7789ec71ce6838cdc82973765441ada2a2c100b9b73ac121c1d3e8aaa77885477d61b578336e6a92b78fc72e6a3acb0bac3cea9be8a2937a8c7710302919

data/README.md

@@ -1,5 +1,7 @@
 # Gembrew
 
+![repocard](https://repocard.dannyben.com/svg/gembrew.svg)
+
 Generate conventional Homebrew formulae for published Ruby command-line gems.
 
 ## Install
@@ -18,38 +20,65 @@ gembrew build
 gembrew check
 ```
 
-`init` requires an empty directory, with the exception of Git's `.git`
-directory. It creates a tap repository containing `gembrew.yml`, `Formula/`,
-and a Docker Compose environment under `support/`. `build` reads the
-configuration and writes the formula.
-
-The configuration filename is always `gembrew.yml`.
+`init` creates a tap repository containing `README.md`, `gembrew/`, `Formula/`,
+and a GitHub Actions workflow that styles, audits, installs, tests, and checks
+the linkage of every formula on Linux and macOS. It accepts an empty directory
+or an existing tap containing `Formula/`.
+Supplying a gem name also creates its first configuration. The gem name is
+optional, so `gembrew init` can prepare an empty tap or add Gembrew to an
+existing one. Existing README and workflow files are never overwritten.
 
 For example, `gembrew init example` generates:
 
+```text
+README.md
+.github/
+  workflows/
+    test.yml
+gembrew/
+  example.yml
+Formula/
+```
+
+`gembrew/example.yml` contains:
+
 ```yaml
 gem: example
-output: Formula/example.rb
 
 test: |-
   system bin/"example", "--version"
 ```
 
-Edit `gembrew.yml` as needed, then generate the formula:
+Edit the configuration as needed, then generate `Formula/example.rb`:
 
 ```shell
 gembrew build
 ```
 
-The required settings are `gem`, `output`, and exactly one of `test` or
-`test_from_file`. Relative paths are resolved from `gembrew.yml`.
+Each YAML file under `gembrew/` describes one formula. Add more published gems
+with:
+
+```shell
+gembrew add another-gem
+```
+
+Plain `build` generates every configured formula. Pass a configuration name to
+generate just one:
+
+```shell
+gembrew build example
+```
+
+The required settings are `gem`, `version`, `source`, and exactly one of `test`
+or `test_from_file`.
+The output defaults to `Formula/NAME.rb`, where `NAME` is the configuration
+filename. Relative paths are resolved from the tap root.
 
 ```yaml
 gem: example
-output: Formula/example.rb
-
-# Optional published gem version. The latest stable version is used by default.
 version: "1.2.3"
+source:
+  type: rubygems
 
 # Optional gem metadata overrides:
 desc: Example command-line application
@@ -57,6 +86,14 @@ homepage: https://example.com
 license: MIT
 executable: example
 
+# Optional additional Homebrew formula dependencies:
+dependencies:
+  - bash
+  - libffi :system_on_macos
+
+# Optional output override. The default for gembrew/example.yml is shown here.
+output: Formula/example.rb
+
 test: |-
   system bin/"example", "--version"
 
@@ -64,6 +101,23 @@ test: |-
 # test_from_file: support/test.rb
 ```
 
+Tag a dependency with `:system_on_macos` when macOS provides it and Homebrew
+should install its formula only on other platforms.
+
+To build the root gem from a GitHub tag while continuing to fetch its
+dependencies from RubyGems, use:
+
+```yaml
+source:
+  type: github
+  repo: owner/repository
+  # tag: v1.2.3
+  # gemspec: example.gemspec
+```
+
+The tag defaults to `vVERSION`; the gemspec path defaults to
+`GEMNAME.gemspec`.
+
 Gembrew resolves the generic Ruby dependency graph and generates a Homebrew
 `resource` for every runtime dependency. Original `.gem` archives are reused
 from RubyGems' local cache when available. Downloaded archives are retained in
@@ -83,6 +137,14 @@ brew style example
 brew audit --new --online example
 brew install --build-from-source example
 brew test example
+brew linkage --test example
+```
+
+To test a published tap without mounting the local repository, open a pristine
+Homebrew shell:
+
+```shell
+gembrew shell --pristine
 ```
 
 Run the complete workflow non-interactively in one clean container:
@@ -91,9 +153,11 @@ Run the complete workflow non-interactively in one clean container:
 gembrew check
 ```
 
-This rebuilds the formula, then runs Homebrew style, online audit, source
-installation, and the formula test. The generated Compose `check` service can
-also be invoked directly.
+This rebuilds every configured formula, then runs Homebrew style, online audit,
+source installation, the formula test, and linkage validation in disposable
+Homebrew containers. Use `gembrew check example` to check only one formula.
+Gembrew invokes Docker directly; the tap does not need generated container
+support files.
 
 ## Contributing / Support
 

data/bin/gembrew

@@ -10,6 +10,8 @@ runner = Gembrew::CLI.runner
 
 begin
   exit runner.run ARGV
+rescue Interrupt
+  exit 130
 rescue => e
   puts e.backtrace.reverse if ENV['DEBUG']
   say! "rib` #{e.class} `\n#{e.message}"

data/lib/gembrew/adder.rb

@@ -0,0 +1,39 @@
+require 'erb'
+require 'pathname'
+require 'gembrew/config'
+require 'gembrew/error'
+
+module Gembrew
+  class Adder
+    attr_reader :gem_name, :project_path
+
+    def initialize(gem_name, project_path: Pathname.pwd)
+      @gem_name = gem_name
+      @project_path = Pathname(project_path).expand_path
+    end
+
+    def call
+      Config.validate_name! gem_name
+      unless formula_path.directory?
+        raise Error, "Directory is not a Homebrew tap: #{project_path} (Formula/ does not exist)"
+      end
+
+      config_directory.mkpath
+      raise Error, "Gem configuration already exists: #{config_path}" if config_path.exist?
+
+      config_path.write render
+      config_path
+    end
+
+  private
+
+    def formula_path = project_path/'Formula'
+    def config_directory = project_path/'gembrew'
+    def config_path = config_directory/"#{gem_name}.yml"
+
+    def render
+      template = Pathname(__dir__)/'templates/gembrew.yml.erb'
+      ERB.new(template.read, trim_mode: '-').result(binding)
+    end
+  end
+end

data/lib/gembrew/cli.rb

@@ -1,5 +1,6 @@
 require 'mister_bin'
 require 'gembrew/commands/build'
+require 'gembrew/commands/add'
 require 'gembrew/commands/check'
 require 'gembrew/commands/init'
 require 'gembrew/commands/shell'
@@ -13,6 +14,7 @@ module Gembrew
         footer: 'Run m`gembrew COMMAND --help` for more information'
 
       runner.route 'init',  to: Commands::Init
+      runner.route 'add',   to: Commands::Add
       runner.route 'build', to: Commands::Build
       runner.route 'check', to: Commands::Check
       runner.route 'shell', to: Commands::Shell

data/lib/gembrew/commands/add.rb

@@ -0,0 +1,20 @@
+require 'mister_bin'
+require 'gembrew/adder'
+
+module Gembrew
+  module Commands
+    class Add < MisterBin::Command
+      help 'Add a Ruby gem to this tap repository'
+
+      usage 'gembrew add GEM'
+      usage 'gembrew add (-h|--help)'
+
+      param 'GEM', 'Published Ruby gem name'
+
+      def run
+        path = Adder.new(args['GEM']).call
+        say "Added m`#{path}`"
+      end
+    end
+  end
+end

data/lib/gembrew/commands/build.rb

@@ -4,14 +4,25 @@ require 'gembrew/generator'
 module Gembrew
   module Commands
     class Build < MisterBin::Command
-      help 'Generate a Homebrew formula from gembrew.yml'
+      help 'Generate Homebrew formulae from gembrew/*.yml'
 
-      usage 'gembrew build'
+      usage 'gembrew build [GEM]'
       usage 'gembrew build (-h|--help)'
 
+      param 'GEM', 'Optional gem configuration name'
+
       def run
-        output_path = Generator.new.call
-        say "Generated m`#{output_path}`"
+        configs.each do |config|
+          say "bb`==> gembrew: building #{config.name}`"
+          output_path = Generator.new(config: config).call
+          say "Generated m`#{output_path}`"
+        end
+      end
+
+    private
+
+      def configs
+        args['GEM'] ? [Config.find(args['GEM'])] : Config.all
       end
     end
   end

data/lib/gembrew/commands/check.rb

@@ -5,17 +5,28 @@ require 'gembrew/generator'
 module Gembrew
   module Commands
     class Check < MisterBin::Command
-      help 'Build and test the formula in a clean Homebrew environment'
+      help 'Build and test formulae in clean Homebrew environments'
 
-      usage 'gembrew check'
+      usage 'gembrew check [GEM]'
       usage 'gembrew check (-h|--help)'
 
+      param 'GEM', 'Optional gem configuration name'
+
       def run
-        output_path = Generator.new.call
-        say "Generated m`#{output_path}`"
-        DockerCheck.new.call
+        configs.each do |config|
+          say "bb`==> gembrew: building #{config.name}`"
+          output_path = Generator.new(config: config).call
+          say "Generated m`#{output_path}`"
+          DockerCheck.new.call output_path.basename('.rb').to_s
+        end
         say 'g`All checks passed`'
       end
+
+    private
+
+      def configs
+        args['GEM'] ? [Config.find(args['GEM'])] : Config.all
+      end
     end
   end
 end

data/lib/gembrew/commands/init.rb

@@ -4,16 +4,18 @@ require 'gembrew/initializer'
 module Gembrew
   module Commands
     class Init < MisterBin::Command
-      help 'Initialize a Homebrew tap repository for a Ruby gem'
+      help 'Initialize a Homebrew tap repository'
 
-      usage 'gembrew init GEM'
+      usage 'gembrew init [GEM]'
       usage 'gembrew init (-h|--help)'
 
-      param 'GEM', 'Published Ruby gem name'
+      param 'GEM', 'Optional published Ruby gem name'
 
       def run
         Initializer.new(args['GEM']).call
-        say "Initialized m`#{Dir.pwd}` for bb`#{args['GEM']}`"
+        message = "Initialized m`#{Dir.pwd}`"
+        message += " for bb`#{args['GEM']}`" if args['GEM']
+        say message
       end
     end
   end

data/lib/gembrew/commands/shell.rb

@@ -6,11 +6,13 @@ module Gembrew
     class Shell < MisterBin::Command
       help 'Open a Homebrew shell for this tap repository'
 
-      usage 'gembrew shell'
+      usage 'gembrew shell [--pristine]'
       usage 'gembrew shell (-h|--help)'
 
+      option '-p --pristine', 'Open without mounting the local tap'
+
       def run
-        DockerShell.new.call
+        DockerShell.new.call pristine: args['--pristine']
       end
     end
   end

data/lib/gembrew/config.rb

@@ -4,32 +4,68 @@ require 'gembrew/error'
 
 module Gembrew
   class Config
-    FILENAME = 'gembrew.yml'
+    Dependency = Data.define(:name, :tags) do
+      def system_on_macos? = tags.include? :system_on_macos
+    end
+
+    DEPENDENCY_TAGS = %w[:system_on_macos].freeze
+    DIRECTORY = 'gembrew'
     ALLOWED_KEYS = %w[
-      gem version output desc homepage license executable test test_from_file
+      gem version source output desc homepage license executable dependencies test test_from_file
     ].freeze
 
-    attr_reader :path
+    attr_reader :path, :project_path
+
+    def self.all(project_path = Pathname.pwd)
+      project_path = Pathname(project_path).expand_path
+      paths = (project_path/DIRECTORY).glob('*.yml').sort
+      raise Error, "No gem configurations found in #{project_path/DIRECTORY}" if paths.empty?
+
+      paths.map { |path| new path, project_path: project_path }
+    end
+
+    def self.find(name, project_path = Pathname.pwd)
+      validate_name! name
+      project_path = Pathname(project_path).expand_path
+      new project_path/DIRECTORY/"#{name}.yml", project_path: project_path
+    end
+
+    def self.validate_name!(name)
+      return name if name&.match?(/\A[a-zA-Z0-9._-]+\z/)
+
+      raise Error, "Invalid gem name: #{name.inspect}"
+    end
 
-    def initialize(project_path = Pathname.pwd)
-      @path = Pathname(project_path).expand_path/FILENAME
+    def initialize(path, project_path: nil)
+      @path = Pathname(path).expand_path
+      @project_path = project_path ? Pathname(project_path).expand_path : @path.dirname.parent
       @data = load_data
       validate
     end
 
+    def name = path.basename('.yml').to_s
     def gem_name = data.fetch('gem').to_s
     def version = data['version']&.to_s
-    def output_path = (path.dirname/data.fetch('output')).expand_path
+    def source = data.fetch('source')
+    def source_type = source.fetch('type')
+    def source_repo = source['repo']
+    def source_tag = source['tag'] || "v#{version}"
+    def source_gemspec = source['gemspec'] || "#{gem_name}.gemspec"
+    def output_path = (project_path/(data['output'] || "Formula/#{name}.rb")).expand_path
     def description = data['desc']
     def homepage = data['homepage']
     def license = data['license']
     def executable = data['executable']
 
+    def dependencies
+      @dependencies ||= data.fetch('dependencies', []).map { |value| parse_dependency value }
+    end
+
     def test_body
       @test_body ||= if data.has_key?('test')
         data.fetch('test').to_s
       else
-        test_path = path.dirname/data.fetch('test_from_file')
+        test_path = project_path/data.fetch('test_from_file')
         raise Error, "Test file does not exist: #{test_path}" unless test_path.file?
 
         test_path.read
@@ -55,7 +91,10 @@ module Gembrew
       raise Error, "Unknown configuration keys: #{unknown_keys.join(', ')}" if unknown_keys.any?
 
       require_value 'gem'
-      require_value 'output'
+      require_value 'version'
+      require_value 'source'
+      validate_source
+      validate_dependencies
 
       return unless data.has_key?('test') == data.has_key?('test_from_file')
 
@@ -66,5 +105,69 @@ module Gembrew
       value = data[key]
       raise Error, "#{key} is required" if value.nil? || value.to_s.empty?
     end
+
+    def validate_source
+      raise Error, 'source must be a mapping' unless source.is_a?(Hash)
+
+      validate_source_keys
+      case source['type']&.to_s
+      when 'rubygems' then validate_rubygems_source
+      when 'github' then validate_github_source
+      else raise Error, 'source.type must be github or rubygems'
+      end
+    end
+
+    def validate_source_keys
+      unknown_keys = source.keys - %w[type repo tag gemspec]
+      raise Error, "Unknown source keys: #{unknown_keys.join(', ')}" if unknown_keys.any?
+    end
+
+    def validate_rubygems_source
+      extra_keys = source.keys - ['type']
+      raise Error, "source.#{extra_keys.first} is only valid for GitHub sources" if extra_keys.any?
+    end
+
+    def validate_github_source
+      repo = source['repo']&.to_s
+      raise Error, 'source.repo is required for GitHub sources' if repo.nil? || repo.empty?
+      raise Error, 'source.repo must be in owner/repository form' unless repo.match?(%r{\A[^/\s]+/[^/\s]+\z})
+
+      validate_relative_source_path 'gemspec' if source.has_key?('gemspec')
+      raise Error, 'source.tag must not be empty' if source.has_key?('tag') && source['tag'].to_s.empty?
+    end
+
+    def validate_relative_source_path(key)
+      value = source[key].to_s
+      path = Pathname(value)
+      valid = !value.empty? && !path.absolute? && path.each_filename.none?('..')
+      raise Error, "source.#{key} must be a relative path within the archive" unless valid
+    end
+
+    def validate_dependencies
+      return unless data.has_key?('dependencies')
+
+      raise Error, 'dependencies must be a sequence' unless data['dependencies'].is_a?(Array)
+
+      dependencies
+      names = dependencies.map(&:name)
+      duplicate = names.find { |name| names.count(name) > 1 }
+      raise Error, "dependency #{duplicate.inspect} is specified more than once" if duplicate
+    end
+
+    def parse_dependency(value)
+      raise Error, 'each dependency must be a name followed by optional tags' unless value.is_a?(String)
+
+      values = value.split
+      name = values.shift
+      unless name && !name.start_with?(':')
+        raise Error, 'dependency name must be a non-empty string'
+      end
+
+      invalid_tag = values.find { |tag| !tag.is_a?(String) || !DEPENDENCY_TAGS.include?(tag) }
+      raise Error, "unknown dependency tag: #{invalid_tag.inspect}" if invalid_tag
+      raise Error, "dependency #{name.inspect} has duplicate tags" unless values.uniq.length == values.length
+
+      Dependency.new(name:, tags: values.map { |tag| tag.delete_prefix(':').to_sym }.freeze)
+    end
   end
 end

data/lib/gembrew/docker_check.rb

@@ -1,25 +1,15 @@
-require 'pathname'
+require 'shellwords'
+require 'gembrew/docker_runner'
 require 'gembrew/error'
 
 module Gembrew
   class DockerCheck
-    COMPOSE_PATH = Pathname('support/compose.yaml')
-
-    attr_reader :project_path
-
-    def initialize(project_path: Pathname.pwd, command_runner: nil)
-      @project_path = Pathname(project_path).expand_path
-      @command_runner = command_runner || method(:run_command)
+    def initialize(runner: DockerRunner.new)
+      @runner = runner
     end
 
-    def call
-      raise Error, "Compose file does not exist: #{compose_path}" unless compose_path.file?
-
-      success = command_runner.call(
-        'docker', 'compose', '-f', COMPOSE_PATH.to_s,
-        'run', '--rm', '--no-TTY', 'check',
-        chdir: project_path
-      )
+    def call(formula)
+      success = runner.call 'bash', '-euc', script(formula)
       raise Error, 'Homebrew checks failed' unless success
 
       true
@@ -27,14 +17,24 @@ module Gembrew
 
   private
 
-    attr_reader :command_runner
-
-    def compose_path
-      project_path/COMPOSE_PATH
-    end
-
-    def run_command(*command, chdir:)
-      system(*command, chdir: chdir.to_s)
+    attr_reader :runner
+
+    def script(formula)
+      formula = Shellwords.escape formula
+      <<~BASH
+        caption() { printf '\\n\\033[1;34m==> gembrew: %s\\033[0m\\n' "$1"; }
+        formula=#{formula}
+        caption "styling $formula"
+        brew style "$formula"
+        caption "auditing $formula"
+        brew audit --new --online "$formula"
+        caption "installing $formula"
+        brew install --build-from-source "$formula"
+        caption "testing $formula"
+        brew test "$formula"
+        caption "checking linkage for $formula"
+        brew linkage --test "$formula"
+      BASH
     end
   end
 end

data/lib/gembrew/docker_runner.rb

@@ -0,0 +1,67 @@
+require 'pathname'
+
+module Gembrew
+  class DockerRunner
+    IMAGE = 'homebrew/brew:main'
+    TAP_PATH = '/home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/gembrew/homebrew-tap'
+
+    attr_reader :project_path
+
+    def initialize(project_path: Pathname.pwd, command_runner: nil)
+      @project_path = Pathname(project_path).expand_path
+      @command_runner = command_runner || method(:run_command)
+    end
+
+    def call(*command, interactive: false, pristine: false)
+      docker_command = ['docker', 'run', '--rm', '--init', '--name', container_name]
+      docker_command << '-it' if interactive
+      docker_command.concat environment(interactive: interactive, pristine: pristine)
+      unless pristine
+        docker_command.push '--workdir', '/work'
+        docker_command.push '--volume', "#{project_path}:/work"
+        docker_command.push '--volume', "#{project_path}:#{TAP_PATH}"
+      end
+      docker_command << IMAGE
+      docker_command.concat command
+      command_runner.call(*docker_command, chdir: project_path)
+    end
+
+  private
+
+    attr_reader :command_runner
+
+    def environment(interactive:, pristine:)
+      result = %w[
+        --env HOMEBREW_NO_AUTO_UPDATE=1
+        --env HOMEBREW_NO_INSTALL_CLEANUP=1
+        --env HOMEBREW_NO_INSTALL_FROM_API=1
+      ]
+      prompt = pristine ? 'homebrew' : 'gembrew'
+      result.push '--env', "PS1=\\n\\n#{prompt} $ " if interactive
+      result
+    end
+
+    def run_command(*command, chdir:)
+      success = system(*command, chdir: chdir.to_s)
+      cleanup_container command unless success
+      success
+    rescue Interrupt
+      previous_handler = Signal.trap 'INT', 'IGNORE'
+      begin
+        cleanup_container command
+      ensure
+        Signal.trap 'INT', previous_handler
+      end
+      raise
+    end
+
+    def container_name
+      "gembrew-#{Process.pid}"
+    end
+
+    def cleanup_container(command)
+      name = command.fetch(command.index('--name') + 1)
+      system 'docker', 'rm', '--force', name, out: File::NULL, err: File::NULL
+    end
+  end
+end

data/lib/gembrew/docker_shell.rb

@@ -1,24 +1,14 @@
-require 'pathname'
+require 'gembrew/docker_runner'
 require 'gembrew/error'
 
 module Gembrew
   class DockerShell
-    COMPOSE_PATH = Pathname('support/compose.yaml')
-
-    attr_reader :project_path
-
-    def initialize(project_path: Pathname.pwd, command_runner: nil)
-      @project_path = Pathname(project_path).expand_path
-      @command_runner = command_runner || method(:run_command)
+    def initialize(runner: DockerRunner.new)
+      @runner = runner
     end
 
-    def call
-      raise Error, "Compose file does not exist: #{compose_path}" unless compose_path.file?
-
-      success = command_runner.call(
-        'docker', 'compose', '-f', COMPOSE_PATH.to_s, 'run', '--rm', 'brew',
-        chdir: project_path
-      )
+    def call(pristine: false)
+      success = runner.call 'bash', '--norc', interactive: true, pristine: pristine
       raise Error, 'Homebrew shell exited with an error' unless success
 
       true
@@ -26,14 +16,6 @@ module Gembrew
 
   private
 
-    attr_reader :command_runner
-
-    def compose_path
-      project_path/COMPOSE_PATH
-    end
-
-    def run_command(*command, chdir:)
-      system(*command, chdir: chdir.to_s)
-    end
+    attr_reader :runner
   end
 end

data/lib/gembrew/generator.rb

@@ -4,14 +4,14 @@ require 'gembrew/resolver'
 
 module Gembrew
   class Generator
-    def initialize(config: Config.new, resolver: Resolver.new, renderer: Renderer.new)
+    def initialize(config:, resolver: Resolver.new, renderer: Renderer.new)
       @config = config
       @resolver = resolver
       @renderer = renderer
     end
 
     def call
-      resolution = resolver.resolve(config.gem_name, config.version)
+      resolution = resolver.resolve(config.gem_name, config.version, source: config.source)
       output_path = config.output_path
       output_path.dirname.mkpath
       output_path.write renderer.render(formula_data(resolution))
@@ -35,14 +35,25 @@ module Gembrew
 
     def metadata(spec)
       {
-        description: config.description || spec.summary,
-        homepage:    config.homepage || inferred_homepage(spec),
-        license:     config.license || spec.license || spec.licenses.first,
-        executable:  config.executable || spec.executables.first || spec.name,
-        test_body:   config.test_body,
+        description:    config.description || spec.summary,
+        homepage:       config.homepage || inferred_homepage(spec),
+        license:        config.license || spec.license || spec.licenses.first,
+        executable:     config.executable || spec.executables.first || spec.name,
+        source_type:    config.source_type,
+        source_repo:    config.source_repo,
+        source_tag:     config.source_tag,
+        source_gemspec: config.source_gemspec,
+        dependencies:   formula_dependencies,
+        test_body:      config.test_body,
       }
     end
 
+    def formula_dependencies
+      ([Config::Dependency.new(name: 'ruby', tags: [])] + config.dependencies)
+        .uniq(&:name)
+        .sort_by(&:name)
+    end
+
     def formula_name(gem_name)
       gem_name.split(/[-_]/).map(&:capitalize).join
     end

data/lib/gembrew/github_archive_store.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+require 'open3'
+require 'pathname'
+require 'gembrew/error'
+require 'gembrew/reporter'
+
+module Gembrew
+  class GithubArchiveStore
+    def initialize(cache_path:, reporter: Reporter.new, command_runner: nil)
+      @cache_path = Pathname(cache_path)
+      @reporter = reporter
+      @command_runner = command_runner || method(:run_command)
+      @cache_path.mkpath
+    end
+
+    def fetch(repository, tag)
+      name = repository.tr '/', '-'
+      path = @cache_path/"#{name}-#{tag.tr '/', '-'}.tar.gz"
+      if path.file? && !path.empty?
+        reporter.archive :github_cache, repository, tag
+        return path
+      end
+
+      reporter.archive :downloading, repository, tag
+      url = "https://github.com/#{repository}/archive/refs/tags/#{tag}.tar.gz"
+      command_runner.call 'curl', '--fail', '--location', '--silent', '--show-error',
+        '--output', path.to_s, url, chdir: @cache_path
+      raise Error, "GitHub archive is empty: #{url}" unless path.file? && !path.empty?
+
+      path
+    end
+
+    def extract(archive, destination)
+      destination = Pathname(destination)
+      destination.mkpath
+      command_runner.call 'tar', '-xzf', archive.to_s, '-C', destination.to_s, chdir: destination
+      destination
+    end
+
+  private
+
+    attr_reader :reporter, :command_runner
+
+    def run_command(*command, chdir:)
+      result, status = Open3.capture2e(*command, chdir: chdir.to_s)
+      raise Error, result unless status.success?
+
+      result
+    end
+  end
+end

data/lib/gembrew/initializer.rb

@@ -1,63 +1,67 @@
 require 'erb'
 require 'fileutils'
 require 'pathname'
+require 'gembrew/adder'
 require 'gembrew/error'
 
 module Gembrew
   class Initializer
-    CONFIG_FILENAME = 'gembrew.yml'
-
     attr_reader :gem_name, :project_path
 
-    def initialize(gem_name, project_path: Pathname.pwd)
+    def initialize(gem_name = nil, project_path: Pathname.pwd)
       @gem_name = gem_name
       @project_path = Pathname(project_path).expand_path
     end
 
     def call
-      raise Error, "Directory is not empty: #{project_path} (found: #{entry_names.join(', ')})" if entries.any?
+      Config.validate_name! gem_name if gem_name
+      validate_project
 
       formula_path.mkpath
-      support_path.mkpath
-      config_path.write render
-      compose_path.write render('compose.yaml.erb')
+      config_directory.mkpath
+      readme_path.write render_readme unless readme_path.exist?
+      workflow_path.dirname.mkpath
+      workflow_path.write workflow_template.read unless workflow_path.exist?
+      Adder.new(gem_name, project_path: project_path).call if gem_name
 
       project_path
     end
 
   private
 
-    def config_path
-      project_path/CONFIG_FILENAME
+    def formula_path
+      project_path/'Formula'
     end
 
-    def compose_path
-      support_path/'compose.yaml'
+    def config_directory
+      project_path/'gembrew'
     end
 
-    def formula_path
-      project_path/'Formula'
+    def readme_path
+      project_path/'README.md'
     end
 
-    def support_path
-      project_path/'support'
+    def workflow_path
+      project_path/'.github/workflows/test.yml'
+    end
+
+    def workflow_template
+      Pathname(__dir__)/'templates/test.yml'
     end
 
     def entries
       @entries ||= project_path.children.reject { |path| path.basename.to_s == '.git' }
     end
 
-    def entry_names
-      entries.map { |path| path.basename.to_s }.sort
-    end
+    def validate_project
+      return if entries.empty? || formula_path.directory?
 
-    def render(filename = 'gembrew.yml.erb')
-      template = asset_path filename
-      ERB.new(template.read, trim_mode: '-').result(binding)
+      raise Error, "Directory is not a Homebrew tap: #{project_path} (Formula/ does not exist)"
     end
 
-    def asset_path(filename)
-      Pathname(__dir__)/'templates'/filename
+    def render_readme
+      template = Pathname(__dir__)/'templates/README.md.erb'
+      ERB.new(template.read, trim_mode: '-').result(binding)
     end
   end
 end

data/lib/gembrew/reporter.rb

@@ -7,6 +7,7 @@ module Gembrew
     LABELS = {
       rubygems_cache: ['g', 'RubyGems cache'],
       gembrew_cache:  ['g', 'Gembrew cache'],
+      github_cache:   ['g', 'GitHub cache'],
       downloading:    %w[y Downloading],
     }.freeze
 

data/lib/gembrew/resolver.rb

@@ -6,6 +6,7 @@ require 'rubygems/package'
 require 'tmpdir'
 require 'gembrew/archive_store'
 require 'gembrew/error'
+require 'gembrew/github_archive_store'
 require 'gembrew/reporter'
 
 module Gembrew
@@ -15,21 +16,22 @@ module Gembrew
   class Resolver
     attr_reader :cache_root
 
-    def initialize(cache_root: nil, reporter: Reporter.new, command_runner: nil, archive_store: nil)
+    def initialize(cache_root: nil, reporter: Reporter.new, command_runner: nil, archive_store: nil,
+                   github_archive_store: nil)
       @cache_root = Pathname(cache_root || default_cache_root)
       @reporter = reporter
       @command_runner = command_runner || method(:run_command)
       @archive_store = archive_store || ArchiveStore.new(
         cache_path: @cache_root/'gems', reporter: reporter, command_runner: @command_runner
       )
+      @github_archive_store = github_archive_store
       temporary_root.mkpath
     end
 
-    def resolve(name, version = nil)
+    def resolve(name, version, source:)
       Dir.mktmpdir('build-', temporary_root.to_s) do |directory|
         temporary = Pathname(directory)
-        root_archive = archive_store.fetch(name, version, temporary)
-        root_spec = Gem::Package.new(root_archive.to_s).spec
+        root_archive, root_spec = root_source name, version, source, temporary
         dependencies = dependency_specs(lock(root_spec, temporary), root_spec)
 
         reporter.collecting dependencies.length
@@ -45,6 +47,57 @@ module Gembrew
 
     attr_reader :reporter, :command_runner, :archive_store
 
+    def github_archive_store
+      @github_archive_store ||= GithubArchiveStore.new(
+        cache_path: cache_root/'github', reporter: reporter, command_runner: command_runner
+      )
+    end
+
+    def root_source(name, version, source_config, temporary)
+      return rubygems_root_source(name, version, temporary) if source_config.fetch('type') == 'rubygems'
+
+      github_root_source name, version, source_config, temporary
+    end
+
+    def rubygems_root_source(name, version, temporary)
+      archive = archive_store.fetch(name, version, temporary)
+      [archive, Gem::Package.new(archive.to_s).spec]
+    end
+
+    def github_root_source(name, version, source_config, temporary)
+      repository = source_config.fetch('repo')
+      tag = source_config['tag'] || "v#{version}"
+      gemspec_path = source_config['gemspec'] || "#{name}.gemspec"
+      archive = github_archive_store.fetch repository, tag
+      root = github_project_root archive, temporary
+      spec = load_github_spec root/gemspec_path, gemspec_path
+      validate_github_spec spec, name, version
+
+      [archive, spec]
+    end
+
+    def github_project_root(archive, temporary)
+      extracted = github_archive_store.extract archive, temporary/'source'
+      roots = extracted.children.select(&:directory?)
+      raise Error, 'Expected one project directory in the GitHub archive' unless roots.one?
+
+      roots.first
+    end
+
+    def load_github_spec(gemspec, gemspec_path)
+      raise Error, "Gemspec not found in GitHub archive: #{gemspec_path}" unless gemspec.file?
+
+      spec = Dir.chdir(gemspec.dirname) { Gem::Specification.load(gemspec.basename.to_s) }
+      raise Error, "Could not load gemspec from GitHub archive: #{gemspec_path}" unless spec
+
+      spec
+    end
+
+    def validate_github_spec(spec, name, version)
+      raise Error, "Gemspec name #{spec.name} does not match configured gem #{name}" unless spec.name == name
+      raise Error, "GitHub gemspec version #{spec.version} does not match #{version}" unless spec.version == Gem::Version.new(version)
+    end
+
     def resource(spec, temporary, index, total)
       archive = archive_store.fetch spec.name, spec.version, temporary, index: index, total: total
       Resource.new spec.name, spec.version.to_s, Digest::SHA256.file(archive).hexdigest
@@ -62,10 +115,11 @@ module Gembrew
     def lock(root_spec, temporary)
       gemfile = temporary/'Gemfile'
       lockfile = temporary/'Gemfile.lock'
-      gemfile.write <<~RUBY
-        source "https://rubygems.org"
-        gem #{root_spec.name.inspect}, "= #{root_spec.version}"
-      RUBY
+      dependencies = root_spec.runtime_dependencies.map do |dependency|
+        requirements = dependency.requirement.requirements.map { |operator, version| "#{operator} #{version}" }
+        "gem #{dependency.name.inspect}, #{requirements.map(&:inspect).join(', ')}"
+      end
+      gemfile.write([[%[source "https://rubygems.org"]], dependencies, ['']].flatten.join("\n"))
 
       reporter.resolving root_spec.name, root_spec.version
       command_runner.call(

data/lib/gembrew/templates/README.md.erb

@@ -0,0 +1,55 @@
+# Homebrew Tap
+
+<!-- Replace OWNER/TAP with your Homebrew tap name, for example dannyben/tools. -->
+
+## Install
+
+```shell
+brew tap OWNER/TAP
+brew install <%= gem_name || 'FORMULA' %>
+```
+
+Or install the formula directly:
+
+```shell
+brew install OWNER/TAP/<%= gem_name || 'FORMULA' %>
+```
+
+## Development
+
+Install [Gembrew](https://github.com/DannyBen/gembrew):
+
+```shell
+gem install gembrew
+```
+
+Generate all formulae:
+
+```shell
+gembrew build
+```
+
+Generate or check one formula:
+
+```shell
+gembrew build <%= gem_name || 'FORMULA' %>
+gembrew check <%= gem_name || 'FORMULA' %>
+```
+
+Check every formula:
+
+```shell
+gembrew check
+```
+
+Add another Ruby gem:
+
+```shell
+gembrew add another-gem
+```
+
+Open an interactive Homebrew environment:
+
+```shell
+gembrew shell
+```

data/lib/gembrew/templates/formula.rb.erb

@@ -1,16 +1,25 @@
-# Generated by Gembrew: https://github.com/dannyben/gembrew
-# Manual edits are not recommended. Update gembrew.yml and regenerate with:
-#   gem install gembrew
-#   gembrew build
-
 class <%= formula_name %> < Formula
   desc <%= description.inspect %>
   homepage <%= homepage.inspect %>
+<% if source_type == 'github' -%>
+  url "https://github.com/<%= source_repo %>/archive/refs/tags/<%= source_tag %>.tar.gz"
+<% else -%>
   url "https://rubygems.org/downloads/<%= gem_name %>-<%= version %>.gem"
+<% end -%>
   sha256 "<%= sha256 %>"
   license <%= license.inspect %>
 
-  depends_on "ruby"
+<% formula_dependencies = dependencies.reject(&:system_on_macos?) -%>
+<% macos_dependencies = dependencies.select(&:system_on_macos?) -%>
+<% formula_dependencies.each do |dependency| -%>
+  depends_on <%= dependency.name.inspect %>
+<% end -%>
+<% if formula_dependencies.any? && macos_dependencies.any? -%>
+
+<% end -%>
+<% macos_dependencies.each do |dependency| -%>
+  uses_from_macos <%= dependency.name.inspect %>
+<% end -%>
 <% resources.each do |resource| -%>
 
   resource <%= resource.name.inspect %> do
@@ -27,8 +36,17 @@ class <%= formula_name %> < Formula
         "--ignore-dependencies", "--install-dir", libexec, "--no-document"
     end
 
+<% if source_type == 'github' -%>
+    system "gem", "build", "<%= source_gemspec %>"
+    system "gem", "install", "--ignore-dependencies", "<%= gem_name %>-#{version}.gem",
+      "--install-dir", libexec, "--no-document"
+<% else -%>
     system "gem", "install", cached_download,
       "--ignore-dependencies", "--install-dir", libexec, "--no-document"
+<% end -%>
+
+    rm libexec.glob("extensions/*/*/*/mkmf.log")
+    deuniversalize_machos if OS.mac?
 
     (bin/<%= executable.inspect %>).write_env_script libexec/"bin/<%= executable %>", GEM_HOME: ENV.fetch("GEM_HOME")
   end

data/lib/gembrew/templates/gembrew.yml.erb

@@ -1,15 +1,29 @@
 gem: <%= gem_name %>
-output: Formula/<%= gem_name %>.rb
+version: "" # required
+
+# Required source. Use the published RubyGem:
+source:
+  type: rubygems
+
+# Or replace the source above with a GitHub tag archive:
+# source:
+#   type: github
+#   repo: owner/repository          # required for GitHub
+#   tag: v1.2.3                    # optional; defaults to vVERSION
+#   gemspec: <%= gem_name %>.gemspec  # optional; defaults to GEMNAME.gemspec
 
 test: |-
   system bin/"<%= gem_name %>", "--version"
 
-# Optional overrides:
-# version: "1.2.3"
+# Optional metadata and formula overrides:
 # desc: Example command-line application
 # homepage: https://example.com
 # license: MIT
 # executable: <%= gem_name %>
+# output: Formula/<%= gem_name %>.rb
+# dependencies:
+#   - bash
+#   - libffi :system_on_macos
 
 # To load the Homebrew test body from a Ruby file, replace `test` above with:
 # test_from_file: support/test.rb

data/lib/gembrew/templates/test.yml

@@ -0,0 +1,65 @@
+name: Test Formulae
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@fd832223f9f99ebf0244dd20658680e5d4aca049 # 2026.08.03.2
+
+      - name: Cache Homebrew Bundler gems
+        id: cache
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ runner.os }}-rubygems-
+
+      - name: Install Homebrew Bundler gems
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: brew install-bundler-gems
+
+      - name: Test formulae
+        shell: bash
+        env:
+          HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          shopt -s nullglob
+          formulae=(Formula/*.rb)
+
+          if (( ${#formulae[@]} == 0 )); then
+            echo "No formulae found in Formula/"
+            exit 1
+          fi
+
+          for formula in "${formulae[@]}"; do
+            formula_name="${formula##*/}"
+            formula_name="${formula_name%.rb}"
+
+            brew style "$formula"
+            brew audit --new --online "$formula_name"
+            brew install --build-from-source "$formula_name"
+            brew test "$formula_name"
+            brew linkage --test "$formula_name"
+            brew uninstall "$formula_name"
+          done

data/lib/gembrew/version.rb

@@ -1,3 +1,3 @@
 module Gembrew
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
 end

data/lib/gembrew.rb

@@ -1,9 +1,12 @@
 require 'gembrew/archive_store'
+require 'gembrew/adder'
 require 'gembrew/config'
 require 'gembrew/docker_check'
 require 'gembrew/docker_shell'
+require 'gembrew/docker_runner'
 require 'gembrew/error'
 require 'gembrew/generator'
+require 'gembrew/github_archive_store'
 require 'gembrew/initializer'
 require 'gembrew/reporter'
 require 'gembrew/renderer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gembrew
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Danny Ben Shitrit
@@ -63,24 +63,29 @@ files:
 - README.md
 - bin/gembrew
 - lib/gembrew.rb
+- lib/gembrew/adder.rb
 - lib/gembrew/archive_store.rb
 - lib/gembrew/cli.rb
+- lib/gembrew/commands/add.rb
 - lib/gembrew/commands/build.rb
 - lib/gembrew/commands/check.rb
 - lib/gembrew/commands/init.rb
 - lib/gembrew/commands/shell.rb
 - lib/gembrew/config.rb
 - lib/gembrew/docker_check.rb
+- lib/gembrew/docker_runner.rb
 - lib/gembrew/docker_shell.rb
 - lib/gembrew/error.rb
 - lib/gembrew/generator.rb
+- lib/gembrew/github_archive_store.rb
 - lib/gembrew/initializer.rb
 - lib/gembrew/renderer.rb
 - lib/gembrew/reporter.rb
 - lib/gembrew/resolver.rb
-- lib/gembrew/templates/compose.yaml.erb
+- lib/gembrew/templates/README.md.erb
 - lib/gembrew/templates/formula.rb.erb
 - lib/gembrew/templates/gembrew.yml.erb
+- lib/gembrew/templates/test.yml
 - lib/gembrew/version.rb
 homepage: https://github.com/DannyBen/gembrew
 licenses:

data/lib/gembrew/templates/compose.yaml.erb

@@ -1,29 +0,0 @@
-services:
-  brew: &base
-    image: homebrew/brew:main
-    working_dir: /work
-    environment:
-      HOMEBREW_NO_AUTO_UPDATE: "1"
-      HOMEBREW_NO_INSTALL_CLEANUP: "1"
-      HOMEBREW_NO_INSTALL_FROM_API: "1"
-      GEMBREW_GEM: <%= gem_name %>
-      PS1: "\n\nbrew $ "
-    volumes:
-      - ..:/work
-      - ..:/home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/gembrew/homebrew-tap
-    command: ["bash", "--norc"]
-    stdin_open: true
-    tty: true
-
-  check:
-    <<: *base
-    command:
-      - bash
-      - -euc
-      - |
-        brew style "$${GEMBREW_GEM}"
-        brew audit --new --online "$${GEMBREW_GEM}"
-        brew install --build-from-source "$${GEMBREW_GEM}"
-        brew test "$${GEMBREW_GEM}"
-    stdin_open: false
-    tty: false