dotsync 0.1.24 → 0.1.26

data/Rakefile

@@ -15,23 +15,137 @@ end
 task default: :spec
 
 namespace :release do
-  desc "Tag git with the current Dotsync::VERSION"
-  task :tag do
-    require_relative "./lib/dotsync/version"
-    version = Dotsync::VERSION
+  desc "Generate CHANGELOG entry for a new version"
+  # Usage: rake release:changelog[0.2.1]
+  task :changelog, [:version] do |_t, args|
+    version = args[:version]
+    unless version
+      require_relative "./lib/dotsync/version"
+      version = Dotsync::VERSION
+    end
+    version = version.sub(/^v/, "")
+    today = Date.today.strftime("%Y-%m-%d")
+
+    latest_tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
+    commits = if latest_tag.empty?
+      `git log --oneline --no-decorate`.strip.split("\n")
+    else
+      `git log #{latest_tag}..HEAD --oneline --no-decorate`.strip.split("\n")
+    end
+
+    if commits.empty?
+      abort "No commits since #{latest_tag}. Nothing to release."
+    end
+
+    categories = { "Added" => [], "Changed" => [], "Fixed" => [], "Removed" => [], "Security" => [], "Dependencies" => [] }
+
+    commits.each do |commit|
+      message = commit.sub(/^[a-f0-9]+\s+/, "")
+      case message.downcase
+      when /^add|^feat|^implement|^create|^new|^support/i then categories["Added"] << message
+      when /^fix|^bugfix|^hotfix|^resolve|^correct/i then categories["Fixed"] << message
+      when /^remove|^delete|^drop/i then categories["Removed"] << message
+      when /^security|^vuln|^cve/i then categories["Security"] << message
+      when /^bump|^upgrade|^update.*dependency|^dep/i then categories["Dependencies"] << message
+      else categories["Changed"] << message
+      end
+    end
+
+    changelog_entry = "## [#{version}] - #{today}\n"
+    categories.each do |category, items|
+      next if items.empty?
+      changelog_entry += "\n### #{category}\n\n"
+      items.each { |item| changelog_entry += "- #{item}\n" }
+    end
+
+    changelog_path = "CHANGELOG.md"
+    abort "CHANGELOG.md not found." unless File.exist?(changelog_path)
+
+    changelog = File.read(changelog_path)
+    abort "Version #{version} already exists in CHANGELOG.md" if changelog.include?("[#{version}]")
+
+    match = changelog.match(/^## \[/m)
+    new_changelog = match ? changelog.sub(/^## \[/m, "#{changelog_entry}\n## [") : changelog.rstrip + "\n\n#{changelog_entry}"
+
+    repo_url = `git remote get-url origin`.strip.sub(/\.git$/, "").sub(/^git@github\.com:/, "https://github.com/")
+    previous_version = latest_tag.empty? ? "v0.0.0" : latest_tag
+    link_entry = "[#{version}]: #{repo_url}/compare/#{previous_version}...v#{version}"
+
+    new_changelog = if new_changelog.match?(/^\[[\d.]+\]:.*compare/m)
+      new_changelog.sub(/^(\[[\d.]+\]:.*compare)/m, "#{link_entry}\n\\1")
+    else
+      new_changelog.rstrip + "\n\n#{link_entry}\n"
+    end
+
+    File.write(changelog_path, new_changelog)
+    puts "Updated CHANGELOG.md with version #{version}"
+    puts "\n#{changelog_entry}"
+  end
+
+  desc "Create annotated git tag from CHANGELOG"
+  # Usage: rake release:tag[0.2.1] or just rake release:tag (uses Dotsync::VERSION)
+  task :tag, [:version] do |_t, args|
+    version = args[:version]
+    unless version
+      require_relative "./lib/dotsync/version"
+      version = Dotsync::VERSION
+    end
+    version = version.sub(/^v/, "")
     tag_name = "v#{version}"
 
-    # Check if tag already exists
     if `git tag --list`.split.include?(tag_name)
       puts "Tag #{tag_name} already exists."
       exit(1)
     end
 
+    changelog_path = "CHANGELOG.md"
+    abort "CHANGELOG.md not found." unless File.exist?(changelog_path)
+
+    changelog = File.read(changelog_path)
+    version_regex = /^## \[#{Regexp.escape(version)}\] - (\d{4}-\d{2}-\d{2})\n(.*?)(?=^## \[|\z)/m
+    match = changelog.match(version_regex)
+
+    unless match
+      abort "Version #{version} not found in CHANGELOG.md\nRun 'rake release:changelog[#{version}]' first."
+    end
+
+    date = match[1]
+    content = match[2].strip
+    tag_message = "#{version} - #{date}\n\n#{content}"
+
     puts "Tagging commit as #{tag_name}..."
-    sh "git tag -a #{tag_name} -m 'Release #{tag_name}'"
-    puts "Pushing tag #{tag_name} to origin..."
-    sh "git push origin #{tag_name}"
-    puts "Done!"
+    sh "git", "tag", "-a", tag_name, "-m", tag_message
+    puts "Tag created. Push with: git push origin #{tag_name}"
+  end
+
+  desc "Full release: update changelog, commit, tag, and push"
+  # Usage: rake release:publish[0.2.1] or rake release:publish (uses Dotsync::VERSION)
+  task :publish, [:version] do |_t, args|
+    version = args[:version]
+    unless version
+      require_relative "./lib/dotsync/version"
+      version = Dotsync::VERSION
+    end
+    version = version.sub(/^v/, "")
+
+    status = `git status --porcelain`.strip
+    uncommitted = status.split("\n").reject { |line| line.end_with?("CHANGELOG.md") }
+    abort "Uncommitted changes:\n#{uncommitted.join("\n")}" unless uncommitted.empty?
+
+    Rake::Task["release:changelog"].invoke(version)
+    puts "\nReview CHANGELOG.md, then press Enter to continue..."
+    $stdin.gets
+
+    sh "git", "add", "CHANGELOG.md"
+    sh "git", "commit", "-m", "Update CHANGELOG for v#{version}\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+    Rake::Task["release:tag"].reenable
+    Rake::Task["release:tag"].invoke(version)
+
+    branch = `git rev-parse --abbrev-ref HEAD`.strip
+    sh "git", "push", "origin", branch
+    sh "git", "push", "origin", "v#{version}"
+    puts "\n✅ Released v#{version}"
   end
 end
 

data/exe/dotsync

@@ -6,6 +6,10 @@ require_relative "../lib/dotsync/version"
 
 options = { apply: false, config_path: nil }
 
+# Initialize logger early for consistent error handling
+require_relative "../lib/dotsync/core"
+logger = Dotsync::Logger.new
+
 opt_parser = OptionParser.new do |opts|
   opts.banner = <<~BANNER
     dotsync #{Dotsync::VERSION}
@@ -30,6 +34,7 @@ opt_parser = OptionParser.new do |opts|
       dotsync diff                       # Show what would change
       dotsync watch                      # Monitor and sync continuously
       dotsync -c ~/custom.toml push      # Use custom config file
+      dotsync push --trace               # Show full error backtraces
 
     Options:
       -a, --apply           Apply changes (push or pull)
@@ -46,6 +51,7 @@ opt_parser = OptionParser.new do |opts|
       --only-config         Show only the config section
       --only-mappings       Show only the mappings section
       -v, --verbose         Force showing all available information
+      --trace               Show full error backtraces (for debugging)
       --version             Show version number
       -h, --help            Show this help message
   BANNER
@@ -106,6 +112,10 @@ opt_parser = OptionParser.new do |opts|
     options[:verbose] = true
   end
 
+  opts.on("--trace", "Show full error backtraces (for debugging)") do
+    options[:trace] = true
+  end
+
   opts.on("--version", "Show version number") do
     puts "dotsync #{Dotsync::VERSION}"
     exit
@@ -117,12 +127,29 @@ opt_parser = OptionParser.new do |opts|
   end
 end
 
-opt_parser.parse!
+begin
+  opt_parser.parse!
+rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => e
+  # Extract just the problematic option from the error message
+  option_match = e.message.match(/invalid (?:option|argument): (.+)/)
+  problem = option_match ? option_match[1] : e.message
+
+  logger.error("Invalid option: #{problem}")
+  logger.info("See 'dotsync --help' for available options")
+
+  if options[:trace]
+    logger.log("\nFull backtrace:", color: 240)
+    e.backtrace.each { |line| logger.log("  #{line}", color: 240) }
+  end
+
+  exit 1
+end
 
 command = ARGV.shift
 
 # Load only the dependencies needed for the specific command
-case command
+begin
+  case command
 when "push"
   require_relative "../lib/dotsync/loaders/push_loader"
   Dotsync::Runner.new(config_path: options[:config_path]).run(:push, options)
@@ -153,9 +180,22 @@ when "diff"
   Dotsync::Runner.new(config_path: options[:config_path]).run(:push, diff_options)
 else
   if command
-    puts "dotsync: no such command '#{command}'"
+    logger.error("Unknown command: '#{command}'")
+    logger.info("See 'dotsync --help' for available commands")
   else
     puts opt_parser.banner
   end
   exit 1
+  end
+rescue => e
+  logger.error("Unexpected error: #{e.message}")
+
+  if options[:trace]
+    logger.log("\nFull backtrace:", color: 240)
+    e.backtrace.each { |line| logger.log("  #{line}", color: 240) }
+  else
+    logger.info("Run with --trace to see full error details")
+  end
+
+  exit 1
 end

data/lib/dotsync/config/concerns/sync_mappings.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Dotsync
+  # SyncMappings provides bidirectional mapping support.
+  # It reads [sync] section mappings and converts them to push or pull format.
+  #
+  # The [sync] section supports multiple sub-types:
+  #
+  # 1. Explicit mappings with [[sync.mappings]]:
+  #    [[sync.mappings]]
+  #    local  = "$XDG_CONFIG_HOME/nvim"
+  #    remote = "$XDG_CONFIG_HOME_MIRROR/nvim"
+  #    force  = true
+  #    ignore = ["lazy-lock.json"]
+  #
+  # 2. XDG shorthand mappings that auto-expand environment variables:
+  #    [[sync.xdg_config]]
+  #    path = "nvim"
+  #    force = true
+  #    # Expands to: local=$XDG_CONFIG_HOME/nvim, remote=$XDG_CONFIG_HOME_MIRROR/nvim
+  #
+  # Supported shorthands:
+  #   - sync.home:       $HOME <-> $HOME_MIRROR
+  #   - sync.xdg_config: $XDG_CONFIG_HOME <-> $XDG_CONFIG_HOME_MIRROR
+  #   - sync.xdg_data:   $XDG_DATA_HOME <-> $XDG_DATA_HOME_MIRROR
+  #   - sync.xdg_cache:  $XDG_CACHE_HOME <-> $XDG_CACHE_HOME_MIRROR
+  #   - sync.xdg_bin:    $XDG_BIN_HOME <-> $XDG_BIN_HOME_MIRROR
+  #   - sync.mappings:   explicit local/remote mappings
+  #
+  # For push: local → remote (src=local, dest=remote)
+  # For pull: remote → local (src=remote, dest=local)
+  module SyncMappings
+    SYNC_SECTION = "sync"
+    MAPPINGS_KEY = "mappings"
+
+    # Shorthand type definitions mapping to local/remote base paths
+    SHORTHANDS = {
+      "home"       => { local: "$HOME",            remote: "$HOME_MIRROR" },
+      "xdg_config" => { local: "$XDG_CONFIG_HOME", remote: "$XDG_CONFIG_HOME_MIRROR" },
+      "xdg_data"   => { local: "$XDG_DATA_HOME",   remote: "$XDG_DATA_HOME_MIRROR" },
+      "xdg_cache"  => { local: "$XDG_CACHE_HOME",  remote: "$XDG_CACHE_HOME_MIRROR" },
+      "xdg_bin"    => { local: "$XDG_BIN_HOME",    remote: "$XDG_BIN_HOME_MIRROR" }
+    }.freeze
+
+    def sync_mappings_for_push
+      all_sync_mappings(:push)
+    end
+
+    def sync_mappings_for_pull
+      all_sync_mappings(:pull)
+    end
+
+    def has_sync_mappings?
+      return false unless sync_section.is_a?(Hash)
+
+      explicit_mappings_raw.any? || shorthand_mappings_raw.any?
+    end
+
+    private
+      def all_sync_mappings(direction)
+        convert_explicit_mappings(direction: direction) + convert_shorthand_mappings(direction: direction)
+      end
+
+      def sync_section
+        @config[SYNC_SECTION]
+      end
+
+      # Explicit [[sync.mappings]] with local/remote keys
+      def explicit_mappings_raw
+        return [] unless sync_section.is_a?(Hash)
+        return [] unless sync_section.key?(MAPPINGS_KEY)
+
+        Array(sync_section[MAPPINGS_KEY])
+      end
+
+      def convert_explicit_mappings(direction:)
+        explicit_mappings_raw.map do |mapping|
+          converted = convert_explicit_mapping(mapping, direction)
+          Dotsync::Mapping.new(converted)
+        end
+      end
+
+      def convert_explicit_mapping(mapping, direction)
+        local = mapping["local"]
+        remote = mapping["remote"]
+
+        base = case direction
+               when :push
+                 { "src" => local, "dest" => remote }
+               when :pull
+                 { "src" => remote, "dest" => local }
+        end
+
+        # Preserve other options
+        base["force"] = mapping["force"] if mapping.key?("force")
+        base["ignore"] = mapping["ignore"] if mapping.key?("ignore")
+        base["only"] = mapping["only"] if mapping.key?("only")
+
+        base
+      end
+
+      # Shorthand mappings: [[sync.home]], [[sync.xdg_config]], etc.
+      def shorthand_mappings_raw
+        return [] unless sync_section.is_a?(Hash)
+
+        mappings = []
+        SHORTHANDS.each_key do |shorthand_type|
+          next unless sync_section.key?(shorthand_type)
+          Array(sync_section[shorthand_type]).each do |mapping|
+            mappings << { type: shorthand_type, mapping: mapping }
+          end
+        end
+        mappings
+      end
+
+      def convert_shorthand_mappings(direction:)
+        shorthand_mappings_raw.map do |entry|
+          converted = convert_shorthand_mapping(entry[:type], entry[:mapping], direction)
+          Dotsync::Mapping.new(converted)
+        end
+      end
+
+      def convert_shorthand_mapping(shorthand_type, mapping, direction)
+        shorthand_def = SHORTHANDS[shorthand_type]
+
+        # Support both 'path' for single paths and 'only' for multiple paths
+        path = mapping["path"]
+        only = mapping["only"]
+
+        local = build_path(shorthand_def[:local], path)
+        remote = build_path(shorthand_def[:remote], path)
+
+        base = case direction
+               when :push
+                 { "src" => local, "dest" => remote }
+               when :pull
+                 { "src" => remote, "dest" => local }
+        end
+
+        # Preserve other options
+        base["force"] = mapping["force"] if mapping.key?("force")
+        base["ignore"] = mapping["ignore"] if mapping.key?("ignore")
+        base["only"] = only if only
+
+        base
+      end
+
+      def build_path(base, path)
+        path ? File.join(base, path) : base
+      end
+
+      def validate_sync_mappings!
+        return unless sync_section
+
+        unless sync_section.is_a?(Hash)
+          raise Dotsync::ConfigError,
+            "Configuration error: [sync] must be a table, not an array. " \
+            "Use [[sync.mappings]] for explicit mappings."
+        end
+
+        validate_explicit_mappings!
+        validate_shorthand_mappings!
+      end
+
+      def validate_explicit_mappings!
+        return unless sync_section.key?(MAPPINGS_KEY)
+
+        explicit_mappings_raw.each_with_index do |mapping, index|
+          unless mapping.is_a?(Hash) && mapping.key?("local") && mapping.key?("remote")
+            raise Dotsync::ConfigError,
+              "Configuration error in sync.mappings ##{index + 1}: " \
+              "Each mapping must have 'local' and 'remote' keys."
+          end
+        end
+      end
+
+      def validate_shorthand_mappings!
+        SHORTHANDS.each_key do |shorthand_type|
+          next unless sync_section.key?(shorthand_type)
+
+          Array(sync_section[shorthand_type]).each_with_index do |mapping, index|
+            unless mapping.is_a?(Hash)
+              raise Dotsync::ConfigError,
+                "Configuration error in sync.#{shorthand_type} ##{index + 1}: " \
+                "Each mapping must be a table."
+            end
+          end
+        end
+      end
+  end
+end

data/lib/dotsync/config/pull_action_config.rb

@@ -3,10 +3,10 @@
 module Dotsync
   class PullActionConfig < BaseConfig
     include XDGBaseDirectory
+    include SyncMappings
 
     def mappings
-      mappings_list = section["mappings"]
-      Array(mappings_list).map { |mapping| Dotsync::Mapping.new(mapping) }
+      section_mappings + sync_mappings_for_pull
     end
 
     def backups_root
@@ -20,13 +20,31 @@ module Dotsync
         SECTION_NAME
       end
 
+      def section_mappings
+        return [] unless section && section["mappings"]
+        Array(section["mappings"]).map { |mapping| Dotsync::Mapping.new(mapping) }
+      end
+
       def validate!
-        validate_section_present!
-        validate_key_present! "mappings"
+        validate_pull_or_sync_present!
+        validate_pull_mappings!
+        validate_sync_mappings!
+      end
+
+      def validate_pull_or_sync_present!
+        has_pull = @config.key?(section_name) && section["mappings"]&.any?
+
+        unless has_pull || has_sync_mappings?
+          raise_error "No [#{section_name}] mappings or [sync] mappings found in config file"
+        end
+      end
+
+      def validate_pull_mappings!
+        return unless section && section["mappings"]
 
         Array(section["mappings"]).each_with_index do |mapping, index|
           unless mapping.is_a?(Hash) && mapping.key?("src") && mapping.key?("dest")
-            raise "Configuration error in mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
+            raise "Configuration error in pull mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
           end
         end
       end

data/lib/dotsync/config/push_action_config.rb

@@ -2,9 +2,10 @@
 
 module Dotsync
   class PushActionConfig < BaseConfig
+    include SyncMappings
+
     def mappings
-      mappings_list = section["mappings"]
-      Array(mappings_list).map { |mapping| Dotsync::Mapping.new(mapping) }
+      section_mappings + sync_mappings_for_push
     end
 
     private
@@ -14,13 +15,31 @@ module Dotsync
         SECTION_NAME
       end
 
+      def section_mappings
+        return [] unless section && section["mappings"]
+        Array(section["mappings"]).map { |mapping| Dotsync::Mapping.new(mapping) }
+      end
+
       def validate!
-        validate_section_present!
-        validate_key_present! "mappings"
+        validate_push_or_sync_present!
+        validate_push_mappings!
+        validate_sync_mappings!
+      end
+
+      def validate_push_or_sync_present!
+        has_push = @config.key?(section_name) && section["mappings"]&.any?
+
+        unless has_push || has_sync_mappings?
+          raise_error "No [#{section_name}] mappings or [sync] mappings found in config file"
+        end
+      end
+
+      def validate_push_mappings!
+        return unless section && section["mappings"]
 
         Array(section["mappings"]).each_with_index do |mapping, index|
           unless mapping.is_a?(Hash) && mapping.key?("src") && mapping.key?("dest")
-            raise "Configuration error in mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
+            raise "Configuration error in push mapping ##{index + 1}: Each mapping must have 'src' and 'dest' keys."
           end
         end
       end

data/lib/dotsync/loaders/pull_loader.rb

@@ -16,6 +16,10 @@ require_relative "../utils/config_cache"
 require_relative "../models/mapping"
 require_relative "../models/diff"
 
+# Config Concerns
+require_relative "../config/concerns/xdg_base_directory"
+require_relative "../config/concerns/sync_mappings"
+
 # Config
 require_relative "../config/base_config"
 require_relative "../config/pull_action_config"

data/lib/dotsync/loaders/push_loader.rb

@@ -16,6 +16,9 @@ require_relative "../utils/config_cache"
 require_relative "../models/mapping"
 require_relative "../models/diff"
 
+# Config Concerns
+require_relative "../config/concerns/sync_mappings"
+
 # Config
 require_relative "../config/base_config"
 require_relative "../config/push_action_config"

data/lib/dotsync/runner.rb

@@ -5,6 +5,7 @@ module Dotsync
     def initialize(logger: nil, config_path: nil)
       @logger = logger || Dotsync::Logger.new
       @config_path = config_path
+      Dotsync.config_path = config_path if config_path
     end
 
     # action_name should be a symbol, e.g., :pull, :watch, :sync

data/lib/dotsync/utils/directory_differ.rb

@@ -36,7 +36,7 @@ module Dotsync
         Find.find(mapping_src) do |src_path|
           rel_path = src_path.sub(/^#{Regexp.escape(mapping_src)}\/?/, "")
 
-          unless @mapping.include?(src_path)
+          unless @mapping.bidirectional_include?(src_path)
             Find.prune
             next
           end

data/lib/dotsync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dotsync
-  VERSION = "0.1.24"
+  VERSION = "0.1.26"
 end

data/lib/dotsync.rb

@@ -22,6 +22,7 @@ require_relative "dotsync/version"
 
 # Config Concerns (loaded early as they're used by other modules)
 require_relative "dotsync/config/concerns/xdg_base_directory"
+require_relative "dotsync/config/concerns/sync_mappings"
 
 # Utils
 require_relative "dotsync/utils/path_utils"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dotsync
 version: !ruby/object:Gem::Version
-  version: 0.1.24
+  version: 0.1.26
 platform: ruby
 authors:
 - David Sáenz
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: toml-rb
@@ -285,9 +284,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".editorconfig"
-- ".github/workflows/gem-push.yml"
-- ".github/workflows/gem-push.yml.bak"
+- ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
+- ".pre-commit-config.yaml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
@@ -317,6 +317,7 @@ files:
 - lib/dotsync/actions/watch_action.rb
 - lib/dotsync/colors.rb
 - lib/dotsync/config/base_config.rb
+- lib/dotsync/config/concerns/sync_mappings.rb
 - lib/dotsync/config/concerns/xdg_base_directory.rb
 - lib/dotsync/config/pull_action_config.rb
 - lib/dotsync/config/push_action_config.rb
@@ -346,7 +347,6 @@ metadata:
   homepage_uri: https://github.com/dsaenztagarro/dotsync
   source_code_uri: https://github.com/dsaenztagarro/dotsync
   changelog_uri: https://github.com/dsaenztagarro/dotsync/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -361,8 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Manage dotfiles like a boss
 test_files: []

data/.github/workflows/gem-push.yml.bak

@@ -1,45 +0,0 @@
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Publish to GPR
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
-      env:
-        GEM_HOST_API_KEY: "Bearer ${{secrets.GITHUB_TOKEN}}"
-        OWNER: ${{ github.repository_owner }}
-
-  publish:
-    needs: test
-    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/master' && matrix.ruby == '3.2'
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
-          bundler-cache: true
-
-      - name: Check if gem version has changed
-        id: gem_version_check
-        run: |
-          gem build *.gemspec
-          gem_name=$(ls *.gem | head -n 1)
-          gem info $gem_name --remote || echo "new_version" > version_changed
-        env:
-          GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"