gembrew 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46aaf0e8b85829162de73512e6c9fe6c892a7dc646513a6cd6d6d9265c06124b
+  data.tar.gz: 90de5846e5cc45f8e0458d0c0dcf6368ea4071595b152b72279cff91b4e349f1
+SHA512:
+  metadata.gz: 40a61361c893f96bc402ef4c4514236cb7ec4313386f3378e1dfcf026a4726a2fbfec786f6ccdd8120495d7c80adfe240f3b182e79d3890e5b2e6bfa2bff57ca
+  data.tar.gz: edf9bd6364b9c2409b43d1777739b9591d02adaee91475b72203b64dbfdd5c75f566aab6d632aa1998318f745120ccfb5102ad7f937b6f9be323817521e575e4

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) Danny Ben Shitrit
+
+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,105 @@
+# Gembrew
+
+Generate conventional Homebrew formulae for published Ruby command-line gems.
+
+## Install
+
+```shell
+gem install gembrew
+```
+
+## Usage
+
+```shell
+mkdir homebrew-tap
+cd homebrew-tap
+gembrew init GEM
+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`.
+
+For example, `gembrew init example` generates:
+
+```yaml
+gem: example
+output: Formula/example.rb
+
+test: |-
+  system bin/"example", "--version"
+```
+
+Edit `gembrew.yml` as needed, then generate the formula:
+
+```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`.
+
+```yaml
+gem: example
+output: Formula/example.rb
+
+# Optional published gem version. The latest stable version is used by default.
+version: "1.2.3"
+
+# Optional gem metadata overrides:
+desc: Example command-line application
+homepage: https://example.com
+license: MIT
+executable: example
+
+test: |-
+  system bin/"example", "--version"
+
+# Use this instead of `test` to load the test body from another file:
+# test_from_file: support/test.rb
+```
+
+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
+`${XDG_CACHE_HOME:-~/.cache}/gembrew/gems`.
+
+Open the generated Homebrew environment with:
+
+```shell
+gembrew shell
+```
+
+The repository is mounted as a local tap, so formulae can be addressed by gem
+name inside the shell:
+
+```shell
+brew style example
+brew audit --new --online example
+brew install --build-from-source example
+brew test example
+```
+
+Run the complete workflow non-interactively in one clean container:
+
+```shell
+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.
+
+## Contributing / Support
+
+If you experience any issue, have a question or a suggestion, or if you wish
+to contribute, feel free to [open an issue][issues].
+
+---
+
+[issues]: https://github.com/DannyBen/gembrew/issues

data/bin/gembrew

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'gembrew'
+require 'gembrew/cli'
+require 'colsole'
+
+include Colsole
+
+runner = Gembrew::CLI.runner
+
+begin
+  exit runner.run ARGV
+rescue => e
+  puts e.backtrace.reverse if ENV['DEBUG']
+  say! "rib` #{e.class} `\n#{e.message}"
+  exit 1
+end

