version-manager 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79b79f83cae2d7a380e74c9bb8ba6658f0713f00
-  data.tar.gz: d4f02a71475f77b35ee8a989ff6861fbbbba70d4
+  metadata.gz: 3860c7e4394f7d49d1c467cabb0fe944f0d049f3
+  data.tar.gz: a8c9694661eca4f788d28a7c991d9b41f1c874aa
 SHA512:
-  metadata.gz: c0a3ba13361846f03c59387d92e831fda1c2edc8d504a5ab094360e14d88551d84267dda075c891980b27f0592ddcf4c3a37d7061c433dcc8308eb4ed32e4d98
-  data.tar.gz: ef2a48b62669f0a412d916a988f9d2039041140f40f74559eb176b57aa7fc374e14c7297eb810d9ba4f1b4b65a4677d13df36565ac8d38718e7eeb60f9be17ff
+  metadata.gz: eebd799dc897df1e401c74a80a01ff12fca1cce18d37f8a6037df74c1a7e3c7f2aa01bc45f5e572ba3616a70b4ee23d6fdbc1fcac07f1d7279c23c9dd3caf782
+  data.tar.gz: 4492d44cce10b4249c2fd543d11ebea4b154d8e2db06ed3f6f9ac9c0d77913356e36df2e4d132165799644ee5365b8321ce0d2cc9dd8e66fd7d83aed4e81cf05

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Metrics/LineLength:
+  Max: 120
+Metrics/AbcSize:
+  Max: 25
+Style/Documentation:
+  Enabled: false
+AllCops:
+  TargetRubyVersion: 2.3
+Metrics/MethodLength:
+  Max: 15

data/Gemfile

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
 source 'https://rubygems.org'
 
 gemspec
+
+group :development, :test do
+  gem 'byebug'
+end

data/README.md

