insta 0.2.9 → 0.3.0

data/lib/insta/config_manifest.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Insta
+  # Bridges configuration from the test process to the standalone CLI.
+  #
+  # `Insta.configure` runs inside the test process (usually from the test
+  # helper), which the CLI never loads. Instead of asking users to maintain
+  # a separate config file, the test run serializes the CLI-relevant
+  # settings next to the snapshots at flush time, and the CLI applies them
+  # on startup. Machine-written state, like the pending manifests.
+  module ConfigManifest
+    FILENAME = ".insta-config.json"
+
+    SYMBOL_KEYS = [:diff_display, :diff_color].freeze #: Array[Symbol]
+    RAW_KEYS = [:diff_width, :snapshot_extension, :heredoc_identifier].freeze #: Array[Symbol]
+
+    #: () -> void
+    def self.write!
+      config = Insta.configuration
+
+      manifest = {} #: Hash[Symbol, untyped]
+      SYMBOL_KEYS.each { |key| manifest[key] = config.public_send(key)&.to_s }
+      RAW_KEYS.each { |key| manifest[key] = config.public_send(key) }
+
+      FileUtils.mkdir_p(config.snapshot_path)
+      File.write(path, JSON.pretty_generate(manifest))
+    end
+
+    #: () -> void
+    def self.apply!
+      return unless File.exist?(path)
+
+      manifest = JSON.parse(File.read(path), symbolize_names: true)
+      config = Insta.configuration
+
+      SYMBOL_KEYS.each do |key|
+        value = manifest[key]
+        config.public_send(:"#{key}=", value.to_sym) if value
+      end
+
+      RAW_KEYS.each do |key|
+        config.public_send(:"#{key}=", manifest[key]) unless manifest[key].nil?
+      end
+    rescue JSON::ParserError
+      nil
+    end
+
+    #: () -> String
+    def self.path
+      File.join(Insta.configuration.snapshot_path, FILENAME)
+    end
+  end
+end

data/lib/insta/configuration.rb

@@ -1,5 +1,89 @@
+# frozen_string_literal: true
+
 module Insta
   class Configuration
-    attr_accessor :proxy_list
+    # @rbs!
+    #   type snapshot_filename_resolver =
+    #     ^(test_name: String, counter: Integer, options: Hash[Symbol, untyped]) -> String
+
+    attr_accessor :snapshot_path #: String
+    attr_accessor :diff_display #: Symbol
+    attr_accessor :diff_width #: Integer?
+    attr_accessor :diff_color #: Symbol
+    attr_accessor :update_mode #: Symbol
+    attr_accessor :default_serializer #: Symbol
+    attr_accessor :heredoc_identifier #: String
+    attr_accessor :ci_mode #: Symbol
+    attr_accessor :snapshot_extension #: String
+    attr_accessor :snapshot_sanitizer #: (^(String) -> String)?
+    attr_accessor :snapshot_filename #: snapshot_filename_resolver?
+    attr_accessor :snapshot_directory #: (^(test_class: String) -> String)?
+    attr_accessor :new_snapshot #: Symbol
+
+    #: () -> void
+    def initialize
+      @snapshot_path = "test/snapshots"
+      @diff_display = :side_by_side
+      @diff_width = nil
+      @diff_color = :auto
+      @update_mode = :auto
+      @default_serializer = :to_s
+      @heredoc_identifier = "SNAP"
+      @ci_mode = :auto
+      @snapshot_extension = ".snap"
+      @snapshot_sanitizer = nil
+      @snapshot_filename = nil
+      @snapshot_directory = nil
+      @new_snapshot = :review
+    end
+
+    #: () -> Symbol
+    def resolved_update_mode
+      if ENV["INSTA_UPDATE"]
+        case ENV.fetch("INSTA_UPDATE", nil)
+        when "always", "force" then :force
+        when "new" then :new
+        when "no" then :no
+        else :auto
+        end
+      elsif ENV["INSTA_FORCE_PASS"]
+        :pending
+      elsif resolved_ci_mode?
+        :no
+      else
+        @update_mode
+      end
+    end
+
+    #: () -> bool
+    def resolved_ci_mode?
+      case @ci_mode
+      when :auto then CI.ci?
+      when true then true
+      else false
+      end
+    end
+
+    #: () -> String
+    def resolved_diff_color
+      return "never" if ENV.key?("NO_COLOR")
+
+      case @diff_color
+      when :always then "always"
+      when :never then "never"
+      when :auto
+        $stdout.tty? ? "always" : "never"
+      else
+        "auto"
+      end
+    end
+
+    #: () -> String
+    def resolved_diff_display
+      case @diff_display
+      when :inline then "inline"
+      else "side-by-side-show-both"
+      end
+    end
   end
