verto 0.9.0 → 0.12.0

data/lib/verto/commands/tag_command.rb

@@ -1,6 +1,20 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
 module Verto
   class TagCommand < BaseCommand
-    desc "up", "Create's a new tag"
+    desc 'init', "Create's the first tag"
+
+    def init
+      load_config_hooks!
+
+      error_message = 'This repository already has tags'
+      raise Verto::ExitError, error_message if tag_repository.any?
+
+      create_git_tag('0.1.0')
+    end
+
+    desc 'up', "Create's a new tag"
 
     option :major, type: :boolean, default: false
     option :minor, type: :boolean, default: false
@@ -13,7 +27,7 @@ module Verto
     def up
       load_config_hooks!
 
-      call_hooks(%i[before before_tag_up], with_attributes: { command_options: options} )
+      call_hooks(%i[before before_tag_up], with_attributes: { command_options: options })
 
       validate_version_option_presence!
 
@@ -27,11 +41,9 @@ module Verto
 
       validate_new_version!(new_version, latest_version)
 
-      call_hooks(:before_tag_creation, with_attributes: { new_version: new_version } )
+      call_hooks(:before_tag_creation, with_attributes: { new_version: new_version })
 
-      stderr.puts "Creating Tag #{version_prefix}#{new_version}..."
-      tag_repository.create!("#{version_prefix}#{new_version}")
-      stderr.puts "Tag #{version_prefix}#{new_version} Created!"
+      create_git_tag(new_version)
 
       call_hooks(:after_tag_up, with_attributes: { new_version: new_version })
       call_hooks(:after)
@@ -42,7 +54,7 @@ module Verto
     include Verto.import['tag_repository']
 
     def up_version(version, options)
-      up_options = options.select { |_, value| value == true }.keys.map(&:to_sym) & [:major, :minor, :patch]
+      up_options = options.select { |_, value| value == true }.keys.map(&:to_sym) & %i[major minor patch]
       up_option = up_options.min
 
       new_version = version.up(up_option)
@@ -50,53 +62,65 @@ module Verto
       if options[:pre_release]
         identifier = pre_release_configured? ? options[:pre_release] : version.pre_release.name || default_identifier
         new_version = new_version.with_pre_release(identifier)
-        new_version = new_version.up(:pre_release) if new_version.pre_release.name == version.pre_release.name && new_version == version
+        if new_version.pre_release.name == version.pre_release.name && new_version == version
+          new_version = new_version.up(:pre_release)
+        end
       end
 
-      if options[:release]
-        new_version = new_version.release_version
-      end
+      new_version = new_version.release_version if options[:release]
 
       new_version
     end
 
+    def create_git_tag(version)
+      stderr.puts "Creating Tag #{version_prefix}#{version}..."
+      tag_repository.create!("#{version_prefix}#{version}")
+      stderr.puts "Tag #{version_prefix}#{version} Created!"
+    end
+
     def pre_release_configured?
       options[:pre_release] != 'pre_release'
     end
 
     def validate_latest_tag!(latest_tag)
+      return if latest_tag
+
       command_error!(
         <<~TEXT
           Project doesn't have a previous tag version, create a new tag with git.
           eg: `git tag #{version_prefix}0.1.0`
         TEXT
-      ) unless latest_tag
+      )
     end
 
     def validate_new_version!(new_version, latest_version)
+      return unless new_version < latest_version && Verto.config.version.validations.new_version_must_be_bigger
+
       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 --patch --pre-release=rc),
-        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
+          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 --patch --pre-release=rc),
+          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 && Verto.config.version.validations.new_version_must_be_bigger
+      )
     end
 
     def validate_version_option_presence!
+      return if options[:major] || options[:minor] || options[:patch] || options[:pre_release] || options[:release]
+
       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:
+          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')
+          context('qa') {
+            before_command('tag_up') {
+              command_options.add(pre_release: 'rc')
+            }
           }
-        }
         TEXT
-      ) unless options[:major] || options[:minor] || options[:patch] || options[:pre_release] || options[:release]
+      )
     end
 
     def load_filter
@@ -108,8 +132,22 @@ module Verto
     end
 
     def load_config_hooks!
