verto 0.9.0 → 0.12.0

data/VERTO_SYNTAX.md

@@ -0,0 +1,350 @@
+# Verto Syntax
+
+## verto_version
+
+Set the minimal verto version compatible with Vertofile
+
+```ruby
+# Vertofile
+verto_version '0.11.0'
+```
+
+## config
+
+Allows you to  customize the behavior for verto commands.
+
+Example:
+```ruby
+# Vertofile
+config {
+ version.prefix = 'v' # Adds a version_prefix
+ pre_release.default_identifier = 'alpha' # Defaults to 'rc'
+ git.pull_before_tag_creation = true # Pull Changes before tag creation
+ git.fetch_before_tag_creation = true # Fetch Branches and Tags before tag creation
+ git.push_after_tag_creation = true # Push changes after tag creation
+
+ ## CHANGELOG FORMAT
+ ## Verto uses Mustache template rendering to render changelog updates, the default value is:
+ ##
+ ##   ## {{new_version}} - #{Time.now.strftime('%d/%m/%Y')}
+ ##       {{#version_changes}}
+ ##       * {{.}}
+ ##       {{/version_changes}}
+ ##
+ ## A custom format can be specified, eg:
+ changelog.format =  <<~CHANGELOG
+                        ## {{new_version}}
+                         {{#version_changes}}
+                         * {{.}}
+                         {{/version_changes}}
+                     CHANGELOG
+}
+
+```
+
+## context
+
+In the context block you can create a scope that will only run if the statment it's true.
+
+Example:
+
+```ruby
+# Vertofile
+
+# Only runs on master branch
+context(branch('master')) {
+...
+}
+
+# Only runs on staging branch
+context(branch('staging')) {
+...
+}
+# Only runs if the branch is not master or staging
+context(!branch('master', 'staging')) {
+...
+}
+
+# You can also run with a custom conditional (With ruby code)
+context(current_branch.match?(/feature\/.+/)) {
+...
+}
+```
+
+## before
+
+Runs before executing a verto command
+
+```ruby
+# Vertofile
+
+before {
+ puts "Before a command"
+}
+context(branch('master')) {
+	before {
+	 puts "Before a command in master branch"
+	}
+}
+```
+## after
+Runs after executing a verto command
+
+Example:
+```ruby
+# Vertofile
+
+after {
+ puts "After a command"
+}
+context(branch('master')) {
+	before {
+	 puts "After a command in master branch"
+	}
+}
+```
+
+## before_command_tag_up
+
+Almost the same as before but run before the tag creation, the new tag can be accessible with as `new_version`
+
+Example:
+```ruby
+# Vertofile
+
+before_tag_creation {
+     puts "New version is #{new_version}"
+     ...
+}
+```
+
+## after_command_tag_up
+
+The same as before_command_tag_up but run after the tag creation, the new tag can be accessible with as `new_version`
+
+Example:
+```ruby
+# Vertofile
+
+after_tag_creation {
+     puts "New version is #{new_version}"
+     ...
+}
+```
+
+## command_options
+
+Allows you to set a specific option without the need to pass it explicity in the verto command (See `verto tag up --help` to see the options).
+
+Example:
+```ruby
+# Vertofile
+
+context(branch('master')) {
+  before_command_tag_up {
+    command_options.add(filter: 'release_only')
+  }
+  ...
+}
+
+context(branch('staging')) {
+  before_command_tag_up {
+    command_options.add(pre_release: 'rc')
+  }
+  ...
+}
+```
+
+## update_changelog
+
+Start a flow to update the changelog (must be in `before_command_tag_up` or  `after_command_tag_up)`
+
+Options include:
+
+* `:merged_pull_requests_with_bracketed_labels`: Uses all PR merged commits after the last tag if they have the [***] pattern
+* `:commits_with_bracketed_labels` : Uses all commits after the last tag if they have the [***] pattern (Exclude merge commits)
+* `:merged_pull_requests_messages` : Uses all merged commit after the last tag
+* `:commit_messages`: Uses all commits after the last tag (Exclude merge commits)
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+     update_changelog(with: :merged_pull_requests_with_bracketed_labels,
+                      confirmation: true, # Asks for confirmation (you can also edit the generated CHANGELOG)
+                      filename: 'CHANGELOG.md')
+     git('add CHANGELOG.md')
+
+     git('commit -m "Updates CHANGELOG"')
+  }
+}
+...
+```
+
+## file
+
+Allows you to do some operations in a specific file.
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+      file('package.json').replace(/"(\d+)\.(\d+)\.(\d+)(-?.*)"/, %Q{"#{new_version}"})
+      git!('add package.json')
+
+      file('README.md').replace_all(latest_version.to_s, new_version.to_s)
+      git!('add README.md')
+      git!('commit -m "Bumps Version"')
+
+	  file('versions_asc').append("#{new_version} - #{Time.now}")
+	  file('versions_desc').prepend("#{new_version} - #{Time.now}")
+    }
+  }
+...
+```
+
+## env
+
+Allows you to access a specifc environment variable
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('staging')) {
+  before_tag_creation {
+	  file('ci.log').append(env('CI_WORKER'))
+	  ...
+    }
+  }
+...
+```
+
+## confirm
+
+Ask for confirmation before executing anything
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+	  confirm('Are you sure?')
+	  ...
+    }
+  }
+...
+```
+
+## error
+
+Sends an error to **stderr**
+
+Example:
+```ruby
+# Vertofile
+...
+context(!branch('master')) {
+   error('Not at master')
+}
+...
+```
+
+## error!
+
+The same as error but exits verto (without creating a tag)
+
+Example:
+```ruby
+# Vertofile
+...
+context(!branch('master')) {
+   error!('Not at master')
+}
+...
+```
+
+## sh
+
+Runs any shell command.
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+      ...
+      sh('bundle install')
+      sh('rake install')
+      git!('add Gemfile.lock')
+
+      git!('commit -m "Bumps Version"')
+    }
+  }
+...
+```
+
+## sh!
+
+The same as sh but exits verto in case of errors
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+      ...
+      sh!('bundle install')
+      sh!('rake install')
+      git!('add Gemfile.lock')
+
+      git!('commit -m "Bumps Version"')
+    }
+  }
+...
+```
+
+## git
+
+Runs git commands in verto
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+      ...
+      update_changelog
+      git('add CHANGELOG.md')
+      git('commit -m "Bumps Version"')
+    }
+  }
+...
+```
+
+## git!
+
+The same as **git** but exits verto in case of errors
+
+Example:
+```ruby
+# Vertofile
+...
+context(branch('master')) {
+  before_tag_creation {
+      ...
+      update_changelog
+      git!('add CHANGELOG.md')
+      git!('commit -m "Bumps Version"')
+    }
+  }
+...
+```

data/Vertofile

@@ -1,4 +1,4 @@
-verto_version '0.7.0'
+verto_version '0.12.0'
 
 config {
   version.prefix = 'v' # Adds a version_prefix
@@ -12,22 +12,7 @@ context(branch('master')) {
   }
 
   before_tag_creation {
-    version_changes = ""
-     bitbucket_changes = sh(
-      %q#git log --oneline --decorate  | grep -B 100 -m 1 "tag:" | grep "pull request" | awk '{print $1}' | xargs git show --format='%b' | grep -v Approved | grep -v "^$" | grep -E "^[[:space:]]*\[.*\]" | sed 's/^[[:space:]]*\(.*\)/ * \1/'#, output: false
-     ).output
-     version_changes = bitbucket_changes
-
-    puts "---------------------------"
-    version_changes = "## #{new_version} - #{Time.now.strftime('%d/%m/%Y')}\n#{version_changes}\n"
-    exit unless confirm("Create new Realease?\n" \
-      "---------------------------\n" \
-      "#{version_changes}" \
-      "---------------------------\n"
-    )
-
-    # CHANGELOG
-    file('CHANGELOG.md').prepend(version_changes)
+    update_changelog
     git!('add CHANGELOG.md')
 
     file('lib/verto/version.rb').replace(latest_version.to_s, new_version.to_s)
@@ -37,7 +22,9 @@ context(branch('master')) {
     git!('add README.md')
 
     file('lib/verto/utils/templates/Vertofile').replace(latest_version.to_s, new_version.to_s)
-    git!('add lib/verto/utils/templates/Vertofile')
+    file('Vertofile').replace(latest_version.to_s, new_version.to_s)
+
+    git!('add Vertofile lib/verto/utils/templates/Vertofile')
 
     sh!('bundle install')
     sh!('rake install')
@@ -46,4 +33,3 @@ context(branch('master')) {
     git!('commit -m "Bumps Version"')
   }
 }
-

data/bin/console

@@ -1,14 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "verto"
+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__)
+require 'pry'
+Pry.start

data/djin.yml

@@ -0,0 +1,50 @@
+djin_version: '0.10.0'
+
+tasks:
+  run:
+    local:
+      run:
+        - {{args}}
+
+  set_verto_version:
+    local:
+      run:
+        - VERTO_BUILD_VERSION=$(cat lib/verto/version.rb | grep -ohE '\d+\.\d+\.\d+')
+
+  tag_up:
+    docker:
+      image: "catks/verto:0.10.1"
+      run:
+        commands:
+          - "verto tag up {{args}}"
+        options: |
+          -v ~/.gitconfig:/etc/gitconfig -v $(pwd):/usr/src/project \
+          -v $HOME/.ssh/known_hosts:/root/.ssh/known_hosts -v $HOME/.ssh/id_rsa:/root/.ssh/id_rsa \
+          -e SSH_PRIVATE_KEY=/root/.ssh/id_rsa \
+          --entrypoint='' \
+    depends_on:
+      - set_verto_version
+
+  release:
+    depends_on:
+      - 'release:gem'
+      - 'release:docker'
+
+  'release:gem':
+    local:
+      run:
+        - bundle exec rake release
+    depends_on:
+      - set_verto_version
+      - tag_up
+
+  'release:docker':
+    local:
+      run:
+        - bundle exec rake release
+        - docker build . -t verto
+        - docker tag verto catks/verto:$VERTO_BUILD_VERSION
+        - docker push catks/verto:$VERTO_BUILD_VERSION
+    depends_on:
+      - set_verto_version
+      - tag_up

data/exe/verto

@@ -1,17 +1,21 @@
 #!/usr/bin/env ruby
-Signal.trap("INT") { exit 2 }
+# frozen_string_literal: true
+
+Signal.trap('INT') { exit 2 }
 
 require_relative '../lib/verto'
 
 vertofile_path = ENV['VERTOFILE_PATH'] || Pathname.new(Dir.pwd).join('Vertofile').to_s
 begin
-  Verto::DSL.load_file(vertofile_path) if File.exists?(vertofile_path)
+  Verto::DSL.load_file(vertofile_path) if File.exist?(vertofile_path)
 
   Verto::MainCommand.start(ARGV)
 
+# TODO: Check why we can't handle this error on CliHelpers
+rescue TTY::Reader::InputInterrupt
 # TODO: Improve error Message Handling
-rescue Verto::ExitError => ex
-  Verto.stderr.puts ex.message
+rescue Verto::ExitError => e
+  Verto.stderr.puts e.message
   Verto.stderr.puts 'Exiting Verto...'
   exit 1
 end

data/lib/verto/commands/base_command.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   class BaseCommand < Thor
     def self.exit_on_failure?
@@ -23,8 +25,11 @@ module Verto
 
       moments_to_call.each do |moment|
         Verto.config.hooks
-          .select { |hook| hook.moment == moment.to_sym }
-          .each { |hook| hook.call(with_attributes: with_attributes) }
+             .select { |hook| hook.moment == moment.to_sym }
+             .each do |hook|
+          Verto.current_moment = hook.moment
+          hook.call(with_attributes: with_attributes)
+        end
       end
     end
   end

data/lib/verto/commands/main_command.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Verto
   class MainCommand < BaseCommand
-    desc "tag SUBCOMMAND ...ARGS", "manage the repository tags"
+    desc 'tag SUBCOMMAND ...ARGS', 'manage the repository tags'
     subcommand 'tag', Verto::TagCommand
 
-    desc "init", "Initialize a Vertofile in your repository"
+    desc 'init', 'Initialize a Vertofile in your repository'
 
     option :path, type: :string, default: nil
     def init
@@ -14,7 +16,7 @@ module Verto
       Template.render('Vertofile', to: path)
     end
 
-    desc "version", "Shows Verto version"
+    desc 'version', 'Shows Verto version'
 
     def version
       Verto.stdout.puts Verto::VERSION
@@ -23,12 +25,14 @@ module Verto
     private
 
     def validate_current_vertofile!(path)
+      return unless Pathname.new(path).join('Vertofile').exist?
+
       command_error!(
         <<~ERROR
-         Project already have a Vertofile.
-         If you want to generate a new with verto init, delete the current one with: `rm Vertofile`
+          Project already have a Vertofile.
+          If you want to generate a new with verto init, delete the current one with: `rm Vertofile`
         ERROR
-      ) if Pathname.new(path).join('Vertofile').exist?
+      )
     end
   end
 end