releasetool 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b0af76c63ee063f38c88599f766cb05f3d139e2048a7e694175778c5f84c43f
+  data.tar.gz: e145cda46f5b692a06ad962c4642636d57c5f86a68f9b5d275b418128edf035a
+SHA512:
+  metadata.gz: ed316d721bfebcd8a7e5a3bc7f0c43d866634ce4ffd3f8e9e00b66ac5004bfcc38a0d88c23c327a245b7a6a60da3592ad83bd7a9af96a80d71afcd679d712b6c
+  data.tar.gz: 0d6652d10950881d889ac7e3ddd7d10fca6c312e1868ce2882eb97ddab068f59633339187e577634b23e22e1e1a05a7ee3977f1480bf20996adaf7c77f68f579

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/spec/fixtures/example_with_releases

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in releasetool.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tim Diggins
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# Releasetool
+
+We use this tool to create releases and their documentation.
+It makes versioned/numbered deployments easier to track.
+Would possibly be nice if there was an engine to display the release notes in a rails app as well.
+
+Not quite one-click release, but getting there...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'releasetool'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install releasetool
+
+## Usage
+
+### List existing tags
+
+```release list```
+
+### Start the release -- generate release notes and update version file
+
+```release start```
+
+This will start a new patch verison, but you can start minor or major 
+
+```release start --minor```
+
+```release start --major```
+
+Or you can specify the new verison. 
+
+```release start NEW_VERSION```
+
+All of these will use the most recent tag as the previous version. If you don't have a most recent tag, or you want to start from something else use:
+
+```release start -s PREVIOUS_VERSION NEW_VERSION```
+
+Now edit the created release notes (release_notes/NEW_VERSION.md)
+
+### Commit release notes
+
+```release commit```
+
+Currently this also commits config/initializers/00-version.rb as this is handy for our rails  projects. Might move this out into a config (or make check for the existings of , but only if need this to span non-rails projects.
+
+### Create a named tag (for later reference using release list)
+
+```release tag```
+
+It will ask for a one-line summary of the release (full details are in the release notes)
+
+### Push commits and tag
+
+```release push```
+
+
+## Testing
+
+The tests work on a known-good repo stored in `spec/fixtures/example_with_releases.tar`. To recreate this:
+```
+cd spec/fixtures/example_with_releases && tar -xvf ../example_with_releases.tar  && cd -
+```
+
+then you can tweak it and save it back with:
+```
+cd spec/fixtures/example_with_releases && tar -cvf ../example_with_releases.tar . && cd -
+```
+
+## Configuration
+
+If you want it to automatically update the version number in a string then set the environment variable
+ `RELEASETOOL_VERSION_FILE`, eg. `export RELEASETOOL_VERSION_FILE=./lib/releasetool.rb`. By default this is configured to config/initializers/00-version.rb (useful for rails projects).
+
+
+## Contributing
+
+see testing above
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+For releasing the releasetool itself we need to set an environment variable `export RELEASETOOL_VERSION_FILE=./lib/releasetool/version.rb`

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/release

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+require File.expand_path('../lib/tasks/release_thor.rb', File.dirname(__FILE__))
+
+Release.start

data/lib/releasetool.rb

@@ -0,0 +1,5 @@
+require "releasetool/release"
+
+module Releasetool
+  VERSION = "0.2.0"
+end

data/lib/releasetool/release.rb

@@ -0,0 +1,81 @@
+require "releasetool/util"
+
+module Releasetool
+  class Release
+    include Releasetool::Util
+
+    def initialize(version, previous:)
+      raise "Version must be a Releasetool::Version" unless version.is_a?(Releasetool::Version)
+      if previous
+        raise "Previous must be nil or a Releasetool::Version" unless version.is_a?(Releasetool::Version)
+      end
+      @version = version
+      @previous = previous
+    end
+
+    def prepare(edit: false)
+      puts headers
+      commits = `git log #{@previous}..HEAD --pretty=format:"- %B"`
+      notes = commits.gsub("\n\n", "\n")
+      notes_file = "#{DIR}/#{@version}.md"
+      if File.exists?(notes_file)
+        puts "-"*80
+        puts " File '#{notes_file}' already exists (appending)"
+        puts "-"*80
+        File.open(notes_file, 'a') do |f|
+          f.puts("\n\nAPPENDED:\n\n")
+          f.puts(notes)
+        end
+      else
+        ensure_dir
+        File.open(notes_file, 'w') do |f|
+          f.puts(headers)
+          f.puts(notes)
+        end
+        puts "written to #{notes_file}"
+        if edit
+          system("open #{notes_file}")
+        end
+      end
+      if File.exists?(VERSION_FILE)
+        from_version = @previous.to_s_without_v
+        to_version = @version.to_s_without_v
+        guarded_system("cat #{VERSION_FILE} | sed s/#{from_version}/#{to_version.gsub('.', '\.')}/ > #{VERSION_FILE}.tmp")
+        guarded_system("mv #{VERSION_FILE}.tmp #{VERSION_FILE}")
+      end
+    end
+
+    private
+
+    def ensure_dir
+      Dir.mkdir(DIR) unless File.exists?(DIR)
+    end
+
+    def headers
+      @headers ||= template.gsub("$VERSION", @version.to_s).gsub("$PREVIOUS", @previous.to_s)
+    end
+
+    def template
+      File.read(ensured_template_file)
+    end
+
+    def ensured_template_file
+      ensure_dir
+      template_file = "#{DIR}/#{TEMPLATE_FILE}"
+      create_template_file(template_file) unless File.exists?(template_file)
+      template_file
+    end
+
+    def create_template_file(template_file)
+      File.open(template_file, "w") do |f|
+        f.write <<~FILEEND
+        $VERSION Release Notes
+        
+        *Changes since $PREVIOUS*
+
+        FILEEND
+      end
+    end
+
+  end
+end

data/lib/releasetool/util.rb

@@ -0,0 +1,23 @@
+module Releasetool
+  module Util
+
+    DIR = "release_notes"
+    VERSION_FILE = ENV['RELEASETOOL_VERSION_FILE'] || "config/initializers/00-version.rb" #rails out of box
+    TEMPLATE_FILE = "__TEMPLATE__.md" # relative to DIR
+    RELEASE_MARKER_FILE = ".RELEASE_NEW_VERSION" # should be a config var
+
+    def stored_version
+      fail Thor::Error.new("No stored version... did you forget to do release start?") unless File.exist?(RELEASE_MARKER_FILE)
+      File.read(RELEASE_MARKER_FILE).strip
+    end
+
+    def remove_stored_version
+      guarded_system("rm #{RELEASE_MARKER_FILE}") if File.exist?(RELEASE_MARKER_FILE)
+    end
+
+    def guarded_system(command)
+      puts command
+      system(command) or raise Thor::Error.new("Couldn't '#{command}'")
+    end
+  end
+end

data/lib/releasetool/version.rb

@@ -0,0 +1,55 @@
+module Releasetool
+  class Version
+    attr_reader :ident
+    def initialize(ident)
+      raise "Not a valid version identifier: #{ident.inspect}" unless ident.is_a?(String)
+      @ident = ident
+    end
+
+    def next_patch
+      self.class.normalized(segments[0], segments[1], incremented(segments[2]))
+    end
+
+    def next_minor
+      self.class.normalized(segments[0], incremented(segments[1]), 0)
+    end
+
+    def next_major
+      self.class.normalized(incremented(segments[0]), 0, 0)
+    end
+
+    def to_s
+      if @ident[0] == "v"
+        @ident
+      else
+        "v#{@ident}"
+      end
+    end
+
+    def to_s_without_v
+      if @ident[0] == "v"
+        @ident[1..-1]
+      else
+        @ident
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Releasetool::Version) && ident == other.ident
+    end
+
+    def self.normalized(major, minor, patch)
+      new("v#{major}.#{minor}.#{patch}")
+    end
+
+    private
+    def incremented(v)
+      raise "Can't work out next version from #{self}" unless v.to_i.to_s == v
+      v.to_i + 1
+    end
+
+    def segments
+      @segments ||= to_s_without_v.split(".")
+    end
+  end
+end

