gemma 4.1.0 → 5.0.0

data/template/base/{Rakefile.rb.erb → Rakefile.erb}

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler/setup'
 require 'gemma'
 
 Gemma::RakeTasks.with_gemspec_file '<%= gem_name %>.gemspec'
 
-task :default => :test
+task default: :test

data/template/base/gem_name.gemspec.erb

@@ -1,29 +1,27 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
- 
-require '<%= gem_name %>/version'
- 
+# frozen_string_literal: true
+
+require_relative 'lib/<%= gem_name %>/version'
+
 Gem::Specification.new do |s|
-  s.name              = '<%= gem_name %>'
-  s.version           = <%= module_name %>::VERSION
-  s.platform          = Gem::Platform::RUBY
-  s.authors           = ['TODO write your name']
-  s.email             = ['TODO write your e-mail address']
-  s.homepage          = 'TODO homepage'
-  s.summary           = %q{TODO write short gem summary}
-  s.description       = %q{TODO write longer gem description}
+  s.name        = '<%= gem_name %>'
+  s.version     = <%= module_name %>::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['TODO write your name']
+  s.email       = ['TODO write your e-mail address']
+  s.homepage    = 'TODO homepage'
+  s.summary     = %(TODO write short gem summary)
+  s.description = %(TODO write longer gem description)
 
-  #s.add_runtime_dependency '...', '~> x.y.z'
+  # s.add_runtime_dependency '...', '~> x.y.z'
   s.add_development_dependency 'gemma', '~> <%= Gemma::VERSION %>'
 
-  s.files       = Dir.glob('{lib,bin}/**/*.rb') + %w(README.rdoc)
+  s.files       = Dir.glob('{lib,bin}/**/*.rb') + %w(README.md)
   s.test_files  = Dir.glob('test/<%= gem_name %>/*_test.rb')
-  s.executables = Dir.glob('bin/*').map{|f| File.basename(f)}
+  s.executables = Dir.glob('bin/*').map { |f| File.basename(f) }
 
   s.rdoc_options = [
-    "--main",    "README.rdoc",
-    "--title",   "#{s.full_name} Documentation"]
-  s.extra_rdoc_files << "README.rdoc"
+    '--main',    'README.md',
+    '--title',   "#{s.full_name} Documentation"
+  ]
+  s.extra_rdoc_files << 'README.md'
 end
-

data/template/base/lib/gem_name.rb.erb

@@ -1,5 +1,10 @@
-require '<%= gem_name %>/version'
+# frozen_string_literal: true
 
+require_relative '<%= gem_name %>/version'
+
+#
+# TODO: write documentation for main class / module
+#
 module <%= module_name %>
-  # TODO write code 
+  # TODO: write code
 end

data/template/base/lib/gem_name/version.rb.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module <%= module_name %>
   VERSION_MAJOR = 0
   VERSION_MINOR = 0

data/template/executable/bin/gem_name.erb

@@ -1,6 +1,6 @@
 #!/usr/bin/env <%= RbConfig::CONFIG['ruby_install_name'] %>
+# frozen_string_literal: true
 
 require '<%= gem_name %>'
 
-abort "TODO write program code"
-
+abort 'TODO write program code'

data/template/minitest/test/gem_name/gem_name_test.rb.erb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require '<%= gem_name %>'
 require 'minitest/autorun'
 
 class Test<%= module_name %> < MiniTest::Test
   def test_<%= gem_name %>
-    assert_equal 3, 1 + 1, "TODO write tests"
+    assert_equal 3, 1 + 1, 'TODO write tests'
   end
 end
-

data/test/gemma/gem_from_template_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gemma/test_helper'
 require 'tmpdir'
 
@@ -18,29 +19,30 @@ class Gemma::GemFromTemplateTest < MiniTest::Test
     # basic create-from-template tests
     #
     gt = Gemma::GemFromTemplate.new
-    gt.gem_name = "my_new_gem"
+    gt.gem_name = 'my_new_gem'
     assert gt.good_gem_name?
 