data/lib/gembrew/archive_store.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+require 'open3'
+require 'pathname'
+require 'rubygems/package'
+require 'gembrew/error'
+require 'gembrew/reporter'
+
+module Gembrew
+  class ArchiveStore
+    attr_reader :cache_path
+
+    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(name, version, download_path, index: nil, total: nil)
+      if (path = locally_cached(name, version))
+        report :rubygems_cache, name, version, index: index, total: total
+        return path
+      end
+
+      if version && (path = gembrew_cached(name, version))
+        report :gembrew_cache, name, version, index: index, total: total
+        return path
+      end
+
+      download name, version, Pathname(download_path), index: index, total: total
+    end
+
+  private
+
+    attr_reader :reporter, :command_runner
+
+    def locally_cached(name, version)
+      return unless version
+
+      Gem.path.each do |gem_path|
+        path = Pathname(gem_path)/'cache'/"#{name}-#{version}.gem"
+        return path if valid_archive?(path, name, version)
+      end
+
+      nil
+    end
+
+    def gembrew_cached(name, version)
+      path = cache_path/"#{name}-#{version}.gem"
+      path if valid_archive?(path, name, version)
+    end
+
+    def valid_archive?(path, name, version)
+      return false unless path.file?
+
+      spec = Gem::Package.new(path.to_s).spec
+      spec.name == name && spec.version == Gem::Version.new(version.to_s) &&
+        spec.platform == Gem::Platform::RUBY
+    rescue Gem::Package::Error
+      false
+    end
+
+    def download(name, version, download_path, index:, total:)
+      report :downloading, name, version, index: index, total: total
+      before = download_path.children
+      command = ['gem', 'fetch', name, '--platform', 'ruby']
+      command.push '--version', version.to_s if version
+      command_runner.call(*command, chdir: download_path)
+
+      candidates = download_path.children - before
+      archive = candidates.find { |path| path.extname == '.gem' }
+      raise Error, "gem fetch did not produce a .gem file for #{name} #{version}" unless archive
+
+      spec = Gem::Package.new(archive.to_s).spec
+      cached_path = cache_path/"#{spec.name}-#{spec.version}.gem"
+      FileUtils.mv archive, cached_path, force: true
+      cached_path
+    end
+
+    def report(state, name, version, index:, total:)
+      reporter.archive state, name, version, index: index, total: total
+    end
+
+    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/cli.rb

@@ -0,0 +1,23 @@
+require 'mister_bin'
+require 'gembrew/commands/build'
+require 'gembrew/commands/check'
+require 'gembrew/commands/init'
+require 'gembrew/commands/shell'
+require 'gembrew/version'
+
+module Gembrew
+  class CLI
+    def self.runner
+      runner = MisterBin::Runner.new version: Gembrew::VERSION,
+        header: 'Gembrew - Homebrew Formula Generator for Ruby Gems',
+        footer: 'Run m`gembrew COMMAND --help` for more information'
+
+      runner.route 'init',  to: Commands::Init
+      runner.route 'build', to: Commands::Build
+      runner.route 'check', to: Commands::Check
+      runner.route 'shell', to: Commands::Shell
+
+      runner
+    end
+  end
+end

data/lib/gembrew/commands/build.rb

@@ -0,0 +1,18 @@
+require 'mister_bin'
+require 'gembrew/generator'
+
+module Gembrew
+  module Commands
+    class Build < MisterBin::Command
+      help 'Generate a Homebrew formula from gembrew.yml'
+
+      usage 'gembrew build'
+      usage 'gembrew build (-h|--help)'
+
+      def run
+        output_path = Generator.new.call
+        say "Generated m`#{output_path}`"
+      end
+    end
+  end
+end

data/lib/gembrew/commands/check.rb

@@ -0,0 +1,21 @@
+require 'mister_bin'
+require 'gembrew/docker_check'
+require 'gembrew/generator'
+
+module Gembrew
+  module Commands
+    class Check < MisterBin::Command
+      help 'Build and test the formula in a clean Homebrew environment'
+
+      usage 'gembrew check'
+      usage 'gembrew check (-h|--help)'
+
+      def run
+        output_path = Generator.new.call
+        say "Generated m`#{output_path}`"
+        DockerCheck.new.call
+        say 'g`All checks passed`'
+      end
+    end
+  end
+end

data/lib/gembrew/commands/init.rb

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

data/lib/gembrew/commands/shell.rb

@@ -0,0 +1,17 @@
+require 'mister_bin'
+require 'gembrew/docker_shell'
+
+module Gembrew
+  module Commands
+    class Shell < MisterBin::Command
+      help 'Open a Homebrew shell for this tap repository'
+
+      usage 'gembrew shell'
+      usage 'gembrew shell (-h|--help)'
+
+      def run
+        DockerShell.new.call
+      end
+    end
+  end
+end

data/lib/gembrew/config.rb

