gitt 1.0.0

data/lib/gitt/commands/tag.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "tempfile"
+
+module Gitt
+  module Commands
+    # A Git tag command wrapper.
+    class Tag
+      include Dry::Monads[:result]
+
+      KEY_MAP = {
+        author_email: "%(*authoremail)",
+        author_name: "%(*authorname)",
+        authored_at: "%(*authordate:raw)",
+        authored_relative_at: "%(*authordate:relative)",
+        committed_at: "%(*committerdate:raw)",
+        committed_relative_at: "%(*committerdate:relative)",
+        committer_email: "%(*committeremail)",
+        committer_name: "%(*committername)",
+        body: "%(body)",
+        sha: "%(objectname)",
+        subject: "%(subject)",
+        version: "%(refname)"
+      }.freeze
+
+      def initialize shell: SHELL, key_map: KEY_MAP, parser: Parsers::Tag.new
+        @shell = shell
+        @key_map = key_map
+        @parser = parser
+      end
+
+      def call(*arguments) = shell.call "tag", *arguments
+
+      def create version, body = EMPTY_STRING, *flags
+        return Failure "Unable to create Git tag without version." unless version
+        return Failure "Tag exists: #{version}." if exist? version
+
+        Tempfile.open "git_plus" do |file|
+          file.write body
+          write version, file.tap(&:rewind), *flags
+        end
+      end
+
+      def exist?(version) = local?(version) || remote?(version)
+
+      def index *arguments
+        arguments.prepend(pretty_format, "--list")
+                 .then { |flags| call(*flags) }
+                 .fmap { |content| String(content).scrub("?").split %("\n") }
+                 .fmap { |entries| build_records entries }
+      end
+
+      def last
+        shell.call("describe", "--abbrev=0", "--tags", "--always")
+             .fmap(&:strip)
+             .or { |error| Failure error.delete_prefix("fatal: ").chomp }
+      end
+
+      def local?(version) = call("--list", version).value_or(EMPTY_STRING).match?(/\A#{version}\Z/)
+
+      def push = shell.call "push", "--tags"
+
+      def remote? version
+        shell.call("ls-remote", "--tags", "origin", version)
+             .value_or(EMPTY_STRING)
+             .match?(%r(.+tags/#{version}\Z))
+      end
+
+      def show version
+        call(pretty_format, "--list", version).fmap { |content| parser.call content }
+      end
+
+      def tagged? = !call.value_or(EMPTY_STRING).empty?
+
+      private
+
+      attr_reader :shell, :key_map, :parser
+
+      def pretty_format
+        key_map.reduce("") { |content, (key, value)| content + "<#{key}>#{value}</#{key}>%n" }
+               .then { |format| %(--format="#{format}") }
+      end
+
+      def build_records(entries) = entries.map { |entry| parser.call entry }
+
+      def write version, file, *flags
+        arguments = ["--annotate", version, "--cleanup", "verbatim", *flags, "--file", file.path]
+        call(*arguments).fmap { version }
+                        .or { Failure "Unable to create tag: #{version}." }
+      end
+    end
+  end
+end

data/lib/gitt/models/commit.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Models
+    # Represents commit details.
+    Commit = Struct.new(
+      :author_email,
+      :author_name,
+      :authored_at,
+      :authored_relative_at,
+      :body,
+      :body_lines,
+      :body_paragraphs,
+      :committed_at,
+      :committed_relative_at,
+      :committer_email,
+      :committer_name,
+      :lines,
+      :raw,
+      :sha,
+      :signature,
+      :subject,
+      :trailers,
+      keyword_init: true
+    ) do
+      def initialize *arguments
+        super
+        freeze
+      end
+
+      def amend? = subject.match?(/\Aamend!\s/)
+
+      def fixup? = subject.match?(/\Afixup!\s/)
+
+      def squash? = subject.match?(/\Asquash!\s/)
+
+      def prefix? = amend? || fixup? || squash?
+    end
+  end
+end

data/lib/gitt/models/person.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Models
+    # Represents a person within a repository.
+    Person = Struct.new :name, :delimiter, :email, keyword_init: true do
+      def self.for(string, parser: Parsers::Person.new) = parser.call string
+
+      def initialize *arguments
+        super
+        freeze
+      end
+
+      def to_s = values.join
+    end
+  end
+end

data/lib/gitt/models/tag.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Models
+    # Represents tag details.
+    Tag = Struct.new(
+      :author_email,
+      :author_name,
+      :authored_at,
+      :authored_relative_at,
+      :body,
+      :committed_at,
+      :committed_relative_at,
+      :committer_email,
+      :committer_name,
+      :sha,
+      :subject,
+      :version,
+      keyword_init: true
+    ) do
+      def initialize *arguments
+        super
+        freeze
+      end
+    end
+  end
+end

data/lib/gitt/models/trailer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Models
+    # Represents commit trailer details.
+    Trailer = Struct.new :key, :delimiter, :space, :value, keyword_init: true do
+      def self.for(string, parser: Parsers::Trailer.new) = parser.call string
+
+      def initialize *arguments
+        super
+        freeze
+      end
+
+      def to_s = values.join
+    end
+  end
+end

data/lib/gitt/parsers/attributer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Parsers
+    # Extracts attributes from XML formatted content.
+    class Attributer
+      def self.with(...) = new(...)
+
+      def initialize keys = []
+        @keys = keys
+      end
+
+      def call content
+        scrub = String(content).scrub "?"
+
+        keys.reduce({}) do |attributes, key|
+          attributes.merge key => scrub[%r(<#{key}>(?<value>.*?)</#{key}>)m, :value]
+        end
+      end
+
+      private
+
+      attr_reader :keys
+    end
+  end
+end

data/lib/gitt/parsers/commit.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "refinements/hashes"
+
+module Gitt
+  module Parsers
+    # Parses raw commit information to produce a commit record.
+    class Commit
+      using Refinements::Hashes
+
+      def self.call(...) = new.call(...)
+
+      def initialize attributer: Attributer.with(Commands::Log::KEY_MAP.keys),
+                     sanitizers: Sanitizers::CONTAINER,
+                     model: Models::Commit
+        @attributer = attributer
+        @sanitizers = sanitizers
+        @model = model
+      end
+
+      def call content
+        attributer.call(content)
+                  .then { |attributes| process attributes }
+                  .then { |attributes| model[attributes] }
+      end
+
+      private
+
+      attr_reader :attributer, :sanitizers, :model
+
+      # :reek:TooManyStatements
+      def process attributes
+        body, trailers = attributes.values_at :body, :trailers
+
+        attributes.transform_with! body: scissors_sanitizer,
+                                   signature: signature_sanitizer,
+                                   trailers: trailers_sanitizer
+
+        attributes[:body] =
+          (trailers ? body.sub(/\n??#{Regexp.escape trailers}\n??/, "") : body).chomp
+
+        private_methods.grep(/\Aprocess_/).sort.each { |method| __send__ method, attributes }
+        attributes
+      end
+
+      # :reek:FeatureEnvy
+      def process_body_lines attributes
+        attributes[:body_lines] = lines_sanitizer.call attributes[:body]
+      end
+
+      # :reek:FeatureEnvy
+      def process_body_paragraphs attributes
+        attributes[:body_paragraphs] = paragraphs_sanitizer.call attributes[:body]
+      end
+
+      # :reek:FeatureEnvy
+      def process_lines attributes
+        attributes[:lines] = lines_sanitizer.call attributes[:raw]
+      end
+
+      def lines_sanitizer = sanitizers.fetch :lines
+
+      def paragraphs_sanitizer = sanitizers.fetch :paragraphs
+
+      def scissors_sanitizer = sanitizers.fetch :scissors
+
+      def signature_sanitizer = sanitizers.fetch :signature
+
+      def trailers_sanitizer = sanitizers.fetch :trailers
+    end
+  end
+end

data/lib/gitt/parsers/person.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Parsers
+    # Parses raw trailer data to produce a trailer record.
+    class Person
+      PATTERN = /
+        \A                 # Start of line.
+        (?<name>.*?)       # Name (smallest possible).
+        (?<delimiter>\s?)  # Space delimiter (optional).
+        (?<email><.+>)?    # Collaborator email (optional).
+        \Z                 # End of line.
+      /x
+
+      def initialize model: Models::Person, pattern: PATTERN
+        @pattern = pattern
+        @model = model
+      end
+
+      def call(content) = model[content.match(pattern).named_captures]
+
+      private
+
+      attr_reader :pattern, :model
+    end
+  end
+end

data/lib/gitt/parsers/tag.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "refinements/hashes"
+
+module Gitt
+  module Parsers
+    # Parses raw tag information to produce a tag record.
+    class Tag
+      using Refinements::Hashes
+
+      def initialize attributer: Attributer.with(Commands::Tag::KEY_MAP.keys),
+                     sanitizers: Sanitizers::CONTAINER,
+                     model: Models::Tag
+        @attributer = attributer
+        @sanitizers = sanitizers
+        @model = model
+      end
+
+      def call content
+        attributes = attributer.call content
+        attributes.transform_with! author_email: email_sanitizer,
+                                   authored_at: date_sanitizer,
+                                   committed_at: date_sanitizer,
+                                   committer_email: email_sanitizer,
+                                   version: -> value { value.delete_prefix "refs/tags/" if value }
+        model[attributes]
+      end
+
+      private
+
+      attr_reader :attributer, :sanitizers, :model
+
+      def date_sanitizer = sanitizers.fetch(:date)
+
+      def email_sanitizer = sanitizers.fetch(:email)
+    end
+  end
+end

data/lib/gitt/parsers/trailer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Parsers
+    # Parses raw trailer data to produce a trailer record.
+    class Trailer
+      PATTERN = /
+        (?<key>\A.+)         # Key (anchored to start of line).
+        (?<delimiter>:)      # Colon delimiter.
+        (?<space>\s?)        # Space (optional).
+        (?<value>.*?)        # Value.
+        \Z                   # End of line.
+      /x
+
+      def initialize model: Models::Trailer, pattern: PATTERN
+        @pattern = pattern
+        @model = model
+      end
+
+      def call content
+        content.match(pattern)
+               .then { |data| data ? data.named_captures : {} }
+               .then { |attributes| model[attributes] }
+      end
+
+      private
+
+      attr_reader :pattern, :model
+    end
+  end
+end

data/lib/gitt/repository.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Gitt
+  # Primary object/wrapper for processing all Git related commands.
+  # :reek:TooManyMethods
+  class Repository
+    COMMANDS = {
+      branch: Commands::Branch,
+      config: Commands::Config,
+      log: Commands::Log,
+      tag: Commands::Tag
+    }.freeze
+
+    def initialize shell: SHELL, commands: COMMANDS
+      @shell = shell
+      @commands = commands.transform_values { |command| command.new shell: }
+    end
+
+    def branch(...) = commands.fetch(__method__).call(...)
+
+    def branch_default = commands.fetch(:branch).default
+
+    def branch_name = commands.fetch(:branch).name
+
+    def call(...) = shell.call(...)
+
+    def commits(...) = commands.fetch(:log).index(...)
+
+    def config(...) = commands.fetch(__method__).call(...)
+
+    def exist? = shell.call("rev-parse", "--git-dir").value_or(EMPTY_STRING).chomp == ".git"
+
+    def get(...) = commands.fetch(:config).get(...)
+
+    def log(...) = commands.fetch(__method__).call(...)
+
+    def origin? = commands.fetch(:config).origin?
+
+    def set(...) = commands.fetch(:config).set(...)
+
+    def tag(...) = commands.fetch(__method__).call(...)
+
+    def tags(...) = commands.fetch(:tag).index(...)
+
+    def tag?(...) = commands.fetch(:tag).exist?(...)
+
+    def tag_create(...) = commands.fetch(:tag).create(...)
+
+    def tag_last = commands.fetch(:tag).last
+
+    def tag_local?(...) = commands.fetch(:tag).local?(...)
+
+    def tag_remote?(...) = commands.fetch(:tag).remote?(...)
+
+    def tag_show(...) = commands.fetch(:tag).show(...)
+
+    def tagged? = commands.fetch(:tag).tagged?
+
+    def tags_push = commands.fetch(:tag).push
+
+    def uncommitted(...) = commands.fetch(:log).uncommitted(...)
+
+    private
+
+    attr_reader :shell, :commands
+  end
+end

data/lib/gitt/sanitizers/container.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    CONTAINER = {
+      date: Date,
+      email: Email,
+      lines: Lines,
+      paragraphs: Paragraphs,
+      scissors: Scissors,
+      signature: Signature,
+      trailers: Trailers.new
+    }.freeze
+  end
+end

data/lib/gitt/sanitizers/date.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Date = -> value { value.sub(/\s.+\Z/, "") if value }
+  end
+end

data/lib/gitt/sanitizers/email.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Email = -> value { value.tr "<>", "" if value }
+  end
+end

data/lib/gitt/sanitizers/lines.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Lines = -> value { value ? value.split("\n") : EMPTY_ARRAY }
+  end
+end

data/lib/gitt/sanitizers/paragraphs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Paragraphs = -> value { value ? value.split("\n\n").map(&:chomp) : EMPTY_ARRAY }
+  end
+end

data/lib/gitt/sanitizers/scissors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Scissors = -> value { value.sub(/^#\s-.+\s>8\s-.+/m, "") if value }
+  end
+end

data/lib/gitt/sanitizers/signature.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    Signature = lambda do |value|
+      case value
+        when "B" then "Bad"
+        when "E" then "Error"
+        when "G" then "Good"
+        when "N" then "None"
+        when "R" then "Revoked"
+        when "U" then "Unknown"
+        when "X" then "Expired"
+        when "Y" then "Expired Key"
+        else "Invalid"
+      end
+    end
+  end
+end

data/lib/gitt/sanitizers/trailers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Gitt
+  module Sanitizers
+    # Sanitizes content by turning it into an array of trailer records.
+    class Trailers
+      def initialize parser: Parsers::Trailer.new
+        @parser = parser
+      end
+
+      def call(value) = String(value).split("\n").map { |text| parser.call text }
+
+      private
+
+      attr_reader :parser
+    end
+  end
+end

data/lib/gitt/shared_contexts/git_commit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "with Git commit" do
+  let :git_commit do
+    Gitt::Models::Commit[
+      author_email: "test@example.com",
+      author_name: "Test User",
+      authored_relative_at: "1 day ago",
+      body: "",
+      raw: "",
+      sha: "180dec7d8ae8cbe3565a727c63c2111e49e0b737",
+      subject: "Added documentation",
+      trailers: ""
+    ]
+  end
+end

data/lib/gitt/shared_contexts/git_repo.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "with Git repository" do
+  include_context "with temporary directory"
+
+  using Refinements::Pathnames
+
+  let(:git_repo_dir) { temp_dir.join "test" }
+
+  around do |example|
+    git_repo_dir.make_dir.change_dir do |path|
+      path.join("README.md").touch
+
+      `git init`
+      `git config user.name "Test User"`
+      `git config user.email "test@example.com"`
+      `git config core.hooksPath /dev/null`
+      `git config commit.gpgSign false`
+      `git config tag.gpgSign false`
+      `git config remote.origin.url https://github.com/bkuhlmann/test`
+      `git add --all .`
+      `git commit --all --message "Added documentation"`
+    end
+
+    example.run
+
+    temp_dir.remove_tree
+  end
+end

data/lib/gitt/shared_contexts/temp_dir.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "with temporary directory" do
+  using Refinements::Pathnames
+
+  let(:temp_dir) { Bundler.root.join "tmp", "rspec" }
+
+  around do |example|
+    temp_dir.make_path
+    example.run
+    temp_dir.remove_tree
+  end
+end

data/lib/gitt/shell.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "open3"
+
+module Gitt
+  # A low-level shell client.
+  class Shell
+    include Dry::Monads[:result]
+
+    def initialize client: Open3
+      @client = client
+    end
+
+    def call(...)
+      client.capture3("git", ...).then do |stdout, stderr, status|
+        status.success? ? Success(stdout) : Failure(stderr)
+      end
+    end
+
+    private
+
+    attr_reader :client
+  end
+end

data/lib/gitt.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+Zeitwerk::Loader.for_gem.then do |loader|
+  loader.inflector.inflect "container" => "CONTAINER"
+  loader.ignore "#{__dir__}/gitt/shared_contexts"
+  loader.setup
+end
+
+# Main namespace.
+module Gitt
+  EMPTY_STRING = ""
+  EMPTY_ARRAY = [].freeze
+  SHELL = Shell.new.freeze
+end