@@ -1,3 +1,4 @@
+[![Code Climate](https://codeclimate.com/github/isolo/version-manager/badges/gpa.svg)](https://codeclimate.com/github/isolo/version-manager)
 # version-manager
 versioning lib (with Git support) written in Ruby
 

data/Rakefile

@@ -1,2 +1,5 @@
-require "bundler/gem_tasks"
-task :default => :spec
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/exe/manver

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/version-manager'
 VersionManager::CLI.new(exec_name: File.basename(__FILE__)).start

data/lib/version-manager.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Style/FileName
+# frozen_string_literal: true
 require 'docopt'
 require 'git'
 require 'pathname'
@@ -10,10 +12,12 @@ module VersionManager
   DEFAULTS = {
     vcs: {
       name: 'git',
-      default_commit_message: -> (version) { "Bumped to version #{version}" },
+      default_commit_message: ->(version) { "Bumped to version #{version}" },
       options: {
         remote: 'origin',
-        master_branch: 'master'
+        master_branch: 'master',
+        dir: ROOT_DIR,
+        version_name: ->(version) { "release-#{version.short_version}" }
       }
     },
     authorized_branches: {
@@ -24,9 +28,8 @@ module VersionManager
     storage: {
       filename: 'VERSION',
       filepath: ROOT_DIR
-    },
-    version_name: -> (version) { "release-#{version.short_version}" }
-  }
+    }
+  }.freeze
 
   def self.options
     @options ||= DEFAULTS.dup
@@ -43,6 +46,7 @@ require_relative 'version-manager/vcs/git'
 require_relative 'version-manager/version'
 require_relative 'version-manager/cli'
 
+require_relative 'version-manager/action_manager'
+require_relative 'version-manager/release_manager'
 require_relative 'version-manager/release_version'
 require_relative 'version-manager/version_storage'
-require_relative 'version-manager/make.rb'

data/lib/version-manager/action_manager.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module VersionManager
+  class ActionManager
+    def initialize(options)
+      @options = options
+      @vcs = VCS.build(options[:vcs])
+      @storage = VersionStorage.new(vcs, options[:storage])
+      @release_manager = ReleaseManager.new(vcs, storage, options)
+    end
+
+    def checkout_to_latest_version
+      version = storage.latest_version
+      return false unless version
+      vcs.switch_branch(VCS.branch_name(version, options.dig(:vcs, :options)))
+      true
+    end
+
+    def release_new_version(release_type, confirmation_func, retrieve_initial_version_func)
+      release_manager.validate!(release_type)
+      version = release_type == :patch ? storage.current_version : storage.latest_version
+      if version
+        new_version = version.public_send("bump_#{release_type}")
+        return unless confirmation_func.call(new_version)
+      else
+        version = retrieve_initial_version_func.call
+      end
+      release_manager.public_send("#{release_type}!", version)
+    end
+
+    private
+
+    attr_reader :vcs, :storage, :release_manager, :options
+  end
+end

data/lib/version-manager/cli.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 module VersionManager
   class CLI
     def initialize(exec_name: __FILE__)
       @exec_name = exec_name
+      @action_manager = ActionManager.new(VersionManager.options)
     end
 
     def start
@@ -21,7 +23,7 @@ module VersionManager
       DOCOPT
 
       begin
-        parse_options(Docopt::docopt(doc))
+        parse_options(Docopt.docopt(doc))
       rescue StandardError => e
         puts e.message
       end
@@ -29,7 +31,7 @@ module VersionManager
 
     private
 
-    attr_reader :exec_name
+    attr_reader :exec_name, :action_manager
 
     def parse_options(options)
       puts VersionManager::VERSION if options['--version']
@@ -41,34 +43,18 @@ module VersionManager
     end
 
     def checkout_to_latest_version
-      storage = build_storage
-      version = storage.latest_version
-      return puts 'There are no any versions.' unless version
-      VCS.build.switch_branch(version.branch)
+      return if action_manager.checkout_to_latest_version
+      puts 'There are no any versions.'
     end
 
     def make_release(release_type)
-      storage = build_storage
-
-      make = Make.new(VCS.build, storage)
-      make.validate!(release_type)
-
-      version = release_type == :patch ? storage.current_version : storage.latest_version
-      if version
-        new_version = version.public_send("bump_#{release_type}")
-        return unless Ask.confirm("You are going to upgrade version to #{new_version}. Do it?", default: false)
-      else
-        version = retrieve_initial_version
-      end
-
-      make.public_send("#{release_type}!", version)
+      action_manager.release_new_version(release_type, method(:confirm_new_version), method(:retrieve_initial_version))
     rescue VersionManager::VersionStorage::WrongLatestVersionError => e
       puts "There is inappropriate version #{e.version} in your local/remote repository. Please remove it"
     end
 
-    def build_storage
-      storage_options = VersionManager.options[:storage]
-      VersionStorage.new(VCS.build, storage_options)
+    def confirm_new_version(new_version)
+      Ask.confirm("You are going to upgrade version to #{new_version}. Do it?", default: false)
     end
 
     def retrieve_initial_version

data/lib/version-manager/{make.rb → release_manager.rb}

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module VersionManager
-  class Make
+  class ReleaseManager
     class BranchIsNotUpToDateError < StandardError
       def message
         'Remote branch and local one are different. You need to update your branch or push your changes'
@@ -12,9 +13,10 @@ module VersionManager
       end
     end
 
-    def initialize(vcs, version_storage)
+    def initialize(vcs, version_storage, options)
       @vcs = vcs
       @version_storage = version_storage
+      @options = options
     end
 
     def validate!(release_type)
@@ -40,15 +42,15 @@ module VersionManager
 
     private
 
-    attr_reader :vcs, :version_storage
+    attr_reader :vcs, :version_storage, :options
 
     def appropriate_branch_for?(action)
-      authorized_mask = VersionManager.options[:authorized_branches][action.to_sym]
+      authorized_mask = options[:authorized_branches][action.to_sym]
       !authorized_mask || !vcs.current_branch.match(authorized_mask).nil?
     end
 
     def default_strategy(version)
-      vcs.create_branch!(version.branch)
+      vcs.create_branch!(version)
       vcs.commit(version_storage.store(version), default_commit_message(version))
       vcs.add_tag(version.to_s, default_commit_message(version))
       vcs.push_tag(version.to_s)
@@ -56,7 +58,7 @@ module VersionManager
     end
 
     def default_commit_message(version)
-      message = VersionManager.options[:vcs][:default_commit_message]
+      message = options[:vcs][:default_commit_message]
       message.respond_to?(:call) ? message.call(version) : message.to_s
     end
   end

data/lib/version-manager/release_version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module VersionManager
   class ReleaseVersion
     include Comparable
@@ -19,28 +20,28 @@ module VersionManager
       recalculate_parts
     end
 
-    def to_str
+    def to_s
       res = parts.map(&:to_i).join('.')
       [res, special].compact.join('--')
     end
-    alias_method :to_s, :to_str
 
     def short_version
       [major, minor].map(&:to_i).join('.')
     end
 
-    def branch
-      VersionManager.options[:version_name].call(self)
+    def <=>(other)
+      parts.zip(other.parts)
+           .map { |this, other_part| this <=> other_part }
+           .find { |res| res != 0 } || 0
     end
 
-    def <=>(other_version)
-      parts.zip(other_version.parts).
-        map { |this, other| this <=> other }.
-        find { |res| res != 0 } || 0
+    def -(other)
+      self.class.new(parts.zip(other.parts).map { |x, y| x - y })
     end
 
-    def -(other_version)
-      self.class.new(parts.zip(other_version.parts).map { |x, y| x - y })
+    def bump(release_type)
+      raise ArgumentError, 'Unknown release type' unless %i(major minor patch).include?(release_type.to_sym)
+      public_send("bump_#{release_type}")
     end
 
     def bump_major

data/lib/version-manager/vcs.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module VersionManager
   module VCS
     class BranchAlreadyExistsError < StandardError
@@ -20,9 +21,14 @@ module VersionManager
       end
     end
 
-    def self.build
-      case VersionManager.options[:vcs][:name]
-      when 'git' then VersionManager::VCS::Git.new(VersionManager.options[:vcs][:options])
+    def self.branch_name(version, vcs_options)
+      version = ReleaseVersion.new(version) if version.is_a?(String)
+      vcs_options[:version_name].call(version)
+    end
+
+    def self.build(vcs_options)
+      case vcs_options[:name]
+      when 'git' then VersionManager::VCS::Git.new(vcs_options[:options])
       else raise UnsupportedVCSError
       end
     end

data/lib/version-manager/vcs/git.rb

@@ -1,33 +1,36 @@
+# frozen_string_literal: true
 module VersionManager
   module VCS
     class Git
       def initialize(options)
         @options = options
-        @git = ::Git.open(ROOT_DIR, options)
+        @git = ::Git.open(options[:dir], options)
       end
 
-      def create_branch!(branch_name)
-        raise VersionManager::VCS::BranchAlreadyExistsError.new(branch_name) if branch_exists?(branch_name)
-        checkout(branch_name)
+      def create_branch!(branch)
+        branch = branch_name(branch)
+        raise VersionManager::VCS::BranchAlreadyExistsError, branch if branch_exists?(branch)
+        checkout(branch)
       end
 
-      def checkout(branch_name)
-        git.branch(branch_name).checkout
+      def checkout(branch)
+        git.branch(branch_name(branch)).checkout
       end
 
-      def switch_branch(branch_name) # checkout moves commits to new branch
-        git.lib.send(:command, 'checkout', branch_name)
+      def switch_branch(branch) # checkout moves commits to new branch
+        git.lib.send(:command, 'checkout', branch_name(branch))
       end
 
       def show_file(branch, filepath)
-        git.object("#{remote}/#{branch}:#{filepath}").contents
+        relative_filepath = Pathname.new(filepath).relative_path_from(Pathname.new(options[:dir])).to_s
+        git.object("#{remote}/#{branch_name(branch)}:#{relative_filepath}").contents
       rescue StandardError
         nil
       end
 
       def commit(filepath, message)
         git.lib.send(:command, 'add', filepath)
-        git.lib.send(:command, 'commit', "-m #{message}", '-o', "#{filepath}")
+        git.lib.send(:command, 'commit', "-m #{message}", '-o', filepath)
       end
 
       def add_tag(tag_name, message)
@@ -52,22 +55,26 @@ module VersionManager
       end
 
       def state_actual?
-        head = ::Git.ls_remote['branches'][git.current_branch]
+        head = git_remote['branches'][git.current_branch]
         remote_head = find_remote_branch(git.current_branch).last
         return unless remote_head
         head[:sha] == remote_head[:sha]
       end
 
       def remote_branch_names
-        ::Git.ls_remote['remotes'].keys
+        git_remote['remotes'].keys
       end
 
       private
 
       attr_reader :git, :options
 
+      def branch_name(version)
+        VCS.branch_name(version, options)
+      end
+
       def branch_exists?(branch_name)
-        branches = ::Git.ls_remote['branches'].keys + ::Git.ls_remote['remotes'].keys
+        branches = git_remote['branches'].keys + git_remote['remotes'].keys
         branches.any? { |b| b.split('/').last == branch_name }
       end
 
@@ -75,16 +82,20 @@ module VersionManager
         options[:master_branch]
       end
 
-      def remote
-        options[:remote]
-      end
-
       def remote_master_branch_name
-        "#{options[:remote]}/#{master_branch_name}"
+        "#{remote}/#{master_branch_name}"
       end
 
       def find_remote_branch(branch_name)
-        ::Git.ls_remote['remotes'].find { |remote, _| branch_name == remote.split('/').last }
+        remote_branch_names.find { |remote| branch_name == remote.split('/').last }
+      end
+
+      def remote
+        options[:remote]
+      end
+
+      def git_remote
+        ::Git.ls_remote(options[:dir])
       end
     end
   end

data/lib/version-manager/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module VersionManager
-  VERSION = '0.0.9'.freeze
+  VERSION = '0.1.0'
 end

data/lib/version-manager/version_storage.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module VersionManager
   class VersionStorage
     class WrongLatestVersionError < StandardError
@@ -38,7 +39,7 @@ module VersionManager
 
     def version_from_file(version)
       return unless version
-      file_content = vcs.show_file(version.branch, relative_path) if version
+      file_content = vcs.show_file(version, full_path) if version
       ReleaseVersion.new(file_content) if file_content && ReleaseVersion.valid?(file_content)
     end
 
@@ -48,10 +49,6 @@ module VersionManager
       ReleaseVersion.new(branch_name) if branch_name.include?('release-') && ReleaseVersion.valid?(branch_name)
     end
 
-    def relative_path
-      Pathname.new(full_path).relative_path_from(Pathname.new(ROOT_DIR)).to_s
-    end
-
     def full_path
       File.expand_path(File.join(filepath, filename))
     end
@@ -62,9 +59,9 @@ module VersionManager
       return prev_last_version unless last_version
       diff = last_version - prev_last_version
       is_appropriate = diff.major == 1
-      is_appropriate ||= diff.major == 0 && diff.minor == 1
-      is_appropriate ||= diff.major == 0 && diff.minor == 0 && diff.patch == 1
-      raise WrongLatestVersionError.new(last_version) unless is_appropriate
+      is_appropriate ||= diff.major.zero? && diff.minor == 1
+      is_appropriate ||= diff.major.zero? && diff.minor.zero? && diff.patch == 1
+      raise WrongLatestVersionError, last_version unless is_appropriate
       last_version
     end
   end

data/spec/features/git_bumping_version_action_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/BlockLength
+RSpec.describe 'bumping version action' do
+  include_context 'shared settings'
+  let(:repo) { Test::GitRepository.new(root_dir, options) }
+
+  context 'when repository does not contain any versions' do
+    let(:initial_version) { VersionManager::ReleaseVersion.new('1.0.0') }
+    before { repo.init }
+    it 'retrieves an initial version' do
+      retrieve_initial_version_func = ->() { initial_version }
+      release_new_version(:major, default_confirmation_func, retrieve_initial_version_func)
+
+      expect(repo).to have_version(initial_version.bump_major)
+      expect(repo).to have_tag(initial_version.bump_major)
+      expect(repo).to have_branch(release_name(initial_version.bump_major))
+    end
+  end
+
+  context 'when initial version is presented' do
+    let(:initial_version) { VersionManager::ReleaseVersion.new('1.0.0') }
+    let(:current_version) { initial_version.bump_major }
+    before do
+      repo.init
+      retrieve_initial_version_func = ->() { initial_version }
+      release_new_version(:major, default_confirmation_func, retrieve_initial_version_func)
+    end
+
+    context 'when current branch is a master branch' do
+      before { repo.checkout_to_master_branch }
+      it 'bumped major version' do
+        release_new_version(:major)
+        expect(repo).to have_version(current_version.bump_major)
+        expect(repo).to have_tag(current_version.bump_major)
+        expect(repo).to have_branch(release_name(current_version.bump_major))
+      end
+
+      it 'bumped minor version' do
+        release_new_version(:minor)
+        expect(repo).to have_version(current_version.bump_minor)
+        expect(repo).to have_tag(current_version.bump_minor)
+        expect(repo).to have_branch(release_name(current_version.bump_minor))
+      end
+
+      it 'does not bump patch version' do
+        expect { release_new_version(:patch) }.to(
+          raise_error(VersionManager::ReleaseManager::ForbiddenBranchError)
+        )
+      end
+    end
+
+    context 'when current branch is different from a master branch' do
+      it 'does not bump major version' do
+        expect { release_new_version(:major) }.to(
+          raise_error(VersionManager::ReleaseManager::ForbiddenBranchError)
+        )
+      end
+
+      it 'does not bump minor version' do
+        expect { release_new_version(:minor) }.to(
+          raise_error(VersionManager::ReleaseManager::ForbiddenBranchError)
+        )
+      end
+
+      it 'bumped patch version' do
+        release_new_version(:patch)
+        expect(repo).to have_version(current_version.bump_patch)
+        expect(repo).to have_tag(current_version.bump_patch)
+        expect(repo).to have_branch(release_name(current_version.bump_patch))
+      end
+    end
+  end
+
+  context 'when repository is not up to date' do
+    let(:initial_version) { VersionManager::ReleaseVersion.new('1.0.0') }
+    let(:current_version) { initial_version.bump_major }
+    before do
+      repo.init
+      retrieve_initial_version_func = ->() { initial_version }
+      release_new_version(:major, default_confirmation_func, retrieve_initial_version_func)
+      repo.checkout_to_master_branch
+      repo.add_and_commit_changes
+    end
+
+    %i(major minor patch).each do |version_type|
+      it "does not bump #{version_type} version" do
+        expect { release_new_version(version_type) }.to(
+          raise_error(VersionManager::ReleaseManager::BranchIsNotUpToDateError)
+        )
+      end
+    end
+  end
+
+  after(:each) do
+    repo.teardown if tmp_dir?
+  end
+end

data/spec/features/git_latest_version_action_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/BlockLength
+RSpec.describe 'latest version action' do
+  include_context 'shared settings'
+  let(:repo) { Test::GitRepository.new(root_dir, options) }
+
+  def checkout_to_latest_version
+    VersionManager::ActionManager.new(options).checkout_to_latest_version
+  end
+
+  context 'when a repository does not contain any versions' do
+    before { repo.init }
+    it 'do nothing' do
+      expect(checkout_to_latest_version).to be_falsy
+    end
+  end
+
+  context 'when a repository has several releases' do
+    let(:initial_version) { VersionManager::ReleaseVersion.new('1.0.0') }
+    let(:current_version) { @current_version }
+    before do
+      repo.init
+      @current_version = initial_version
+      retrieve_initial_version_func = ->() { initial_version }
+      (1..10).to_a.sample.times do
+        release_type = %i(major minor).sample
+        @current_version = @current_version.bump(release_type)
+        release_new_version(release_type, default_confirmation_func, retrieve_initial_version_func)
+        repo.checkout_to_master_branch
+      end
+    end
+
+    it 'checkouts to latest version' do
+      expect(checkout_to_latest_version).to be_truthy
+      expect(repo).to have_version(current_version)
+      expect(repo).to have_tag(current_version)
+      expect(repo).to have_branch(release_name(current_version))
+    end
+  end
+
+  after(:each) do
+    repo.teardown if tmp_dir?
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+begin
+  require 'byebug'
+rescue LoadError
+  nil
+end
+
+require 'securerandom'
+
+require 'version-manager'
+
+require_relative 'support/git_repository'
+require_relative 'support/shared_settings'
+require_relative 'support/repository_matchers'
+
+RSpec.configure do |config|
+  config.order = :random
+end

data/spec/support/git_repository.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Test
+  class GitRepository
+    def initialize(root_dir, options)
+      @options = options
+      @root_dir = root_dir
+    end
+
+    def init
+      @remote_dir = File.join(@root_dir, 'remote')
+      @remote = Git.init(@remote_dir, bare: true)
+      @local = Git.clone(@remote_dir, 'local', path: @root_dir)
+      @local2 = Git.clone(@remote_dir, 'local2', path: @root_dir)
+
+      initial_commit(@local)
+      @local
+    end
+
+    def checkout_to_master_branch
+      @local.lib.send(:command, 'checkout', @options.dig(:vcs, :options, :master_branch))
+    end
+
+    def current_local_branch_version
+      path = File.join(@options[:storage][:filepath], @options[:storage][:filename])
+      File.open(path).read
+    end
+
+    def current_local_tag
+      @local.tags.last&.name
+    end
+
+    def current_local_branch
+      @local.branches.to_a.last&.name
+    end
+
+    def add_and_commit_changes
+      add_random_changes(@local)
+      @local.add
+      @local.commit('some changes')
+    end
+
+    def teardown
+      FileUtils.rm_f(@remote_dir)
+      FileUtils.rm_f(@local.dir.path)
+      FileUtils.rm_f(@local2.dir.path)
+    end
+
+    private
+
+    def initial_commit(repo)
+      add_random_changes(repo)
+      repo.add
+      repo.commit('initial commit')
+      repo.push
+    end
+
+    def add_random_changes(repo)
+      File.open(File.join(repo.dir.path, SecureRandom.urlsafe_base64), 'w') do |f|
+        f << SecureRandom.urlsafe_base64
+      end
+    end
+  end
+end

data/spec/support/repository_matchers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+RSpec::Matchers.define :have_version do |version|
+  match do |repo|
+    repo.current_local_branch_version == version.to_s
+  end
+end
+
+RSpec::Matchers.define :have_tag do |version|
+  match do |repo|
+    repo.current_local_tag == version.to_s
+  end
+end
+
+RSpec::Matchers.define :have_branch do |version|
+  match do |repo|
+    repo.current_local_branch == version.to_s
+  end
+end

data/spec/support/shared_settings.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# rubocop:disable Metrics/BlockLength
+RSpec.shared_context 'shared settings' do
+  let(:root_dir) { Dir.mktmpdir }
+  let(:tmp_dir?) { true }
+  let(:repo_dir) { File.join(root_dir, 'local') }
+
+  let(:vcs) { 'git' }
+  let(:default_commit_message) do
+    ->(version) { "Bumped to version #{version}" }
+  end
+  let(:vcs_opts) do
+    {
+      name: vcs,
+      default_commit_message: default_commit_message,
+      options: {
+        remote: 'origin',
+        master_branch: 'master',
+        dir: repo_dir,
+        version_name: ->(version) { "release-#{version.short_version}" }
+      }
+    }
+  end
+
+  let(:authorized_branches_opts) do
+    {
+      major: '^\bmaster\b$',
+      minor: '^\bmaster\b$',
+      patch: '^\brelease-[a-zA-Z0-9.]*$\b$'
+    }
+  end
+
+  let(:storage_opts) do
+    {
+      filename: 'VERSION',
+      filepath: repo_dir
+    }
+  end
+
+  let(:options) do
+    {
+      vcs: vcs_opts,
+      authorized_branches: authorized_branches_opts,
+      storage: storage_opts
+    }
+  end
+
+  let(:default_confirmation_func) { ->(_new_version) { true } }
+
+  def release_new_version(release_type, confirmation_func = default_confirmation_func, retrieve_init_version_func = nil)
+    VersionManager::ActionManager
+      .new(options)
+      .release_new_version(release_type, confirmation_func, retrieve_init_version_func)
+  end
+
+  def release_name(version)
+    VersionManager::VCS.branch_name(version, options.dig(:vcs, :options))
+  end
+end

data/version-manager.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'version-manager/version'
@@ -6,7 +7,7 @@ require 'version-manager/version'
 Gem::Specification.new do |spec|
   spec.name          = 'version-manager'
   spec.version       = VersionManager::VERSION
-  spec.authors       = ['isolo']
+  spec.authors       = ['Ilya Solo']
   spec.email         = ['ilya.i.solo@gmail.com']
 
   spec.summary       = 'Versioning lib (with Git support)'
@@ -18,9 +19,20 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.3'
+
   spec.add_development_dependency 'bundler', '~> 1.12'
   spec.add_development_dependency 'rake', '~> 10.0'
+
+  # Testing
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rubocop'
+
+  # Command line utils
   spec.add_dependency 'docopt', '~> 0.5'
   spec.add_dependency 'inquirer', '~> 0.2'
+
+  # Other
   spec.add_dependency 'git', '~> 1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: version-manager
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
-- isolo
+- Ilya Solo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-02 00:00:00.000000000 Z
+date: 2017-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: rubocop
+  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: docopt
   requirement: !ruby/object:Gem::Requirement
@@ -89,22 +131,28 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".ruby-version"
+- ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- bin/console
-- bin/setup
 - exe/manver
 - lib/version-manager.rb
+- lib/version-manager/action_manager.rb
 - lib/version-manager/cli.rb
-- lib/version-manager/make.rb
+- lib/version-manager/release_manager.rb
 - lib/version-manager/release_version.rb
 - lib/version-manager/vcs.rb
 - lib/version-manager/vcs/git.rb
 - lib/version-manager/version.rb
 - lib/version-manager/version_storage.rb
+- spec/features/git_bumping_version_action_spec.rb
+- spec/features/git_latest_version_action_spec.rb
+- spec/spec_helper.rb
+- spec/support/git_repository.rb
+- spec/support/repository_matchers.rb
+- spec/support/shared_settings.rb
 - version-manager.gemspec
 homepage: https://github.com/isolo/version-manager
 licenses:
@@ -118,7 +166,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.ruby-version

@@ -1 +0,0 @@
-2.3.1

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "version/manager"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here