Good Code, Bad Codeの擬似コードをDart（Flutter）でリライトして理解を深める 〜抽象化レイヤー編〜

// HTTPコネクションの接続
HttpConnection connection = HttpConnection.connect("<http://example.com/server>");

// 送信処理
connection.send("Hello server")

// HTTPコネクションの切断
connection.close();

class TextSummarizer {
    ...

    String summarizeText(String text) {
        return splitIntoParagraphs(text)
            .filter(paragraph -> calculateImportance(paragraph) >= IMPORTANCE_THRESHOLD)
            .join("\n\n");
    }

    private Double calculateImportance(String paragraph) {
        List<String> nouns = extractImportantNouns(paragraph);
        List<String> verbs = extractImportantVerbs(paragraph);
        List<String> adjectives = extractImportantAdjectives(paragraph);
        ... 複雑な方程式 ...
        return importanceScore;
    }

    private List<String> extractImportantNouns(String text) { ... }
    private List<String> extractImportantVerbs(String text) { ... }
    private List<String> extractImportantAdjectives(String text) { ... }

    private List<String> splitIntoParagraphs(String text) {
        List<String> paragraphs = [];
        Int? start = detectParagraphStartOffset(text, 0);
        while (start != null) {
            Int? end = detectParagraphEndOffset(text, start);
            if (end == null) {
                break;
            }
            paragraphs.add(text.substring(start, end));
            start = detectParagraphStartOffset(text, end);
        }
        return paragraphs;
    }

    private Int? detectParagraphStartOffset(String text, Int fromOffset) { ... }
    private Int? detectParagraphEndOffset(String text, Int fromOffset) { ... }

    ...
}

class TextSummarizer {
    private final ParagraphFinder paragraphFinder;
    private final TextImportanceScorer importanceScorer;

    TextSummarizer(
        ParagraphFinder paragraphFinder,
        TextImportanceScorer importanceScorer
    ) {
        this.paragraphFinder = paragraphFinder;
        this.importanceScorer = importanceScorer;
    }

    static TextSummarizer createDefault() {
        return new TextSummarizer(
            new ParagraphFinder(),
            new TextImportanceScorer());
    }

    String summarizeText(String text) {
        return paragraphFinder.find(text)
            .filter(paragraph ->
                importanceScorer.isImportant(paragraph))
            .join("\n\n");
    }
}

class ParagraphFinder {
    List<String> find(String text) {
        List<String> paragraphs = [];
        Int? start = detectParagraphStartOffset(text, 0);
        while (start != null) {
            Int? end = detectParagraphEndOffset(text, start);
            if (end == null) {
                break;
            }
            paragraphs.add(text.substring(start, end));
            start = detectParagraphStartOffset(text, end);
        }
        return paragraphs;
    }

    private Int? detectParagraphStartOffset(String text, Int fromOffset) { ... }
    private Int? detectParagraphEndOffset(String text, Int fromOffset) { ... }
}

class TextImportanceScorer {
    ...

    Boolean isImportant(String text) {
        return calculateImportance(text) >= IMPORTANCE_THRESHOLD;
    }

    private Double calculateImportance(String text) {
        List<String> nouns = extractImportantNouns(text);
        List<String> verbs = extractImportantVerbs(text);
        List<String> adjectives = extractImportantAdjectives(text);
        ...複雑な方程式...
        return importanceScore;
    }

    private List<String> extractImportantNouns(String text) { ... }
    private List<String> extractImportantVerbs(String text) { ... }
    private List<String> extractImportantAdjectives(String text) { ... }
}

/// 文章を要約するクラス
class TextSummarizer {
  /// ==== ポイント① ====
  /// 適切に抽象化レイヤーを作成したため、TextSummarizerクラス内に小さな問題を解決する具体的な
  /// コード（ex extractImportantNouns）の記述がなく、同レイヤーのメソッドを把握していればよい。
  /// ->非常に見通しが良い!

  final ParagraphFinder _paragraphFinder;
  final TextImportanceScorer _importanceScorer;

  TextSummarizer._(this._paragraphFinder, this._importanceScorer);  

  // 単語ベースで重要度を算出し、要約するファクトリコンストラクタ
  factory TextSummarizer.createWordBased() => TextSummarizer(
        ParagraphFinder(),
        WordBasedScorer(),
      );

  // 機械学習モデルで重要度を算出し、要約するファクトリコンストラクタ
  factory TextSummarizer.createModelBased() => TextSummarizer(
        ParagraphFinder(),
        ModelBasedScorer(),
      );