-    assert_equal "MyNewGem", gt.module_name
-    gt.module_name = "Foo" # override default
-    assert_equal "Foo", gt.module_name
+    assert_equal 'MyNewGem', gt.module_name
+    gt.module_name = 'Foo' # override default
+    assert_equal 'Foo', gt.module_name
     gt.module_name = nil # revert back to default
-    assert_equal "MyNewGem", gt.module_name
+    assert_equal 'MyNewGem', gt.module_name
 
-    assert_equal "my_new_gem", gt.dir_name
-    gt.dir_name = "bar" # override default
-    assert_equal "bar", gt.dir_name
+    assert_equal 'my_new_gem', gt.dir_name
+    gt.dir_name = 'bar' # override default
+    assert_equal 'bar', gt.dir_name
     gt.dir_name = nil # revert back to default
-    assert_equal "my_new_gem", gt.dir_name
+    assert_equal 'my_new_gem', gt.dir_name
 
-    template_paths = Gemma::GemFromTemplate::BUILTIN_TEMPLATES.map{|path|
-      File.join(Gemma::GemFromTemplate::TEMPLATE_ROOT,path)}
+    template_paths = Gemma::GemFromTemplate::BUILTIN_TEMPLATES.map do |path|
+      File.join(Gemma::GemFromTemplate::TEMPLATE_ROOT, path)
+    end
     assert_equal 'base', File.basename(template_paths.first)
 
-    gt.dir_name = "my_new_gem_base"
+    gt.dir_name = 'my_new_gem_base'
     gt.create_gem template_paths[0..0] # just base
 
-    gt.dir_name = "my_new_gem_full"
+    gt.dir_name = 'my_new_gem_full'
     gt.create_gem template_paths # expand all templates
   end
 
@@ -49,16 +51,16 @@ class Gemma::GemFromTemplateTest < MiniTest::Test
     # we should be able to find the to-do markers in a newly created gem
     #
     gt = Gemma::GemFromTemplate.new
-    gt.gem_name = "test_gem"
+    gt.gem_name = 'test_gem'
 
-    template_paths = Gemma::GemFromTemplate::BUILTIN_TEMPLATES.map{|path|
-      File.join(Gemma::GemFromTemplate::TEMPLATE_ROOT,path)}
+    template_paths = Gemma::GemFromTemplate::BUILTIN_TEMPLATES.map do |path|
+      File.join(Gemma::GemFromTemplate::TEMPLATE_ROOT, path)
+    end
     gt.create_gem template_paths
 
     # look for some to-do markers
     io = StringIO.new
     Gemma::Utility.rgrep(/TODO/, gt.destination_path, io)
-    assert io.string =~ /README\.rdoc/
+    assert io.string =~ /README\.md/
   end
 end
-

data/test/gemma/gemma_new_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gemma/test_helper'
 require 'tmpdir'
 require 'open4'
@@ -20,13 +21,9 @@ class Gemma::GemmaNewTest < MiniTest::Test
   # stdout and stderr using Open4. (On 1.9.2, we can use <tt>Open3.popen2e</tt>,
   # which is nicer, but Open3 on ruby 1.8.7 doesn't let us get exitstatus.)
   #
-  def run_cmd *args
-    Bundler.with_clean_env {
-      # FIXME in bundler 1.1, this should not be necessary; see
-      # https://github.com/carlhuda/bundler/issues/1133
-      ENV.delete_if { |k,_| k[0,7] == 'BUNDLE_' }
-
-      # We also have to clear RUBYOPT, because Bundler::ORIGINAL_ENV in the test
+  def run_cmd(*args)
+    Bundler.with_clean_env do
+      # We have to clear RUBYOPT, because Bundler::ORIGINAL_ENV in the test
       # runner's process still contains some bundler stuff from rake's process.
       # This suggests that we might have to stop using rake's built-in TestTask,
       # and instead use one that runs the tests in a Bundler.with_clean_env
@@ -35,12 +32,12 @@ class Gemma::GemmaNewTest < MiniTest::Test
       ENV.delete('RUBYOPT')
 
       output = nil
-      status = Open4.popen4(*args) {|pid,i,o,e|
+      status = Open4.popen4(*args) do |_pid, i, o, e|
         i.close
         output = o.read + e.read
-      }
+      end
       [status, output]
-    }
+    end
   end
 
   def setup
