gem-release 1.0.0 → 2.0.0.dev.1

data/lib/gem/release/templates/main.rb

@@ -0,0 +1 @@
+<%= define :module %>

data/lib/gem/release/templates/rspec/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--order rand

data/lib/gem/release/templates/rspec/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'lib/<%= gem_path %>'
+
+RSpec.configure do |c|
+end

data/lib/gem/release/templates/travis/.travis.yml

@@ -0,0 +1 @@
+language: ruby

data/lib/gem/release/templates/version.rb

@@ -0,0 +1 @@
+<%= define(:module) { "VERSION = '0.0.1'" } %>

data/lib/gem/release/version.rb

@@ -0,0 +1,5 @@
+module Gem
+  module Release
+    VERSION = '2.0.0.dev.1'
+  end
+end

data/lib/gem/release/version/number.rb

@@ -0,0 +1,102 @@
+module Gem
+  module Release
+    module Version
+      class Number < Struct.new(:number, :target)
+        NUMBER = /^(\d+)\.(\d+).(\d+).?(\w+)?.?(\d+)?$/
+
+        STAGES = %i(alpha beta pre rc)
+
+        def bump
+          return target if specific?
+          validate_stage
+          [major, minor, patch, stage, num].compact.join('.')
+        end
+
+        private
+
+          def specific?
+            target =~ NUMBER
+          end
+
+          def major
+            part = parts[0]
+            part += 1 if to?(:major)
+            part
+          end
+
+          def minor
+            part = parts[1]
+            part = 0 if to?(:major)
+            part += 1 if to?(:minor) || fresh_pre_release?
+            part
+          end
+
+          def patch
+            part = parts[2]
+            part = 0 if to?(:major, :minor) || fresh_pre_release?
+            part += 1 if to?(:patch) && from_release?
+            part
+          end
+
+          def stage
+            target unless to_release?
+          end
+
+          def num
+            return if to_release?
+            part = parts[4].to_i
+            part += 1 if from_release? || same_stage?
+            part
+          end
+
+          def to?(*targets)
+            targets.include?(target)
+          end
+
+          def to_release?
+            to?(:major, :minor, :patch)
+          end
+
+          def fresh_pre_release?
+            from_release? && to?(:pre, :rc)
+          end
+
+          def from_release?
+            !from_pre_release?
+          end
+
+          def from_pre_release?
+            !!from_stage
+          end
+
+          def same_stage?
+            from_stage == target
+          end
+
+          def from_stage
+            parts[3]
+          end
+
+          def target
+            super || (from_pre_release? ? from_stage : :patch)
+          end
+
+          def validate_stage
+            from, to = STAGES.index(from_stage), STAGES.index(target)
+            return unless from && to && from > to
+            raise Abort, "Cannot go from an #{from_stage} version to a #{target} version"
+          end
+
+          def parts
+            @parts ||= matches.compact.map(&:to_i).tap do |parts|
+              parts[3] = matches[3] && matches[3].to_sym
+            end
+          end
+
+          def matches
+            @matches ||= number.match(NUMBER).to_a[1..-1]
+          end
+      end
+    end
+  end
+end

data/lib/rubygems/commands/bootstrap_command.rb

@@ -1,96 +1,7 @@
-require 'rubygems/commands/gemspec_command'
-require 'core_ext/kernel/silence'
+require 'gem/release/support/gem_command'
+require 'gem/release/cmds/bootstrap'
 
 class Gem::Commands::BootstrapCommand < Gem::Command