-      Verto.config.hooks.prepend Verto::DSL::BuiltInHooks::GitPullCurrentBranch if Verto.config.git.pull_before_tag_creation
-      Verto.config.hooks << Verto::DSL::BuiltInHooks::GitPushCurrentBranch if Verto.config.git.push_after_tag_creation
+      enabled_hooks = ->(_, v) { v }
+
+      config_hooks[:before].select(&enabled_hooks).each_key { |hook| Verto.config.hooks.prepend(hook) }
+      config_hooks[:after].select(&enabled_hooks).each_key { |hook| Verto.config.hooks << hook }
+    end
+
+    def config_hooks
+      @config_hooks ||= {
+        before: {
+          Verto::DSL::BuiltInHooks::GitPullCurrentBranch => Verto.config.git.pull_before_tag_creation,
+          Verto::DSL::BuiltInHooks::GitFetch => Verto.config.git.fetch_before_tag_creation
+        },
+        after: {
+          Verto::DSL::BuiltInHooks::GitPushCurrentBranch => Verto.config.git.push_after_tag_creation
+        }
+      }
     end
 
     def default_identifier
@@ -117,3 +155,4 @@ module Verto
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/verto/dsl/built_in_hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     module BuiltInHooks
@@ -5,8 +7,12 @@ module Verto
         git!("pull origin #{current_branch}")
       end
 
+      GitFetch = DSL::Hook.new(moment: :before) do
+        git!('fetch')
+      end
+
       GitPushTags = DSL::Hook.new(moment: :after) do
-        git!("push --tags")
+        git!('push --tags')
       end
 
       GitPushCurrentBranchCommits = DSL::Hook.new(moment: :after) do

data/lib/verto/dsl/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     class File
@@ -36,8 +38,8 @@ module Verto
         end
       end
 
-      alias_method :gsub, :replace_all
-      alias_method :sub, :replace
+      alias gsub replace_all
+      alias sub replace
 
       private
 

data/lib/verto/dsl/hook.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     class Hook

data/lib/verto/dsl/interpreter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     class Interpreter
@@ -6,15 +8,14 @@ module Verto
       # TODO: Wrap stacktrace
       Error = Class.new(Verto::ExitError)
 
-      def evaluate(vertofile_content=nil, attributes: {}, &block)
+      def evaluate(vertofile_content = nil, attributes: {}, &block)
         with_attributes(attributes) do
-          vertofile_content ? instance_eval(vertofile_content)  : instance_eval(&block)
+          vertofile_content ? instance_eval(vertofile_content) : instance_eval(&block)
         end
+      rescue StandardError => e
+        raise e if e.is_a?(Verto::ExitError)
 
-      rescue StandardError => error
-        raise error if error.is_a?(Verto::ExitError)
-
-        raise Error, error.message
+        raise Error, e.message
       end
 
       private
@@ -27,7 +28,7 @@ module Verto
 
         block.call
 
-        attributes.each do |key, value|
+        attributes.each do |key, _value|
           instance_variable_set("@#{key}", nil)
           singleton_class.remove_method(key)
         end

data/lib/verto/dsl/syntax.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     module Syntax
@@ -100,6 +102,28 @@ module Verto
         Verto.config.hooks << Hook.new(moment: 'before_tag_creation', &block)
       end
 
+      # Start the flow to Update the CHANGELOG file
+      # @param :with [Symbol] The strategy to search commit messages
+      #   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)
+      # @param :confirmation [Boolean] Adds a confirmation step before updating the CHANGELOG
+      # @param filename [String] The CHANGELOG filename
+      # @param message_pattern [Regexp] A regexp pattern to filter commit messages
+      def update_changelog(with: :merged_pull_requests_with_bracketed_labels, confirmation: true, filename: 'CHANGELOG.md')
+        permitted_moments = %w[before_tag_creation after_tag_up]
+        unless permitted_moments.include? Verto.current_moment.to_s
+          raise ExitError, 'update_changelog is only supported in before_tag_creation or after_command_tag_up'
+        end
+
+        UpdateChangelog.new.call(with: with,
+                                 new_version: new_version,
+                                 confirmation: confirmation,
+                                 filename: filename)
+      end
+
       def file(filepath)
         DSL::File.new(filepath)
       end
@@ -108,8 +132,9 @@ module Verto
         ENV[environment_name]
       end
 
+      # TODO: Use delegator
       def confirm(text)
-        shell_basic.yes?("#{text} (y/n)")
+        CliHelpers.confirm(text)
       end
 
       def error(text)
@@ -128,16 +153,12 @@ module Verto
         @executors ||= {
           from_config: Verto::SystemCommandExecutor.new,
           true => Verto::SystemCommandExecutor.new(stdout: $stdout, stderr: $stderr),
-          false => Verto::SystemCommandExecutor.new(stdout: nil, stderr: nil),
+          false => Verto::SystemCommandExecutor.new(stdout: nil, stderr: nil)
         }
 
         @executors[output]
       end
 