  String summarizeText(String text) =>
      paragraphFinder.find(text).where(importanceScorer.isImportant).join('\n');
}

/// 文章を段落毎に分割するクラス
class ParagraphFinder {
  List<String> find(String text) {
    List<String> paragraphs = [];
    int? start = 0;
    while (start != null && start < text.length) {
      int? end = _detectParagraphEndOffset(text, start);
      end ??= text.length;
      paragraphs.add(text.substring(start, end).trim());
      start = _detectParagraphStartOffset(text, end);
    }
    return paragraphs;
  }

  /// ==== ポイント② ====
  /// OffsetDetectorというインターフェースを用意して、ParagraphStartOffDetectorとParagraphEndOffDetector
  /// を実装することで、もう一階層抽象化レイヤーを作ることも可能だが、以下の理由より推奨されない。
  /// - detectParagraphStartOffsetはParagraphFinder以外から使われる可能性が低いと考えられるため
  ///   別クラスにすることで凝集性が下がる。
  /// - 抽象化レイヤーが薄すぎるため、ボイラープレートが多く、コードの把握やデバッグに多くの労力が必要になる。

  // 次の段落の開始位置を見つける
  int? _detectParagraphStartOffset(String text, int fromOffset) {
    int nextOffset = text.indexOf('\n', fromOffset);
    return nextOffset == -1 ? null : nextOffset + 1;
  }

  // 現在の段落の終了位置を見つける
  int? _detectParagraphEndOffset(String text, int fromOffset) {
    int endOffset = text.indexOf('\n', fromOffset);
    return endOffset == -1 ? null : endOffset;
  }
}

/// 文の重要度を判定する抽象クラス
/// ==== ポイント③ ====
/// TextImportanceScorerを抽象クラスにし、重要度を算出するロジックを具象クラスに実装することで
/// ロジックの変更が容易になる。
abstract class TextImportanceScorer {
  bool isImportant(String paragraph);
}

/// 文の重要度を「ロジックベース」算出し、判定する具象クラス
class WordBasedScorer implements TextImportanceScorer {
  final double _importanceThreshold = 1;

  @override
  bool isImportant(String paragraph) {
    // 「重要」という単語が1つ以上入っていれば重要な文と判定する
    return _calculateImportance(paragraph) >= _importanceThreshold;
  }

  double _calculateImportance(String text) {
    final nouns = _extractImportantNouns(text);
    final verbs = _extractImportantVerbs(text);
    final adjectives = _extractImportantAdjectives(text);

    // 本来は上記の単語数から重要度を判定するロジックが記述されるが本質ではないためここでは省略する。
    // 「重要」という単語が1つ以上入っていれば重要な文と判定する。
    // ・・・
    return '重要'.allMatches(text).length.toDouble();
  }

  List<String> _extractImportantNouns(String text) {
    // 重要な名詞を抽出するロジック
    // ・・・
    return [];
  }

  List<String> _extractImportantVerbs(String text) {
    // 重要な動詞を抽出するロジック
    // ・・・
    return [];
  }

  List<String> _extractImportantAdjectives(String text) {
    // 重要な形容詞を抽出するロジック
    // ・・・
    return [];
  }
}

/// 文の重要度を「機械学習モデルベースで」算出し、判定する具象クラス
class ModelBasedScorer implements TextImportanceScorer {
  @override
  bool isImportant(String paragraph) {
    // 本来は機械学習のモデルで重要度を判定するロジックが記述されるが本質ではないためここでは省略する。
    // 「重要」や「大事」を含んでいれば重要な文と判定する。
    // ・・・
    return paragraph.contains("重要") || paragraph.contains("大事");
  }
}

void main() {
  /// 要約したい文章
  const String text = """
  1行目の重要な文章です。
  2行目のあまり意味のない文章です。
  3行目の大事な文章です。
  """;


  /// ==== ポイント④ ====
  /// ファクトリコンストラクタを活用し、名前がついたコンストラクタを利用させ誤用させにくくする。
  final summarizer = TextSummarizer.createWordBased();

  final summary = summarizer.summarizeText(text);

  print('要約された文章:\n$summary');
}

// 単語ベースで重要度計算の場合 （TextSummarizer.createWordBased()で生成）
要約された文章:
1行目の重要な文章です。

// 機械学習ベースで重要度計算をした場合 （TextSummarizer.createModelBased()で生成）
要約された文章:
1行目の重要な文章です。
3行目の大事な文章です。