verto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57720313b35dae31896c4cc8ed940487c14c6f268269474dcaf7a739eb31f371
+  data.tar.gz: 37b947db3e863ba538e945eff7f02241f862b6d021b43223c9c95d28bf7df144
+SHA512:
+  metadata.gz: e3791c56946d015d4199863331a836d661d159ceed0c817f80c169ee8ea71523a874b31a656be6df2fb7bf7671041ab2430dac4fcc08420292ee76e0fe826997
+  data.tar.gz: dc69546ca9d8427bfe51610fd6444061d3356f840a6836fe81c275ad0bba5abe14592095b92be5bb719392e32de9678ecc9b85785d382084c22f8a2cd92f233a

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.0.2

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    verto (0.1.0)
+      dry-auto_inject (~> 0.6)
+      dry-configurable (~> 0.8)
+      dry-container (~> 0.7)
+      thor (~> 1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.1)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    dry-auto_inject (0.7.0)
+      dry-container (>= 0.3.4)
+    dry-configurable (0.9.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.4, >= 0.4.7)
+    dry-container (0.7.2)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.4.9)
+      concurrent-ruby (~> 1.0)
+    rake (10.5.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+    thor (1.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  verto!
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Carlos Atkinson
+
+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,82 @@
+# Verto
+
+Verto is a CLI to generate git tags (following the [Semantic Versioning](https://semver.org/) system)
+
+## Installation
+
+Verto is distributed as a ruby gem, to install run:
+
+```
+$ gem install verto
+```
+
+## Usage
+
+Now you can run verto right out of the box without any configuration:
+
+```
+  verto tag up --patch # Creates a new tag increasing the patch number
+  verto tag up --minor # Creates a new tag increasing the minor number
+  verto tag up --major # Creates a new tag increasing the major number
+```
+
+### Verto DSL
+
+If you need a more specific configuration or want to reflect your development proccess in some way, you can use Verto DSL creating a Vertofile with the configuration.
+
+```ruby
+# Vertofile
+config {
+  pre_release.initial_number = 0
+  project.path = "my/repo/path"
+}
+
+before { sh('echo "Creating Tag"') }
+
+context(branch('master')) {
+  on('before_tag_creation') {
+    versions_changes = "## #{new_version} - #{Time.now.strftime('%d/%m/%Y')}\n"
+    exit unless confirm("Create a new release?\n" \
+      "#{versions_changes}"
+    )
+
+    file('CHANGELOG.md').prepend(versions_changes)
+    git('add CHANGELOG.md')
+    git('commit -m "Updates CHANGELOG"')
+  }
+
+  after_command('tag_up') {
+    git('push --tags')
+    git('push origin master')
+  }
+}
+
+context(branch('qa')) {
+  before_command('tag_up') {
+    command_options.add(pre_release: 'rc')
+  }
+
+  after_command('tag_up') {
+    file('releases.log').append(new_version.to_s)
+  }
+}
+
+```
+
+#### Verto Syntax
+
+...TODO...
+
+## TODO
+
+  1. Complete README.md description
+  2. Add a configuration to enable, disable or specify the number of tags that a single commit can have(eg: only one release and one pre-release)
+  3. Enable the *sh* dsl output to be show as default
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/catks/verto.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require_relative "lib/verto"
+require_relative "spec/helpers/test_repo.rb"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc 'Verto REPL'
+task :console do
+  exec 'irb -r ./lib/verto -r ./spec/helpers/test_repo.rb'
+end
+
+namespace :temp_repo do
+  desc 'Initialize a temp git repo'
+  task :init do
+    TestRepo.new.init!
+  end
+
+  desc 'clear the temp git repo'
+  task :clear do
+    TestRepo.new.clear
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "verto"
+
+# 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(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/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

data/exe/verto

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/verto'
+
+vertofile_path = ENV['VERTOFILE_PATH'] || Pathname.new(Dir.pwd).join('Vertofile').to_s
+
+Verto::DSL.load_file(vertofile_path) if File.exists?(vertofile_path)
+
+Verto::MainCommand.start(ARGV)

data/lib/verto/commands/base_command.rb

@@ -0,0 +1,27 @@
+module Verto
+  class BaseCommand < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    private
+
+    def command_error!(message)
+      raise Thor::Error, message
+    end
+
+    def options
+      super.merge Verto.config.command_options
+    end
+
+    def call_hooks(moments = [], with_attributes: {})
+      moments_to_call = ([] << moments).flatten
+
+      moments_to_call.each do |moment|
+        Verto.config.hooks
+          .select { |hook| hook.moment == moment.to_sym }
+          .each { |hook| hook.call(with_attributes: with_attributes) }
+      end
+    end
+  end
+end

data/lib/verto/commands/main_command.rb

@@ -0,0 +1,6 @@
+module Verto
+  class MainCommand < BaseCommand
+    desc "tag SUBCOMMAND ...ARGS", "manage the repository tags"
+    subcommand 'tag', Verto::TagCommand
+  end
+end

data/lib/verto/commands/tag_command.rb

@@ -0,0 +1,88 @@
+module Verto
+  class TagCommand < BaseCommand
+    desc "up", "Create's a new tag"
+
+    option :major, type: :boolean, default: false
+    option :minor, type: :boolean, default: false
+    option :patch, type: :boolean, default: false
+    option :pre_release, type: :string
+    option :filter, type: :string
+
+    def up
+      call_hooks(%i[before before_tag_up])
+
+      validate_version_option_presence!
+
+      latest_tag = tag_repository.latest(filter: load_filter)
+
+      validate_latest_tag!(latest_tag)
+
+      latest_version = SemanticVersion.new(latest_tag)
+
+      version_up_options = options.select { |key,value| value == true }.keys.map(&:to_sym) & [:major, :minor, :patch]
+
+      new_version = version_up_options.reduce(latest_version) { |version, up_option| version.up(up_option) }
+
+      if options[:pre_release]
+        identifier = pre_release_configured? ? options[:pre_release] : latest_version.pre_release.name
+        new_version = new_version.with_pre_release(identifier)
+        new_version = new_version.up(:pre_release) if new_version.pre_release.name == latest_version.pre_release.name
+      end
+
+      validate_new_version!(new_version, latest_version)
+      call_hooks(:before_tag_creation, with_attributes: { new_version: new_version, latest_version: latest_version } )
+      tag_repository.create!(new_version.to_s)
+
+      call_hooks(:after_tag_up, with_attributes: { new_version: new_version })
+      call_hooks(:after)
+    end
+
+    private
+
+    include Verto.import['tag_repository']
+
+    def pre_release_configured?
+      options[:pre_release] != 'pre_release'
+    end
+
+    def validate_latest_tag!(latest_tag)
+      command_error!(
+        <<~TEXT
+          Project doesn't have a previous tag version, create a new tag with git or verto init.
+          eg: `git tag 0.0.1` or `verto init`
+        TEXT
+      ) unless latest_tag
+    end
+
+    def validate_new_version!(new_version, latest_version)
+      command_error!(
+        <<~TEXT
+        New version(#{new_version}) can't be equal or lower than latest version(#{latest_version})
+        run up --pre-release with --patch, --minor or --major (eg: verto tag up --pre-release --patch),
+        add filters (eg: verto tag up --pre-release --filter=pre_release_only)
+        or disable tag validation in Vertofile with config.version.validations.new_version_must_be_bigger = false
+        TEXT
+      ) if new_version < latest_version
+    end
+
+    def validate_version_option_presence!
+      command_error!(
+        <<~TEXT
+        You must specify the version number to be increased, use the some of the options(eg: --major, --minor, --patch, --pre_release=rc)
+        or configure a Vertofile to specify a default option for current context, eg:
+
+        context('qa') {
+          before_command('tag_up') {
+            command_options.add(pre_release: 'rc')
+          }
+        }
+        TEXT
+      ) unless options[:major] || options[:minor] || options[:patch] || options[:pre_release]
+
+    end
+
+    def load_filter
+      TagFilter.for(options[:filter]) || Regexp.new(options[:filter].to_s)
+    end
+  end
+end

data/lib/verto/dsl/file.rb

@@ -0,0 +1,49 @@
+module Verto
+  module DSL
+    class File
+      def initialize(filename, path: Verto.config.project.path)
+        @filename = filename
+        @path = Pathname.new(path)
+      end
+
+      def replace(to_match, to_replace)
+        content = file.read
+
+        file.open('w') do |f|
+          f << content.sub(to_match, to_replace)
+        end
+      end
+
+      def replace_all(to_match, to_replace)
+        content = file.read
+
+        file.open('w') do |f|
+          f << content.gsub(to_match, to_replace)
+        end
+      end
+
+      def append(content)
+        file.open('a') do |f|
+          f << content
+        end
+      end
+
+      def prepend(content)
+        file_content = file.read
+
+        file.open('w') do |f|
+          f << (content + file_content)
+        end
+      end
+
+      alias_method :gsub, :replace_all
+      alias_method :sub, :replace
+
+      private
+
+      def file
+        @path.join(@filename)
+      end
+    end
+  end
+end

data/lib/verto/dsl/hook.rb

@@ -0,0 +1,17 @@
+module Verto
+  module DSL
+    class Hook
+      attr_accessor :moment
+
+      def initialize(interpreter: DSL.interpreter, moment: :before, &block)
+        @moment = moment.to_sym
+        @interpreter = interpreter
+        @block = block
+      end
+
+      def call(with_attributes: {})
+        @interpreter.evaluate(attributes: with_attributes, &@block)
+      end
+    end
+  end
+end

data/lib/verto/dsl/interpreter.rb

@@ -0,0 +1,29 @@
+module Verto
+  module DSL
+    class Interpreter
+      include DSL::Syntax
+
+      def evaluate(vertofile_content=nil, attributes: {}, &block)
+        with_attributes(attributes) do
+          vertofile_content ? instance_eval(vertofile_content)  : instance_eval(&block)
+        end
+      end
+
+      private
+
+      def with_attributes(attributes, &block)
+        attributes.each do |key, value|
+          instance_variable_set("@#{key}", value)
+          define_singleton_method(key) { instance_variable_get("@#{key}") }
+        end
+
+        block.call
+
+        attributes.each do |key, value|
+          instance_variable_set("@#{key}", nil)
+          singleton_class.remove_method(key)
+        end
+      end
+    end
+  end
+end

data/lib/verto/dsl/syntax.rb

@@ -0,0 +1,75 @@
+module Verto
+  module DSL
+    module Syntax
+      def config(&block)
+        Verto.config.instance_eval(&block)
+      end
+
+      def current_branch
+        git('rev-parse --abbrev-ref HEAD').output.chomp.strip
+      end
+
+      def branch(*branch_names)
+        branch_names.map(&:to_s).include? current_branch
+      end
+
+      def context(condition, &block)
+        block.call if condition
+      end
+
+      def git(subcommand)
+        sh("git #{subcommand}")
+      end
+
+      def sh(command)
+        command_executor.run command
+      end
+
+      def command_options
+        Verto.config.command_options
+      end
+
+      def on(moment, &block)
+        Verto.config.hooks << Hook.new(moment: moment, &block)
+      end
+
+      def before(&block)
+        Verto.config.hooks << Hook.new(moment: :before, &block)
+      end
+
+      def after(&block)
+        Verto.config.hooks << Hook.new(moment: :after, &block)
+      end
+
+      def before_command(command_name, &block)
+        Verto.config.hooks << Hook.new(moment: "before_#{command_name}", &block)
+      end
+
+      def after_command(command_name, &block)
+        Verto.config.hooks << Hook.new(moment: "after_#{command_name}", &block)
+      end
+
+      def file(filepath)
+        DSL::File.new(filepath)
+      end
+
+      def env(environment_name)
+        ENV[environment_name]
+      end
+
+      def confirm(text)
+        shell_basic.yes?("#{text} (y/n)")
+      end
+
+      private
+
+      def command_executor
+        @command_executor ||= SystemCommandExecutor.new
+      end
+
+      def shell_basic
+        @shell_basic ||= Thor::Shell::Basic.new
+      end
+    end
+  end
+end

data/lib/verto/dsl.rb

@@ -0,0 +1,13 @@
+module Verto
+  module DSL
+    def self.load_file(filepath)
+      vertofile_content = IO.read(filepath)
+
+      interpreter.evaluate(vertofile_content)
+    end
+
+    def self.interpreter
+      @interpreter ||= Interpreter.new
+    end
+  end
+end

data/lib/verto/repositories/tag_repository.rb

@@ -0,0 +1,20 @@
+module Verto
+  class TagRepository
+    include Verto.import[executor: 'system_command_executor']
+
+    def latest(filter: nil)
+      all(filter: filter).last
+    end
+
+    def create!(tag)
+      # TODO: Implements tag in other commits
+      executor.run! "git tag #{tag}"
+    end
+
+    def all(filter: nil)
+      results = executor.run("git tag | grep -Eo '[0-9]+\.[0-9]+\.[0-9]+(-.+\.[0-9]+)*' | sed 's/\([0-9]\.[0-9]\.[0-9]$\)/\1-zzzzzzzzzz/' | sort -V |  sed 's/-zzzzzzzzzz//' | cat").output.split
+
+      filter ?  results.select { |tag| tag.match?(filter) } : results
+    end
+  end
+end

data/lib/verto/utils/semantic_version.rb

@@ -0,0 +1,126 @@
+module Verto
+  class SemanticVersion
+    include Comparable
+
+    REGEXP = /(\d+)\.(\d+)\.(\d+)(-?.*)/
+
+    class PreRelease
+      include Comparable
+
+      REGEXP = /-?(.+)\.(\d+)/
+
+      attr_accessor :name, :number
+
+      def self.with(name:, number: Verto.config.pre_release.initial_number)
+        instance = allocate
+        instance.name = name
+        instance.number = number
+        instance
+      end
+
+      def initialize(pre_release, initial_number: Verto.config.pre_release.initial_number)
+        name, number = pre_release.match(REGEXP)&.captures
+
+        @initial_number = initial_number
+        return if name.nil? && number.nil?
+
+        @name = name
+        @number = number ? number.to_i : initial_number
+      end
+
+      def up
+        raise BlankPreRelease if blank?
+
+        new_pre_release = self.dup
+        new_pre_release.number = number ? number + 1 : @initial_number
+        new_pre_release
+      end
+
+      def <=>(other)
+        return -1 if present? && other.blank?
+        return  1 if blank? && other.present?
+        to_s <=> other.to_s
+      end
+
+      def blank?
+        name.nil? && number.nil?
+      end
+
+      def present?
+        !blank?
+      end
+
+      def to_s
+        return '' if blank?
+
+        "-#{@name}.#{@number}"
+      end
+    end
+
+    attr_accessor :major, :minor, :patch, :pre_release
+
+    def initialize(version, pre_release_initial_number: Verto.config.pre_release.initial_number)
+      major, minor, patch, pre_release = version.match(REGEXP).captures
+
+      @major = major.to_i
+      @minor = minor.to_i
+      @patch = patch.to_i
+      @pre_release = PreRelease.new(pre_release)
+
+      @pre_release_initial_number = pre_release_initial_number
+    end
+
+    def up(version_type)
+      new_version = self.dup
+
+      case version_type
+      when :major
+        new_version.major += 1
+        new_version.minor = 0
+        new_version.patch = 0
+        new_version.pre_release.number = @pre_release_initial_number if pre_release?
+      when :minor
+        new_version.minor += 1
+        new_version.patch = 0
+        new_version.pre_release.number = @pre_release_initial_number if pre_release?
+      when :patch
+        new_version.patch += 1
+        new_version.pre_release.number = @pre_release_initial_number if pre_release?
+      when :pre_release
+        new_version.pre_release = new_version.pre_release.up
+      end
+
+      new_version
+    end
+
+    def with_pre_release(name)
+      new_version = self.dup
+
+      return new_version if new_version.pre_release? && new_version.pre_release.name == name
+
+      new_version.pre_release = PreRelease.with(name: name)
+
+      new_version
+    end
+
+    def pre_release?
+      pre_release.present?
+    end
+
+    def <=>(other)
+      return 1 if major > other.major
+      return 1 if major == other.major && minor > other.minor
+      return 1 if major == other.major && minor == other.minor && patch > other.patch
+      return 1 if major == other.major && minor == other.minor && patch == other.patch && pre_release > other.pre_release
+      return 0 if major == other.major && minor == other.minor && patch == other.patch && pre_release == other.pre_release
+
+      -1
+    end
+
+    def to_s
+      version = "#{@major}.#{@minor}.#{@patch}"
+      version << @pre_release.to_s if @pre_release
+      version
+    end
+  end
+end

data/lib/verto/utils/system_command_executor.rb

@@ -0,0 +1,34 @@
+require 'open3'
+
+module Verto
+  class SystemCommandExecutor
+    include Verto.import['project.path']
+
+    class Result < Struct.new(:output, :error, :result)
+      def success?
+        @result.success?
+      end
+
+      def error?
+        !success?
+      end
+    end
+    Error = Class.new(StandardError)
+
+    def run(command)
+      Open3.popen3(command, chdir: path.to_s) do |stdin, stdout, stderr, wait_thread|
+        @output = stdout.read
+        @error = stderr.read
+        @result = wait_thread.value
+      end
+
+      Result.new(@output, @error, @result)
+    end
+
+    def run!(command)
+      run(command)
+
+      raise Error, @error unless @error.empty?
+    end
+  end
+end

data/lib/verto/utils/tag_filter.rb

@@ -0,0 +1,13 @@
+module TagFilter
+  REALEASE_ONLY = /\d+\.\d+\.\d+$/
+  PRE_REALEASE_ONLY = /\d+\.\d+\.\d+-.*\d+/
+
+  FILTERS = {
+    release_only: REALEASE_ONLY,
+    pre_release_only: PRE_REALEASE_ONLY,
+  }
+
+  def self.for(tag_key)
+    FILTERS[tag_key.to_sym] if tag_key
+  end
+end

data/lib/verto/version.rb

@@ -0,0 +1,3 @@
+module Verto
+  VERSION = "0.1.0"
+end

data/lib/verto.rb

@@ -0,0 +1,56 @@
+require "thor"
+require "dry-container"
+require "dry-configurable"
+require "dry-auto_inject"
+require "pathname"
+
+require "verto/version"
+
+module Verto
+  extend Dry::Configurable
+
+  setting :pre_release do
+    setting :initial_number, 1
+  end
+
+  setting :project do
+    setting :path, './'
+  end
+
+  setting :hooks, []
+  setting :command_options, Class.new(Hash) { alias_method :add, :merge! }.new
+
+  def self.root_path
+    Pathname.new File.expand_path(File.dirname(__FILE__) + '/..')
+  end
+
+
+  def self.container
+    @container ||= Dry::Container.new.tap do |container|
+      container.register('system_command_executor') { SystemCommandExecutor.new }
+      container.register('tag_repository') { TagRepository.new }
+
+      # TODO: Remove project.path from container
+      container.namespace('project') do
+        register('path') { Verto.config.project.path }
+      end
+    end
+  end
+
+  def self.import
+    @import ||= Dry::AutoInject(container)
+  end
+end
+
+require "verto/utils/semantic_version.rb"
+require "verto/utils/system_command_executor"
+require "verto/utils/tag_filter"
+require "verto/dsl"
+require "verto/dsl/syntax"
+require "verto/dsl/interpreter"
+require "verto/dsl/hook"
+require "verto/dsl/file"
+require "verto/commands/base_command"
+require "verto/commands/tag_command"
+require "verto/commands/main_command"
+require "verto/repositories/tag_repository"

data/verto.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "verto/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "verto"
+  spec.version       = Verto::VERSION
+  spec.authors       = ["Carlos Atkinson"]
+  spec.email         = ["carlos.atks@gmail.com"]
+
+  spec.summary       = %q{Verto helps you to versionate your project}
+  spec.homepage      = "https://github.com/catks/verto"
+  spec.license       = "MIT"
+
+
+  # spec.metadata["homepage_uri"] = spec.homepage
+  # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "thor", "~> 1.0.1"
+  spec.add_dependency             "dry-configurable", "~> 0.8"
+  spec.add_dependency             "dry-container", "~> 0.7"
+  spec.add_dependency             "dry-auto_inject", "~> 0.6"
+
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: verto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carlos Atkinson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: dry-auto_inject
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- carlos.atks@gmail.com
+executables:
+- verto
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/verto
+- lib/verto.rb
+- lib/verto/commands/base_command.rb
+- lib/verto/commands/main_command.rb
+- lib/verto/commands/tag_command.rb
+- lib/verto/dsl.rb
+- lib/verto/dsl/file.rb
+- lib/verto/dsl/hook.rb
+- lib/verto/dsl/interpreter.rb
+- lib/verto/dsl/syntax.rb
+- lib/verto/repositories/tag_repository.rb
+- lib/verto/utils/semantic_version.rb
+- lib/verto/utils/system_command_executor.rb
+- lib/verto/utils/tag_filter.rb
+- lib/verto/version.rb
+- verto.gemspec
+homepage: https://github.com/catks/verto
+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.3
+signing_key: 
+specification_version: 4
+summary: Verto helps you to versionate your project
+test_files: []