data/lib/tasks/release_thor.rb

@@ -0,0 +1,119 @@
+require 'thor'
+require "releasetool/release"
+require "releasetool/util"
+require "releasetool/version"
+
+class Release < Thor
+
+  include Releasetool::Util
+  desc "list", <<-END
+    show a list of tags ordered by date (just a git listing).
+  END
+
+  def list
+    system("git for-each-ref --sort='*authordate' --format='%(taggerdate:short) | %(tag) | %(contents)' refs/tags")
+  end
+
+  # ========================
+
+  desc "latest", <<-END
+    output the latest version (tag)
+  END
+
+  def latest
+    puts previous_version
+  end
+
+  # ========================
+
+  desc "log", <<-END
+    output the latest version (tag)
+  END
+
+  def log(*args)
+    extra = " #{args.join(" ")}" if args.length > 0
+    guarded_system("git log #{previous_version}..#{extra}")
+  end
+
+  # ========================
+
+  method_option :since, type: :string, desc: "since commit_ref (or will use most recent tag)", required: false,
+    aliases: 's'
+  method_option :edit, type: :boolean, desc: "edit", required: false, aliases: 'e'
+  method_option :minor, type: :boolean, desc: "minor version", required: false, default: false
+
+  desc "start (NEW_VERSION)", <<-END
+    Start a release by doing a prepare, and storing the target release in #{RELEASE_MARKER_FILE}.
+  END
+
+  def start(specified_version=nil)
+    if File.exists?(RELEASE_MARKER_FILE)
+      raise Thor::Error.new("Can't start when already started on a version. release abort or release finish")
+    end
+    version = next_version(specified_version)
+    File.open(RELEASE_MARKER_FILE, 'w') do |f|
+      f.write(version)
+    end
+    Releasetool::Release.new(version, previous: previous_version).prepare(edit: options[:edit])
+  end
+
+  DEFAULT_COMMIT_MESSAGE = 'preparing for release [CI SKIP]'
+  desc "commit (NEW_VERSION)", <<-END
+      Commit release and version identifier to git with message '#{DEFAULT_COMMIT_MESSAGE}'.
+      If no version given, it will use the version stored by release start
+  END
+
+  def commit(version=nil)
+    version ||= stored_version
+    guarded_system("git add #{DIR}")
+    guarded_system("git add #{VERSION_FILE}") if File.exists?(VERSION_FILE)
+    guarded_system("git commit #{DIR} #{File.exists?(VERSION_FILE) ? VERSION_FILE : ''} -e -m\"#{DEFAULT_COMMIT_MESSAGE}\"")
+  end
+
+  desc "tag (NEW_VERSION)", <<-END
+      Tag release.
+      If no version given, it will use the version stored by release start
+  END
+
+  def tag(version=nil)
+    version ||= stored_version
+    guarded_system("git tag -a #{version}")
+  end
+
+  desc "push (NEW_VERSION)", <<-END
+      pushes current branch and tag
+      If no version given, it will use the version stored by release start.
+  END
+
+  def push(version=nil)
+    version ||= stored_version
+    guarded_system("git push")
+    guarded_system("git push origin #{version}")
+    remove_stored_version
+  end
+
+  desc "abort", <<-END
+      throws away the version stored by release start.
+  END
+
+  def abort
+    remove_stored_version
+  end
+
+  protected
+
+  def next_version(specified)
+    return Releasetool::Version.new(specified) if specified
+    if options[:major]
+      previous_version.next_major
+    elsif options[:minor]
+      previous_version.next_minor
+    else
+      previous_version.next_patch
+    end
+  end
+
+  def previous_version
+    Releasetool::Version.new(options[:since] || `git describe --abbrev=0 --tags`.strip)
+  end
+end