@@ -0,0 +1,70 @@
+require 'pathname'
+require 'yaml'
+require 'gembrew/error'
+
+module Gembrew
+  class Config
+    FILENAME = 'gembrew.yml'
+    ALLOWED_KEYS = %w[
+      gem version output desc homepage license executable test test_from_file
+    ].freeze
+
+    attr_reader :path
+
+    def initialize(project_path = Pathname.pwd)
+      @path = Pathname(project_path).expand_path/FILENAME
+      @data = load_data
+      validate
+    end
+
+    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 description = data['desc']
+    def homepage = data['homepage']
+    def license = data['license']
+    def executable = data['executable']
+
+    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')
+        raise Error, "Test file does not exist: #{test_path}" unless test_path.file?
+
+        test_path.read
+      end
+    end
+
+  private
+
+    attr_reader :data
+
+    def load_data
+      raise Error, "Configuration does not exist: #{path}" unless path.file?
+
+      YAML.safe_load_file(path, aliases: false)
+    rescue Psych::Exception => e
+      raise Error, "Invalid configuration: #{e.message}"
+    end
+
+    def validate
+      raise Error, 'Configuration must be a YAML mapping' unless data.is_a?(Hash)
+
+      unknown_keys = data.keys - ALLOWED_KEYS
+      raise Error, "Unknown configuration keys: #{unknown_keys.join(', ')}" if unknown_keys.any?
+
+      require_value 'gem'
+      require_value 'output'
+
+      return unless data.has_key?('test') == data.has_key?('test_from_file')
+
+      raise Error, 'Provide exactly one of test or test_from_file'
+    end
+
+    def require_value(key)
+      value = data[key]
+      raise Error, "#{key} is required" if value.nil? || value.to_s.empty?
+    end
+  end
+end

data/lib/gembrew/docker_check.rb

@@ -0,0 +1,40 @@
+require 'pathname'
+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)
+    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
+      )
+      raise Error, 'Homebrew checks failed' unless success
+
+      true
+    end
+
+  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
+  end
+end

data/lib/gembrew/docker_shell.rb

@@ -0,0 +1,39 @@
+require 'pathname'
+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)
+    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
+      )
+      raise Error, 'Homebrew shell exited with an error' unless success
+
+      true
+    end
+
+  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
+  end
+end

data/lib/gembrew/error.rb

@@ -0,0 +1,3 @@
+module Gembrew
+  class Error < StandardError; end
+end

data/lib/gembrew/generator.rb

@@ -0,0 +1,54 @@
+require 'gembrew/config'
+require 'gembrew/renderer'
+require 'gembrew/resolver'
+
+module Gembrew
+  class Generator
+    def initialize(config: Config.new, resolver: Resolver.new, renderer: Renderer.new)
+      @config = config
+      @resolver = resolver
+      @renderer = renderer
+    end
+
+    def call
+      resolution = resolver.resolve(config.gem_name, config.version)
+      output_path = config.output_path
+      output_path.dirname.mkpath
+      output_path.write renderer.render(formula_data(resolution))
+      output_path
+    end
+
+  private
+
+    attr_reader :config, :resolver, :renderer
+
+    def formula_data(resolution)
+      spec = resolution.spec
+      {
+        formula_name: formula_name(spec.name),
+        gem_name:     spec.name,
+        version:      spec.version.to_s,
+        sha256:       resolution.sha256,
+        resources:    resolution.resources,
+      }.merge metadata(spec)
+    end
+
+    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,
+      }
+    end
+
+    def formula_name(gem_name)
+      gem_name.split(/[-_]/).map(&:capitalize).join
+    end
+
+    def inferred_homepage(spec)
+      spec.homepage.to_s.empty? ? spec.metadata['homepage_uri'] : spec.homepage
+    end
+  end
+end

data/lib/gembrew/initializer.rb

