Download a Git repo without .git folder

Question

Coming from Python, JavaScript and PHP, I'd like to learn to write Ruby in the way it's "supposed to". Well-written Python code is called "Pythonic", so I'd like to know how idiomatic my Ruby code is.

I've had great help from Rubocop, slapping my face if I didn't write properly, but I still feel some things can be done better.

Application

This set of scripts downloads a github/gitlab/bitbucket repository, removes the .git folder and moves it to the specified folder, so that the files are "de-git".

Some commands:

# Run tests (for regexes)
./degit.rb --test

# Extract repo to folder with repo name
./degit.rb zpqrtbnk/test-repo

# Extract tag/branch of repo to folder with repo name
./degit.rb zpqrtbnk/test-repo#temp

# Extract repo to specified folder
./degit.rb zpqrtbnk/test-repo some-folder

Code

Ruby v2.4.5
Idea came from degit by Rich Harris

degit.rb

#!/usr/bin/env ruby

require "tmpdir"

require_relative "repo"
require_relative "repo_type"

REPO_TYPES = {
  github: RepoType.new("github", "https://github.com", "github.com"),
  gitlab: RepoType.new("gitlab", "https://gitlab.com", "gitlab.com"),
  bitbucket: RepoType.new("bitbucket", "https://bitbucket.org", "bitbucket.org"),
  custom: RepoType.new("custom", :custom, :custom),
}.freeze

# TODO: Error handling
def main
  repo_name = ARGV[0]
  folder_name = ARGV[1]
  raise "Required parameter repo name not specified" if repo_name.nil?

  if repo_name == "--test"
    require_relative "tests"
    run_tests
    return
  end

  degit repo_name, folder_name
end

def temp_dir
  dir = Dir.mktmpdir("degit-", "/tmp")
  at_exit { FileUtils.remove_entry(dir) }
  dir
end

def degit(repo_name, folder_name)
  repo = Repo.new repo_name
  folder_name ||= repo.name
  dest_dir = File.join Dir.pwd, folder_name
  dir_exists = Dir.exist? dest_dir
  if dir_exists
    abort "Aborted" unless confirm_overwrite dest_dir
  end

  dir = temp_dir
  tmp_repo_path = File.join(dir, folder_name)
  cmd = repo.download_command tmp_repo_path
  puts `#{cmd}`
  FileUtils.remove_entry File.join(tmp_repo_path, ".git")
  FileUtils.remove_entry dest_dir if dir_exists
  FileUtils.mv(tmp_repo_path, Dir.pwd, force: true)
end

def confirm_overwrite(dest_dir)
  print "Destination folder #{dest_dir} already exists. Overwrite folder? [y/n] "
  # ARGV interferes with gets, so use STDIN.gets
  input = STDIN.gets.chomp.downcase
  return (input == "y") if %w[y n].include? input

  # Continue to ask until input is either y or n
  confirm_overwrite dest_dir
end

main if $PROGRAM_NAME == __FILE__

repo_type.rb

class RepoType
  attr_reader :name, :full_url

  def initialize(name, full_url, base_url, short_code=nil)
    @name = name
    @full_url = full_url
    @base_url = base_url
    @short_code = short_code || name.to_s.downcase
  end

  def id?(id)
    [@short_code, @base_url].include? id
  end
end

repo.rb

