ast-merge 3.1.0 → 4.0.1

data/lib/ast/merge/rspec/dependency_tags.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "merge_gem_registry"
+
 # Ast::Merge RSpec Dependency Tags
 #
 # This module provides dependency detection helpers for conditional test execution
-# in the ast-merge gem family. It extends tree_haver's dependency tags with
-# merge-gem-specific checks.
+# in the ast-merge gem family. It uses MergeGemRegistry for dynamic merge gem detection.
 #
 # @example Loading in spec_helper.rb
 #   require "ast/merge/rspec/dependency_tags"
@@ -18,50 +19,26 @@
 #     # This test only runs when prism-merge is available
 #   end
 #
-# == Available Tags
-#
-# === Merge Gem Tags (run when dependency IS available)
-#
-# [:markly_merge]
-#   markly-merge gem is available and functional.
-#
-# [:commonmarker_merge]
-#   commonmarker-merge gem is available and functional.
-#
-# [:markdown_merge]
-#   markdown-merge gem is available and functional.
-#
-# [:prism_merge]
-#   prism-merge gem is available and functional.
-#
-# [:json_merge]
-#   json-merge gem is available and functional.
+# == Dynamic Tag Registration
 #
-# [:jsonc_merge]
-#   jsonc-merge gem is available and functional.
+# Merge gems register themselves with MergeGemRegistry, which automatically:
+# - Defines `*_available?` methods on DependencyTags
+# - Configures RSpec exclusion filters for the tag
+# - Supports negated tags (`:not_*`)
 #
-# [:toml_merge]
-#   toml-merge gem is available and functional.
+# @example How merge gems register (in their lib file)
+#   Ast::Merge::RSpec::MergeGemRegistry.register(
+#     :markly_merge,
+#     require_path: "markly/merge",
+#     merger_class: "Markly::Merge::SmartMerger",
+#     test_source: "# Test\n\nParagraph",
+#     category: :markdown
+#   )
 #
-# [:bash_merge]
-#   bash-merge gem is available and functional.
-#
-# [:psych_merge]
-#   psych-merge gem is available and functional.
-#
-# [:rbs_merge]
-#   rbs-merge gem is available and functional.
+# == Built-in Composite Tags
 #
 # [:any_markdown_merge]
-#   At least one markdown merge gem (markly-merge or commonmarker-merge) is available.
-#
-# === Negated Tags (run when dependency is NOT available)
-#
-# All positive tags have negated versions prefixed with `not_`:
-# - :not_markly_merge, :not_commonmarker_merge, :not_markdown_merge
-# - :not_prism_merge, :not_json_merge, :not_jsonc_merge
-# - :not_toml_merge, :not_bash_merge, :not_psych_merge, :not_rbs_merge
-# - :not_any_markdown_merge
+#   At least one markdown merge gem is available (category: :markdown).
 
 module Ast
   module Merge
@@ -70,96 +47,16 @@ module Ast
       module DependencyTags
         class << self
           # ============================================================
-          # Merge Gem Availability
+          # Composite Availability Checks
           # ============================================================
 