@@ -52,32 +49,39 @@ class Gemma::GemmaNewTest < MiniTest::Test
     # create a test gem; note that here we DO want the gemma bundler
     # environment, because it puts our gemma executable on the bin path
     output = `gemma new --name="test_gem"`
-    raise "gemma new failed:\n#{output}" unless $?.exitstatus
+    raise "gemma new failed:\n#{output}" unless $CHILD_STATUS.exitstatus
 
     # we should get some TODOs from the template in the output
-    assert_match /TODO write your name/, output
+    assert_match(/TODO write your name/, output)
 
     Dir.chdir('test_gem')
 
     # edit the test gem's Gemfile to point to this gemma
-    raise "no Gemfile in test gem" unless File.exists?('Gemfile')
+    raise 'no Gemfile in test gem' unless File.exist?('Gemfile')
     File.open('Gemfile', 'a') do |f|
       f.puts "gem 'gemma', :path => #{@old_pwd.dump}"
     end
 
+    # bundler will complain if we don't fill in the TODOs
+    gemspec_name = 'test_gem.gemspec'
+    gemspec = File.read(gemspec_name)
+    gemspec.gsub!(/TODO\s*/, '')
+    gemspec.gsub!(/'homepage'/, "'http://example.com'")
+    File.open(gemspec_name, 'w') { |f| f.puts gemspec }
+
     # run bundler on the test gem; it should find the same gems that we're using
     # in the gemma bundle
     status, output = run_cmd('bundle', 'install', '--local')
-    raise "bundle failed:\n#{output}" unless status.exitstatus == 0
+    raise "bundle failed:\n#{output}" unless status.exitstatus.zero?
 
     # it should say that it has loaded two things from source: gemma and the
     # test_gem itself; if it doesn't it indicates that something strange
     # happened with bundler's environment (or it may just break on future
     # versions of bundler)
-    raise "did not load from source" unless output =~ /from source at/
+    raise 'did not load from source' unless output =~ /from source at/
 
     # bundler should produce a lock file
-    raise "no Gemfile.lock in test gem" unless File.exists?('Gemfile.lock')
+    raise 'no Gemfile.lock in test gem' unless File.exist?('Gemfile.lock')
   end
 
   def teardown
@@ -89,27 +93,25 @@ class Gemma::GemmaNewTest < MiniTest::Test
     # list the rake tasks; this ensures that gemma loaded
     status, output = run_cmd('rake -T')
     assert_equal 0, status.exitstatus
-    assert_match /rake test/, output
-    assert_match /rake rdoc/, output
-    assert_match /rake yard/, output
+    assert_match(/rake test/, output)
+    assert_match(/rake rdoc/, output)
+    assert_match(/rake yard/, output)
 
     # run the tests; they should fail initially
     status, output = run_cmd('rake')
-    assert status.exitstatus != 0
-    assert_match /TODO write tests/, output
+    assert status.exitstatus.nonzero?
+    assert_match(/TODO write tests/, output)
 
     # generate rdoc output
-    status, output = run_cmd('rake rdoc')
+    status, _output = run_cmd('rake rdoc')
     assert_equal 0, status.exitstatus
 
     # generate yard output
-    status, output = run_cmd('rake yard')
+    status, _output = run_cmd('rake yard')
     assert_equal 0, status.exitstatus
 
-    # build the gem; this should fail, because we have invalid authors, etc.
-    status, output = run_cmd('rake build')
-    assert_match /TODO/, output # "... is not a valid author"
-    assert_equal 1, status.exitstatus
+    # build the gem
+    status, _output = run_cmd('rake build')
+    assert_equal 0, status.exitstatus
   end
 end
-

data/test/gemma/gemma_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gemma/test_helper'
 require 'set'
 
