metasploit-version 0.1.2-java

data/features/support/env.rb

@@ -0,0 +1,41 @@
+# Has to be the first file required so that all other files show coverage information
+require 'simplecov'
+
+#
+# Standard Library
+#
+
+require 'pathname'
+
+#
+# Gems
+#
+
+require 'aruba/cucumber'
+# only does jruby customization if actually in JRuby
+require 'aruba/jruby'
+
+Before do |scenario|
+  command_name = case scenario
+                   when Cucumber::Ast::Scenario, Cucumber::Ast::ScenarioOutline
+                     "#{scenario.feature.title} #{scenario.name}"
+                   when Cucumber::Ast::OutlineTable::ExampleRow
+                     scenario_outline = scenario.scenario_outline
+
+                     "#{scenario_outline.feature.title} #{scenario_outline.name} #{scenario.name}"
+                   else
+                     raise TypeError, "Don't know how to extract command name from #{scenario.class}"
+                 end
+
+  # Used in simplecov_setup so that each scenario has a different name and their coverage results are merged instead
+  # of overwriting each other as 'Cucumber Features'
+  set_env('SIMPLECOV_COMMAND_NAME', command_name)
+
+  simplecov_setup_pathname = Pathname.new(__FILE__).expand_path.parent.join('simplecov_setup')
+  # set environment variable so child processes will merge their coverage data with parent process's coverage data.
+  set_env('RUBYOPT', "-r#{simplecov_setup_pathname} #{ENV['RUBYOPT']}")
+end
+
+Before do
+  @aruba_timeout_seconds = 10 * 60
+end

data/features/support/simplecov_setup.rb

@@ -0,0 +1,12 @@
+# @note this file is loaded in env.rb to setup simplecov using RUBYOPTs for child processes
+
+require 'simplecov'
+
+require 'pathname'
+
+root = Pathname(__FILE__).expand_path.parent.parent.parent
+
+SimpleCov.command_name(ENV['SIMPLECOV_COMMAND_NAME'])
+SimpleCov.root(root)
+load root.join('.simplecov')
+

data/lib/metasploit/version.rb

@@ -0,0 +1,19 @@
+#
+# Standard Library
+#
+
+require 'pathname'
+
+#
+# Project
+#
+
+require 'metasploit/version/version'
+
+# Namespace used across all metasploit gems
+module Metasploit
+  # Namespace for this gem.
+  module Version
+    autoload :Branch, 'metasploit/version/branch'
+  end
+end

data/lib/metasploit/version/branch.rb