-  include GemRelease, Gem::Commands
-  include Helpers, CommandOptions
-
-  DEFAULTS = {
-    :gemspec  => true,
-    :strategy => 'git',
-    :scaffold => true,
-    :github   => false,
-    :quiet    => false
-  }
-
-  attr_reader :arguments, :usage, :name
-
-  def initialize(options = {})
-    @name = 'bootstrap'
-    super @name, 'Bootstrap a new gem source repository', default_options_with(options)
-
-    option :gemspec,  '-g', 'Generate a .gemspec'
-    option :scaffold, '-s', 'Scaffold lib/[gem_name]/version.rb README test/'
-    option :strategy, '-f', 'Strategy for collecting files [glob|git] in .gemspec'
-    option :github,   '-h', 'Bootstrap a git repo, create on github and push'
-    option :quiet,    '-q', 'Do not output status messages'
-
-    @arguments = "gemname - option name of the gem, will use the current directory if not specified"
-    @usage = "#{program_name} [gemname]"
-  end
-
-  def execute
-    in_bootstrapped_dir do
-      write_scaffold if options[:scaffold]
-      write_gemspec  if options[:gemspec]
-      init_git       if options[:github] || options[:args] # safe to 'git init' in new dir
-      create_repo    if options[:github]
-    end
-
-    success
-  end
-
-  def write_gemspec
-    GemspecCommand.new(:quiet => quiet?, :strategy => options[:strategy], :quiet_success => true).execute
-  end
-
-  def write_scaffold
-    say 'scaffolding ...' unless quiet?
-
-    create_file Template.new('gitignore', :filename => '.gitignore')
-    create_file Template.new('README.md')
-    create_file Template.new('LICENSE', :year => Time.now.year, :author => user_name, :email => user_email)
-    create_file Template.new('Gemfile')
-    create_file Template.new('Rakefile')
-    create_file Template.new('test/test_helper.rb')
-    create_file VersionTemplate.new(options)
-  end
-
-  def create_lib
-    `mkdir -p lib test`
-  end
-
-  def create_file(template)
-    if File.exists?(template.filename)
-      say "Skipping #{template.filename}: already exists" unless quiet?
-    else
-      say "Creating #{template.filename}" unless quiet?
-      template.write
-    end
-  end
-
-  def init_git
-    say 'Initializing git repository'
-    `git init`
-  end
-
-  def create_repo
-    options = { :login => github_user, :token => github_token, :name  => gem_name }
-    options = options.map { |name, value| "-F '#{name}=#{value}'" }.join(' ')
-
-    say 'Staging files'
-    `git add .`
-
-    say 'Creating initial commit'
-    `git commit -m "initial commit"`
-
-    say "Adding remote origin git@github.com:#{github_user}/#{gem_name}.git"
-    `git remote add origin git@github.com:#{github_user}/#{gem_name}.git`
-
-    say 'Creating repository on Github'
-    silence { `curl #{options} http://github.com/api/v2/yaml/repos/create` }
-
-    say 'Pushing to Github'
-    `git push origin master`
-  end
+  include Gem::Release::GemCommand
+  self.cmd = :bootstrap
 end

data/lib/rubygems/commands/bump_command.rb

@@ -1,113 +1,7 @@
-require 'gem_release'
-require 'rubygems/commands/tag_command'
-require 'rubygems/commands/release_command'
-require 'shellwords'
+require 'gem/release/support/gem_command'
+require 'gem/release/cmds/bump'
 
 class Gem::Commands::BumpCommand < Gem::Command
-  include GemRelease, Gem::Commands
-  include Helpers, CommandOptions
-
-  attr_reader :arguments, :usage, :name
-
-  DEFAULTS = {
-    :version => '',
-    :commit  => true,
-    :push    => false,
-    :tag     => false,
-    :release => false,
-    :key     => '',
-    :host    => '',
-    :quiet   => false,
-    :destination  => "origin",
-  }
-
-  def initialize(options = {})
-    @name = 'bump'
-    super @name, 'Bump the gem version', default_options_with(options)
-
-    option :version,     '-v', 'Target version: next [major|minor|patch|pre|release] or a given version number [x.x.x]'
-    option :commit,      '-c', 'Perform a commit after incrementing gem version'
-    option :push,        '-p', 'Push to the git destination'
-    option :destination, '-d', 'destination git repository'
-    option :tag,         '-t', 'Create a git tag and push it to the git destination'
-    option :release,     '-r', 'Build gem from a gemspec and push to rubygems.org'
-    option :key,         '-k', 'When releasing: use the given API key from ~/.gem/credentials'
-    option :host,        '-h', 'When releasing: push to a gemcutter-compatible host other than rubygems.org'
-    option :quiet,       '-q', 'Do not output status messages'
-  end
-
-  def execute
-    @new_version_number = nil
-
-    tasks = [:commit, :push, :release, :tag]
-
-    # enforce option dependencies
-    options[:push] = true if options[:tag]
-    options[:commit] = options[:commit] || options[:push] || options[:tag] || options[:release]
-
-    in_gemspec_dirs do
-      run_cmd(:bump)
-    end
-
-    if @new_version_number == nil
-      say "No version files could be found, so no actions were performed." unless quiet?
-    else
-      tasks.each do |task|
-        run_cmd(task) if options[task]
-      end
-
-      success
-    end
-  end
-
-  protected
-
-    def bump
-      version = VersionFile.new(:target => (@new_version_number || options[:version]))
-      if File.exist?(version.filename)
-        @new_version_number ||= version.new_number
-        say "Bumping #{gem_name} from #{version.old_number} to version #{version.new_number}" unless quiet?
-        version.bump!
-        return system("git add #{escape(version.filename)}") if options[:commit]
-      else
-        say "Ignoring #{gem_name}. Version file #{version.filename} not found" unless quiet?
-      end
-      true
-    end
-
-    def escape(string)
-      Shellwords.escape(string)
-    end
-
-    def commit
-      say "Creating commit" unless quiet?
-      system("git commit -m \"Bump to #{@new_version_number}\"")
-    end
-
-    def push
-      destination = options[:destination]
-      say "Pushing to the #{destination} git repository" unless quiet?
-      system("git push #{destination}")
-    end
-
-    def release
-      cmd = ReleaseCommand.new
-      [:key, :host].each do |option|
-        cmd.options[option] = options[option]
-      end
-      cmd.options[:quiet] = options[:quiet]
-      cmd.options[:quiet_success] = true
-      cmd.execute
-      true
-    end
-
-    def tag
-      cmd = TagCommand.new
-      cmd.options[:quiet] = options[:quiet]
-      cmd.options[:quiet_success] = true
-      cmd.options[:push_tags_only] = true
-      cmd.options[:destination] = options[:destination]
-      cmd.execute
-      true
-    end
+  include Gem::Release::GemCommand
+  self.cmd = :bump
 end