-end
+end

data/lib/insta/diff.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "difftastic"
+
+module Insta
+  class Diff
+    #: () -> Difftastic::Differ
+    def self.differ
+      config = Insta.configuration
+
+      Difftastic::Differ.new(
+        color: config.resolved_diff_color.to_sym,
+        display: config.resolved_diff_display,
+        width: config.diff_width,
+        left_label: "Expected",
+        right_label: "Actual"
+      )
+    end
+
+    #: (String, String) -> String
+    def self.diff(expected, actual)
+      differ.diff_strings(expected, actual)
+    end
+
+    #: (String, String, ?file_extension: String?) -> String
+    def self.diff_with_language(expected, actual, file_extension: nil)
+      if file_extension
+        differ.diff_strings(expected, actual, file_extension: file_extension)
+      else
+        differ.diff_strings(expected, actual)
+      end
+    end
+
+    #: (String, String, String, ?String?, ?String?, ?file_extension: String?) -> String
+    def self.failure_message(expected, actual, test_name, snapshot_path = nil, line = nil, file_extension: nil)
+      dim = "\e[2m"
+      cyan = "\e[36m"
+      reset = "\e[0m"
+      divider = "#{dim}#{"─" * terminal_width}#{reset}"
+
+      message = +""
+      message << "#{reset}\n"
+      message << "Snapshot for #{cyan}\"#{test_name}\"#{reset} didn't match.\n"
+      message << "\n"
+      message << "  #{dim}Snapshot:#{reset} #{snapshot_path}\n" if snapshot_path
+      message << "  #{dim}Test:#{reset}     #{caller_file_location(line)}\n" if line
+      message << "\n"
+      message << "#{divider}\n"
+      message << diff_with_language(expected, actual, file_extension: file_extension)
+      message << "\n#{divider}\n"
+      message << "\n"
+
+      if line
+        message << "  #{dim}Update snapshot and re-run this test:#{reset}\n"
+        message << "  #{cyan}INSTA_UPDATE=force #{run_test_command(line)}#{reset}\n"
+        message << "\n"
+      end
+
+      message << "  #{dim}Interactively review all pending snapshots:#{reset}\n"
+      message << "  #{cyan}bundle exec insta review#{reset}\n"
+      message << "\n#{divider}\n"
+      message << reset
+
+      message
+    end
+
+    #: (String) -> String
+    def self.caller_file_location(caller_line)
+      file, lineno = caller_line.split(":", 3).first(2)
+
+      file && lineno ? "#{file}:#{lineno}" : caller_line
+    end
+
+    #: (String) -> String
+    def self.run_test_command(caller_line)
+      file, lineno = caller_line.split(":", 3).first(2)
+
+      if rspec?
+        "bundle exec rspec #{file}:#{lineno}"
+      elsif rails?
+        "bin/rails test #{file}:#{lineno}"
+      elsif minitest_cli?
+        "bundle exec minitest #{file}:#{lineno}"
+      elsif mtest?
+        "bundle exec mtest #{file}:#{lineno}"
+      else
+        "bundle exec ruby -Itest #{file}"
+      end
+    end
+
+    #: () -> bool
+    def self.rspec?
+      return @rspec if defined?(@rspec)
+
+      @rspec = !!defined?(::RSpec)
+    end
+
+    #: () -> bool
+    def self.rails?
+      return @rails if defined?(@rails)
+
+      @rails = !!(defined?(::Rails) && defined?(::ActiveSupport::TestCase))
+    end
+
+    #: () -> bool
+    def self.minitest_cli?
+      return @minitest_cli if defined?(@minitest_cli)
+
+      @minitest_cli = !!(defined?(::Minitest::VERSION) && Gem::Version.new(::Minitest::VERSION) >= Gem::Version.new("6.0"))
+    end
+
+    #: () -> bool
+    def self.mtest?
+      return @mtest if defined?(@mtest)
+
+      spec = Gem.loaded_specs["maxitest"]
+      @mtest = !minitest_cli? && spec.is_a?(Gem::Specification) &&
+               spec.version < Gem::Version.new("7.0")
+    end
+
+    #: () -> Integer
+    def self.terminal_width
+      if $stdout.tty?
+        begin
+          `tput cols`.strip.to_i
+        rescue StandardError
+          80
+        end
+      else
+        80
+      end
+    end
+  end
+end