data/release_notes/__TEMPLATE__.md

@@ -0,0 +1,4 @@
+$VERSION Release Notes
+
+*Changes since $PREVIOUS*
+

data/release_notes/v0.0.1.md

@@ -0,0 +1,4 @@
+#v0.0.1 Release Notes
+
+Just have a release prepare command
+```release help prepare```

data/release_notes/v0.0.2.md

@@ -0,0 +1,9 @@
+#v0.0.2 Release Notes
+
+lifecycle (with no need to specify versions after release start)
+- `release start -s OLD NEW`
+- `release commit`
+- `release tag`
+- `release push`
+
+`release list` to review tags

data/release_notes/v0.0.3.md

@@ -0,0 +1,6 @@
+#v0.0.3 Release Notes
+
+*Changes since #v0.0.2*
+
+- `release abort`
+- can now configure the VERSION file adjusted by `release start` (used for releasing release tool)

data/release_notes/v0.1.0.md

@@ -0,0 +1,8 @@
+#v0.1.0 Release Notes
+
+*Changes since #v0.0.3*
+
+- fix
+- better spacing
+- can infer next patch version (or --minor or --major)
+- can automatically work out previous version from previous tags

data/release_notes/v0.1.1.md

@@ -0,0 +1,6 @@
+#v0.1.1 Release Notes
+
+*Changes since #v0.1.0*
+
+* `release latest` to output latest version
+* `release log` will git log from latest to current -- optional args passed through to git log

