jeweler 0.10.2

data/test/test_helper.rb

@@ -0,0 +1,118 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'shoulda'
+begin
+  require 'ruby-debug' 
+rescue LoadError
+end
+require 'rr'
+require 'time'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'jeweler'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'shoulda_macros/jeweler_macros'
+
+# Use vendored gem because of limited gem availability on runcoderun
+# This is loosely based on 'vendor everything'.
+Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', '**')].each do |dir|
+  lib = "#{dir}/lib"
+  $LOAD_PATH.unshift(lib) if File.directory?(lib)
+end
+
+class RubyForgeStub
+  attr_accessor :userconfig, :autoconfig
+  
+  def initialize
+    @userconfig = {}
+    @autoconfig = {}
+  end
+end
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
+
+  def fixture_dir
+    File.join(File.dirname(__FILE__), 'fixtures', 'bar')
+  end
+
+  def tmp_dir
+    File.join(File.dirname(__FILE__), 'tmp')
+  end
+
+  def build_spec(*files)
+    Gem::Specification.new do |s|
+      s.name = "bar"
+      s.summary = "Simple and opinionated helper for creating Rubygem projects on GitHub"
+      s.email = "josh@technicalpickles.com"
+      s.homepage = "http://github.com/technicalpickles/jeweler"
+      s.description = "Simple and opinionated helper for creating Rubygem projects on GitHub"
+      s.authors = ["Josh Nichols"]
+      s.files = FileList[*files] unless files.empty?
+    end
+  end
+
+  def self.rubyforge_command_context(description, &block)
+    context description do
+      setup do
+        @command = eval(self.class.name.gsub(/::Test/, '::')).new
+
+        if @command.respond_to? :gemspec=
+          @gemspec = Object.new
+          @command.gemspec = @gemspec
+        end
+
+        if @command.respond_to? :gemspec_helper=
+          @gemspec_helper = Object.new
+          @command.gemspec_helper = @gemspec_helper
+        end
+
+        if @command.respond_to? :rubyforge=
+          @rubyforge = RubyForgeStub.new
+          @command.rubyforge = @rubyforge
+        end
+
+        if @command.respond_to? :output
+          @output = StringIO.new
+          @command.output = @output
+        end
+      end
+
+      context "", &block
+    end
+  end
+
+  def self.build_command_context(description, &block)
+    context description do
+      setup do
+
+        @repo           = Object.new
+        @version_helper = Object.new
+        @gemspec        = Object.new
+        @commit         = Object.new
+        @version        = Object.new
+        @output         = Object.new
+        @base_dir       = Object.new
+        @gemspec_helper = Object.new
+        @rubyforge      = Object.new
+
+        @jeweler        = Object.new
+
+        stub(@jeweler).repo           { @repo }
+        stub(@jeweler).version_helper { @version_helper }
+        stub(@jeweler).gemspec        { @gemspec }
+        stub(@jeweler).commit         { @commit }
+        stub(@jeweler).version        { @version }
+        stub(@jeweler).output         { @output }
+        stub(@jeweler).gemspec_helper { @gemspec_helper }
+        stub(@jeweler).base_dir       { @base_dir }
+        stub(@jeweler).rubyforge    { @rubyforge }
+      end
+
+      context "", &block
+    end
+
+  end
+end

data/test/test_jeweler.rb