data/lib/insta/inline/call_finder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Insta
+  module Inline
+    class CallFinder < Prism::Visitor
+      METHODS = [:assert_inline_snapshot, :match_inline_snapshot].freeze #: Array[Symbol]
+
+      attr_reader :found_call #: Prism::CallNode?
+
+      #: (Integer) -> void
+      def initialize(target_line)
+        super()
+
+        @target_line = target_line
+        @found_call = nil
+      end
+
+      #: (Prism::CallNode) -> void
+      def visit_call_node(node)
+        @found_call = node if METHODS.include?(node.name) && covers_line?(node)
+
+        super
+      end
+
+      private
+
+      #: (Prism::Node) -> bool
+      def covers_line?(node)
+        location = node.location
+
+        @target_line.between?(location.start_line, location.end_line)
+      end
+    end
+  end
+end

data/lib/insta/inline/edit.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Insta
+  module Inline
+    # @rbs!
+    #   type pending_entry = { line: Integer, content: String, type: Symbol }
+
+    class Edit
+      attr_reader :start_offset #: Integer
+      attr_reader :end_offset #: Integer
+      attr_reader :replacement #: String
+
+      #: (Integer, Integer, String) -> void
+      def initialize(start_offset, end_offset, replacement)
+        @start_offset = start_offset
+        @end_offset = end_offset
+        @replacement = replacement
+      end
+    end
+  end
+end