@@ -0,0 +1,63 @@
+require 'erb'
+require 'fileutils'
+require 'pathname'
+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)
+      @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?
+
+      formula_path.mkpath
+      support_path.mkpath
+      config_path.write render
+      compose_path.write render('compose.yaml.erb')
+
+      project_path
+    end
+
+  private
+
+    def config_path
+      project_path/CONFIG_FILENAME
+    end
+
+    def compose_path
+      support_path/'compose.yaml'
+    end
+
+    def formula_path
+      project_path/'Formula'
+    end
+
+    def support_path
+      project_path/'support'
+    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 render(filename = 'gembrew.yml.erb')
+      template = asset_path filename
+      ERB.new(template.read, trim_mode: '-').result(binding)
+    end
+
+    def asset_path(filename)
+      Pathname(__dir__)/'templates'/filename
+    end
+  end
+end

data/lib/gembrew/renderer.rb

@@ -0,0 +1,18 @@
+require 'erb'
+require 'pathname'
+
+module Gembrew
+  class Renderer
+    def render(locals)
+      context = Object.new
+      locals.each { |name, value| context.define_singleton_method(name) { value } }
+      ERB.new(template_path.read, trim_mode: '-').result(context.instance_eval { binding })
+    end
+
+  private
+
+    def template_path
+      Pathname(__dir__)/'templates/formula.rb.erb'
+    end
+  end
+end

data/lib/gembrew/reporter.rb

@@ -0,0 +1,40 @@
+require 'colsole'
+
+module Gembrew
+  class Reporter
+    include Colsole
+
+    LABELS = {
+      rubygems_cache: ['g', 'RubyGems cache'],
+      gembrew_cache:  ['g', 'Gembrew cache'],
+      downloading:    %w[y Downloading],
+    }.freeze
+
+    def archive(state, name, version, index: nil, total: nil)
+      color, label = LABELS.fetch state
+      parts = []
+      parts << counter(index, total) if index && total
+      parts << "#{color}`#{label.ljust label_width}`"
+      parts << ["nb`#{name}`", version&.to_s].compact.join(' ')
+      say parts.join('  ')
+    end
+
+    def resolving(name, version)
+      say "Resolving dependencies for nb`#{name}` #{version}..."
+    end
+
+    def collecting(count)
+      say "Collecting nb`#{count}` resources..."
+    end
+
+  private
+
+    def counter(index, total)
+      "%#{total.to_s.length}d/%d" % [index, total]
+    end
+
+    def label_width
+      @label_width ||= LABELS.values.map { |_color, label| label.length }.max
+    end
+  end
+end

data/lib/gembrew/resolver.rb

@@ -0,0 +1,99 @@
+require 'bundler'
+require 'digest'
+require 'open3'
+require 'pathname'
+require 'rubygems/package'
+require 'tmpdir'
+require 'gembrew/archive_store'
+require 'gembrew/error'
+require 'gembrew/reporter'
+
+module Gembrew
+  Resource = Data.define(:name, :version, :sha256)
+  Resolution = Data.define(:spec, :sha256, :resources)
+
+  class Resolver
+    attr_reader :cache_root
+
+    def initialize(cache_root: nil, reporter: Reporter.new, command_runner: nil, 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
+      )
+      temporary_root.mkpath
+    end
+
+    def resolve(name, version = nil)
+      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
+        dependencies = dependency_specs(lock(root_spec, temporary), root_spec)
+
+        reporter.collecting dependencies.length
+        resources = dependencies.each_with_index.map do |spec, index|
+          resource spec, temporary, index + 1, dependencies.length
+        end
+
+        Resolution.new(root_spec, Digest::SHA256.file(root_archive).hexdigest, resources)
+      end
+    end
+
+  private
+
+    attr_reader :reporter, :command_runner, :archive_store
+
+    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
+    end
+
+    def default_cache_root
+      cache_home = ENV.fetch('XDG_CACHE_HOME', File.expand_path('~/.cache'))
+      Pathname(cache_home)/'gembrew'
+    end
+
+    def temporary_root
+      cache_root/'tmp'
+    end
+
+    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
+
+      reporter.resolving root_spec.name, root_spec.version
+      command_runner.call(
+        'bundle', 'lock', '--gemfile', gemfile.to_s, '--lockfile', lockfile.to_s,
+        '--add-platform', 'ruby',
+        chdir: temporary,
+        env:   {
+          'BUNDLE_FORCE_RUBY_PLATFORM' => 'true',
+          'BUNDLE_GEMFILE'             => gemfile.to_s,
+        }
+      )
+      lockfile
+    end
+
+    def dependency_specs(lockfile, root_spec)
+      specs = Bundler::LockfileParser.new(lockfile.read).specs
+      selected = specs.group_by(&:name).values.map do |variants|
+        variants.find { |spec| spec.platform == Gem::Platform::RUBY } || variants.first
+      end
+
+      selected.reject { |spec| spec.name == root_spec.name }.sort_by(&:name)
+    end
+
+    def run_command(*command, chdir:, env: {})
+      result, status = Open3.capture2e(env, *command, chdir: chdir.to_s)
+      raise Error, result unless status.success?
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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

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