@@ -0,0 +1,177 @@
+require 'test_helper'
+
+class TestJeweler < Test::Unit::TestCase
+
+  def build_jeweler(base_dir = nil)
+    base_dir ||= non_git_dir_path
+
+    Jeweler.new(build_spec, base_dir)
+  end
+
+  def git_dir_path
+    File.join(tmp_dir, 'git')
+  end
+
+  def non_git_dir_path
+    File.join(tmp_dir, 'nongit')
+  end
+
+  def build_git_dir
+    return_to = Dir.pwd
+
+    FileUtils.mkdir_p git_dir_path
+    begin
+      Dir.chdir git_dir_path
+      Git.init
+    ensure
+      Dir.chdir return_to
+    end
+  end
+
+  def build_non_git_dir
+    FileUtils.mkdir_p non_git_dir_path
+  end
+
+  should "raise an error if a nil gemspec is given" do
+    assert_raises Jeweler::GemspecError do
+      Jeweler.new(nil)
+    end
+  end
+
+  should "know if it is in a git repo" do
+    build_git_dir
+
+    assert build_jeweler(git_dir_path).in_git_repo?
+  end
+
+  should "know if it is not in a git repo" do
+    build_non_git_dir
+
+    jeweler = build_jeweler(non_git_dir_path)
+    assert ! jeweler.in_git_repo?, "jeweler doesn't know that #{jeweler.base_dir} is not a git repository"
+  end
+
+  should "build and run write gemspec command when writing gemspec" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::WriteGemspec).build_for(jeweler) { command }
+
+    jeweler.write_gemspec
+  end
+
+  should "build and run validate gemspec command when validating gemspec" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::ValidateGemspec).build_for(jeweler) { command }
+
+    jeweler.validate_gemspec
+  end
+
+  should "build and run build gem command when building gem" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::BuildGem).build_for(jeweler) { command }
+
+    jeweler.build_gem
+  end
+
+  should "build and run build gem command when installing gem" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::InstallGem).build_for(jeweler) { command }
+
+    jeweler.install_gem
+  end
+
+  should "build and run bump major version command when bumping major version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Version::BumpMajor).build_for(jeweler) { command }
+
+    jeweler.bump_major_version
+  end
+
+  should "build and run bump minor version command when bumping minor version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Version::BumpMinor).build_for(jeweler) { command }
+
+    jeweler.bump_minor_version
+  end
+
+  should "build and run write version command when writing version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+    mock(command).major=(1)
+    mock(command).minor=(5)
+    mock(command).patch=(2)
+
+    mock(Jeweler::Commands::Version::Write).build_for(jeweler) { command }
+
+    jeweler.write_version(1, 5, 2)
+  end
+
+  should "build and run release command when running release" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Release).build_for(jeweler) { command }
+
+    jeweler.release
+  end
+
+  should "build and run release to rubyforge command when running release to rubyforge" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::ReleaseToRubyforge).build_for(jeweler) { command }
+
+    jeweler.release_gem_to_rubyforge
+  end
+
+
+  should "respond to gemspec_helper" do
+    assert_respond_to build_jeweler, :gemspec_helper
+  end
+
+  should "respond to version_helper" do
+    assert_respond_to build_jeweler, :version_helper
+  end
+
+  should "respond to repo" do
+    assert_respond_to build_jeweler, :repo
+  end
+
+  should "respond to commit" do
+    assert_respond_to build_jeweler, :commit
+  end
+
+  should "respond to rubyforge" do
+    assert_respond_to build_jeweler, :rubyforge
+  end
+
+end

data/test/test_options.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class TestOptions < Test::Unit::TestCase
+
+  def self.should_have_testing_framework(testing_framework)
+    should "use #{testing_framework} for testing" do
+      assert_equal testing_framework.to_sym, @options[:testing_framework]
+    end
+  end
+
+  def setup_options(*arguments)
+    @options = Jeweler::Generator::Options.new(arguments)
+  end
+
+  def self.for_options(*options)
+    context options.join(' ') do
+      setup { setup_options *options }
+      yield
+    end
+  end
+
+  context "default options" do
+    setup { setup_options }
+    should_have_testing_framework :shoulda
+    should 'not create repository' do
+      assert ! @options[:create_repo]
+    end
+  end
+
+  for_options '--shoulda' do
+    should_have_testing_framework :shoulda
+  end
+
+  for_options "--bacon" do
+    should_have_testing_framework :bacon
+  end
+
+  for_options "--testunit" do
+    should_have_testing_framework :testunit
+  end
+
+  for_options '--minitest' do
+    should_have_testing_framework :minitest
+  end
+
+  for_options '--rspec' do
+    should_have_testing_framework :rspec
+  end
+
+  for_options '--micronaut' do
+    should_have_testing_framework :micronaut
+  end
+
+  for_options '--cucumber' do
+    should 'enable cucumber' do
+      assert_equal true, @options[:use_cucumber]
+    end
+  end
+
+  for_options '--create-repo' do
+    should 'create repository' do
+      assert @options[:create_repo]
+    end
+  end
+
+  for_options '--rubyforge' do
+    should 'enable rubyforge' do
+      assert @options[:rubyforge]
+    end
+  end
+
+  for_options '--summary', 'zomg so awesome' do
+    should 'have summary zomg so awesome' do
+      assert_equal 'zomg so awesome', @options[:summary]
+    end
+  end
+
+  for_options '--directory', 'foo' do
+    should 'have directory foo' do
+      assert_equal 'foo', @options[:directory]
+    end
+  end
+
+  for_options '--help' do
+    should 'show help' do
+      assert @options[:show_help]
+    end
+  end
+
+  for_options '-h' do
+    should 'show help' do
+      assert @options[:show_help]
+    end
+  end
+
+end