data/lib/insta/inline/file_patcher.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "prism"
+require "tempfile"
+
+module Insta
+  module Inline
+    class FilePatcher
+      #: (String, Array[Inline::pending_entry]) -> String
+      def self.patch(file_path, pending_entries)
+        source = File.read(file_path)
+        result = Prism.parse(source)
+        edits = [] #: Array[Edit]
+
+        pending_entries.each do |entry|
+          line = entry[:line]
+          content = entry[:content]
+          type = entry[:type]
+
+          finder = CallFinder.new(line)
+          finder.visit(result.value)
+
+          call = finder.found_call
+          next unless call
+
+          edit = build_edit(source, call, content, type)
+          edits << edit if edit
+        end
+
+        apply_edits(source, edits)
+      end
+
+      #: (String, Array[Edit]) -> String
+      def self.apply_edits(source, edits)
+        sorted = edits.sort_by { |e| -e.start_offset }
+        result = source.dup
+
+        sorted.each do |edit|
+          before = result.byteslice(0, edit.start_offset) || ""
+          after = result.byteslice(edit.end_offset..) || ""
+          result = before + edit.replacement + after
+        end
+
+        result
+      end
+
+      #: (String, Prism::CallNode, String, Symbol) -> Edit?
+      def self.build_edit(source, call, content, type)
+        arguments = call.arguments
+
+        return build_insert_edit(source, call, content) if type == :insert || arguments.nil? || arguments.arguments.empty?
+
+        snapshot_arg = find_snapshot_argument(arguments)
+        return build_insert_edit(source, call, content) unless snapshot_arg
+
+        if heredoc_node?(snapshot_arg)
+          if single_line?(content)
+            build_heredoc_to_string_edit(source, _ = snapshot_arg, content)
+          else
+            build_heredoc_edit(source, _ = snapshot_arg, content)
+          end
+        elsif snapshot_arg.is_a?(Prism::StringNode)
+          if single_line?(content)
+            build_string_edit(snapshot_arg, content)
+          else
+            build_string_to_heredoc_edit(source, call, snapshot_arg, content)
+          end
+        end
+      end
+
+      #: (Prism::Node) -> bool
+      def self.heredoc_node?(node)
+        case node
+        when Prism::InterpolatedStringNode
+          true
+        when Prism::StringNode
+          opening = node.opening_loc
+
+          opening ? opening.slice.start_with?("<<") : false
+        else
+          false
+        end
+      end
+
+      #: (Prism::ArgumentsNode) -> Prism::Node?
+      def self.find_snapshot_argument(arguments)
+        args = arguments.arguments
+
+        positional_strings = args.select { |arg|
+          case arg
+          when Prism::StringNode, Prism::InterpolatedStringNode
+            true
+          else
+            false
+          end
+        }
+
+        positional_strings.last
+      end
+
+      #: (Prism::StringNode, String) -> Edit?
+      def self.build_string_edit(node, content)
+        content_location = node.content_loc
+        return nil unless content_location
+
+        trimmed = content.chomp
+
+        Edit.new(content_location.start_offset, content_location.end_offset, trimmed)
+      end
+
+      #: (String, Prism::StringNode | Prism::InterpolatedStringNode, String) -> Edit?
+      def self.build_heredoc_edit(source, node, content)
+        opening = node.opening_loc
+        closing = node.closing_loc
+        return nil unless opening && closing
+
+        content_start = source.b.index("\n".b, opening.end_offset)
+        return nil unless content_start
+
+        indent = closing.slice[/\A(\s*)/, 1].to_s.length
+        indented_content = SnapshotContent.indent(content, indent + 2)
+
+        Edit.new(content_start + 1, closing.start_offset, indented_content)
+      end
+
+      #: (String, Prism::StringNode | Prism::InterpolatedStringNode, String) -> Edit?
+      def self.build_heredoc_to_string_edit(source, node, content)
+        opening = node.opening_loc
+        closing = node.closing_loc
+        return nil unless opening && closing
+
+        newline_position = source.b.index("\n".b, opening.end_offset)
+        return nil unless newline_position
+
+        suffix = source.byteslice(opening.end_offset, newline_position - opening.end_offset) || ""
+        replacement = "#{content.chomp.inspect}#{suffix}\n"
+
+        Edit.new(opening.start_offset, closing.end_offset, replacement)
+      end
+
+      #: (String, Prism::CallNode, Prism::StringNode, String) -> Edit?
+      def self.build_string_to_heredoc_edit(source, call, node, content)
+        opening = node.opening_loc
+        closing_quote = node.closing_loc
+        return nil unless opening && closing_quote
+
+        heredoc_id = Insta.configuration.heredoc_identifier
+        indent = detect_indent(source, call.location.start_offset)
+        indented_content = SnapshotContent.indent(content, indent + 2)
+        newline_position = source.b.index("\n".b, closing_quote.end_offset)
+        return nil unless newline_position
+
+        suffix = source.byteslice(closing_quote.end_offset, newline_position - closing_quote.end_offset) || ""
+        replacement = "<<~#{heredoc_id}#{suffix}\n#{indented_content}#{" " * indent}#{heredoc_id}\n"
+
+        Edit.new(opening.start_offset, newline_position + 1, replacement)
+      end
+
+      #: (String, Prism::CallNode, String) -> Edit?
+      def self.build_insert_edit(source, call, content)
+        closing = call.closing_loc
+
+        unless closing
+          location = call.location
+          return build_bare_call_insert_edit(source, call, location, content)
+        end
+
+        if single_line?(content)
+          build_insert_string_edit(call, closing, content)
+        else
+          build_insert_heredoc_edit(source, call, closing, content)
+        end
+      end
+
+      #: (String, Prism::CallNode, Prism::Location, String) -> Edit
+      def self.build_bare_call_insert_edit(source, call, location, content)
+        if single_line?(content)
+          replacement = "(#{content.chomp.inspect})"
+        else
+          heredoc_id = Insta.configuration.heredoc_identifier
+          indent = detect_indent(source, call.location.start_offset)
+          indented_content = SnapshotContent.indent(content, indent + 2)
+          replacement = "(<<~#{heredoc_id})\n#{indented_content}#{" " * indent}#{heredoc_id}"
+        end
+
+        Edit.new(location.end_offset, location.end_offset, replacement)
+      end
+
+      #: (String) -> bool
+      def self.single_line?(content)
+        content.chomp.count("\n").zero?
+      end
+
+      #: (Prism::CallNode, Prism::Location, String) -> Edit
+      def self.build_insert_string_edit(call, closing, content)
+        trimmed = content.chomp.inspect
+        arguments = call.arguments
+        has_args = arguments && !arguments.arguments.empty?
+
+        replacement = has_args ? ", #{trimmed})" : "(#{trimmed})"
+
+        if has_args
+          Edit.new(closing.start_offset, closing.end_offset, replacement)
+        else
+          opening = call.opening_loc
+          start = opening ? opening.start_offset : closing.start_offset
+
+          Edit.new(start, closing.end_offset, replacement)
+        end
+      end
+
+      #: (String, Prism::CallNode, Prism::Location, String) -> Edit
+      def self.build_insert_heredoc_edit(source, call, closing, content)
+        heredoc_id = Insta.configuration.heredoc_identifier
+        indent = detect_indent(source, call.location.start_offset)
+        indented_content = SnapshotContent.indent(content, indent + 2)
+
+        arguments = call.arguments
+        has_args = arguments && !arguments.arguments.empty?
+
+        replacement = if has_args
+                        ", <<~#{heredoc_id})\n#{indented_content}#{" " * indent}#{heredoc_id}"
+                      else
+                        "(<<~#{heredoc_id})\n#{indented_content}#{" " * indent}#{heredoc_id}"
+                      end
+
+        if has_args
+          Edit.new(closing.start_offset, closing.end_offset, replacement)
+        else
+          opening = call.opening_loc
+          start = opening ? opening.start_offset : closing.start_offset
+
+          Edit.new(start, closing.end_offset, replacement)
+        end
+      end
+
+      #: (String, Integer) -> Integer
+      def self.detect_indent(source, offset)
+        line_start = source.b.rindex("\n".b, offset)
+        line_start = line_start ? line_start + 1 : 0
+        line_content = source.byteslice(line_start, offset - line_start) || ""
+
+        line_content.match(/^(\s*)/).to_a[1].to_s.length
+      end
+
+      #: (String, String) -> void
+      def self.atomic_write(file_path, content)
+        directory = File.dirname(file_path)
+
+        temp = Tempfile.new("insta", directory)
+        temp.write(content)
+        temp.close
+
+        File.rename(temp.path.to_s, file_path)
+      rescue StandardError
+        temp&.unlink
+        raise
+      end
+
+      private_class_method :build_edit, :heredoc_node?, :find_snapshot_argument,
+                           :build_string_edit, :build_heredoc_edit,
+                           :build_heredoc_to_string_edit, :build_string_to_heredoc_edit,
+                           :build_insert_edit, :build_bare_call_insert_edit,
+                           :single_line?,
+                           :build_insert_string_edit, :build_insert_heredoc_edit,
+                           :detect_indent
+    end
+  end
+end

