In Files

  • bundler/cli/gem.rb

Parent

Methods

Class/Module Index [+]

Quicksearch

Bundler::CLI::Gem

Attributes

gem_name[R]
name[R]
options[R]
target[R]
thor[R]

Public Class Methods

new(options, gem_name, thor) click to toggle source
 
               # File bundler/cli/gem.rb, line 20
def initialize(options, gem_name, thor)
  @options = options
  @gem_name = resolve_name(gem_name)

  @thor = thor
  thor.behavior = :invoke
  thor.destination_root = nil

  @name = @gem_name
  @target = SharedHelpers.pwd.join(gem_name)

  validate_ext_name if options[:ext]
end
            

Public Instance Methods

run() click to toggle source
 
               # File bundler/cli/gem.rb, line 34
def run
  Bundler.ui.confirm "Creating gem '#{name}'..."

  underscored_name = name.tr("-", "_")
  namespaced_path = name.tr("-", "/")
  constant_name = name.gsub(/-[_-]*(?![_-]|$)/) { "::" }.gsub(/([_-]+|(::)|^)(.|$)/) { $2.to_s + $3.upcase }
  constant_array = constant_name.split("::")

  use_git = Bundler.git_present? && options[:git]

  git_author_name = use_git ? %x`git config user.name`.chomp : ""
  github_username = use_git ? %x`git config github.user`.chomp : ""
  git_user_email = use_git ? %x`git config user.email`.chomp : ""

  config = {
    :name             => name,
    :underscored_name => underscored_name,
    :namespaced_path  => namespaced_path,
    :makefile_path    => "#{underscored_name}/#{underscored_name}",
    :constant_name    => constant_name,
    :constant_array   => constant_array,
    :author           => git_author_name.empty? ? "TODO: Write your name" : git_author_name,
    :email            => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
    :test             => options[:test],
    :ext              => options[:ext],
    :exe              => options[:exe],
    :bundler_version  => bundler_dependency_version,
    :git              => use_git,
    :github_username  => github_username.empty? ? "[USERNAME]" : github_username,
    :required_ruby_version => Gem.ruby_version < Gem::Version.new("2.4.a") ? "2.3.0" : "2.4.0",
  }
  ensure_safe_gem_name(name, constant_array)

  templates = {
    "#{Bundler.preferred_gemfile_name}.tt" => Bundler.preferred_gemfile_name,
    "lib/newgem.rb.tt" => "lib/#{namespaced_path}.rb",
    "lib/newgem/version.rb.tt" => "lib/#{namespaced_path}/version.rb",
    "newgem.gemspec.tt" => "#{name}.gemspec",
    "Rakefile.tt" => "Rakefile",
    "README.md.tt" => "README.md",
    "bin/console.tt" => "bin/console",
    "bin/setup.tt" => "bin/setup",
  }

  executables = %w[
    bin/console
    bin/setup
  ]

  templates.merge!("gitignore.tt" => ".gitignore") if use_git

  if test_framework = ask_and_set_test_framework
    config[:test] = test_framework
    config[:test_framework_version] = TEST_FRAMEWORK_VERSIONS[test_framework]

    case test_framework
    when "rspec"
      templates.merge!(
        "rspec.tt" => ".rspec",
        "spec/spec_helper.rb.tt" => "spec/spec_helper.rb",
        "spec/newgem_spec.rb.tt" => "spec/#{namespaced_path}_spec.rb"
      )
      config[:test_task] = :spec
    when "minitest"
      templates.merge!(
        "test/minitest/test_helper.rb.tt" => "test/test_helper.rb",
        "test/minitest/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
      )
      config[:test_task] = :test
    when "test-unit"
      templates.merge!(
        "test/test-unit/test_helper.rb.tt" => "test/test_helper.rb",
        "test/test-unit/newgem_test.rb.tt" => "test/#{namespaced_path}_test.rb"
      )
      config[:test_task] = :test
    end
  end

  config[:ci] = ask_and_set_ci
  case config[:ci]
  when "github"
    templates.merge!("github/workflows/main.yml.tt" => ".github/workflows/main.yml")
  when "travis"
    templates.merge!("travis.yml.tt" => ".travis.yml")
  when "gitlab"
    templates.merge!("gitlab-ci.yml.tt" => ".gitlab-ci.yml")
  when "circle"
    templates.merge!("circleci/config.yml.tt" => ".circleci/config.yml")
  end

  if ask_and_set(:mit, "Do you want to license your code permissively under the MIT license?",
    "This means that any other developer or company will be legally allowed to use your code "          "for free as long as they admit you created it. You can read more about the MIT license "          "at https://choosealicense.com/licenses/mit.")
    config[:mit] = true
    Bundler.ui.info "MIT License enabled in config"
    templates.merge!("LICENSE.txt.tt" => "LICENSE.txt")
  end

  if ask_and_set(:coc, "Do you want to include a code of conduct in gems you generate?",
    "Codes of conduct can increase contributions to your project by contributors who "          "prefer collaborative, safe spaces. You can read more about the code of conduct at "          "contributor-covenant.org. Having a code of conduct means agreeing to the responsibility "          "of enforcing it, so be sure that you are prepared to do that. Be sure that your email "          "address is specified as a contact in the generated code of conduct so that people know "          "who to contact in case of a violation. For suggestions about "          "how to enforce codes of conduct, see https://bit.ly/coc-enforcement.")
    config[:coc] = true
    Bundler.ui.info "Code of conduct enabled in config"
    templates.merge!("CODE_OF_CONDUCT.md.tt" => "CODE_OF_CONDUCT.md")
  end

  if ask_and_set(:changelog, "Do you want to include a changelog?",
    "A changelog is a file which contains a curated, chronologically ordered list of notable "          "changes for each version of a project. To make it easier for users and contributors to"          " see precisely what notable changes have been made between each release (or version) of"          " the project. Whether consumers or developers, the end users of software are"          " human beings who care about what's in the software. When the software changes, people "          "want to know why and how. see https://keepachangelog.com")
    config[:changelog] = true
    Bundler.ui.info "Changelog enabled in config"
    templates.merge!("CHANGELOG.md.tt" => "CHANGELOG.md")
  end

  if ask_and_set(:rubocop, "Do you want to add rubocop as a dependency for gems you generate?",
    "RuboCop is a static code analyzer that has out-of-the-box rules for many "          "of the guidelines in the community style guide. "          "For more information, see the RuboCop docs (https://docs.rubocop.org/en/stable/) "          "and the Ruby Style Guides (https://github.com/rubocop-hq/ruby-style-guide).")
    config[:rubocop] = true
    config[:rubocop_version] = Gem.ruby_version < Gem::Version.new("2.4.a") ? "0.81.0" : "1.7"
    Bundler.ui.info "RuboCop enabled in config"
    templates.merge!("rubocop.yml.tt" => ".rubocop.yml")
  end

  templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]

  if options[:ext]
    templates.merge!(
      "ext/newgem/extconf.rb.tt" => "ext/#{name}/extconf.rb",
      "ext/newgem/newgem.h.tt" => "ext/#{name}/#{underscored_name}.h",
      "ext/newgem/newgem.c.tt" => "ext/#{name}/#{underscored_name}.c"
    )
  end

  if File.exist?(target) && !File.directory?(target)
    Bundler.ui.error "Couldn't create a new gem named `#{gem_name}` because there's an existing file named `#{gem_name}`."
    exit Bundler::BundlerError.all_errors[Bundler::GenericSystemCallError]
  end

  if use_git
    Bundler.ui.info "Initializing git repo in #{target}"
    %x`git init #{target}`

    config[:git_default_branch] = File.read("#{target}/.git/HEAD").split("/").last.chomp
  end

  templates.each do |src, dst|
    destination = target.join(dst)
    thor.template("newgem/#{src}", destination, config)
  end

  executables.each do |file|
    path = target.join(file)
    executable = (path.stat.mode | 0o111)
    path.chmod(executable)
  end

  if use_git
    Dir.chdir(target) do
      %x`git add .`
    end
  end

  # Open gemspec in editor
  open_editor(options["edit"], target.join("#{name}.gemspec")) if options[:edit]

  Bundler.ui.info "Gem '#{name}' was successfully created. "          "For more information on making a RubyGem visit https://bundler.io/guides/creating_gem.html"
end