Remove exceptional control flow

This introduces a new intermediate object, `Block` to manage the parser
state.

Co-authored-by: @dbalexandre

lib/gitlab/front_matter.rb

@@ -15,7 +15,7 @@ module Gitlab
       \s*
       ^(?<delim>#{DELIM})[ \t]*(?<lang>\S*)  # opening front matter marker (optional language specifier)
       \s*
-      ^(?<front_matter>.*?)                  # front matter (not greedy)
+      ^(?<front_matter>.*?)                  # front matter block content (not greedy)
       \s*
       ^(\k<delim> | \.{3})                   # closing front matter marker
       \s*

lib/gitlab/wiki_pages/front_matter_parser.rb

@@ -3,19 +3,6 @@
 module Gitlab
   module WikiPages
     class FrontMatterParser
-      # A ParseResult contains the de-serialized front-matter, the stripped
-      # content, and maybe an error, explaining why there is no front-matter.
-      ParseResult = Struct.new(:front_matter, :content, :reason, :error, keyword_init: true)
-
-      class NoFrontMatter < StandardError
-        attr_reader :reason
-
-        def initialize(reason)
-          super
-          @reason = reason
-        end
-      end
-
       FEATURE_FLAG = :wiki_front_matter
 
       # We limit the maximum length of text we are prepared to parse as YAML, to
@@ -29,9 +16,21 @@ module Gitlab
       SLUG_LINE_LENGTH = (4 + Gitlab::WikiPages::MAX_DIRECTORY_BYTES + 1 + Gitlab::WikiPages::MAX_TITLE_BYTES)
       MAX_FRONT_MATTER_LENGTH = (8 + Gitlab::WikiPages::MAX_TITLE_BYTES) + 7 + (SLUG_LINE_LENGTH * MAX_SLUGS)
 
+      ParseError = Class.new(StandardError)
+
+      class Result
+        attr_reader :front_matter, :content, :reason, :error
+
+        def initialize(content:, front_matter: {}, reason: nil, error: nil)
+          @content      = content
+          @front_matter = front_matter.freeze
+          @reason       = reason
+          @error        = error
+        end
+      end
+
       # @param [String] wiki_content
       # @param [FeatureGate] feature_gate The scope for feature availability
-      #                                    (usually a project)
       def initialize(wiki_content, feature_gate)
         @wiki_content = wiki_content
         @feature_gate = feature_gate
@@ -42,52 +41,78 @@ module Gitlab
       end
 
       def parse
-        ParseResult.new(front_matter: extract_front_matter, content: strip_front_matter)
-      rescue NoFrontMatter => e
-        ParseResult.new(front_matter: {}, content: wiki_content, reason: e.reason, error: e.cause)
+        return empty_result unless enabled? && wiki_content.present?
+        return empty_result(block.error) unless block.valid?
+
+        Result.new(front_matter: block.data, content: strip_front_matter_block)
+      rescue ParseError => error
+        empty_result(:parse_error, error)
       end
 
-      private
+      class Block
+        include Gitlab::Utils::StrongMemoize
 
-      attr_reader :wiki_content, :feature_gate
+        def initialize(delim = nil, lang = '', text = nil)
+          @lang = lang.downcase.presence || Gitlab::FrontMatter::DELIM_LANG[delim]
+          @text = text
+        end
 
-      def extract_front_matter
-        ensure_enabled!
-        front_matter, lang = extract
-        front_matter = parse_string(front_matter, lang)
-        validate(front_matter)
+        def data
+          @data ||= YAML.safe_load(text, symbolize_names: true)
+        rescue Psych::DisallowedClass, Psych::SyntaxError => error
+          raise ParseError, error.message
+        end
 
-        front_matter
-      end
+        def valid?
+          error.nil?
+        end
 
-      def parse_string(source, lang)
-        raise NoFrontMatter, :not_yaml unless lang == 'yaml'
+        def error
+          strong_memoize(:error) { no_match? || too_long? || not_yaml? || not_mapping? }
+        end
 
-        YAML.safe_load(source, symbolize_names: true)
-      rescue Psych::DisallowedClass, Psych::SyntaxError
-        raise NoFrontMatter, :parse_error
-      end
+        private
+
+        attr_reader :lang, :text
+
+        def no_match?
+          :no_match if text.nil?
+        end
+
+        def not_yaml?
+          :not_yaml if lang != 'yaml'
+        end
+
+        def too_long?
+          :too_long if text.size > MAX_FRONT_MATTER_LENGTH
+        end
 
-      def validate(parsed)
-        raise NoFrontMatter, :not_mapping unless Hash === parsed
+        def not_mapping?
+          :not_mapping unless data.is_a?(Hash)
+        end
       end
 
-      def extract
-        raise NoFrontMatter, :no_content unless wiki_content.present?
+      private
+
+      attr_reader :wiki_content, :feature_gate
+
+      def empty_result(reason = nil, error = nil)
+        Result.new(content: wiki_content, reason: reason, error: error)
+      end
 
-        match = Gitlab::FrontMatter::PATTERN.match(wiki_content) if wiki_content.present?
-        raise NoFrontMatter, :no_pattern_match unless match
-        raise NoFrontMatter, :too_long if match[:front_matter].size > MAX_FRONT_MATTER_LENGTH
+      def enabled?
+        self.class.enabled?(feature_gate)
+      end
 
-        lang = match[:lang].downcase.presence || Gitlab::FrontMatter::DELIM_LANG[match[:delim]]
-        [match[:front_matter], lang]
+      def block
+        @block ||= parse_front_matter_block
       end
 
-      def ensure_enabled!
-        raise NoFrontMatter, :feature_flag_disabled unless self.class.enabled?(feature_gate)
+      def parse_front_matter_block
+        wiki_content.match(Gitlab::FrontMatter::PATTERN) { |m| Block.new(*m.captures) } || Block.new
       end
 
-      def strip_front_matter
+      def strip_front_matter_block
         wiki_content.gsub(Gitlab::FrontMatter::PATTERN, '')
       end
     end

spec/lib/gitlab/wiki_pages/front_matter_parser_spec.rb

@@ -45,7 +45,13 @@ describe Gitlab::WikiPages::FrontMatterParser do
     context 'there is no content' do
       let(:raw_content) { '' }
 
-      it { is_expected.to have_attributes(reason: :no_content) }
+      it do
+        is_expected.to have_attributes(
+          front_matter: {},
+          content: raw_content,
+          error: be_nil
+        )
+      end
     end
 
     context 'there is no front_matter' do
@@ -53,7 +59,7 @@ describe Gitlab::WikiPages::FrontMatterParser do
 
       it { is_expected.to have_attributes(front_matter: be_empty, content: raw_content) }
 
-      it { is_expected.to have_attributes(reason: :no_pattern_match) }
+      it { is_expected.to have_attributes(reason: :no_match) }
     end
 
     context 'the feature flag is disabled' do
@@ -265,12 +271,4 @@ describe Gitlab::WikiPages::FrontMatterParser do
       it { is_expected.to have_attributes(reason: :not_mapping) }
     end
   end
-
-  describe '#strip_front_matter' do
-    let(:raw_content) { with_front_matter }
-
-    it 'removes the front-matter from the content' do
-      expect(subject.send(:strip_front_matter)).to eq(content + "\n")
-    end
-  end
 end