data/lib/rubygems/commands/gemspec_command.rb

@@ -1,31 +1,7 @@
-class Gem::Commands::GemspecCommand < Gem::Command
-  include GemRelease
-  include Helpers, CommandOptions
-
-  DEFAULTS = {
-    :strategy => 'git',
-    :quiet    => false
-  }
-
-  attr_reader :arguments, :usage, :name
-
-  def initialize(options = {})
-    @name = 'bootstrap'
-    super @name, 'Bootstrap a new gem source repository', default_options_with(options)
+require 'gem/release/support/gem_command'
+require 'gem/release/cmds/gemspec'
 
-    option :strategy, '-f', 'Strategy for collecting files [glob|git] in .gemspec'
-    option :quiet,    '-q', 'Do not output status messages'
-  end
-
-  def execute
-    gemspec = GemspecTemplate.new(options)
-    if gemspec.exists?
-      say "Skipping #{gemspec.filename}: already exists" unless quiet?
-    else
-      say "Creating #{gemspec.filename}" unless quiet?
-      gemspec.write
-
-      success
-    end
-  end
+class Gem::Commands::GemspecCommand < Gem::Command
+  include Gem::Release::GemCommand
+  self.cmd = :gemspec
 end

data/lib/rubygems/commands/release_command.rb

@@ -1,73 +1,7 @@
-require 'rubygems/commands/build_command'
-require 'rubygems/commands/push_command'
-require 'rubygems/commands/tag_command'
+require 'gem/release/support/gem_command'
+require 'gem/release/cmds/release'
 
 class Gem::Commands::ReleaseCommand < Gem::Command
-  include GemRelease, Gem::Commands
-  include Helpers, CommandOptions
-
-  DEFAULTS = {
-    :tag         => false,
-    :quiet       => false,
-    :key         => '',
-    :host        => '',
-    :destination => "origin",
-  }
-
-  attr_reader :arguments, :usage, :name
-
-  def initialize(options = {})
-    @name = 'release'
-    super @name, 'Build gem from a gemspec and push to rubygems.org', default_options_with(options)
-
-    option :tag,         '-t', 'Create a git tag and push it to the destination'
-    option :destination, '-d', 'Destination git repository'
-    option :quiet,       '-q', 'Do not output status messages'
-    option :key,         '-k', 'Use the given API key from ~/.gem/credentials'
-    option :host,        '-h', 'Push to a gemcutter-compatible host other than rubygems.org'
-
-    @arguments = "gemspec - optional gemspec file name, will use the first *.gemspec if not specified"
-    @usage = "#{program_name} [gemspec]"
-  end
-
-  def execute
-    tasks = [:build, :push, :cleanup]
-    tasks.push(:tag) if options[:tag]
-
-    in_gemspec_dirs do
-      tasks.each do |task|
-        run_cmd(task)
-      end
-    end
-
-    success
-  end
-
-  protected
-
-    def build
-      BuildCommand.new.invoke(gemspec_filename)
-      true
-    end
-
-    def push
-      args = []
-      [:key, :host].each do |option|
-        args += ["--#{option}", options[option]] unless options[option] == ''
-      end
-      args += "--quiet" if quiet?
-
-      PushCommand.new.invoke(gem_filename, *args)
-      true
-    end
-
-    def cleanup
-      say "Deleting left over gem file #{gem_filename}" unless quiet?
-      system("rm #{gem_filename}")
-    end
-
-    def tag
-      TagCommand.new(:quiet => quiet?, :quiet_success => true).invoke
-      true
-    end
+  include Gem::Release::GemCommand
+  self.cmd = :release
 end