-      def shell_basic
-        @shell_basic ||= Thor::Shell::Basic.new
-      end
-
       def stderr
         Verto.stderr
       end

data/lib/verto/dsl/update_changelog/filtered_by.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Verto
+  module DSL
+    class UpdateChangelog
+      module FilteredBy
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def filtered_by(filter)
+            Proxy.new(self, filter)
+          end
+        end
+
+        class Proxy
+          def initialize(filter_class, final_filter)
+            @filter_class = filter_class
+            @final_filter = final_filter
+          end
+
+          def new
+            filter_object
+
+            self
+          end
+
+          def call(*args)
+            filter_object
+              .call(*args)
+              .select { |message| @final_filter.match?(message) }
+          end
+
+          private
+
+          # Lazy evaluete object to load Verto dependencies only at the last
+          def filter_object
+            @filter_object ||= @filter_class.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/verto/dsl/update_changelog/with_commit_messages.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Verto
+  module DSL
+    class UpdateChangelog
+      class WithCommitMessages
+        include Verto.import[executor: 'system_command_executor_without_output', tag_repository: 'tag_repository']
+        include FilteredBy
+
+        def call(message_pattern = /.+/)
+          executor.run(
+            "git log --no-merges --pretty=format:%s #{commit_range}"
+          ).output.split("\n").map(&:strip).select { |message| message_pattern.match? message }
+        end
+
+        private
+
+        def commit_range
+          return unless latest_tag
+
+          "HEAD ^#{latest_tag}"
+        end
+
+        def latest_tag
+          tag_repository.latest
+        end
+      end
+    end
+  end
+end

data/lib/verto/dsl/update_changelog/with_merged_pull_requests.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Verto
+  module DSL
+    class UpdateChangelog
+      class WithMergedPullRequests
+        include Verto.import[executor: 'system_command_executor_without_output']
+        include FilteredBy
+
+        def call(message_pattern = /.+/)
+          # FIXME: Format the command
+          executor.run(
+            %q(git log --oneline --decorate  | grep -B 100 -m 1 "tag:" | grep "pull request" | awk '{print $1}' | xargs -r git show --format='%b' | grep -v Approved | grep -v "^$") # rubocop:disable Layout/LineLength
+          ).output.split("\n").map(&:strip).select { |pr_message| message_pattern.match? pr_message }
+        end
+      end
+    end
+  end
+end

data/lib/verto/dsl/update_changelog.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Verto
+  module DSL
+    class UpdateChangelog
+      include Verto.import[:cli_helpers, :stdout, changelog_format: 'changelog.format']
+
+      InvalidChangelogSource = Class.new(Verto::ExitError)
+
+      BRACKETED_LABELS_REGEXP = /^[[:space:]]*\[.*\]/.freeze
+
+      SOURCES = StrictHash.new(
+        {
+          merged_pull_requests_with_bracketed_labels: WithMergedPullRequests.filtered_by(BRACKETED_LABELS_REGEXP),
+          commits_with_bracketed_labels: WithCommitMessages.filtered_by(BRACKETED_LABELS_REGEXP),
+          merged_pull_requests_messages: WithMergedPullRequests,
+          commit_messages: WithCommitMessages
+        },
+        default_proc: ->(hash, _) { raise InvalidChangelogSource, "Invalid CHANGELOG Source, avaliable options: '#{hash.keys.join(',')}'" }
+      )
+
+      def call(new_version:, confirmation: true, filename: 'CHANGELOG.md', with: :merged_pull_requests_with_bracketed_labels, message_pattern: nil)
+        verify_file_presence!(filename)
+
+        changelog_changes = format_changes(new_version, version_changes(with, message_pattern))
+
+        if confirmation
+          stdout.puts separator
+          stdout.puts changelog_changes
+          stdout.puts separator
+          changelog_changes = select_changelog_text(changelog_changes)
+        end
+
+        update_file(filename, changelog_changes)
+      end
+
+      private
+
+      # TODO: Refactor
+      def select_changelog_text(changelog_changes) # rubocop:disable Metrics/MethodLength
+        choices = [
+          { key: 'y', name: 'Create a new Release CHANGELOG', value: :yes },
+          { key: 'n', name: 'Cancel the Release CHANGELOG', value: :no },
+          { key: 'e', name: 'Edit the Release CHANGELOG before continuing', value: :edit }
+        ]
+        case cli_helpers.select_options('Create new Release?', choices)
+        when :no
+          exit
+        when :edit
+          cli_helpers.edit_text(changelog_changes)
+        else
+          changelog_changes
+        end
+      end
+
+      def verify_file_presence!(filename)
+        return if Verto.project_path.join(filename).exist?
+
+        raise Verto::ExitError, "changelog file '#{filename}' doesnt exist"
+      end
+
+      def version_changes(with, message_pattern)
+        SOURCES[with.to_sym].new.call(*args_if_any(message_pattern))
+      end
+
+      def update_file(filename, changelog_changes)
+        DSL::File.new(filename).prepend(changelog_changes)
+      end
+
+      def format_changes(new_version, version_changes)
+        changes = Mustache.render(changelog_format,
+                                  { new_version: new_version, version_changes: version_changes })
+        "#{changes}\n"
+      end
+
+      def separator
+        '---------------------------'
+      end
+
+      def args_if_any(arg)
+        [arg].compact
+      end
+    end
+  end
+end