@@ -19,7 +20,7 @@ class Gemma::GemmaTest < MiniTest::Test
       assert_equal %w(lib FAQ README.md).to_set, g.rdoc.files.to_set
       assert_equal [], g.rdoc.options
       assert_equal 'README.md', g.rdoc.main
-      assert_equal nil, g.rdoc.title
+      assert_nil g.rdoc.title
 
       g.rdoc.with_rdoc_task do |rd|
         assert_equal rd.rdoc_files, g.rdoc.files
@@ -44,14 +45,16 @@ class Gemma::GemmaTest < MiniTest::Test
       assert_equal [], g.yard.options
       assert_equal 'yard', g.yard.output
       assert_equal :yard, g.yard.task_name
-      assert_equal nil, g.yard.title
+      assert_nil g.yard.title
 
       g.yard.with_yardoc_task do |yd|
         assert_equal %w(lib), yd.files
         assert_equal 4, yd.options.size
-        assert_equal 'README.rdoc',
+        assert_equal \
+          'README.rdoc',
           Gemma::Options.extract(%w(--main), yd.options).argument
-        assert_equal 'yard',
+        assert_equal \
+          'yard',
           Gemma::Options.extract(%w(--output), yd.options).argument
       end
     end
@@ -83,8 +86,10 @@ class Gemma::GemmaTest < MiniTest::Test
 
     # Some more complicated options.
     # Note that we ignore things that could be files ('bat').
-    s.rdoc_options = ['foo bar', '--baz', 'bat', '--title', 'a b c',
-      '--diagram', '--main', 'README.rdoc', 'ABCD']
+    s.rdoc_options = [
+      'foo bar', '--baz', 'bat', '--title', 'a b c', '--diagram', '--main',
+      'README.rdoc', 'ABCD'
+    ]
     Gemma::RakeTasks.new(s) do |g|
       assert_equal 'a b c', g.yard.title
       assert_equal [], g.yard.options
@@ -92,11 +97,14 @@ class Gemma::GemmaTest < MiniTest::Test
       g.yard.with_yardoc_task do |yd|
         assert_equal %w(lib - FAQ), yd.files
         assert_equal 6, yd.options.size
-        assert_equal 'README.rdoc',
+        assert_equal \
+          'README.rdoc',
           Gemma::Options.extract(%w(--main), yd.options).argument
-        assert_equal 'yard',
+        assert_equal \
+          'yard',
           Gemma::Options.extract(%w(--output), yd.options).argument
-        assert_equal 'a b c',
+        assert_equal \
+          'a b c',
           Gemma::Options.extract(%w(--title), yd.options).argument
       end
     end
@@ -115,33 +123,37 @@ class Gemma::GemmaTest < MiniTest::Test
     Gemma::RakeTasks.new(s) do |g|
       g.test.with_test_task do |tt|
         assert_equal %w(lib foo test).to_set, tt.libs.to_set
-        assert_equal %w(test/test_a.rb test/test_b.rb).to_set,
+        assert_equal \
+          %w(test/test_a.rb test/test_b.rb).to_set,
           tt.file_list.to_a.to_set
       end
     end
   end
 
   def test_conventions_good_gem_name
-    assert  Gemma::Conventions.good_gem_name?("my_gem_name")
-    assert  Gemma::Conventions.good_gem_name?("my-gem-name")
-    assert  Gemma::Conventions.good_gem_name?("foo")
-    assert  Gemma::Conventions.good_gem_name?("foo1")
-    assert  Gemma::Conventions.good_gem_name?("foo_4_bar")
-    assert !Gemma::Conventions.good_gem_name?("Foo")
-    assert !Gemma::Conventions.good_gem_name?("FooBar")
-    assert !Gemma::Conventions.good_gem_name?("Foo_Bar")
-    assert !Gemma::Conventions.good_gem_name?("Foo-Bar")
+    assert  Gemma::Conventions.good_gem_name?('my_gem_name')
+    assert  Gemma::Conventions.good_gem_name?('my-gem-name')
+    assert  Gemma::Conventions.good_gem_name?('foo')
+    assert  Gemma::Conventions.good_gem_name?('foo1')
+    assert  Gemma::Conventions.good_gem_name?('foo_4_bar')
+    assert !Gemma::Conventions.good_gem_name?('Foo')
+    assert !Gemma::Conventions.good_gem_name?('FooBar')
+    assert !Gemma::Conventions.good_gem_name?('Foo_Bar')
+    assert !Gemma::Conventions.good_gem_name?('Foo-Bar')
   end
 
   def test_conventions_gem_name_to_module_name