-          # rubocop:disable ThreadSafety/ClassInstanceVariable
-          # Check if markly-merge is available and functional
-          #
-          # @return [Boolean] true if markly-merge works
-          def markly_merge_available?
-            return @markly_merge_available if defined?(@markly_merge_available)
-            @markly_merge_available = merge_gem_works?("markly/merge", "Markly::Merge::SmartMerger", "# Test\n\nParagraph")
-          end
-
-          # Check if commonmarker-merge is available and functional
-          #
-          # @return [Boolean] true if commonmarker-merge works
-          def commonmarker_merge_available?
-            return @commonmarker_merge_available if defined?(@commonmarker_merge_available)
-            @commonmarker_merge_available = merge_gem_works?("commonmarker/merge", "Commonmarker::Merge::SmartMerger", "# Test\n\nParagraph")
-          end
-
-          # Check if markdown-merge is available and functional
-          #
-          # @return [Boolean] true if markdown-merge works
-          def markdown_merge_available?
-            return @markdown_merge_available if defined?(@markdown_merge_available)
-            @markdown_merge_available = merge_gem_works?("markdown/merge", "Markdown::Merge::SmartMerger", "# Test\n\nParagraph")
-          end
-
-          # Check if prism-merge is available and functional
-          #
-          # @return [Boolean] true if prism-merge works
-          def prism_merge_available?
-            return @prism_merge_available if defined?(@prism_merge_available)
-            @prism_merge_available = merge_gem_works?("prism/merge", "Prism::Merge::SmartMerger", "puts 1")
-          end
-
-          # Check if json-merge is available and functional
-          #
-          # @return [Boolean] true if json-merge works
-          def json_merge_available?
-            return @json_merge_available if defined?(@json_merge_available)
-            @json_merge_available = merge_gem_works?("json/merge", "Json::Merge::SmartMerger", '{"key": "value"}')
-          end
-
-          # Check if jsonc-merge is available and functional
-          #
-          # @return [Boolean] true if jsonc-merge works
-          def jsonc_merge_available?
-            return @jsonc_merge_available if defined?(@jsonc_merge_available)
-            @jsonc_merge_available = merge_gem_works?("jsonc/merge", "Jsonc::Merge::SmartMerger", '{"key": "value" /* comment */}')
-          end
-
-          # Check if toml-merge is available and functional
-          #
-          # @return [Boolean] true if toml-merge works
-          def toml_merge_available?
-            return @toml_merge_available if defined?(@toml_merge_available)
-            @toml_merge_available = merge_gem_works?("toml/merge", "Toml::Merge::SmartMerger", 'key = "value"')
-          end
-
-          # Check if bash-merge is available and functional
-          #
-          # @return [Boolean] true if bash-merge works
-          def bash_merge_available?
-            return @bash_merge_available if defined?(@bash_merge_available)
-            @bash_merge_available = merge_gem_works?("bash/merge", "Bash::Merge::SmartMerger", "echo hello")
-          end
-
-          # Check if psych-merge is available and functional
-          #
-          # @return [Boolean] true if psych-merge works
-          def psych_merge_available?
-            return @psych_merge_available if defined?(@psych_merge_available)
-            @psych_merge_available = merge_gem_works?("psych/merge", "Psych::Merge::SmartMerger", "key: value")
-          end
-
-          # Check if rbs-merge is available and functional
-          #
-          # @return [Boolean] true if rbs-merge works
-          def rbs_merge_available?
-            return @rbs_merge_available if defined?(@rbs_merge_available)
-            @rbs_merge_available = merge_gem_works?("rbs/merge", "Rbs::Merge::SmartMerger", "class Foo end")
-          end
-          # rubocop:enable ThreadSafety/ClassInstanceVariable
-
           # Check if at least one markdown merge gem is available
           #
           # @return [Boolean] true if any markdown merge gem works
           def any_markdown_merge_available?
-            markly_merge_available? || commonmarker_merge_available? || markdown_merge_available?
+            MergeGemRegistry.gems_by_category(:markdown).any? do |tag|
+              MergeGemRegistry.available?(tag)
+            end
           end
 
           # ============================================================
@@ -170,45 +67,16 @@ module Ast
           #
           # @return [Hash{Symbol => Boolean}] map of dependency name to availability
           def summary
-            {
-              markly_merge: markly_merge_available?,
-              commonmarker_merge: commonmarker_merge_available?,
-              markdown_merge: markdown_merge_available?,
-              prism_merge: prism_merge_available?,
-              json_merge: json_merge_available?,
-              jsonc_merge: jsonc_merge_available?,
-              toml_merge: toml_merge_available?,
-              bash_merge: bash_merge_available?,
-              psych_merge: psych_merge_available?,
-              rbs_merge: rbs_merge_available?,
-              any_markdown_merge: any_markdown_merge_available?,
-            }
+            result = MergeGemRegistry.summary
+            result[:any_markdown_merge] = any_markdown_merge_available?
+            result
           end
 
           # Reset all memoized availability checks
           #
           # @return [void]
           def reset!
-            instance_variables.each do |ivar|
-              remove_instance_variable(ivar) if ivar.to_s.end_with?("_available")
-            end
-          end
-
-          private
-
-          # Generic helper to check if a merge gem is available and functional
-          #
-          # @param require_path [String] the require path for the gem
-          # @param merger_class [String] the full class name of the SmartMerger
-          # @param test_source [String] sample source code to test merging
-          # @return [Boolean] true if the merger can be instantiated
-          def merge_gem_works?(require_path, merger_class, test_source)
-            require require_path
-            klass = Object.const_get(merger_class)
-            klass.new(test_source, test_source)
-            true
-          rescue LoadError, StandardError
-            false
+            MergeGemRegistry.reset_availability!
           end
         end
       end