data/lib/verto/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   module DSL
     def self.load_file(filepath)

data/lib/verto/repositories/tag_repository.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   class TagRepository
     include Verto.import[executor: 'system_command_executor_without_output']
@@ -11,6 +13,10 @@ module Verto
       executor.run! "git tag #{tag}"
     end
 
+    def any?
+      all.any?
+    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
 

data/lib/verto/utils/cli_helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Verto
+  module CliHelpers
+    class << self
+      def confirm(text)
+        shell_basic.yes?("#{text} (y/n)")
+      end
+
+      def select_options(question, choices)
+        tty_prompt.expand(question, choices)
+      end
+
+      def edit_text(text)
+        tempfile = "/tmp/verto-changelog-edit-#{SecureRandom.hex}"
+
+        TTY::Editor.open(tempfile, text: text)
+
+        edited_text = File.read(tempfile)
+
+        File.delete(tempfile)
+
+        edited_text
+      end
+
+      private
+
+      def shell_basic
+        @shell_basic ||= Thor::Shell::Basic.new
+      end
+
+      def tty_prompt
+        @tty_prompt = TTY::Prompt.new
+      end
+    end
+  end
+end

data/lib/verto/utils/command_options.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Verto
   class CommandOptions < Thor::CoreExt::HashWithIndifferentAccess
-    alias_method :add, :merge!
+    alias add merge!
 
     def except(*keys)
-      self.reject { |key, v| keys.include?(key) }
+      reject { |key, _v| keys.include?(key) }
     end
   end
 end

data/lib/verto/utils/semantic_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   class SemanticVersion < Vseries::SemanticVersion
     DEFAULT_PRE_RELEASE_INITIAL_NUMBER = Verto.config.pre_release.initial_number

data/lib/verto/utils/strict_hash.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class StrictHash < Hash
+  def initialize(hash, default_proc: nil)
+    super()
+    self.default_proc = default_proc if default_proc
+    merge!(hash)
+  end
+end

data/lib/verto/utils/system_command_executor.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'open3'
 
 module Verto
   class SystemCommandExecutor
     include Verto.import['project.path', 'stdout', 'stderr']
 
-    class Result < Struct.new(:output, :error, :result)
+    Result = Struct.new(:output, :error, :result) do
       def success?
         result.success?
       end
@@ -16,7 +18,7 @@ module Verto
     Error = Class.new(StandardError)
 
     def run(command)
-      stderr.puts running_log(command, path) if stderr
+      stderr&.puts running_log(command, path)
 
       Open3.popen3(command, chdir: path.to_s) do |_, stdout, stderr, wait_thread|
         @output = stdout.read

data/lib/verto/utils/tag_filter.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module TagFilter
-  REALEASE_ONLY = /\d+\.\d+\.\d+$/
-  PRE_REALEASE_ONLY = /\d+\.\d+\.\d+-.*\d+/
+  RELEASE_ONLY = /\d+\.\d+\.\d+$/.freeze
+  PRE_RELEASE_ONLY = /\d+\.\d+\.\d+-.*\d+/.freeze
 
   FILTERS = {
-    release_only: REALEASE_ONLY,
-    pre_release_only: PRE_REALEASE_ONLY,
+    release_only: RELEASE_ONLY,
+    pre_release_only: PRE_RELEASE_ONLY,
     all: nil
-  }
+  }.freeze
 
   def self.for(tag_key)
     FILTERS[tag_key.to_sym] if tag_key

data/lib/verto/utils/template.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Verto
   class Template
     def self.render(template_name, to:)