-    assert_equal 'MyGem',
-      Gemma::Conventions.gem_name_to_module_name("my_gem")
-    assert_equal 'MyGem3',
-      Gemma::Conventions.gem_name_to_module_name("my_gem3")
-    assert_equal 'A4B',
-      Gemma::Conventions.gem_name_to_module_name("a_4_b")
-    assert_equal 'A4b',
-      Gemma::Conventions.gem_name_to_module_name("a4b")
+    assert_equal \
+      'MyGem', Gemma::Conventions.gem_name_to_module_name('my_gem')
+    assert_equal \
+      'MyGem3',
+      Gemma::Conventions.gem_name_to_module_name('my_gem3')
+    assert_equal \
+      'A4B',
+      Gemma::Conventions.gem_name_to_module_name('a_4_b')
+    assert_equal \
+      'A4b',
+      Gemma::Conventions.gem_name_to_module_name('a4b')
   end
 
   #
@@ -157,9 +169,8 @@ class Gemma::GemmaTest < MiniTest::Test
   def test_plugin_abstract
     s = Gem::Specification.new
     plugin = Gemma::RakeTasks::Plugin.new(s)
-    assert_raises(NotImplementedError) {
+    assert_raises(NotImplementedError) do
       plugin.create_rake_tasks # abstract method
-    }
+    end
   end
 end
-

data/test/gemma/options_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'gemma/test_helper'
 
 class OptionsTest < MiniTest::Test
@@ -5,7 +6,8 @@ class OptionsTest < MiniTest::Test
 
   def test_empty
     # empty input
-    assert_equal Options::ExtractResult.new(nil, []),
+    assert_equal \
+      Options::ExtractResult.new(nil, []),
       Options.extract(%w(--a), [])
   end
 
@@ -13,87 +15,108 @@ class OptionsTest < MiniTest::Test
     input = %w(--a av --b --c=cv)
 
     # option a has an argument
-    assert_equal Options::ExtractResult.new('av', %w(--b --c=cv)),
+    assert_equal \
+      Options::ExtractResult.new('av', %w(--b --c=cv)),
       Options.extract(%w(--a), input)
 
     # option b has no argument; result is ''
-    assert_equal Options::ExtractResult.new('', %w(--a av --c=cv)),
+    assert_equal \
+      Options::ExtractResult.new('', %w(--a av --c=cv)),
       Options.extract(%w(--b), input)
 
     # option c also has argument
-    assert_equal Options::ExtractResult.new('cv', %w(--a av --b)),
+    assert_equal \
+      Options::ExtractResult.new('cv', %w(--a av --b)),
       Options.extract(%w(--c), input)
 
     # there is no option d; result is nil
-    assert_equal Options::ExtractResult.new(nil, input),
+    assert_equal \
+      Options::ExtractResult.new(nil, input),
       Options.extract(%w(--d), input)
   end
 
   def test_terminator
     # just the -- terminator
-    assert_equal Options::ExtractResult.new(nil, ['--']),
+    assert_equal \
+      Options::ExtractResult.new(nil, ['--']),
       Options.extract(%w(--a), ['--'])
 
     # should keep content before and after the -- terminator
-    assert_equal Options::ExtractResult.new(nil, %w(a -- b)),
+    assert_equal \
+      Options::ExtractResult.new(nil, %w(a -- b)),
       Options.extract(%w(--a), %w(a -- b))
   end
 
   def test_terminator_2