data/release_notes/v0.2.0.md

@@ -0,0 +1,6 @@
+v0.2.0 Release Notes
+
+*Changes since v0.1.1*
+
+- use explicit template file: You can edit the template that is used for new release_notes (it will be created within the folder next time you do release start)
+- append when already present (if the file already exists then release start / release prepare will add the commit history to the file rather than just printing it out)

data/releasetool.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'releasetool'
+
+Gem::Specification.new do |spec|
+  spec.name          = "releasetool"
+  spec.version       = Releasetool::VERSION
+  spec.authors       = ["Tim Diggins"]
+  spec.email         = ["tim@red56.co.uk"]
+  spec.description   = %q{Some release-related functions, initially just release notes management and creation}
+  spec.summary       = %q{Release management tools}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor', '~> 0.18'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/releasetool_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'fileutils'
+require File.expand_path('../../lib/tasks/release_thor', __FILE__)
+
+describe Releasetool do
+  it 'should have a version number' do
+    expect(Releasetool::VERSION).not_to be_nil
+  end
+end
+
+describe Release, quietly: true do
+  subject { Release.new }
+  TMPDIR = File.expand_path('../../tmp/testing', __FILE__)
+  ROOT_DIR = File.expand_path('../..', __FILE__)
+  before {
+    FileUtils.rmtree(TMPDIR)
+    FileUtils.mkdir_p(TMPDIR)
+    FileUtils.chdir(TMPDIR)
+    system('tar -xf ../../spec/fixtures/example_with_releases.tar')
+  }
+  after {
+    FileUtils.chdir(ROOT_DIR)
+  }
+  it "should respond to list" do
+    subject.list
+  end
+
+  let(:mock_target){ instance_double(Releasetool::Release)}
+  let(:v_0_0_1) {Releasetool::Version.new("v0.0.1")}
+  let(:v_0_0_2) {Releasetool::Version.new("v0.0.2")}
+  let(:v_0_0_3) {Releasetool::Version.new("v0.0.3")}
+  let(:v_0_1_0) {Releasetool::Version.new("v0.1.0")}
+  let(:v_1_0_0) {Releasetool::Version.new("v1.0.0")}
+
+  context "start" do
+    context "with a since" do
+      subject { Release.new([], {since: 'v0.0.2'}, {}) }
+      it "it should do a prepare and store a file" do
+        expect(Releasetool::Release).to receive(:new).with(v_0_0_3, previous: v_0_0_2).and_return(mock_target)
+        expect(mock_target).to receive(:prepare)
+        subject.start('v0.0.3')
+      end
+      it "stores a release-version file" do
+        allow(Releasetool::Release).to receive(:new).with(v_0_0_3, previous: v_0_0_2).and_return(mock_target)
+        allow(mock_target).to receive(:prepare)
+        expect { subject.start('v0.0.3') }.to change {
+              File.exist?(File.join(TMPDIR, '.RELEASE_NEW_VERSION'))
+            }
+        expect(File.read(File.join(TMPDIR, '.RELEASE_NEW_VERSION')).to_s).to eq('v0.0.3')
+      end
+
+      it "with existing release-version file, it should freak out" do
+        FileUtils.touch(File.join(TMPDIR, '.RELEASE_NEW_VERSION'))
+        expect { subject.start('v0.0.3') }.to raise_error
+      end
+    end
+
+    context "without a since" do
+      it "it should use latest tag" do
+        expect(Releasetool::Release).to receive(:new).with(v_0_0_3, previous: v_0_0_1).and_return(mock_target)
+        expect(mock_target).to receive(:prepare)
+        subject.start('v0.0.3')
+      end
+    end
+
+    context "without a new version" do
+      it "it should use next patch level" do
+        expect(Releasetool::Release).to receive(:new).with(v_0_0_2, previous: v_0_0_1).and_return(mock_target)
+        expect(mock_target).to receive(:prepare)
+        subject.start
+      end
+    end
+
+    context "without a new version but with --minor modifier" do
+      subject { Release.new([], {minor: true}, {}) }
+
+      it "it should use next minor level" do
+        expect(Releasetool::Release).to receive(:new).with(v_0_1_0, previous: v_0_0_1).and_return(mock_target)
+        expect(mock_target).to receive(:prepare)
+        subject.start
+      end
+    end
+
+    context "without a new version but with --major modifier" do
+      subject { Release.new([], {major: true}, {}) }
+
+      it "it should use next minor level" do
+        expect(Releasetool::Release).to receive(:new).with(v_1_0_0, previous: v_0_0_1).and_return(mock_target)
+        expect(mock_target).to receive(:prepare)
+        subject.start
+      end
+    end
+  end
+
+  describe "latest" do
+    it "outputs latest version" do
+      expect{subject.latest}.to output("v0.0.1\n").to_stdout
+    end
+  end
+
+  describe "log" do
+    it "executes correct git log code" do
+      expect(subject).to receive(:guarded_system).with("git log v0.0.1..")
+      subject.log
+    end
+
+    it "allow other args" do
+      expect(subject).to receive(:guarded_system).with("git log v0.0.1.. --stat --reverse")
+      subject.log("--stat", "--reverse")
+    end
+  end
+
+
+  # describe 'CLI' do
+  #   it "should work with source and no target" do
+  #     puts "CLI"
+  #     puts "PWD: #{`pwd`}"
+  #     system('cat config/initializers/00-version.rb')
+  #     expect(capture(:stderr) {
+  #           Release.start(%w[prepare -s v0.0.2 v0.0.3"])
+  #         }.strip).to eq('')
+  #   end
+  #   it "should not work with no target" do
+  #     expect(capture(:stderr) {
+  #           Release.start(%w[prepare -s v0.0.2"])
+  #         }.strip).not_to eq('')
+  #   end
+  #   it "should not work with no source" do
+  #     expect(capture(:stderr) {
+  #           Release.start(%w[flong v0.0.3"])
+  #         }.strip).not_to eq('')
+  #   end
+  #
+  #   it "should not work with no args" do
+  #     expect(capture(:stderr) {
+  #           Release.start(%w[prepare"])
+  #         }.strip).not_to eq('')
+  #   end
+  # end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'releasetool'
+
+RSpec.configure do |config|
+  config.around quietly: true do |example|
+    RSpec.configure do |config|
+      original_stderr = $stderr
+      original_stdout = $stdout
+      # Redirect stderr and stdout
+      $stderr = File.open(File::NULL, "w")
+      $stdout = File.open(File::NULL, "w")
+      example.run
+      $stderr = original_stderr
+      $stdout = original_stdout
+    end
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+require "releasetool/version"
+describe Releasetool::Version do
+  describe "to_s" do
+    it "includes v" do
+      expect(Releasetool::Version.new("v1.2.3").to_s).to eq("v1.2.3")
+    end
+    it "includes v even if not given" do
+      expect(Releasetool::Version.new("1.2.3").to_s).to eq("v1.2.3")
+    end
+  end
+
+  describe "to_s_without_v" do
+    it "strips" do
+      expect(Releasetool::Version.new("v1.2.3").to_s_without_v).to eq("1.2.3")
+    end
+    it "works without" do
+      expect(Releasetool::Version.new("1.2.3").to_s_without_v).to eq("1.2.3")
+    end
+  end
+
+  describe "next_patch" do
+    let(:v_0_0_1) {Releasetool::Version.new("v0.0.1")}
+    let(:v_0_0_2) {Releasetool::Version.new("v0.0.2")}
+    let(:v_0_0_3) {Releasetool::Version.new("v0.0.3")}
+
+    it "is next" do
+      expect(v_0_0_1.next_patch).to eq(v_0_0_2)
+    end
+    it "is next" do
+      expect(v_0_0_2.next_patch).to eq(v_0_0_3)
+    end
+  end
+
+  describe "next_minor" do
+    let(:v_0_0_1) {Releasetool::Version.new("v0.0.1")}
+    let(:v_0_1_0) {Releasetool::Version.new("v0.1.0")}
+    let(:v_0_2_0) {Releasetool::Version.new("v0.2.0")}
+
+    it "is next" do
+      expect(v_0_0_1.next_minor).to eq(v_0_1_0)
+    end
+    it "is next" do
+      expect(v_0_1_0.next_minor).to eq(v_0_2_0)
+    end
+  end
+
+  describe "next_major" do
+    let(:v_0_1_1) {Releasetool::Version.new("v0.1.1")}
+    let(:v_1_0_0) {Releasetool::Version.new("v1.0.0")}
+    let(:v_2_0_0) {Releasetool::Version.new("v2.0.0")}
+
+    it "is next" do
+      expect(v_0_1_1.next_major).to eq(v_1_0_0)
+    end
+    it "is next" do
+      expect(v_1_0_0.next_major).to eq(v_2_0_0)
+    end
+  end
+
+  describe "==" do
+    let(:v_0_0_2) {Releasetool::Version.new("v0.0.2")}
+
+    it "is self same" do
+      expect(v_0_0_2 == v_0_0_2).to be_truthy
+    end
+    it "is same if other is a version of same" do
+      expect(v_0_0_2 == Releasetool::Version.new("v0.0.2")).to be_truthy
+    end
+    it "is false if other is otherversion " do
+      expect(v_0_0_2 == Releasetool::Version.new("v0.0.3")).to be_falsey
+    end
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: releasetool
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Tim Diggins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Some release-related functions, initially just release notes management
+  and creation
+email:
+- tim@red56.co.uk
+executables:
+- release
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/release
+- lib/releasetool.rb
+- lib/releasetool/release.rb
+- lib/releasetool/util.rb
+- lib/releasetool/version.rb
+- lib/tasks/release_thor.rb
+- release_notes/__TEMPLATE__.md
+- release_notes/v0.0.1.md
+- release_notes/v0.0.2.md
+- release_notes/v0.0.3.md
+- release_notes/v0.1.0.md
+- release_notes/v0.1.1.md
+- release_notes/v0.2.0.md
+- releasetool.gemspec
+- spec/fixtures/example_with_releases.tar
+- spec/releasetool_spec.rb
+- spec/spec_helper.rb
+- spec/version_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Release management tools
+test_files:
+- spec/fixtures/example_with_releases.tar
+- spec/releasetool_spec.rb
+- spec/spec_helper.rb
+- spec/version_spec.rb