schmersion 1.0.0

data/lib/schmersion/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Schmersion
+  class Error < StandardError
+  end
+end

data/lib/schmersion/formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Schmersion
+  class Formatter
+
+    attr_reader :filename
+
+    def initialize(filename, options = {})
+      @filename = filename
+      @options = options
+    end
+
+    # Generate the output which should be included in the export. This
+    # should return a string which will also be displayed when doing
+    # dry-runs of a release.
+    # rubocop:disable Lint/UnusedMethodArgument
+    def generate(repo, version)
+      ''
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Insert a given part into the given source file path
+    #
+    # @param part [String]
+    # @return [void]
+    def insert(part)
+    end
+
+  end
+end

data/lib/schmersion/formatters.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'schmersion/formatters/markdown'
+require 'schmersion/formatters/yaml'
+
+module Schmersion
+  module Formatters
+
+    FORMATTERS = {
+      yaml: YAML,
+      markdown: Markdown
+    }.freeze
+
+  end
+end

data/lib/schmersion/formatters/markdown.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'schmersion/formatter'
+
+module Schmersion
+  module Formatters
+    class Markdown < Formatter
+
+      def generate(repo, version)
+        lines = []
+        lines << "## #{version.version}\n"
+
+        sections_for_commits(version.commits).each do |section, commits|
+          lines << "### #{section['title']}\n"
+          commits.each do |_, scope_commits|
+            scope_commits.sort_by { |c| c.message.description.upcase }.each do |commit|
+              lines << commit_line(repo, commit)
+            end
+          end
+          lines << nil
+        end
+        lines.join("\n")
+      end
+
+      def insert(part)
+        text_to_insert = "#{header}\n#{part}"
+
+        unless File.file?(@filename)
+          File.write(@filename, text_to_insert)
+          return
+        end
+
+        # If we already have a changelog markdown file, we're going to remove
+        # everyting up to the first level 2 heading and replace it with the
+        # header and the new version's data.
+        contents = File.read(@filename)
+        contents_without_header = contents.sub(/\A.*?##/m, '##')
+        File.write(@filename, "#{text_to_insert}\n#{contents_without_header}")
+
+        true
+      end
+
+      private
+
+      def header
+        lines = []
+        lines << "# #{@options['description']}\n"
+        lines << @options['description'] if @options['description']
+        lines << nil
+        lines.join("\n")
+      end
+
+      def sections_for_commits(commits)
+        return [] if @options['sections'].empty?
+
+        @options['sections'].each_with_object([]) do |section, array|
+          section_commits = commits.select do |commit|
+            section['types'].nil? ||
+              !section['types'].is_a?(Array) ||
+              section['types'].include?(commit.message.type)
+          end
+
+          next if section_commits.empty?
+
+          section_commits = section_commits.group_by do |c|
+            c.message.scope
+          end
+
+          section_commits = section_commits.sort_by do |s, _|
+            s&.upcase || 'ZZZZZZ'
+          end
+
+          array << [section, section_commits]
+        end
+      end
+
+      def capitalize_as_required(string)
+        return string unless @options['capitalize_strings']
+
+        string.sub(/\A([a-z])/) { Regexp.last_match(1).upcase }
+      end
+
+      def commit_url_for(repo, ref)
+        if @options['urls']&.key?('commit')
+          template = @options.dig('urls', 'commit')
+          return nil if template.nil?
+
+          return template.gsub('$REF', ref)
+        end
+
+        repo.host&.url_for_commit(ref)
+      end
+
+      def commit_line(repo, commit)
+        first_line = '- '
+        first_line += "**#{commit.message.scope}:** " if commit.message.scope
+        first_line += capitalize_as_required(commit.message.description)
+        if url = commit_url_for(repo, commit.ref)
+          first_line += ' ('
+          first_line += "[#{commit.ref[0, 6]}](#{url})"
+          first_line += ')'
+        end
+        first_line
+      end
+
+    end
+  end
+end

data/lib/schmersion/formatters/yaml.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'schmersion/formatter'
+
+module Schmersion
+  module Formatters
+    class YAML < Formatter
+
+      DEFAULT_STRUCTURE = [].to_yaml.freeze
+
+      def generate(_, version)
+        commits = version.commits.sort_by { |c| c.message.description.upcase }
+
+        commits = commits.each_with_object([]) do |commit, array|
+          next unless include_type?(commit.message.type)
+
+          array << commit_to_hash(commit)
+        end
+
+        {
+          'version' => version.version.to_s,
+          'commits' => commits
+        }.to_yaml
+      end
+
+      def insert(part)
+        unless File.file?(@filename)
+          File.write(@filename, DEFAULT_STRUCTURE)
+        end
+
+        part_as_hash = ::YAML.safe_load(part)
+        existing_yaml = ::YAML.load_file(@filename)
+        existing_yaml = [] unless existing_yaml.is_a?(Array)
+        existing_yaml.prepend(part_as_hash)
+        File.write(@filename, existing_yaml.to_yaml)
+      end
+
+      private
+
+      def commit_to_hash(commit)
+        {
+          'ref' => commit.ref,
+          'date' => commit.date.to_s,
+          'type' => commit.message.type,
+          'scope' => commit.message.scope,
+          'description' => commit.message.description,
+          'breaking_change' => commit.message.breaking_change?,
+          'breaking_changes' => commit.message.breaking_changes,
+          'pull_request_id' => commit.message.pull_request_id,
+          'footers' => commit.message.footers
+        }
+      end
+
+      def include_type?(type)
+        return true if @options[:types].nil?
+
+        @options[:types].include(type.to_s)
+      end
+
+    end
+  end
+end

data/lib/schmersion/helpers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Schmersion
+  class Helpers
+
+    class << self
+
+      def print_commit_list(commits, prefix: '')
+        commits.each do |commit|
+          print prefix
+          print '['
+          print commit.ref[0, 10].blue
+          print ']'
+          print ' '
+          print commit.message.type.green
+          if commit.message.scope
+            print '('
+            print commit.message.scope.magenta
+            print ')'
+          end
+          if commit.message.breaking_change?
+            print ' ! '.white.on_red
+          end
+          print ': '
+          puts commit.message.description
+        end
+      end
+
+    end
+
+  end
+end

data/lib/schmersion/host.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Schmersion
+  class Host
+
+    def initialize(url)
+      @url = url
+    end
+
+    def url_for_commit(commit_ref)
+    end
+
+    def url_for_comparison(ref1, ref2)
+    end
+
+    class << self
+
+      def suitable?(_)
+        false
+      end
+
+    end
+
+  end
+end

data/lib/schmersion/hosts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'schmersion/hosts/github'
+
+module Schmersion
+  module Hosts
+
+    HOSTS = [GitHub].freeze
+
+    class << self
+
+      def host_for_url(url)
+        HOSTS.each do |host|
+          if host.suitable?(url)
+            return host.new(url)
+          end
+        end
+
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/schmersion/hosts/github.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'schmersion/host'
+
+module Schmersion
+  module Hosts
+    class GitHub < Host
+
+      SSH_REGEXP = /\Agit@github\.com:([\w-]+)\/([\w-]+)(\.git)?\z/.freeze
+      HTTP_REGEXP = /\Ahttps:\/\/github\.com\/([\w-]+)\/([\w-]+)(\.git)?\z/.freeze
+
+      class << self
+
+        def suitable?(url)
+          !!(url.match(SSH_REGEXP) || url.match(HTTP_REGEXP))
+        end
+
+      end
+
+      def initialize(url)
+        super
+        get_user_and_repo(url)
+        @base_url = "https://github.com/#{@user}/#{@repo}"
+      end
+
+      def url_for_commit(ref)
+        "#{@base_url}/commit/#{ref}"
+      end
+
+      def url_for_comparison(ref1, ref2)
+        "#{@base_url}/compare/#{ref1}..#{ref2}"
+      end
+
+      private
+
+      def get_user_and_repo(url)
+        if m = url.match(SSH_REGEXP)
+          @user = m[1]
+          @repo = m[2]
+        elsif m = url.match(HTTP_REGEXP)
+          @user = m[1]
+          @repo = m[2]
+        else
+          raise Error, 'Could not determine appropriate details for repository from URL'
+        end
+      end
+
+    end
+  end
+end

data/lib/schmersion/linter.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'schmersion/message'
+require 'schmersion/message_validator'
+
+module Schmersion
+  class Linter
+
+    def initialize(repo)
+      @repo = repo
+    end
+
+    def prepare(path, source = nil)
+      previous_commit_message = read_previous_commit_message
+
+      return unless source.nil?
+
+      unless File.file?(path)
+        raise Error, "No commit message file at the given path (#{path})"
+      end
+
+      lines = []
+
+      if previous_commit_message
+        lines << previous_commit_message
+        lines << ''
+      else
+        lines << "\n"
+      end
+
+      lines << '# ====================================================================='
+      lines << '# Commit messages must conform to conventional commit formatting.'
+      lines << '# This means each commit message must be prefixed with an appropriate'
+      lines << '# type and, optionally, a scope. Your message will be validated before'
+      lines << '# the commit will be created. '
+      lines << '#'
+
+      add_list_for(lines, :types)
+
+      unless @repo.config.scopes.empty?
+        lines << '#'
+        add_list_for(lines, :scopes)
+      end
+
+      lines << '# ====================================================================='
+
+      lines = lines.join("\n")
+
+      contents = File.read(path)
+      File.write(path, "#{lines}\n#\n#{contents.strip}")
+    end
+
+    def validate_file(path)
+      unless File.file?(path)
+        raise Error, "No commit message file at the given path (#{path})"
+      end
+
+      contents = get_commit_message_from_file(File.read(path))
+      return [] if contents.length.zero?
+
+      message = Message.new(contents)
+
+      validator = MessageValidator.new(@repo.config, message)
+
+      unless validator.valid?
+        # Save the commit message to a file if its invalid.
+        save_commit_message(contents)
+      end
+
+      validator.errors
+    end
+
+    def setup(force: false)
+      create_hook('lint-prepare', 'prepare-commit-msg', force: force)
+      create_hook('lint-validate', 'commit-msg', force: force)
+    end
+
+    private
+
+    def read_previous_commit_message
+      path = '.git/SCHMERSION_EDITMSG'
+      return unless File.file?(path)
+
+      contents = File.read(path)
+      FileUtils.rm(path)
+      contents
+    end
+
+    def save_commit_message(message)
+      File.write('.git/SCHMERSION_EDITMSG', message)
+    end
+
+    def add_list_for(lines, type)
+      lines << "# The following #{type.to_s.upcase} are available to choose from:"
+      lines << '#'
+      @repo.config.public_send(type).sort.each_slice(3) do |names|
+        types = names.map { |t| " * #{t.to_s.ljust(16)}" }.join
+        lines << "# #{types}".strip
+      end
+    end
+
+    def get_commit_message_from_file(contents)
+      contents = contents.split('------------------------ >8 ------------------------', 2)[0]
+      contents.split("\n").reject { |l| l.start_with?('#') }.join("\n").strip
+    end
+
+    # Returns the path to schmersion for use in commit files.
+    # For production installs, we'll just call it `schmersion` and hope that it is
+    # included in the path. For development, we'll use the path to the binary in
+    # repository.
+    def path_to_schmersion
+      if development?
+        return File.join(schmersion_root, 'bin', 'schmersion')
+      end
+
+      'schmersion'
+    end
+
+    def development?
+      !File.file?(File.join(schmersion_root, 'VERSION'))
+    end
+
+    def schmersion_root
+      File.expand_path('../../', __dir__)
+    end
+
+    def hook_file_contents(command)
+      <<~FILE
+        #!/bin/bash
+
+        #{path_to_schmersion} #{command} $1 $2 $3
+      FILE
+    end
+
+    def create_hook(command, name, force: false)
+      hook_path = File.join(@repo.path, '.git', 'hooks', name)
+      if File.file?(hook_path) && !force
+        raise Error, "Cannot install hook into #{name} because a hook file already exists."
+      end
+
+      File.write(hook_path, hook_file_contents(command))
+      FileUtils.chmod('u+x', hook_path)
+      hook_path
+    end
+
+  end
+end