-    input = %w(foo --a av  -- --b bv)
+    input = %w(foo --a av -- --b bv)
 
     # should not be able to find options after the -- terminator
-    assert_equal Options::ExtractResult.new('av', %w(foo -- --b bv)),
+    assert_equal \
+      Options::ExtractResult.new('av', %w(foo -- --b bv)),
       Options.extract(%w(--a), input)
-    assert_equal Options::ExtractResult.new(nil, input),
+    assert_equal \
+      Options::ExtractResult.new(nil, input),
       Options.extract(%w(--b), input)
-    assert_equal Options::ExtractResult.new('', %w(-- --b)),
+    assert_equal \
+      Options::ExtractResult.new('', %w(-- --b)),
       Options.extract(%w(--a), %w(--a -- --b))
-    assert_equal Options::ExtractResult.new(nil, %w(--a -- --b)),
+    assert_equal \
+      Options::ExtractResult.new(nil, %w(--a -- --b)),
       Options.extract(%w(--b), %w(--a -- --b))
   end
 
   def test_short_form
     # should be able to find -a but not -b
-    input = %w(foo -a av  -- -b bv)
-    assert_equal Options::ExtractResult.new('av', %w(foo -- -b bv)),
+    input = %w(foo -a av -- -b bv)
+    assert_equal \
+      Options::ExtractResult.new('av', %w(foo -- -b bv)),
       Options.extract(%w(-a), input)
-    assert_equal Options::ExtractResult.new(nil, input),
+    assert_equal \
+      Options::ExtractResult.new(nil, input),
       Options.extract(%w(-b), input)
 
     # the -aav and -b bv forms
     input = %w(-aav -b bv)
-    assert_equal Options::ExtractResult.new('av', %w(-b bv)),
+    assert_equal \
+      Options::ExtractResult.new('av', %w(-b bv)),
       Options.extract(%w(-a), input)
-    assert_equal Options::ExtractResult.new('bv', %w(-aav)),
+    assert_equal \
+      Options::ExtractResult.new('bv', %w(-aav)),
       Options.extract(%w(-b), input)
 
     # short form with no argument
-    assert_equal Options::ExtractResult.new('', %w(-a av)),
+    assert_equal \
+      Options::ExtractResult.new('', %w(-a av)),
       Options.extract(%w(-b), %w(-a av -b))
 
     # missing short form argument
-    assert_equal Options::ExtractResult.new(nil, %w(-a av -b foo bar.txt)),
+    assert_equal \
+      Options::ExtractResult.new(nil, %w(-a av -b foo bar.txt)),
       Options.extract(%w(-c), %w(-a av -b foo bar.txt))
   end
 
   def test_multiple_options
     # single -a means we pick up a1
-    assert_equal Options::ExtractResult.new('a1', []),
+    assert_equal \
+      Options::ExtractResult.new('a1', []),
       Options.extract(%w(-a), %w(-a a1))
 
     # the second -a means that we pick up a2
-    assert_equal Options::ExtractResult.new('a2', []),
+    assert_equal \
+      Options::ExtractResult.new('a2', []),
       Options.extract(%w(-a), %w(-a a1 -a a2))
-    assert_equal Options::ExtractResult.new('a2', %w(hi -bfoo)),
+    assert_equal \
+      Options::ExtractResult.new('a2', %w(hi -bfoo)),
       Options.extract(%w(-a), %w(hi -a a1 -a a2 -bfoo))
 
     # mixing long and short forms doesn't affect this
-    assert_equal Options::ExtractResult.new('a2', []),
+    assert_equal \
+      Options::ExtractResult.new('a2', []),
       Options.extract(%w(-a --a), %w(-a a1 --a a2))
 
     # a duplicate option after the -- terminator makes no difference
-    assert_equal Options::ExtractResult.new('a1', %w(-- -aa2)),
+    assert_equal \
+      Options::ExtractResult.new('a1', %w(-- -aa2)),
       Options.extract(%w(-a), %w(-a a1 -- -aa2))
   end
 end