@@ -219,10 +87,11 @@ end
 # Configure RSpec with dependency-based exclusion filters
 RSpec.configure do |config|
   deps = Ast::Merge::RSpec::DependencyTags
+  registry = Ast::Merge::RSpec::MergeGemRegistry
 
   config.before(:suite) do
     # Print dependency summary if AST_MERGE_DEBUG is set
-    if ENV["AST_MERGE_DEBUG"]
+    unless ENV.fetch("AST_MERGE_DEBUG", "false").casecmp?("false")
       puts "\n=== Ast::Merge Test Dependencies ==="
       deps.summary.each do |dep, available|
         status = available ? "✓ available" : "✗ not available"
@@ -233,34 +102,24 @@ RSpec.configure do |config|
   end
 
   # ============================================================
-  # Merge Gem Tags
+  # Dynamic Merge Gem Tags
   # ============================================================
+  # Tags are configured dynamically based on what's registered in MergeGemRegistry.
+  # Each merge gem registers itself, and exclusion filters are set up automatically.
 
-  config.filter_run_excluding(markly_merge: true) unless deps.markly_merge_available?
-  config.filter_run_excluding(commonmarker_merge: true) unless deps.commonmarker_merge_available?
-  config.filter_run_excluding(markdown_merge: true) unless deps.markdown_merge_available?
-  config.filter_run_excluding(prism_merge: true) unless deps.prism_merge_available?
-  config.filter_run_excluding(json_merge: true) unless deps.json_merge_available?
-  config.filter_run_excluding(jsonc_merge: true) unless deps.jsonc_merge_available?
-  config.filter_run_excluding(toml_merge: true) unless deps.toml_merge_available?
-  config.filter_run_excluding(bash_merge: true) unless deps.bash_merge_available?
-  config.filter_run_excluding(psych_merge: true) unless deps.psych_merge_available?
-  config.filter_run_excluding(rbs_merge: true) unless deps.rbs_merge_available?
-  config.filter_run_excluding(any_markdown_merge: true) unless deps.any_markdown_merge_available?
+  registry.registered_gems.each do |tag|
+    # Positive tag: run when gem IS available
+    config.filter_run_excluding(tag => true) unless registry.available?(tag)
+
+    # Negated tag: run when gem is NOT available
+    negated_tag = :"not_#{tag}"
+    config.filter_run_excluding(negated_tag => true) if registry.available?(tag)
+  end
 
   # ============================================================
-  # Negated Tags (run when dependency is NOT available)
+  # Composite Tags
   # ============================================================
 
-  config.filter_run_excluding(not_markly_merge: true) if deps.markly_merge_available?
-  config.filter_run_excluding(not_commonmarker_merge: true) if deps.commonmarker_merge_available?
-  config.filter_run_excluding(not_markdown_merge: true) if deps.markdown_merge_available?
-  config.filter_run_excluding(not_prism_merge: true) if deps.prism_merge_available?
-  config.filter_run_excluding(not_json_merge: true) if deps.json_merge_available?
-  config.filter_run_excluding(not_jsonc_merge: true) if deps.jsonc_merge_available?
-  config.filter_run_excluding(not_toml_merge: true) if deps.toml_merge_available?
-  config.filter_run_excluding(not_bash_merge: true) if deps.bash_merge_available?
-  config.filter_run_excluding(not_psych_merge: true) if deps.psych_merge_available?
-  config.filter_run_excluding(not_rbs_merge: true) if deps.rbs_merge_available?
+  config.filter_run_excluding(any_markdown_merge: true) unless deps.any_markdown_merge_available?
   config.filter_run_excluding(not_any_markdown_merge: true) if deps.any_markdown_merge_available?
 end