data/test/test_tasks.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+require 'rake'
+class TestTasks < Test::Unit::TestCase
+  include Rake
+
+  context 'instantiating Jeweler::Tasks' do
+    setup do
+      Task.clear
+
+      @jt = Jeweler::Tasks.new do |s|
+      end
+    end
+
+    should 'assign @gemspec' do
+      assert_not_nil @jt.gemspec
+    end
+
+    should 'assign @jeweler' do
+      assert_not_nil @jt.jeweler
+    end
+
+    should 'define tasks' do
+      assert Task.task_defined?(:build)
+      assert Task.task_defined?(:install)
+      assert Task.task_defined?(:gemspec)
+      assert Task.task_defined?(:build)
+      assert Task.task_defined?(:install)
+      assert Task.task_defined?(:'gemspec:validate')
+      assert Task.task_defined?(:'gemspec:generate')
+      assert Task.task_defined?(:version)
+      assert Task.task_defined?(:'version:write')
+      assert Task.task_defined?(:'version:bump:major')
+      assert Task.task_defined?(:'version:bump:minor')
+      assert Task.task_defined?(:'version:bump:patch')
+      assert Task.task_defined?(:'release')
+      assert Task.task_defined?(:'rubyforge:release:gem')
+      assert Task.task_defined?(:'rubyforge:setup')
+    end
+  end
+end

data/test/test_version_helper.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+class TestVersionHelper < Test::Unit::TestCase
+
+  VERSION_TMP_DIR = File.dirname(__FILE__) + '/version_tmp'
+
+  def self.should_have_version(major, minor, patch)
+    should "have major version #{major}" do
+      assert_equal major, @version_helper.major
+    end
+
+    should "have minor version #{minor}" do
+      assert_equal minor, @version_helper.minor
+    end
+
+    should "have patch version #{patch}" do
+      assert_equal patch, @version_helper.patch
+    end
+
+    version_s = "#{major}.#{minor}.#{patch}"
+    should "render string as #{version_s.inspect}" do
+      assert_equal version_s, @version_helper.to_s
+    end
+
+    version_hash = {:major => major, :minor => minor, :patch => patch}
+    should "render hash as #{version_hash.inspect}" do
+      assert_equal version_hash, @version_helper.to_hash
+    end
+    
+  end
+
+  context "VERSION.yml with 3.5.4" do
+    setup do
+      FileUtils.rm_rf VERSION_TMP_DIR
+      FileUtils.mkdir_p VERSION_TMP_DIR
+
+      build_version_yml VERSION_TMP_DIR, 3, 5, 4
+
+      @version_helper = Jeweler::VersionHelper.new VERSION_TMP_DIR
+    end
+
+    should_have_version 3, 5, 4
+
+    context "bumping major version" do
+      setup { @version_helper.bump_major }
+      should_have_version 4, 0, 0
+    end
+
+    context "bumping the minor version" do
+      setup { @version_helper.bump_minor }
+      should_have_version 3, 6, 0
+    end
+
+    context "bumping the patch version" do
+      setup { @version_helper.bump_patch }
+      should_have_version 3, 5, 5
+    end
+  end
+
+  context "Non-existant VERSION.yml" do
+    setup do
+      FileUtils.rm_rf VERSION_TMP_DIR
+      FileUtils.mkdir_p VERSION_TMP_DIR
+    end
+
+    should "not raise error if the VERSION.yml doesn't exist" do
+      assert_nothing_raised Jeweler::VersionYmlError do
+        Jeweler::VersionHelper.new(VERSION_TMP_DIR)
+      end
+    end
+
+    context "setting an initial version" do
+      setup do
+        @version_helper = Jeweler::VersionHelper.new(VERSION_TMP_DIR)
+        @version_helper.update_to 0, 0, 1
+      end
+
+      should_have_version 0, 0, 1
+      should "not create VERSION.yml" do
+        assert ! File.exists?(File.join(VERSION_TMP_DIR, 'VERSION.yml'))
+      end
+
+      context "outputting" do
+        setup do
+          @version_helper.write
+        end
+
+        should "create VERSION.yml" do
+          assert File.exists?(File.join(VERSION_TMP_DIR, 'VERSION.yml'))
+        end
+
+        context "re-reading VERSION.yml" do
+          setup do
+            @version_helper = Jeweler::VersionHelper.new(VERSION_TMP_DIR)
+          end
+
+          should_have_version 0, 0, 1
+        end
+      end
+    end
+  end
+
+  def build_version_yml(base_dir, major, minor, patch)
+    version_yaml_path = File.join(base_dir, 'VERSION.yml')
+
+    File.open(version_yaml_path, 'w+') do |f|
+      version_hash = {
+        'major' => major.to_i,
+        'minor' => minor.to_i,
+        'patch' => patch.to_i
+      }
+      YAML.dump(version_hash, f)
+    end
+  end
+end