@@ -0,0 +1,39 @@
+# 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 %>
+  url "https://rubygems.org/downloads/<%= gem_name %>-<%= version %>.gem"
+  sha256 "<%= sha256 %>"
+  license <%= license.inspect %>
+
+  depends_on "ruby"
+<% resources.each do |resource| -%>
+
+  resource <%= resource.name.inspect %> do
+    url "https://rubygems.org/downloads/<%= resource.name %>-<%= resource.version %>.gem"
+    sha256 "<%= resource.sha256 %>"
+  end
+<% end -%>
+
+  def install
+    ENV["GEM_HOME"] = libexec
+
+    resources.each do |resource|
+      system "gem", "install", resource.cached_download,
+        "--ignore-dependencies", "--install-dir", libexec, "--no-document"
+    end
+
+    system "gem", "install", cached_download,
+      "--ignore-dependencies", "--install-dir", libexec, "--no-document"
+
+    (bin/<%= executable.inspect %>).write_env_script libexec/"bin/<%= executable %>", GEM_HOME: ENV.fetch("GEM_HOME")
+  end
+
+  test do
+<%= test_body.lines.map { |line| "    #{line}" }.join %>
+  end
+end

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

@@ -0,0 +1,15 @@
+gem: <%= gem_name %>
+output: Formula/<%= gem_name %>.rb
+
+test: |-
+  system bin/"<%= gem_name %>", "--version"
+
+# Optional overrides:
+# version: "1.2.3"
+# desc: Example command-line application
+# homepage: https://example.com
+# license: MIT
+# executable: <%= gem_name %>
+
+# To load the Homebrew test body from a Ruby file, replace `test` above with:
+# test_from_file: support/test.rb

data/lib/gembrew/version.rb

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

data/lib/gembrew.rb

@@ -0,0 +1,11 @@
+require 'gembrew/archive_store'
+require 'gembrew/config'
+require 'gembrew/docker_check'
+require 'gembrew/docker_shell'
+require 'gembrew/error'
+require 'gembrew/generator'
+require 'gembrew/initializer'
+require 'gembrew/reporter'
+require 'gembrew/renderer'
+require 'gembrew/resolver'
+require 'gembrew/version'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: gembrew
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Danny Ben Shitrit
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colsole
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mister_bin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Generate conventional Homebrew formulae for published Ruby command-line
+  gems
+email: db@dannyben.com
+executables:
+- gembrew
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/gembrew
+- lib/gembrew.rb
+- lib/gembrew/archive_store.rb
+- lib/gembrew/cli.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_shell.rb
+- lib/gembrew/error.rb
+- lib/gembrew/generator.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/formula.rb.erb
+- lib/gembrew/templates/gembrew.yml.erb
+- lib/gembrew/version.rb
+homepage: https://github.com/DannyBen/gembrew
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/DannyBen/gembrew/issues
+  changelog_uri: https://github.com/DannyBen/gembrew/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/DannyBen/gembrew
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.17
+specification_version: 4
+summary: Homebrew formula generator for Ruby gems
+test_files: []