data/lib/insta/inline/pending_registry.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Insta
+  module Inline
+    module PendingRegistry
+      @pending = {} #: Hash[String, Array[Inline::pending_entry]]
+      @mutex = Mutex.new
+
+      #: (file: String, line: Integer, content: String, type: Symbol) -> void
+      def self.add(file:, line:, content:, type:)
+        @mutex.synchronize do
+          @pending[file] = @pending[file] || [] #: Array[Inline::pending_entry]
+          @pending[file] << { line: line, content: content, type: type }
+        end
+      end
+
+      #: () -> void
+      def self.flush!
+        entries = @mutex.synchronize do
+          result = @pending.dup
+          @pending.clear
+
+          result
+        end
+
+        return if entries.empty?
+
+        entries.each do |file, pending_entries|
+          unless File.exist?(file)
+            warn "insta: skipping inline snapshot update for missing file: #{file}"
+
+            next
+          end
+
+          patched = FilePatcher.patch(file, pending_entries)
+
+          FilePatcher.atomic_write(file, patched)
+        end
+      end
+
+      #: () -> bool
+      def self.any?
+        @mutex.synchronize { !@pending.empty? }
+      end
+
+      #: () -> Integer
+      def self.size
+        @mutex.synchronize { @pending.values.sum(&:length) }
+      end
+
+      #: () -> void
+      def self.clear!
+        @mutex.synchronize { @pending.clear }
+      end
+    end
+  end
+end