@@ -0,0 +1,172 @@
+require 'metasploit/version'
+
+# Regular expressions for parsing the branch name into its component parts
+module Metasploit::Version::Branch
+  #
+  # CONSTANTS
+  #
+
+  # Regular expression that matches, but does not capture an optional prefix of `ref/remotes` for when a branch name is
+  # fully qualified on Jenkins. Remote name after `ref/remotes` is captured in `:remote` group.
+  JENKINS_PREFIX_REGEXP = %r{(?:ref/remotes/(?<remote>[^/]+)/)?}
+
+  # Matches runs of alphanumeric characters that are valid in prerelease segments.  Prerelease segments must be
+  # separated by `.` or `-`.
+  PRERELEASE_SEGMENT_REGEXP = /[0-9a-zA-Z]+/
+
+  # Version pattern allowed by Rubygems for pre-release: runs of alphanumeric characters separated by `.` or `-`.
+  # Group is captured to `:prerelease` name.
+  PRERELEASE_REGEXP = /(?<prerelease>#{PRERELEASE_SEGMENT_REGEXP}([-.]#{PRERELEASE_SEGMENT_REGEXP})*)/
+
+  # Regular expression that matches exactly a staging branch.  It may
+  # {JENKINS_PREFIX_REGEXP optionally start with `ref/remotes`}, followed by a type of `staging`, no story ID, and a
+  # {PRERELEASE_REGEXP pre-release name}.
+  #
+  # @example Staging Branch
+  #   'staging/long-running'
+  #
+  # @example Staging Branch on Jenkins
+  #   'ref/remotes/origin/staging/long-running'
+  STAGING_REGEXP = %r{
+    \A
+    #{JENKINS_PREFIX_REGEXP}
+    (?<type>staging)
+    /
+    #{PRERELEASE_REGEXP}
+    \z
+  }x
+
+  # Regular expression that matches exactly a chore, feature or bug branch.  It may
+  # {JENKINS_PREFIX_REGEXP optionally start with `ref/remotes`}, followed by a type of `staging`, story ID, and a
+  # {PRERELEASE_REGEXP pre-release name}.
+  #
+  # @example Bug Branch
+  #   'bug/MSP-666/nasty'
+  #
+  # @example Bug Branch on Jenkins
+  #   'ref/remotes/origin/bug/MSP-666/nasty'
+  #
+  # @example Chore Branch
+  #   'chore/MSP-1234/recurring'
+  #
+  # @example Chore Branch on Jenkins
+  #   'ref/remotes/origin/chore/MSP-1234/recurring'
+  #
+  # @example Feature Branch
+  #   'feature/MSP-31337/cool'
+  #
+  # @example Feature Branch on Jenkins
+  #   'ref/remotes/origin/feature/MSP-31337/cool'
+  #
+  STORY_REGEXP = %r{
+    \A
+    #{JENKINS_PREFIX_REGEXP}
+    (?<type>bug|chore|feature)
+    /
+    (?<story>[^/]+)
+    /
+    #{PRERELEASE_REGEXP}
+    \z
+  }x
+
+  # Regular expression that matches separator used between {PRERELEASE_SEGMENT_REGEXP prerelease segments} for gem
+  # versions and tag versions.
+  VERSION_PRERELEASE_SEGMENT_SEPARATOR_REGEXP = /\.pre\./
+
+  # Regular expression that exactly matches a release or pre-release version tag prefixed with `v` and followed by
+  # the major, minor, and patch numbers separated by '.' with an optional prerelease version suffix.
+  #
+  # @example Releease Tag
+  #   'v1.2.3'
+  #
+  # @example Prerelease Tag
+  #   'v1.2.3.pre.cool'
+  #
+  VERSION_REGEXP = %r{
+    \A
+    v(?<major>\d+)
+    \.
+    (?<minor>\d+)
+    \.
+    (?<patch>\d+)
+    (?:
+      #{VERSION_PRERELEASE_SEGMENT_SEPARATOR_REGEXP}
+      (?<gem_version_prerelease>
+        #{PRERELEASE_SEGMENT_REGEXP}
+        (#{VERSION_PRERELEASE_SEGMENT_SEPARATOR_REGEXP}#{PRERELEASE_SEGMENT_REGEXP})*
+      )
+    )?
+    \z
+  }x
+
+  # The current branch name from travis-ci or git.
+  #
+  # @return [String]
+  def self.current
+    branch = ENV['TRAVIS_BRANCH']
+
+    if branch.nil? || branch.empty?
+      branch = `git rev-parse --abbrev-ref HEAD`.strip
+    end
+
+    branch
+  end
+
+  # Parses the branch
+  #
+  # @param branch [String] the branch name
+  # @return ['HEAD'] if `branch` is 'HEAD' (such as in a detached head state for git)
+  # @return ['master'] if `branch` is `master`
+  # @return [Hash{type: 'staging', prerelease: String}] if a staging branch
+  # @return [Hash{type: String, story: String, prerelease: String}] if not a staging branch
+  # @return [Hash{major: Integer, minor: Integer, patch: Integer, prerelease: String}]
+  # @return [nil] if `branch` does not match any of the formats
+  def self.parse(branch)
+    if ['HEAD', 'master'].include? branch
+      branch
+    else
+      match = branch.match(STAGING_REGEXP)
+
+      if match
+        {
+            prerelease: match[:prerelease],
+            type: match[:type]
+        }
+      else
+        match = branch.match(STORY_REGEXP)
+
+        if match
+          {
+              prerelease: match[:prerelease],
+              story: match[:story],
+              type: match[:type]
+          }
+        else
+          match = branch.match(VERSION_REGEXP)
+
+          if match
+            prerelease = prerelease(match[:gem_version_prerelease])
+
+            {
+                major: match[:major].to_i,
+                minor: match[:minor].to_i,
+                patch: match[:patch].to_i,
+                prerelease: prerelease
+            }
+          end
+        end
+      end
+    end
+  end
+
+  # Replaces `.pre.` in `gem_version_prerelease` with `-` to undo conversion to rubygems 1.8.6 compatible pre-release
+  # version.
+  #
+  # @return [String] unless `gem_version_prerelease` is `nil`.
+  # @return [nil] if `gem_version_prerelease` is `nil`.
+  def self.prerelease(gem_version_prerelease)
+    unless gem_version_prerelease.nil?
+      gem_version_prerelease.gsub('.pre.', '-')
+    end
+  end
+end

data/lib/metasploit/version/version.rb

@@ -0,0 +1,57 @@
+module Metasploit
+  module Version
+    # Holds components of {VERSION} as defined by {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0}.
+    module Version
+      #
+      # Constants
+      #
+
+      # The major version number.
+      MAJOR = 0
+      # The minor version number, scoped to the {MAJOR} version number.
+      MINOR = 1
+      # The patch number, scoped to the {MINOR} version number.
+      PATCH = 2
+
+      #
+      # Module Methods
+      #
+
+      # The full version string, including the {Metasploit::Version::Version::MAJOR},
+      # {Metasploit::Version::Version::MINOR}, {Metasploit::Version::Version::PATCH}, and optionally, the
+      # `Metasploit::Version::Version::PRERELEASE` in the
+      # {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0} format.
+      #
+      # @return [String] '{Metasploit::Version::Version::MAJOR}.{Metasploit::Version::Version::MINOR}.{Metasploit::Version::Version::PATCH}' on master.
+      #   '{Metasploit::Version::Version::MAJOR}.{Metasploit::Version::Version::MINOR}.{Metasploit::Version::Version::PATCH}-PRERELEASE'
+      #   on any branch other than master.
+      def self.full
+        version = "#{MAJOR}.#{MINOR}.#{PATCH}"
+
+        if defined? PRERELEASE
+          version = "#{version}-#{PRERELEASE}"
+        end
+
+        version
+      end
+
+      # The full gem version string, including the {Metasploit::Version::Version::MAJOR},
+      # {Metasploit::Version::Version::MINOR}, {Metasploit::Version::Version::PATCH}, and optionally, the
+      # `Metasploit::Version::Version::PRERELEASE` in the
+      # {http://guides.rubygems.org/specification-reference/#version RubyGems versioning} format.
+      #
+      # @return [String] '{Metasploit::Version::Version::MAJOR}.{Metasploit::Version::Version::MINOR}.{Metasploit::Version::Version::PATCH}'
+      #   on master.  '{Metasploit::Version::Version::MAJOR}.{Metasploit::Version::Version::MINOR}.{Metasploit::Version::Version::PATCH}.PRERELEASE'
+      #   on any branch other than master.
+      def self.gem
+        full.gsub('-', '.pre.')
+      end
+    end
+
+    # (see Version.gem)
+    GEM_VERSION = Version.gem
+
+    # (see Version.full)
+    VERSION = Version.full
+  end
+end

data/metasploit-version.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metasploit/version/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'metasploit-version'
+  spec.version       = Metasploit::Version::GEM_VERSION
+  spec.authors       = ['Luke Imhoff']
+  spec.email         = ['luke_imhoff@rapid7.com']
+  spec.summary       = 'Semantic versioning helpers and shared examples'
+  spec.description   = "Metasploit::Version::Full for deriving String VERSION from constants in Version module and " \
+                       "shared examples: 'Metasploit::Version VERSION constant' to check VERSION and " \
+                       "'Metasploit::Version Version Module' to check Version."
+  spec.homepage      = 'https://github.com/rapid7/metasploit-version'
+  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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency 'metasploit-yard', '~> 1.0'
+  spec.add_development_dependency "rake"
+
+
+  if RUBY_PLATFORM =~ /java/
+    # markdown library for YARD to enable proper parsing of README.md and CONTRIBUTING.md
+    spec.add_development_dependency 'kramdown'
+
+    spec.platform = Gem::Platform::JAVA
+  else
+    # markdown library for YARD to enable proper parsing of README.md and CONTRIBUTING.md
+    spec.add_development_dependency 'redcarpet'
+
+    spec.platform = Gem::Platform::RUBY
+  end
+
+  spec.add_runtime_dependency 'rspec'
+end

data/spec/lib/metasploit/version/branch_spec.rb

@@ -0,0 +1,660 @@
+require 'spec_helper'
+
+describe Metasploit::Version::Branch do
+  context 'CONSTANTS' do
+    context 'JENKINS_PREFIX_REGEXP' do
+      subject(:jenkins_prefix_regexp) {
+        described_class::JENKINS_PREFIX_REGEXP
+      }
+
+      it "matches 'ref/remotes/' by itself" do
+        expect(jenkins_prefix_regexp).to match('ref/remotes/')
+      end
+
+      it "matches 'ref/remotes/' prefix" do
+        expect(jenkins_prefix_regexp).to match('ref/remotes/remote-name')
+      end
+
+      it 'matches nothing' do
+        expect(jenkins_prefix_regexp).to match('')
+      end
+    end
+
+    context 'PRERELEASE_REGEXP' do
+      subject(:prerelease_regexp) {
+        described_class::PRERELEASE_REGEXP
+      }
+
+      it 'matches a single segment' do
+        expected_prerelease = 'singlesegment'
+        match = prerelease_regexp.match(expected_prerelease)
+
+        expect(match).not_to be_nil
+        expect(match[:prerelease]).to eq(expected_prerelease)
+      end
+
+      it "matches segments separated by '-'" do
+        expected_prerelease = 'first-second'
+        match = prerelease_regexp.match(expected_prerelease)
+
+        expect(match).not_to be_nil
+        expect(match[:prerelease]).to eq(expected_prerelease)
+      end
+
+      it "matches segmented separated by '.'" do
+        expected_prerelease = 'first.second'
+        match = prerelease_regexp.match(expected_prerelease)
+
+        expect(match).not_to be_nil
+        expect(match[:prerelease]).to eq(expected_prerelease)
+      end
+
+      it "matches segmented separated by a mix of '.' and '-'" do
+        expected_prerelease = 'first.second-third'
+        match = prerelease_regexp.match(expected_prerelease)
+
+        expect(match).not_to be_nil
+        expect(match[:prerelease]).to eq(expected_prerelease)
+      end
+    end
+
+    context 'PRERELEASE_SEGMENT_REGEXP' do
+      subject(:prerelease_segment_regexp) {
+        described_class::PRERELEASE_SEGMENT_REGEXP
+      }
+
+      it 'does not match an empty string' do
+        expect(prerelease_segment_regexp).not_to match('')
+      end
+
+      it 'matches 0-9, a-z, and A-Z' do
+        ranges = [
+            '0'..'9',
+            'a'..'z',
+            'A'..'Z'
+        ]
+        string = ranges.map(&:to_a).map(&:join).join
+
+        expect(prerelease_segment_regexp).to match(string)
+      end
+    end
+
+    context 'STAGING_REGEXP' do
+      subject(:staging_regexp) {
+        described_class::STAGING_REGEXP
+      }
+
+      it 'matches staging branch' do
+        expect(staging_regexp).to match('staging/long-running')
+      end
+
+      it 'does not match bug branch' do
+        expect(staging_regexp).not_to match('bug/MSP-1234/nasty')
+      end
+
+      it 'does not match chore branch' do
+        expect(staging_regexp).not_to match('chore/MSP-1234/repeating')
+      end
+
+      it 'does not match feature branch' do
+        expect(staging_regexp).not_to match('feature/MSP-1234/new-feature')
+      end
+
+      it 'does not match pre-release tag' do
+        expect(staging_regexp).not_to match('v1.2.3.pre.release')
+      end
+
+      it 'does not match release tag' do
+        expect(staging_regexp).not_to match('v1.2.3')
+      end
+    end
+
+    context 'STORY_REGEXP' do
+      subject(:story_regexp) {
+        described_class::STORY_REGEXP
+      }
+
+      it 'does not match staging branch' do
+        expect(story_regexp).not_to match('staging/long-running')
+      end
+
+      context 'type' do
+        context 'bug' do
+          let(:type) {
+            'bug'
+          }
+
+          context 'with story' do
+            it 'matches' do
+              expect(story_regexp).to match("#{type}/MSP-1234/nasty")
+            end
+          end
+
+          context 'without story' do
+            it 'does not match' do
+              expect(story_regexp).not_to match("#{type}/nasty")
+            end
+          end
+        end
+
+        context 'chore' do
+          let(:type) {
+            'chore'
+          }
+
+          context 'with story' do
+            it 'matches' do
+              expect(story_regexp).to match("#{type}/MSP-1234/repeating")
+            end
+          end
+
+          context 'without story' do
+            it 'does not match' do
+              expect(story_regexp).not_to match("#{type}/repeating")
+            end
+          end
+        end
+
+        context 'feature' do
+          let(:type) {
+            'feature'
+          }
+
+          context 'with story' do
+            it 'matches' do
+              expect(story_regexp).to match("#{type}/MSP-1234/cool")
+            end
+          end
+
+          context 'without story' do
+            it 'does not match' do
+              expect(story_regexp).not_to match("#{type}/cool")
+            end
+          end
+        end
+      end
+
+      it 'does not match pre-release tag' do
+        expect(story_regexp).not_to match('v1.2.3.pre.release')
+      end
+
+      it 'does not match release tag' do
+        expect(story_regexp).not_to match('v1.2.3')
+      end
+    end
+
+    context 'VERSION_PRERELEASE_SEGMENT_SEPARATOR_REGEXP' do
+      subject(:version_prerelease_segment_separator_regexp) {
+        described_class::VERSION_PRERELEASE_SEGMENT_SEPARATOR_REGEXP
+      }
+
+      it { is_expected.to match('.pre.') }
+
+      it "escapes '.' around 'pre'" do
+        expect(version_prerelease_segment_separator_regexp).not_to match('aprea')
+      end
+    end
+
+    context 'VERSION_REGEXP' do
+      subject(:version_regexp) {
+        described_class::VERSION_REGEXP
+      }
+
+      it "does not match tag without 'v' prefix" do
+        expect(version_regexp).not_to match('1.2.3')
+      end
+
+      it 'matches release tag' do
+        expect(version_regexp).to match('v1.2.3')
+      end
+
+      it 'matches prerelease tag' do
+        expect(version_regexp).to match('v1.2.3.pre.release')
+      end
+
+      it 'does not match staging branch' do
+        expect(version_regexp).not_to match('staging/long-running')
+      end
+
+      it 'does not match bug branch' do
+        expect(version_regexp).not_to match('bug/MSP-1234/nasty')
+      end
+
+      it 'does not match chore branch' do
+        expect(version_regexp).not_to match('chore/MSP-1234/recurring')
+      end
+
+      it 'does not match feature branch' do
+        expect(version_regexp).not_to match('feature/MSP-1234/cool')
+      end
+    end
+  end
+
+  context 'current' do
+    subject(:current) {
+      described_class.current
+    }
+
+    around(:each) do |example|
+      env_before = ENV.to_hash
+
+      begin
+        example.run
+      ensure
+        ENV.replace(env_before)
+      end
+    end
+
+    context 'with TRAVIS_BRANCH' do
+      before(:each) do
+        ENV['TRAVIS_BRANCH'] = travis_branch
+      end
+
+      context 'that is empty' do
+        let(:travis_branch) {
+          ''
+        }
+
+        it 'parses git abbreviated ref' do
+          expect(current).to eq(`git rev-parse --abbrev-ref HEAD`.strip)
+        end
+      end
+
+      context 'that is not empty' do
+        let(:travis_branch) {
+          'feature/MSP-1234/travis-ci'
+        }
+
+        it 'is TRAVIS_BRANCH' do
+          expect(current).to eq(travis_branch)
+        end
+      end
+    end
+
+    context 'without TRAVIS_BRANCH' do
+      before(:each) do
+        ENV.delete('TRAVIS_BRANCH')
+      end
+
+      it 'parses git abbreviated ref' do
+        expect(current).to eq(`git rev-parse --abbrev-ref HEAD`.strip)
+      end
+    end
+  end
+
+  context 'parse' do
+    subject(:parse) {
+      described_class.parse(branch)
+    }
+
+    context 'with HEAD' do
+      let(:branch) {
+        'HEAD'
+      }
+
+      it { is_expected.to eq('HEAD') }
+    end
+
+    context 'with master' do
+      let(:branch) {
+        'master'
+      }
+
+      it { is_expected.to eq('master') }
+    end
+
+    context 'with staging branch' do
+      #
+      # Shared examples
+      #
+
+      shared_examples_for 'staging branch' do
+        it { is_expected.to be_a(Hash) }
+
+        context '[:prerelease]' do
+          subject(:prerelease) {
+            parse[:prerelease]
+          }
+
+          it "is name after 'staging/'" do
+            expect(prerelease).to eq(expected_prerelease)
+          end
+        end
+
+        context '[:type]' do
+          subject(:type) {
+            parse[:type]
+          }
+
+          it { is_expected.to eq(expected_type) }
+        end
+      end
+
+      #
+      # lets
+      #
+
+      let(:branch) {
+        "#{jenkins_prefix}#{expected_type}/#{expected_prerelease}"
+      }
+
+      let(:expected_prerelease) {
+        'long-running'
+      }
+
+      let(:expected_type) {
+        'staging'
+      }
+
+      context 'with Jenkins prefix' do
+        let(:jenkins_prefix) {
+          'ref/remotes/origin/'
+        }
+
+        it_should_behave_like 'staging branch'
+      end
+
+      context 'without Jenkins prefix' do
+        let(:jenkins_prefix) {
+          ''
+        }
+
+        it_should_behave_like 'staging branch'
+      end
+    end
+
+    context 'with story branch' do
+      shared_examples_for 'story branch' do
+        context 'with story' do
+          shared_examples_for 'with story' do
+            it { should be_a Hash }
+
+            context '[:prerelease]' do
+              subject(:prerelease) {
+                parse[:prerelease]
+              }
+
+              it "is name after last '/'" do
+                expect(prerelease).to eq(expected_prerelease)
+              end
+            end
+
+            context '[:story]' do
+              subject(:story) {
+                parse[:story]
+              }
+
+              it 'is middle name' do
+                expect(story).to eq(expected_story)
+              end
+            end
+
+            context '[:type]' do
+              subject(:type) {
+                parse[:type]
+              }
+
+              it { is_expected.to eq(expected_type) }
+            end
+          end
+
+          let(:expected_story) {
+            'MSP-1234'
+          }
+
+          let(:branch) {
+            "#{jenkins_prefix}#{expected_type}/#{expected_story}/#{expected_prerelease}"
+          }
+
+          context 'with Jenkins prefix' do
+            let(:jenkins_prefix) {
+              'ref/remotes/upstream/'
+            }
+
+            it_should_behave_like 'with story'
+          end
+
+          context 'without Jenkins prefix' do
+            let(:jenkins_prefix) {
+              ''
+            }
+
+            it_should_behave_like 'with story'
+          end
+        end
+
+        context 'without story' do
+          let(:branch) {
+            "#{expected_type}/#{expected_prerelease}"
+          }
+
+          it { is_expected.to be_nil }
+        end
+      end
+
+      context 'for a bug' do
+        let(:expected_prerelease) {
+          'nasty'
+        }
+
+        let(:expected_type) {
+          'bug'
+        }
+
+        it_should_behave_like 'story branch'
+      end
+
+      context 'for a chore' do
+        let(:expected_prerelease) {
+          'recurring'
+        }
+
+        let(:expected_type) {
+          'chore'
+        }
+
+        it_should_behave_like 'story branch'
+      end
+
+      context 'for a bug' do
+        let(:expected_prerelease) {
+          'cool-new'
+        }
+
+        let(:expected_type) {
+          'feature'
+        }
+
+        it_should_behave_like 'story branch'
+      end
+    end
+
+    context 'with version tag' do
+      let(:expected_major) {
+        10
+      }
+
+      let(:expected_minor) {
+        20
+      }
+
+      let(:expected_patch) {
+        30
+      }
+
+      context 'for pre-release' do
+        let(:branch) {
+          "v#{expected_major}.#{expected_minor}.#{expected_patch}.pre.early.pre.release"
+        }
+
+        it { is_expected.to be_a Hash }
+
+        context '[:major]' do
+          subject(:major) {
+            parse[:major]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is first number in dotted version' do
+            expect(major).to eq(expected_major)
+          end
+        end
+
+        context '[:minor]' do
+          subject(:minor) {
+            parse[:minor]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is second number in dotted version' do
+            expect(minor).to eq(expected_minor)
+          end
+        end
+
+        context '[:patch]' do
+          subject(:patch) {
+            parse[:patch]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is third number in dotted version' do
+            expect(patch).to eq(expected_patch)
+          end
+        end
+
+        context '[:prerelease]' do
+          subject(:prerelease) {
+            parse[:prerelease]
+          }
+
+          it "converts '.pre.' separators from prerelease back to '-'" do
+            expect(prerelease).to eq('early-release')
+          end
+        end
+      end
+
+      context 'for release' do
+        let(:branch) {
+          "v#{expected_major}.#{expected_minor}.#{expected_patch}"
+        }
+
+        it { is_expected.to be_a Hash }
+
+        context '[:major]' do
+          subject(:major) {
+            parse[:major]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is first number in dotted version' do
+            expect(major).to eq(expected_major)
+          end
+        end
+
+        context '[:minor]' do
+          subject(:minor) {
+            parse[:minor]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is second number in dotted version' do
+            expect(minor).to eq(expected_minor)
+          end
+        end
+
+        context '[:patch]' do
+          subject(:patch) {
+            parse[:patch]
+          }
+
+          it { is_expected.to be_an Integer }
+
+          it 'is third number in dotted version' do
+            expect(patch).to eq(expected_patch)
+          end
+        end
+
+        context '[:prerelease]' do
+          subject(:prerelease) {
+            parse[:prerelease]
+          }
+
+          it { is_expected.to be_nil }
+        end
+      end
+    end
+
+    context 'with malformed bug branch' do
+      let(:branch) {
+        'bug/without-story'
+      }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'with malformed chore branch' do
+      let(:branch) {
+        'chore/without-story'
+      }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'with malformed feature branch' do
+      let(:branch) {
+        'feature/without-story'
+      }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'with malformed version tag' do
+      let(:branch) {
+        '1.2.3.pre.without.pre.v'
+      }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  context 'prerelease' do
+    subject(:prerelease) {
+      described_class.prerelease(gem_version_prerelease)
+    }
+
+    context 'with nil' do
+      let(:gem_version_prerelease) {
+        nil
+      }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'without nil' do
+      context "with '.pre.'" do
+        let(:gem_version_prerelease) {
+          'second.pre.early.pre.release'
+        }
+
+        it "replaces '.pre.' with '-'" do
+          expect(prerelease).to eq('second-early-release')
+        end
+      end
+
+      context "without '.pre.'" do
+        let(:gem_version_prerelease) {
+          'prerelease'
+        }
+
+        it 'is unchanged' do
+          expect(prerelease).to eq(gem_version_prerelease)
+        end
+      end
+    end
+  end
+end