featureparity 0.0.27 → 0.0.29

data/lib/fp/commands/mark.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Fp
+  module Commands
+    # fp mark <slug> <file>:<line> [--surface a,b] [--type e2e] [--comment '#'] [--dry-run]
+    #
+    # Insert an fp:<slug> marker directly above the test at <file>:<line>, in that
+    # file's own comment syntax and indentation (Fizzy #1786). Marking by hand across
+    # Ruby, JS, Swift and SQL meant a script per language and the occasional marker the
+    # scanner didn't recognise; this writes one the scanner reads back, and says which
+    # test it binds to. Purely local: no API key, no network.
+    class Mark < Base
+      help_summary 'Insert an fp:<slug> marker above a test, in the file\'s own comment syntax'
+      help_usage 'fp mark <slug> <file>:<line> [--surface a,b] [--type <test-type>] [--dry-run]'
+      help_flag :surface, 'Pin the marker to these surfaces (fp:slug@a,b); omit to use --surface at report time'
+      help_flag :type, 'Pin the kind of test (fp:slug@surface:e2e); needs --surface'
+      help_flag :comment, "Comment prefix to use when the extension isn't known (e.g. '#', '//', '--')"
+      help_flag :dry_run, 'Show the marker and where it would go; change nothing'
+      help_example 'fp mark academic_experience_required_fields spec/models/academic_experience_spec.rb:52'
+      help_example 'fp mark checkout_flow e2e/checkout.spec.ts:10 --surface web --type e2e'
+      help_note "<line> is the test's own line (the `it`/`test`/`def test_` line); the marker goes directly above it.\n" \
+                'Marking a test binds it to a requirement: never mark a test that is currently failing to make it count.'
+
+      KNOWN_FLAGS = {
+        surface: :string,
+        type: :string,
+        comment: :string,
+        dry_run: :boolean
+      }.freeze
+
+      COMMENT_PREFIXES = {
+        '#' => %w[rb rake gemspec ru py sh bash zsh yml yaml toml ex exs r pl cr jl nim tf],
+        '//' => %w[js jsx mjs cjs ts tsx mts cts swift kt kts java go rs c cc cpp cxx h hpp m mm cs dart
+                   scala php groovy gradle zig v],
+        '--' => %w[sql lua hs elm]
+      }.freeze
+
+      # Files named without an extension that are Ruby.
+      RUBY_FILENAMES = %w[Rakefile Gemfile Guardfile Podfile Fastfile].freeze
+
+      SLUG_RE = /\A[a-z0-9][a-z0-9_-]*\z/.freeze
+      KEY_RE = /\A[a-z0-9_-]+\z/.freeze
+
+      def run(args)
+        opts, positional = parse_flags(args, KNOWN_FLAGS)
+        slug, location = positional
+
+        unless slug && location
+          output.error('Usage: fp mark <slug> <file>:<line>')
+          exit 1
+        end
+
+        fail_with("'#{slug}' isn't a valid slug (lowercase letters, numbers, - and _).") unless slug.match?(SLUG_RE)
+
+        path, line_no = parse_location(location)
+        surfaces = (opts[:surface] || '').split(',').map(&:strip).reject(&:empty?)
+        bad = surfaces.reject { |s| s.match?(KEY_RE) }
+        fail_with("Invalid surface key(s): #{bad.join(', ')}") unless bad.empty?
+        if opts[:type]
+          fail_with("Invalid test type '#{opts[:type]}'") unless opts[:type].match?(KEY_RE)
+          fail_with('--type needs --surface: a marker pins its kind after its surfaces (fp:slug@api:e2e)') if surfaces.empty?
+        end
+
+        prefix = opts[:comment] || comment_prefix_for(path)
+        unless prefix
+          fail_with("Don't know the comment syntax for #{File.basename(path)}. Pass --comment, e.g. --comment '#' or --comment '//'.")
+        end
+
+        lines = File.read(path).lines
+        if line_no > lines.length
+          fail_with("#{path} has #{lines.length} line(s); there is no line #{line_no}.")
+        end
+
+        marker = "fp:#{slug}"
+        marker += "@#{surfaces.join(',')}" unless surfaces.empty?
+        marker += ":#{opts[:type]}" if opts[:type]
+
+        target = lines[line_no - 1]
+        indent = target[/\A[ \t]*/]
+        comment_line = "#{indent}#{prefix} #{marker}#{line_ending(target)}"
+
+        if already_marked?(lines, line_no, marker)
+          return report(path, line_no, marker, nil, already: true)
+        end
+
+        updated = lines.dup.insert(line_no - 1, comment_line)
+        found = Fp::JUnit.scan_markers(updated.join).find { |m| m[:line] == line_no && m[:slug] == slug }
+        unless found
+          fail_with("A '#{prefix}' comment isn't one fp's scanner reads as a marker. Use #, //, -- or /* … */.")
+        end
+
+        File.write(path, updated.join) unless opts[:dry_run]
+        report(path, line_no, marker, found, dry_run: opts[:dry_run], comment_line: comment_line.chomp)
+      end
+
+      private
+
+      def parse_location(location)
+        m = location.match(/\A(.+):(\d+)\z/)
+        fail_with("Give the test's location as <file>:<line> (got '#{location}').") unless m
+
+        path = m[1]
+        line_no = m[2].to_i
+        fail_with("No such file: #{path}") unless File.file?(path)
+        fail_with('Line numbers start at 1.') if line_no < 1
+
+        [path, line_no]
+      end
+
+      def comment_prefix_for(path)
+        base = File.basename(path)
+        return '#' if RUBY_FILENAMES.include?(base)
+
+        ext = File.extname(base).delete('.').downcase
+        COMMENT_PREFIXES.find { |_, exts| exts.include?(ext) }&.first
+      end
+
+      def line_ending(line)
+        line.end_with?("\r\n") ? "\r\n" : "\n"
+      end
+
+      # The same marker already sits in the comment block directly above the test.
+      def already_marked?(lines, line_no, marker)
+        i = line_no - 2
+        while i >= 0 && lines[i].match?(Fp::JUnit::COMMENT_LINE_RE)
+          return true if lines[i].scan(Fp::JUnit::MARKER_RE).any? { |m| marker_string(m) == marker }
+
+          i -= 1
+        end
+        false
+      end
+
+      def marker_string((slug, surfaces, type))
+        s = "fp:#{slug}"
+        s += "@#{surfaces}" if surfaces
+        s += ":#{type}" if type
+        s
+      end
+
+      def report(path, line_no, marker, found, already: false, dry_run: false, comment_line: nil)
+        data = { file: path, line: line_no, marker: marker, already_marked: already, dry_run: dry_run,
+                 binds_to: found && found[:title] }.compact
+        output.success(data) do
+          if already
+            puts "#{path}:#{line_no} is already marked #{marker}; nothing changed."
+            next
+          end
+
+          verb = dry_run ? 'Would insert' : 'Inserted'
+          puts "#{verb} at #{path}:#{line_no}:"
+          puts "  #{comment_line.strip}"
+          if found[:title]
+            puts "It binds to: #{found[:title]}"
+          else
+            puts "⚠️  No test declaration was recognised below line #{line_no}. Check that the line is the test itself;"
+            puts '    if the runner reports file paths, the marker still binds by file.'
+          end
+        end
+      end
+
+      def fail_with(message)
+        output.error(message)
+        exit 1
+      end
+    end
+  end
+end

data/lib/fp/commands/projects.rb

@@ -87,7 +87,11 @@ module Fp
         output.success(result[:data]) do
           if projects.empty?
             puts 'No projects found.'
-            puts 'Create one with: fp projects create <slug> --name "<Name>"'
+            if (hint = config&.environment_mismatch_hint)
+              puts hint
+            else
+              puts 'Create one with: fp projects create <slug> --name "<Name>"'
+            end
           else
             headers = %w[SLUG NAME SURFACES]
             rows = projects.map do |w|
@@ -132,6 +136,7 @@ module Fp
         surfaces = split_list(opts[:surfaces])
         params[:surfaces] = surfaces unless surfaces.empty?
 
+        warn_if_not_production!
         result = client.create_project(params)
 
         unless result[:ok]