gouteur 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 001d0213cebc3a146615388dff657d573cc671395e2e8d62995e11b3b3a84f6e
+  data.tar.gz: 45ed7d535d16effa0c9ad2bd6044e973257d08a111e606beb6b65dd2e7483b83
+SHA512:
+  metadata.gz: 2664a0c872fbd8da4b638841454904ae43015652c10e3d2fabbd52f7c5f15fb2f5541eb677954952228e48153ca4ef6f6d85cac5ca3b7ca5abbbac07c11a67a2
+  data.tar.gz: 1befe751c803a11255163d29ef64b37ce143381c11b197c9826ee1f020e249bace18fb597a318840293c7b2d72fac78e3a42b86a99be059db7d8eb5628270a02

data/.github/workflows/build.yml

@@ -0,0 +1,28 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby: [ '2.5', '3.0', 'ruby-head' ]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Prepare
+        run: |
+          git config --global init.defaultBranch main
+          git config --global user.email "testuser@example.com"
+          git config --global user.name "Test User"
+          gem install bundler -v 2.2.8
+          bundle install --jobs 4
+      - name: Run the specs
+        run: |
+          bundle exec rspec

data/.github/workflows/lint.yml

@@ -0,0 +1,29 @@
+# based on https://github.com/rails/rails/blob/4a78dcb/.github/workflows/rubocop.yml
+
+name: rubocop linting
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0
+    - name: Cache gems
+      uses: actions/cache@v1
+      with:
+        path: vendor/bundle
+        key: ${{ runner.os }}-rubocop-${{ hashFiles('**/Gemfile.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-rubocop-
+    - name: Install gems
+      run: |
+        bundle config path vendor/bundle
+        bundle install --jobs 4 --retry 3
+    - name: Run rubocop
+      run: bundle exec rubocop

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/example_repo/.git
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.gouteur
+Gemfile.gouteur.lock
+
+TODO

data/.gouteur.yml

@@ -0,0 +1,2 @@
+repos:
+  - uri: example_uri_in_dotfile

data/.rspec

@@ -0,0 +1,4 @@
+--format documentation
+--color
+--require spec_helper
+--exclude-pattern "**/example_*/**/*_spec.rb"

data/.rubocop.yml

@@ -0,0 +1,16 @@
+inherit_gem:
+  relaxed-rubocop: .rubocop.yml
+
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 2.5
+
+Layout/LineLength:
+  Max: 80
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [1.0.0] - 2021-02-08
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gouteur.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+gem 'rspec', '~> 3.0'
+
+gem 'rubocop', '~> 1.7'
+
+gem 'relaxed-rubocop'
+
+gem 'example_repo', '0.1.0', path: './spec/gouteur/example_repo'
+
+gem 'byebug'

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    gouteur (1.0.0)
+
+PATH
+  remote: spec/gouteur/example_repo
+  specs:
+    example_repo (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    byebug (11.1.3)
+    diff-lcs (1.4.4)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.3)
+    regexp_parser (2.0.3)
+    relaxed-rubocop (2.5)
+    rexml (3.2.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rubocop (1.9.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.2.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.4.1)
+      parser (>= 2.7.1.5)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  example_repo (= 0.1.0)!
+  gouteur!
+  rake (~> 13.0)
+  relaxed-rubocop
+  rspec (~> 3.0)
+  rubocop (~> 1.7)
+
+BUNDLED WITH
+   2.2.8

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Jannosch Müller
+
+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,94 @@
+# 👨‍🍳 Gouteur
+
+[![Gem Version](https://badge.fury.io/rb/gouteur.svg)](http://badge.fury.io/rb/gouteur)
+[![Build Status](https://github.com/jaynetics/gouteur/workflows/build/badge.svg)](https://github.com/jaynetics/gouteur/actions)
+
+Treat the people that use your gem like royalty! Send for a [gouteur](https://en.wikipedia.org/wiki/Food_taster) before serving them something new!
+
+## What?
+
+This gem runs the build tasks of other projects against your unreleased changes.
+
+## Why?
+
+Sometimes, other projects start depending on your gem.
+
+When you release a new version of your gem, these projects might break.
+
+[Semantic versioning](https://semver.org) obviously helps. People make mistakes, though. The boundary between public and private APIs can also be fuzzy, particularly in an open language like Ruby.
+
+Thus, when you update your gem, you might feel as if you should check whether things that depend on it will keep working.
+
+Gouteur automates this step.
+
+## Installation
+
+Add `gouteur` to the development dependencies of your gem.
+
+## Usage
+
+### Recommended usage
+
+Create a `.gouteur.yml` in the root of your project:
+
+```yml
+repos:
+  - uri: https://github.com/someone/some_gem
+    ref: some_specific_branch # optional, default is the default branch
+    before: setup_special_dependency # optional, bundle is always installed
+    tasks: ['rspec', 'rake foo'] # optional, default is `rake`
+    locked: true # optional, prevents setting an incompatible VERSION
+```
+
+Then simply `bundle exec gouteur` or add the rake task to your Rakefile:
+
+```ruby
+require 'gouteur/rake_task'
+Gouteur::RakeTask.new
+
+# default name is :gouteur, e.g. to include it in the default task:
+task default: %i[rspec gouteur]
+```
+
+Pro tip: for large repos, running only relevant specs can speed up things a lot, e.g.:
+
+```yml
+tasks: 'rspec spec/known_relevant_spec.rb'
+```
+```yml
+tasks: 'rspec --pattern "**/{,*}{keyword1,keyword2}{,*,*/**/*}_spec.rb"'`
+```
+
+### Manual usage
+
+From the shell:
+
+```shell
+gouteur 'https://github.com/foo/bar'
+```
+
+From Ruby:
+
+```ruby
+repo = Gouteur::Repo.new(uri: 'https://github.com/foo/bar')
+success, message = Gouteur::Checker.call(repo)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jaynetics/gouteur.
+
+## Outlook
+
+Possible future improvements:
+
+- consider caching of dependent repositories in CI, e.g. in GitHub workflows
+- support more sources of code, e.g. latest release, private GitHub repositories
+- improve performance by tracing & rerunning only specs/tests that use the gem
+- save time in MiniTest by forcing it to run in fail-fast mode like RSpec
+- add help output and more options to the CLI executable
+- other ideas? open an issue!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+require_relative 'lib/gouteur/rake_task'
+Gouteur::RakeTask.new

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'gouteur'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/gouteur

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative File.join(__dir__, '..', 'lib', 'gouteur')
+
+success = Gouteur::CLI.call
+exit(success ? 0 : 1)

data/gouteur.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/gouteur/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gouteur'
+  spec.version       = Gouteur::VERSION
+  spec.authors       = ['Janosch Müller']
+  spec.email         = ['janosch84@gmail.com']
+
+  spec.summary       = 'See if your lib is still digestible.'
+  spec.description   = 'Run tests of dependent gems against your changes.'
+  spec.homepage      = 'https://github.com/jaynetics/gouteur'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/jaynetics/gouteur'
+  spec.metadata['changelog_uri'] =
+    'https://github.com/jaynetics/gouteur/blob/master/CHANGELOG.md'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = ['gouteur']
+  spec.require_paths = ['lib']
+end

data/lib/gouteur.rb

@@ -0,0 +1,16 @@
+require 'bundler'
+
+require 'gouteur/bundle'
+require 'gouteur/checker'
+require 'gouteur/cli'
+require 'gouteur/dotfile'
+require 'gouteur/host'
+require 'gouteur/message'
+require 'gouteur/repo'
+require 'gouteur/shell'
+require 'gouteur/version'
+
+# :nodoc:
+module Gouteur
+  class Error < StandardError; end
+end

data/lib/gouteur/bundle.rb

@@ -0,0 +1,27 @@
+module Gouteur
+  # thin wrapper for bundler calls
+  class Bundle
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def install(env: {})
+      Shell.run(%w[bundle update --quiet --jobs 4], pwd: path, env: env)
+    end
+
+    def depends_on?(gem_name)
+      Shell.run(%W[bundle info #{gem_name}], pwd: path).success?
+    end
+
+    def exec(task, env: {})
+      name = task.sub(/bundle exec +/, '')
+      Shell.run(%W[bundle exec #{name}], pwd: path, env: env)
+    end
+
+    def gemfile_path
+      File.join(path, 'Gemfile')
+    end
+  end
+end

data/lib/gouteur/checker.rb

@@ -0,0 +1,127 @@
+require 'yaml'
+
+module Gouteur
+  # main process class
+  class Checker
+    attr_reader :repo
+
+    def self.call(repo, silent: false)
+      new(repo, silent: silent).call
+    end
+
+    def initialize(repo, silent: false)
+      @repo = repo
+      @silent = silent
+    end
+
+    def call
+      puts "Preparing `#{repo}` for checks..."
+      prepare
+      check_dependence
+
+      run_tasks(adapted: false)
+
+      create_adapted_gemfile
+      install_adapted_bundle or return [
+        true, Message.skipped_incompatible(repo: repo)
+      ]
+
+      run_tasks(adapted: true)
+
+      [true, Message.success(repo: repo)]
+    rescue Gouteur::Error => e
+      [false, e.message.chomp]
+    end
+
+    def prepare
+      repo.fetch
+      repo.prepare
+      result = repo.bundle.install
+      result.success? || raise(Error, result.full_error)
+    end
+
+    def check_dependence
+      repo.bundle.depends_on?(Host.name) ||
+        raise(Error, Message.no_dependence(repo: repo))
+    end
+
+    def run_tasks(adapted: false)
+      repo.tasks.empty? && raise(Error, Message.no_tasks(repo: repo))
+      repo.tasks.each { |task| run_task(task, adapted: adapted) }
+    end
+
+    def run_task(task, adapted: false)
+      puts("Running `#{task}` with #{adapted ? :new : :old} `#{Host.name}`...")
+      result = repo.bundle.exec(task, env: adapted ? adaptation_env : {})
+      result.success? or raise Error, Message.send(
+        adapted ? :broken_after_update : :broken,
+        repo: repo, task: task, output: result.stdout, error: result.stderr
+      )
+    end
+
+    def create_adapted_gemfile
+      content = File.exist?(gemfile_path) ? File.read(gemfile_path) : ''
+      adapted_content = adapt_gemfile_content(content)
+      File.open(adapted_gemfile_path, 'w') { |f| f.puts(adapted_content) }
+    end
+
+    def adapt_gemfile_content(content)
+      new_entry = "gem '#{Host.name}', path: '#{Host.root}' # set by gouteur "
+
+      existing_ref_pattern =
+        /^ *gem +(?<q>'|")#{Host.name}\k<q>(?<v> *,\s*(?<q2>'|")[^'"]+\k<q2>*)?/
+
+      if content =~ existing_ref_pattern
+        content.gsub(existing_ref_pattern) do
+          # keep version specification if there was one
+          new_entry.sub(/(?=, path:)/, Regexp.last_match[:v].to_s)
+        end
+      else
+        "#{content}\n#{new_entry}\n"
+      end
+    end
+
+    def gemfile_path
+      repo.bundle.gemfile_path
+    end
+
+    def adapted_gemfile_path
+      "#{repo.bundle.gemfile_path}.gouteur"
+    end
+
+    BUNDLER_INCOMPATIBLE_VERSION_CODE = 6
+    BUNDLER_GEM_NOT_FOUND_CODE        = 7 # includes some incompatibility cases
+
+    def install_adapted_bundle
+      result = repo.bundle.install(env: adaptation_env)
+
+      if result.success?
+        true
+      elsif result.exitstatus == BUNDLER_INCOMPATIBLE_VERSION_CODE ||
+            result.exitstatus == BUNDLER_GEM_NOT_FOUND_CODE &&
+            result.stderr =~ /following version/
+        if repo.locked?
+          raise Error,
+                Message.incompatible_failure(repo: repo, error: result.stderr)
+        else
+          false
+        end
+      else
+        raise Error, result.full_error
+      end
+    end
+
+    def adaptation_env
+      {
+        'BUNDLE_GEMFILE' => adapted_gemfile_path,
+        'SPEC_OPTS' => '--fail-fast', # saves time with rspec tasks
+      }
+    end
+
+    private
+
+    def puts(*args)
+      @silent ? nil : Kernel.puts(*args)
+    end
+  end
+end

data/lib/gouteur/cli.rb

@@ -0,0 +1,26 @@
+module Gouteur
+  # command line interface - prints to stdout and returns true or false
+  module CLI
+    module_function
+
+    def call(args = ARGV)
+      repos = pick_repos(args)
+      if repos.empty?
+        puts '', Message.no_repos, ''
+        return false
+      end
+
+      repos.all? do |repo|
+        success, message = Gouteur::Checker.call(repo)
+        puts '', message, ''
+        success
+      end
+    end
+
+    def pick_repos(args)
+      repos = args.map { |arg| Gouteur::Repo.new(uri: arg) }
+      repos = Dotfile.repos if repos.empty?
+      repos
+    end
+  end
+end

data/lib/gouteur/dotfile.rb

@@ -0,0 +1,23 @@
+module Gouteur
+  # interface for gouteur's configuration dotfile
+  module Dotfile
+    module_function
+
+    def present?
+      File.exist?(path)
+    end
+
+    def path
+      File.join(Host.root, '.gouteur.yml')
+    end
+
+    def content
+      @content ||=
+        present? ? YAML.safe_load(File.read(path), symbolize_names: true) : {}
+    end
+
+    def repos
+      (content[:repos] || []).map { |attrs| Gouteur::Repo.new(**attrs) }
+    end
+  end
+end

data/lib/gouteur/host.rb

@@ -0,0 +1,23 @@
+module Gouteur
+  # the gem/library/project under test
+  module Host
+    module_function
+
+    def name
+      gemspec.name || raise(Error, "No name set in `#{gemspec.loaded_from}`")
+    end
+
+    def gemspec
+      @gemspec ||= begin
+        gemspecs = Dir[File.join(root, '*.gemspec')]
+        (count = gemspecs.count) == 1 ||
+          raise(Error, "Found #{count} gemspecs, could not determine own name")
+        Bundler.load_gemspec(gemspecs.first)
+      end
+    end
+
+    def root
+      Bundler.root
+    end
+  end
+end

data/lib/gouteur/message.rb

@@ -0,0 +1,105 @@
+module Gouteur
+  # user-facing messages are here so they don't clutter the code
+  module Message
+    module_function
+
+    def shell_error(args:, pwd:, stderr:)
+      <<~MSG
+        👨‍🍳 Oh non!
+
+        The command `$ #{args.join(' ')}` failed in `#{pwd}`.
+        #{original_error_part(stderr)}
+      MSG
+    end
+
+    def success(repo:)
+      <<~MSG
+        👨‍🍳 Délicieux!
+
+        Your changes to `#{Host.name}` are fine for `#{repo}`. All tasks succeeded.
+      MSG
+    end
+
+    def no_repos
+      <<~MSG
+        👨‍🍳 Quoi?
+
+        Found no repos to test. Pass repo URIs as command line arguments or list them under `repos:` in `#{Dotfile.path}`.
+      MSG
+    end
+
+    def no_tasks(repo:)
+      <<~MSG
+        👨‍🍳 Quoi?
+
+        You have defined no tasks to run for `#{repo}`.
+      MSG
+    end
+
+    def no_dependence(repo:)
+      <<~MSG
+        👨‍🍳 Sacrebleu!
+
+        `#{Host.name}` is not listed in the Gemfile or gemspec of `#{repo}`. Hence it does not make sense to test changes against it.
+      MSG
+    end
+
+    def broken(repo:, task:, error:)
+      <<~MSG
+        👨‍🍳 Zut alors!
+
+        Task `#{task}` failed for `#{repo}` even before inserting the new code of `#{Host.name}`.
+
+        This likely means the task is broken or does not exist.
+        #{original_error_part(error)}
+      MSG
+    end
+
+    def broken_after_update(repo:, task:, output:, error:)
+      <<~MSG
+        👨‍🍳 Répugnant!
+
+        Task `#{task}` failed for `#{repo}` after inserting the new code of `#{Host.name}`.
+
+        This likely means you ruined it! (Or the task is not idempotent. Or this is a bug in gouteur.)
+        #{original_output_part(output)}
+        #{original_error_part(error)}
+      MSG
+    end
+
+    def skipped_incompatible(repo:)
+      <<~MSG
+        👨‍🍳 Attention!
+
+        The new version number of `#{Host.name}` is incompatible with the version requirements specified by `#{repo}`.
+
+        Releasing incompatible versions is considered OK by default, so tasks will be SKIPPED in this case. If you want gouteur to FAIL in this case, set the `locked` flag.
+      MSG
+    end
+
+    def incompatible_failure(repo:, error:)
+      <<~MSG
+        👨‍🍳 Zut alors!
+
+        The new version number of `#{Host.name}` is incompatible with the version requirements specified by `#{repo}`.
+
+        Incompatible version numbers can be allowed by removing the `locked` flag. This will make gouteur SKIP the tasks in this case.
+        #{original_error_part(error)}
+      MSG
+    end
+
+    def original_error_part(stderr)
+      msg = strip(stderr)
+      msg.empty? ? '' : "\n👇 The original error was:\n\n#{msg}"
+    end
+
+    def original_output_part(stdout)
+      msg = strip(stdout)
+      msg.empty? ? '' : "\n👇 The original output was:\n\n#{msg}"
+    end
+
+    def strip(string)
+      string.to_s.gsub(/\A\s+|\s+\z/, '')
+    end
+  end
+end

data/lib/gouteur/rake_task.rb

@@ -0,0 +1,26 @@
+# this file isn't required by default so rake isn't needed as runtime dependency
+
+require 'rake'
+require 'rake/tasklib'
+
+module Gouteur
+  # provides a custom rake task
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name
+
+    def initialize(name = :gouteur, *args)
+      super()
+
+      self.name = name
+
+      desc 'Run Gouteur' unless ::Rake.application.last_description
+      task(name, *args) do |_, task_args|
+        # lazy-load gouteur so that the task doesn't impact Rakefile load time
+        require 'gouteur'
+
+        success = Gouteur::CLI.call(task_args.extras)
+        success || abort('Gouteur failed!')
+      end
+    end
+  end
+end

data/lib/gouteur/repo.rb

@@ -0,0 +1,71 @@
+require 'uri'
+
+module Gouteur
+  # a repository of code that depends on the library under test
+  class Repo
+    attr_reader :uri, :name, :ref, :tasks
+    alias to_s name
+
+    def initialize(uri:, ref: nil, before: [], tasks: 'rake', locked: false)
+      @uri    = URI.parse(uri)
+      @name   = extract_name_from_uri(uri)
+      @ref    = ref
+      @before = Array(before)
+      @tasks  = Array(tasks)
+      @locked = !!locked
+    end
+
+    def fetch
+      cloned? ? pull : clone
+    end
+
+    def prepare
+      @before.each { |cmd| Shell.run!(cmd, pwd: clone_path) }
+    end
+
+    def remove
+      cloned? && Shell.run!(%W[rm -rf #{clone_path}])
+    end
+
+    def clone_path
+      File.join(store_dir, name)
+    end
+
+    def bundle
+      @bundle ||= Gouteur::Bundle.new(clone_path)
+    end
+
+    def locked?
+      @locked
+    end
+
+    private
+
+    def extract_name_from_uri(uri)
+      uri[%r{git(?:hub|lab)\.com/[^/]+/([^/]+)}, 1] ||
+        uri.split('/').last.to_s[/[a-z0-9\-_]+/i] ||
+        raise(Error, 'could not determine repository name from uri')
+    end
+
+    def cloned?
+      File.exist?(clone_path)
+    end
+
+    def pull
+      Shell.run!(%w[git fetch origin], pwd: clone_path)
+      Shell.run!(%w[git reset --hard --quiet], pwd: clone_path)
+      Shell.run!(%w[git clean -f -d -x], pwd: clone_path)
+      Shell.run!(%w[git pull --ff-only --quiet], pwd: clone_path)
+    end
+
+    def clone
+      Shell.run!(%W[mkdir -p #{store_dir}])
+      Shell.run!(%W[git clone --quiet #{uri} #{clone_path}])
+      Shell.run!(%W[git checkout #{ref}], pwd: clone_path) if ref
+    end
+
+    def store_dir
+      File.join(Host.root, 'tmp', 'gouteur_repos')
+    end
+  end
+end

data/lib/gouteur/shell.rb

@@ -0,0 +1,50 @@
+require 'open3'
+
+module Gouteur
+  # thin wrapper for Open3
+  module Shell
+    module_function
+
+    def run(args, pwd: Dir.pwd, env: {})
+      stdout, stderr, status = begin
+        Bundler.with_original_env { Open3.capture3(env, *args, chdir: pwd) }
+      rescue Errno::ENOENT => e
+        # bring errors such as "command not found: bundle" into the same form
+        ['', e.message, $?]
+      end
+
+      Result.new(
+        args: args, pwd: pwd, stdout: stdout, stderr: stderr, status: status
+      )
+    end
+
+    def run!(args, pwd: Dir.pwd, env: {})
+      result = run(args, pwd: pwd, env: env)
+      result.success? || raise(Error, result.full_error)
+      result
+    end
+
+    # return value object of Shell methods
+    class Result
+      attr_reader :stdout, :stderr, :exitstatus
+
+      def initialize(args:, pwd:, stdout:, stderr:, status:)
+        @args = args
+        @pwd = pwd
+        @stdout = stdout
+        @stderr = stderr
+        @exitstatus = status.exitstatus
+      end
+
+      def success?
+        exitstatus.zero?
+      end
+
+      def full_error
+        return nil if success?
+
+        Message.shell_error(args: @args, pwd: @pwd, stderr: stderr)
+      end
+    end
+  end
+end

data/lib/gouteur/version.rb

@@ -0,0 +1,3 @@
+module Gouteur
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: gouteur
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Janosch Müller
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-02-22 00:00:00.000000000 Z
+dependencies: []
+description: Run tests of dependent gems against your changes.
+email:
+- janosch84@gmail.com
+executables:
+- gouteur
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/build.yml"
+- ".github/workflows/lint.yml"
+- ".gitignore"
+- ".gouteur.yml"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/gouteur
+- gouteur.gemspec
+- lib/gouteur.rb
+- lib/gouteur/bundle.rb
+- lib/gouteur/checker.rb
+- lib/gouteur/cli.rb
+- lib/gouteur/dotfile.rb
+- lib/gouteur/host.rb
+- lib/gouteur/message.rb
+- lib/gouteur/rake_task.rb
+- lib/gouteur/repo.rb
+- lib/gouteur/shell.rb
+- lib/gouteur/version.rb
+homepage: https://github.com/jaynetics/gouteur
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jaynetics/gouteur
+  source_code_uri: https://github.com/jaynetics/gouteur
+  changelog_uri: https://github.com/jaynetics/gouteur/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: See if your lib is still digestible.
+test_files: []