class Repo
  attr_reader :type, :tag, :name

  PREFIX_REGEX = %r{
    \A
    ((?<type>github|gitlab|bitbucket):)?
    (?<owner>[\w-]+)/(?<name>[\w-]+)
    (\#(?<tag>[\w\-\.]+))?
    \z
  }xi.freeze

  SSH_REGEX = %r{
    \A
    (?<source_url>
      git@(?<type>github\.com|gitlab\.com|bitbucket\.org):
      (?<owner>[\w-]+)/(?<name>[\w-]+)
      (\.git)?
    )
    (\#(?<tag>[\w\-\.]+))?
    \z
  }xi.freeze

  HTTPS_REGEX = %r{
    \A
    (?<source_url>
      https://(?<type>github\.com|gitlab\.com|bitbucket\.org)/
      (?<owner>[\w-]+)/(?<name>[\w-]+)
    )
    (\#(?<tag>[\w\-\.]+))?
    \z
  }xi.freeze

  def initialize(uri)
    @uri = uri

    raise "Required constant REPO_TYPES not defined" unless defined? REPO_TYPES

    parse_uri
    # debug unless @source_url.nil?
  end

  def valid_uri?
    @uri.end_with?(".git") || @uri.include?("/")
  end

  def parse_uri
    if @uri.end_with? ".git"
      @type = REPO_TYPES[:custom]
      return
    end

    repo = match_repo_info
    return nil if repo.nil?

    @owner = repo[:owner]
    @name = repo[:name]
    @tag = repo[:tag]
    @source_url = make_source_url repo
  end

  def match_repo_info
    [PREFIX_REGEX, SSH_REGEX, HTTPS_REGEX].each do |regex|
      repo_matches = regex.match @uri
      unless repo_matches.nil?
        @type = find_repo_type repo_matches[:type]
        return repo_matches
      end
    end

    nil
  end

  def find_repo_type(type)
    REPO_TYPES.each do |_, repo_type|
      return repo_type if repo_type.id? type
    end

    REPO_TYPES[:github]
  end

  def make_source_url(repo)
    return repo[:source_url] if repo.names.include? "source_url"

    source_url = @type.full_url || @uri
    "#{source_url}/#{@owner}/#{@name}"
  end

  def download_command(output_folder=nil)
    tag_spec = @tag.nil? ? "" : "--branch #{@tag}"
    parts = [
      "git clone --quiet --depth 1",
      tag_spec,
      @source_url,
      output_folder || @name,
    ]
    parts.join " "
  end

  def debug
    puts ""
    puts "source_url:   #{@source_url}" unless @source_url.nil?
    puts "owner:        #{@owner}" unless @owner.nil?
    puts "name:         #{@name}" unless @name.nil?
    puts "tag:          #{@tag}" unless @tag.nil?
    puts "download cmd: #{download_command}"
  end
end

tests.rb

VALID = %w[
  user1/repo1

  github:user2/repo2
  [email protected]:user3/repo3
  https://github.com/rmccue/test-repository

  gitlab:user5/repo5
  [email protected]:user6/repo6
  https://gitlab.com/user7/repo7

  bitbucket:user8/repo8
  [email protected]:user9/repo9
  https://bitbucket.org/user0/repo0
].freeze

INVALID = %w[
  http://github.com/user1/repo1
  https://github.com/user2
  https://github.comuser3/repo3
].freeze

WITH_TAG = %w[
  user1/repo1#dev
  user2/repo2#v1.2.3
  user3/repo3#1234abcd
].freeze

WITH_GIT_SUFFIX = %w[
  https://github.com/Rich-Harris/degit.git
  user@host:~/repos/website.nl.git
].freeze

def pf(str)
  print str
  $stdout.flush
end

def run_tests
  pf "          VALID: "
  VALID.each do |r|
    pf "."
    repo = Repo.new r
    raise "#{r} isn't valid" if repo.type.nil?
  end
  puts ""

  pf "        INVALID: "
  INVALID.each do |r|
    pf "."
    repo = Repo.new r
    raise "#{r} isn't invalid" unless repo.type.nil?
  end
  puts ""

  pf "       WITH_TAG: "
  WITH_TAG.each do |r|
    pf "."
    repo = Repo.new r
    raise "#{r} isn't valid" if repo.type.nil?
    raise "#{r} has no tag" if repo.tag.nil?
  end
  puts ""

  pf "WITH_GIT_SUFFIX: "
  WITH_GIT_SUFFIX.each do |r|
    pf "."
    repo = Repo.new r
    raise "#{r} isn't valid" if repo.type.nil?
  end
  puts ""
end

Answer 1

Ruby does not have an import system like python, so variables and methods at the top level like REPO_TYPES and temp_dir are effectively global variables and methods.

Use modules to aggressively namespace, even for your main, especially when a small script begins to span more than one file:

module Degit
  def self.main # define singleton method
  end
end

Degit.main # call singleton method

This is also true for methods as well. def self.main in the example defines a singleton method on Degit itself. (Degit is a singleton in the sense that it will be the only instance of Module named "Degit", and main is a method it will now have).

Ruby classes operate in the same way:

class Foo
  class << self # opens singleton context
    def foo # also defines a singleton method
    end
  end
end

On another note, I feel like RepoType should either be:

• completely removed and its responsibilities handled by Repo

Or

• named Host and be more cohesive by owning variables and methods REPO_TYPE and find_repo_type within it, along with the regex definitions associated with each Host

Here's an example combining what I've outlined above:

class Host
  HOST_DEFN = {
    github:    'github.com',
    gitlab:    'gitlab.com',
    bitbucket: 'bitbucket.org',
  }

  attr_reader :name, :hostname

  def initialize(name, hostname)
    @name = name
    @hostname = hostname
  end

  def match?(uri)
    regexes.each_value.any? do |regex|
      regex.match?(uri)
    end
  end

  private

  def regexes
    {
      ssh:   /ssh #{hostname} ssh/,
      https: /https #{hostname} https/,
    }
  end

  class << self
    def hosts
      @hosts ||= HOST_DEFN.map { |name, hostname| [name, new(name, hostname)] }.to_h
    end

    def matching_uri(uri)
      hosts.each_value.detect { |host| host.match?(uri) }
    end
  end
end

# usage

Host.hosts[:github]           # => #<Host:0x00007fd95c48b5d8 @hostname="github.com", @name=:github>

uri = 'https gitlab.com https'
Host.matching_uri(uri)        # => #<Host:0x00007fd95c462c00 @hostname="gitlab.com", @name=:gitlab>