data/lib/ast/merge/rspec/merge_gem_registry.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module Ast
+  module Merge
+    module RSpec
+      # Registry for merge gem dependency tag availability checkers
+      #
+      # This module allows merge gems (like markly-merge, prism-merge, json-merge)
+      # to register their availability checker for RSpec dependency tags without
+      # ast-merge needing to know about them directly.
+      #
+      # == Purpose
+      #
+      # When running RSpec tests with dependency tags (e.g., `:markly_merge`),
+      # ast-merge needs to know if each merge gem is available. The MergeGemRegistry
+      # provides a way for gems to register their availability checkers, and also
+      # pre-configures known merge gems so they can be checked before being loaded.
+      #
+      # == Pre-configured Gems
+      #
+      # The following merge gems are pre-configured so that their availability can
+      # be checked before they are loaded (e.g., during RSpec setup):
+      # - :markly_merge, :commonmarker_merge, :markdown_merge (markdown)
+      # - :prism_merge, :bash_merge, :rbs_merge (code)
+      # - :json_merge, :jsonc_merge (data)
+      # - :toml_merge, :psych_merge, :dotenv_merge (config)
+      #
+      # External merge gems can also register themselves by calling {register}
+      # when loaded.
+      #
+      # == Registration
+      #
+      # Each merge gem registers itself when loaded using {register}:
+      # - Tag name (e.g., :markly_merge)
+      # - Require path (e.g., "markly/merge")
+      # - Merger class name (e.g., "Markly::Merge::SmartMerger")
+      # - Test source code to verify the merger works
+      # - Optional category for grouping (e.g., :markdown, :data, :code)
+      #
+      # When a tag is registered, an availability method is automatically defined
+      # on `Ast::Merge::RSpec::DependencyTags`.
+      #
+      # == Thread Safety
+      #
+      # All operations are thread-safe using a Mutex for synchronization.
+      # Results are cached after first check for performance.
+      #
+      # @example Registering a merge gem (in your gem's lib file)
+      #   # In markly-merge/lib/markly/merge.rb
+      #   if defined?(Ast::Merge::RSpec::MergeGemRegistry)
+      #     Ast::Merge::RSpec::MergeGemRegistry.register(
+      #       :markly_merge,
+      #       require_path: "markly/merge",
+      #       merger_class: "Markly::Merge::SmartMerger",
+      #       test_source: "# Test\n\nParagraph",
+      #       category: :markdown
+      #     )
+      #   end
+      #
+      # @example Checking availability
+      #   Ast::Merge::RSpec::MergeGemRegistry.available?(:markly_merge)  # => true/false
+      #
+      # @example Getting all registered gems
+      #   Ast::Merge::RSpec::MergeGemRegistry.registered_gems # => [:markly_merge, :prism_merge, ...]
+      #
+      # @see Ast::Merge::RSpec::DependencyTags Uses MergeGemRegistry for dynamic gem detection
+      # @api public
+      module MergeGemRegistry
+        @mutex = Mutex.new
+        @registry = {} # rubocop:disable ThreadSafety/MutableClassInstanceVariable
+        @availability_cache = {} # rubocop:disable ThreadSafety/MutableClassInstanceVariable
+
+        # Valid categories for merge gems
+        CATEGORIES = %i[markdown data code config other].freeze
+
+        # Pre-configured known merge gems
+        # These can be checked before the gems are actually loaded
+        KNOWN_GEMS = {
+          # Markdown gems
+          markly_merge: {
+            require_path: "markly/merge",
+            merger_class: "Markly::Merge::SmartMerger",
+            test_source: "# Test\n\nParagraph",
+            category: :markdown,
+            skip_instantiation: false,
+          },
+          commonmarker_merge: {
+            require_path: "commonmarker/merge",
+            merger_class: "Commonmarker::Merge::SmartMerger",
+            test_source: "# Test\n\nParagraph",
+            category: :markdown,
+            skip_instantiation: false,
+          },
+          markdown_merge: {
+            require_path: "markdown/merge",
+            merger_class: "Markdown::Merge::SmartMerger",
+            test_source: "# Test\n\nParagraph",
+            category: :markdown,
+            skip_instantiation: true, # Requires backend
+          },
+          # Code gems
+          prism_merge: {
+            require_path: "prism/merge",
+            merger_class: "Prism::Merge::SmartMerger",
+            test_source: "def foo; end",
+            category: :code,
+            skip_instantiation: false,
+          },
+          bash_merge: {
+            require_path: "bash/merge",
+            merger_class: "Bash::Merge::SmartMerger",
+            test_source: "#!/bin/bash\necho hello",
+            category: :code,
+            skip_instantiation: false,
+          },
+          rbs_merge: {
+            require_path: "rbs/merge",
+            merger_class: "Rbs::Merge::SmartMerger",
+            test_source: "class Foo\nend",
+            category: :code,
+            skip_instantiation: false,
+          },
+          # Data gems
+          json_merge: {
+            require_path: "json/merge",
+            merger_class: "Json::Merge::SmartMerger",
+            test_source: '{"key": "value"}',
+            category: :data,
+            skip_instantiation: false,
+          },
+          jsonc_merge: {
+            require_path: "jsonc/merge",
+            merger_class: "Jsonc::Merge::SmartMerger",
+            test_source: "// comment\n{\"key\": \"value\"}",
+            category: :data,
+            skip_instantiation: false,
+          },
+          # Config gems
+          toml_merge: {
+            require_path: "toml/merge",
+            merger_class: "Toml::Merge::SmartMerger",
+            test_source: "[section]\nkey = \"value\"",
+            category: :config,
+            skip_instantiation: false,
+          },
+          psych_merge: {
+            require_path: "psych/merge",
+            merger_class: "Psych::Merge::SmartMerger",
+            test_source: "key: value",
+            category: :config,
+            skip_instantiation: false,
+          },
+          dotenv_merge: {
+            require_path: "dotenv/merge",
+            merger_class: "Dotenv::Merge::SmartMerger",
+            test_source: "KEY=value",
+            category: :config,
+            skip_instantiation: false,
+          },
+        }.freeze
+
+        module_function
+
+        # Register a merge gem for dependency tag support
+        #
+        # When a gem is registered, this also dynamically defines a `*_available?` method
+        # on `Ast::Merge::RSpec::DependencyTags` if it doesn't already exist.
+        #
+        # @param tag_name [Symbol] the RSpec tag name (e.g., :markly_merge)
+        # @param require_path [String] the require path for the gem (e.g., "markly/merge")
+        # @param merger_class [String] the full class name of the SmartMerger
+        # @param test_source [String] sample source code to test merging
+        # @param category [Symbol] category for grouping (:markdown, :data, :code, :config, :other)
+        # @param skip_instantiation [Boolean] if true, only check class exists (for gems requiring backends)
+        # @return [void]
+        #
+        # @example Register a merge gem
+        #   Ast::Merge::RSpec::MergeGemRegistry.register(
+        #     :markly_merge,
+        #     require_path: "markly/merge",
+        #     merger_class: "Markly::Merge::SmartMerger",
+        #     test_source: "# Test\n\nParagraph",
+        #     category: :markdown
+        #   )
+        def register(tag_name, require_path:, merger_class:, test_source:, category: :other, skip_instantiation: false)
+          raise ArgumentError, "Invalid category: #{category}" unless CATEGORIES.include?(category)
+
+          tag_sym = tag_name.to_sym
+
+          @mutex.synchronize do
+            @registry[tag_sym] = {
+              require_path: require_path,
+              merger_class: merger_class,
+              test_source: test_source,
+              category: category,
+              skip_instantiation: skip_instantiation,
+            }
+            # Clear cache when re-registering
+            @availability_cache.delete(tag_sym)
+          end
+
+          # Define availability method on DependencyTags
+          define_availability_method(tag_sym)
+
+          nil
+        end
+
+        # Check if a merge gem is available and functional
+        #
+        # This method will try to load the gem if it's not yet registered but
+        # is known (in KNOWN_GEMS). This allows availability checking before
+        # the gem is explicitly loaded.
+        #
+        # @param tag_name [Symbol] the tag name to check
+        # @return [Boolean] true if the merge gem is available and works
+        def available?(tag_name)
+          tag_sym = tag_name.to_sym
+
+          # Check cache first
+          @mutex.synchronize do
+            return @availability_cache[tag_sym] if @availability_cache.key?(tag_sym)
+          end
+
+          # Get registration info (from registry or known gems)
+          info = @mutex.synchronize { @registry[tag_sym] }
+          info ||= KNOWN_GEMS[tag_sym]
+
+          return false unless info
+
+          # Check if gem works
+          result = gem_works?(
+            info[:require_path],
+            info[:merger_class],
+            info[:test_source],
+            info[:skip_instantiation],
+          )
+
+          # Cache result
+          @mutex.synchronize do
+            @availability_cache[tag_sym] = result
+          end
+
+          result
+        end
+
+        # Check if a tag is registered
+        #
+        # @param tag_name [Symbol] the tag name
+        # @return [Boolean] true if the tag is registered
+        def registered?(tag_name)
+          @mutex.synchronize do
+            @registry.key?(tag_name.to_sym)
+          end
+        end
+
+        # Get all registered gem tag names (including pre-configured known gems)
+        #
+        # @return [Array<Symbol>] list of registered tag names
+        def registered_gems
+          @mutex.synchronize do
+            (KNOWN_GEMS.keys + @registry.keys).uniq
+          end
+        end
+
+        # Get gems filtered by category
+        #
+        # @param category [Symbol] one of :markdown, :data, :code, :config, :other
+        # @return [Array<Symbol>] list of tag names in that category
+        def gems_by_category(category)
+          @mutex.synchronize do
+            known = KNOWN_GEMS.select { |_, info| info[:category] == category }.keys
+            registered = @registry.select { |_, info| info[:category] == category }.keys
+            (known + registered).uniq
+          end
+        end
+
+        # Get registration info for a gem
+        #
+        # @param tag_name [Symbol] the tag name
+        # @return [Hash, nil] registration info or nil if not registered/known
+        def info(tag_name)
+          tag_sym = tag_name.to_sym
+          @mutex.synchronize do
+            @registry[tag_sym]&.dup || KNOWN_GEMS[tag_sym]&.dup
+          end
+        end
+
+        # Get a summary of all registered gems and their availability
+        #
+        # @return [Hash{Symbol => Boolean}] map of tag name to availability
+        def summary
+          registered_gems.each_with_object({}) do |tag, result|
+            result[tag] = available?(tag)
+          end
+        end
+
+        # Clear the availability cache
+        #
+        # @return [void]
+        def clear_cache!
+          @mutex.synchronize do
+            @availability_cache.clear
+          end
+          nil
+        end
+
+        # Clear all registrations and cache
+        #
+        # @return [void]
+        def clear!
+          @mutex.synchronize do
+            @registry.clear
+            @availability_cache.clear
+          end
+          nil
+        end
+
+        # Reset memoized availability on DependencyTags
+        #
+        # @return [void]
+        def reset_availability!
+          clear_cache!
+          return unless defined?(DependencyTags)
+
+          registered_gems.each do |tag|
+            ivar = :"@#{tag}_available"
+            DependencyTags.remove_instance_variable(ivar) if DependencyTags.instance_variable_defined?(ivar)
+          end
+        end
+
+        # ============================================================
+        # Private Helpers
+        # ============================================================
+
+        # Check if a merge gem is available and functional
+        #
+        # @param require_path [String] the require path for the gem
+        # @param merger_class [String] the full class name of the SmartMerger
+        # @param test_source [String] sample source code to test merging
+        # @param skip_instantiation [Boolean] if true, only check class exists
+        # @return [Boolean] true if the merger can be loaded/instantiated
+        # @api private
+        def gem_works?(require_path, merger_class, test_source, skip_instantiation)
+          require require_path
+          klass = Object.const_get(merger_class)
+
+          if skip_instantiation
+            # Just check that the class exists and looks like a SmartMerger
+            klass.is_a?(Class) && klass.ancestors.any? { |a| a.name&.include?("SmartMergerBase") }
+          else
+            klass.new(test_source, test_source)
+            true
+          end
+        rescue LoadError, StandardError
+          false
+        end
+        private_class_method :gem_works?
+
+        # Dynamically define an availability method on DependencyTags
+        #
+        # @param tag_name [Symbol] the tag name (e.g., :markly_merge)
+        # @return [void]
+        # @api private
+        def define_availability_method(tag_name)
+          method_name = :"#{tag_name}_available?"
+
+          # Only define if DependencyTags is loaded
+          return unless defined?(DependencyTags)
+
+          # Don't override existing methods
+          return if DependencyTags.respond_to?(method_name)
+
+          # Define the method dynamically - MergeGemRegistry.available? handles caching
+          DependencyTags.define_singleton_method(method_name) do
+            MergeGemRegistry.available?(tag_name)
+          end
+        end
+        private_class_method :define_availability_method
+      end
+    end
+  end
+end

data/lib/ast/merge/version.rb

@@ -5,7 +5,7 @@ module Ast
     # Version information for Ast::Merge
     module Version
       # Current version of the ast-merge gem
-      VERSION = "3.1.0"
+      VERSION = "4.0.1"
     end
     VERSION = Version::VERSION # traditional location
   end