hachiwari 0.4.0 → 1.0.0

data/lib/hachiwari/cli.rb

@@ -1,76 +1,277 @@
-# require "hachiwari"
+# frozen_string_literal: true
+
 require "thor"
-require 'yaml/store'
+require_relative "status_runner"
+require_relative "storage"
+require_relative "locales"
 
 module Hachiwari
   class CLI < Thor
-
-    Results   = Struct.new(:wins, :losses, :target, :language)
-    @@db      = YAML::Store.new("#{Dir.home}/.hachiwari")
-    @@results = @@db.transaction { @@db[:results] } if @@db
-    @@results ||= Results.new(0, 0, 80, :ja)
+    HIDDEN_GENERAL_HELP_COMMANDS = %w[info i calculate s].freeze
+    DEFAULT_THOR_LOCALE = :ja
 
     class << self
-      def save
-        @@db.transaction { @@db[:results] = @@results }
+      # CLI 起動時に旧フォーマットの保存データをマイグレートし、ヘルプやバージョン表示を先に処理する
+      def start(given_args = ARGV, config = {}, &)
+        migrate_legacy_store
+
+        args = Array(given_args).dup
+        return display_help(nil) if args.empty?
+        return if handle_direct_option?(args)
+
+        args = ["status", *args] if default_to_status?(args)
+        super(args, config, &)
       end
-    end
-    CLI.save
-
-    desc "status [wins] [losses] [target] [language]", "Displays winning percentage and number of wins to achieve the goal. (with save status)"
-    def status(wins = @@results.wins, losses = @@results.losses, target = @@results.target, language = @@results.language, save = true)
-      wins     = wins.to_i       if ARGV[1]
-      losses   = losses.to_i     if ARGV[2]
-      target   = target.to_i     if ARGV[3]
-      language = language.to_sym if ARGV[4]
-
-      if save
-        @@results.wins     = wins
-        @@results.losses   = losses
-        @@results.target   = target
-        @@results.language = language
-        CLI.save
-      end
-
-      case language
-      when :ja
-        puts "#{wins+losses} 戦 #{wins} 勝 #{losses} 敗 勝率 #{winning_percentage(wins, losses)} % です"
-        puts "あと #{reach_wins(wins, losses)} 勝で 勝率 #{(@@results.target).to_i} % です"
-      when :en
-        puts "#{wins+losses} games #{wins} wins #{losses} losses a winning percentage of #{winning_percentage(wins, losses)} %."
-        puts "You need #{reach_wins(wins, losses)} more wins to reach #{(@@results.target).to_i} %"
+
+      # ヘルプ用の文字列をユーザー設定ロケール優先で取得する
+      def thor_string(command, key)
+        fetch_locale_value(help_language, command, key) || fetch_locale_value(DEFAULT_THOR_LOCALE, command, key) || ""
+      end
+
+      # ヘルプ詳細文をロケール順に取得して配列化する
+      def thor_details(command)
+        value = fetch_locale_value(help_language, command, :details)
+        value = fetch_locale_value(DEFAULT_THOR_LOCALE, command, :details) if value.nil?
+        array_wrap(value)
+      end
+
+      # 長文説明をメイン文と詳細の組み合わせで構築する
+      def thor_long_description(command)
+        build_long_description(thor_string(command, :long), thor_details(command))
+      end
+
+      # デフォルトロケールから短い説明を取得する
+      def default_thor_string(command, key)
+        fetch_locale_value(DEFAULT_THOR_LOCALE, command, key) || ""
+      end
+
+      # デフォルトロケールの詳細情報を配列で取得する
+      def default_thor_details(command)
+        array_wrap(fetch_locale_value(DEFAULT_THOR_LOCALE, command, :details))
+      end
+
+      # デフォルトロケールで長文説明を生成する
+      def default_thor_long_description(command)
+        build_long_description(default_thor_string(command, :long), default_thor_details(command))
+      end
+
+      private
+
+      # 引数に含まれるバージョン/ヘルプ系の即時オプションを処理する
+      def handle_direct_option?(args)
+        case args.first
+        when "--version", "-v"
+          puts Hachiwari::VERSION
+          return true
+        when "--help", "-h", "help"
+          display_help(args[1])
+          return true
+        end
+
+        help_index = args.index("--help") || args.index("-h")
+        return false unless help_index
+
+        display_help(extract_command_for_help(args, help_index))
+        true
+      end
+
+      # 旧ストレージ形式が存在する場合にマイグレーションを実行する
+      def migrate_legacy_store
+        Storage.new.send(:migrate_legacy_if_needed)
+      rescue StandardError
+        # 続行
+      end
+
+      # ヘルプ引数の位置からコマンド名候補を取得する
+      def extract_command_for_help(args, help_index)
+        before = help_index.positive? ? args[help_index - 1] : nil
+        after = args[help_index + 1]
+        [before, after].compact.find { |candidate| candidate && !candidate.start_with?("-") }
+      end
+
+      # 指定されたコマンドのヘルプを出力する
+      def display_help(command)
+        command = command&.to_s&.strip
+        command = nil if command.nil? || command.empty?
+        command ? print_command_help(command) : print_general_help
+      end
+
+      # 全体ヘルプの各コマンド情報を出力する
+      def print_general_help
+        data = help_content
+        puts data[:general_intro]
+        data[:commands].each do |name, info|
+          next if HIDDEN_GENERAL_HELP_COMMANDS.include?(name.to_s)
+
+          puts "  #{info[:usage]}"
+          puts "    #{info[:description]}"
+          Array(info[:details]).each { |detail| puts "    #{detail}" }
+        end
+        Array(data[:general_footer]).each { |line| puts line }
+      end
+
+      # 個別コマンドの詳細ヘルプを出力する
+      def print_command_help(command)
+        data = help_content
+        info = data[:commands][command.to_sym] || data[:commands][command.to_s]
+
+        unless info
+          puts format(data[:unknown_command], command: command)
+          puts
+          print_general_help
+          return
+        end
+
+        puts format(data[:command_heading], usage: info[:usage])
+        puts format(data[:description_heading], description: info[:description])
+        Array(info[:details]).each { |detail| puts "  #{detail}" }
+      end
+
+      # ロケールごとのヘルプデータを取得する
+      def help_content
+        Hachiwari::Locales.t(help_language, :help)
+      rescue KeyError
+        Hachiwari::Locales.t(:ja, :help)
+      end
+
+      # 保存ロケールが利用可能か確認し、ヘルプ用ロケールを返す
+      def help_language
+        locale = Storage.new.load.language
+        available = Hachiwari::Locales.available_locales
+        available.include?(locale) ? locale : :ja
+      rescue StandardError
+        :ja
+      end
+
+      # 指定コマンドが登録済みか判定し、未登録なら status へフォールバックする
+      def default_to_status?(args)
+        return false if args.empty?
+
+        first = args.first
+        return true if first.start_with?("-")
+
+        !all_commands.key?(first)
+      end
+
+      # ロケール付きの Thor 文言を取得する
+      def fetch_locale_value(locale, command, key)
+        Hachiwari::Locales.t(locale, :thor, command, key)
+      rescue KeyError
+        nil
+      end
+
+      # メイン文と詳細配列から長文を組み立てる
+      def build_long_description(primary, extra_lines)
+        lines = []
+        lines << primary if primary && !primary.empty?
+        lines.concat(array_wrap(extra_lines))
+        lines.compact.join("\n")
+      end
+
+      # 値を配列にラップして扱いやすくする
+      def array_wrap(value)
+        case value
+        when nil
+          []
+        when Array
+          value
+        else
+          [value]
+        end
       end
     end
 
-    desc "s   [wins] [losses] [target] [language]", "Another name for the status command."
-    def s(wins = @@results.wins, losses = @@results.losses, target = @@results.target, language = @@results.language)
-      status(wins, losses, target, language)
+    attr_reader :runner, :storage
+
+    # コマンド実行時に利用するストレージとランナーを初期化する
+    def initialize(*args, **kwargs)
+      super
+      @storage = Storage.new
+      @runner = StatusRunner.new(storage: storage)
+    end
+
+    option :trial, type: :boolean, aliases: "-t", desc: CLI.default_thor_string(:status, :option_trial)
+    desc "status [wins] [losses] [target] [language]", CLI.default_thor_long_description(:status)
+
+    # 勝敗・目標勝率・言語を受け取り、状態を保存しながら結果を表示
+    def status(*args)
+      run_status_with_trial_flag(trial: options[:trial], **parse_status_arguments(args))
     end
 
-    desc "info [wins] [losses] [target] [language]", "Displays winning percentage and number of wins to achieve the goal. (Information only)"
-    def info(wins = @@results.wins, losses = @@results.losses, target = @@results.target, language = @@results.language)
-      status(wins, losses, target, language, false)
+    option :trial, type: :boolean, aliases: "-t", desc: CLI.default_thor_string(:info, :option_trial)
+    desc "info [wins] [losses] [target] [language]", CLI.default_thor_long_description(:info)
+    # 状態を保存せず試算だけ行うコマンド
+    def info(*args)
+      warn_deprecation("info", locale_key: :trial)
+      run_status_with_trial_flag(trial: true, **parse_status_arguments(args))
     end
 
-    desc "i   [wins] [losses] [target] [language]", "Another name for the info command."
-    def i(wins = @@results.wins, losses = @@results.losses, target = @@results.target, language = @@results.language)
-      status(wins, losses, target, language, false)
+    desc "i   [wins] [losses] [target] [language]", CLI.default_thor_long_description(:alias_i)
+    # `info` と同等の動作を行う短縮エイリアス
+    def i(*args)
+      warn_deprecation("i", locale_key: :alias)
+      run_status_with_trial_flag(trial: true, **parse_status_arguments(args))
     end
 
-    desc "version", "Displays the version number."
+    desc "version", CLI.default_thor_string(:version, :short)
+    # CLI のバージョン情報を表示する
     def version
       puts Hachiwari::VERSION
     end
 
+    desc "clear", CLI.default_thor_string(:clear, :short)
+    # 保存済みの状態データを削除する
+    def clear
+      if storage.clear
+        say("Saved status data has been cleared.", :green)
+      else
+        say("No saved status data found.", :yellow)
+      end
+    end
+
+    desc "calculate [wins] [losses]", CLI.default_thor_long_description(:calculate)
+    option :target, type: :numeric, desc: CLI.default_thor_string(:calculate, :option_target)
+    option :language, type: :string, desc: CLI.default_thor_string(:calculate, :option_language)
+    # `status`/`info` とは別に、オプション経由でパラメータを受け取って計算のみ行う
+    def calculate(wins, losses)
+      warn_deprecation("calculate")
+      run_status_with_trial_flag(
+        trial: true,
+        wins: wins, losses: losses, target: options[:target], language: options[:language]
+      )
+    end
+
     private
 
-    def winning_percentage(wins, losses)
-      (wins / (wins + losses).to_f * 100).round(4)
+    # トライアル指定の有無に応じて保存フラグを切り替える
+    def run_status_with_trial_flag(trial:, **params)
+      run_status(save: !trial, **params)
+    end
+
+    # 位置引数から勝敗・目標・言語を取り出して整形する
+    def parse_status_arguments(args)
+      %i[wins losses target language].zip(args).to_h
+    end
+
+    # 非推奨コマンド利用時の警告をユーザーへ通知する
+    def warn_deprecation(command, message = nil, locale_key: :trial)
+      message ||= localized_deprecation(locale_key)
+      say("`hachiwari #{command}`: #{message}", :yellow)
+    end
+
+    # 保存された言語設定で非推奨メッセージを取得する
+    def localized_deprecation(key)
+      locale = storage.load.language
+      available = Hachiwari::Locales.available_locales
+      locale = :ja unless available.include?(locale)
+      Hachiwari::Locales.t(locale, :deprecations, key)
+    rescue StandardError
+      Hachiwari::Locales.t(:ja, :deprecations, key)
     end
 
-    def reach_wins(wins, losses)
-      target = @@results.target / 100.0
-      (target / (1 - target) * losses - wins).round(6).ceil
+    # `StatusRunner` へ依頼し、不要な nil を除いて保存フラグ付きで実行
+    def run_status(save:, **params)
+      runner.call(params.compact, save: save)
     end
   end
 end

data/lib/hachiwari/locales.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Hachiwari
+  # 自前の軽量ローカライゼーションローダー
+  module Locales
+    module_function
+
+    # 指定ロケールの翻訳データを YAML から読み込みキャッシュする
+    def load(locale)
+      cache[locale.to_sym] ||= begin
+        path = locale_path(locale)
+        raise KeyError, "Unknown locale: #{locale}" unless path
+
+        data = YAML.safe_load_file(path, aliases: true, symbolize_names: true)
+        data.fetch(locale.to_sym)
+      rescue Errno::ENOENT
+        raise KeyError, "Missing locale file: #{locale}"
+      end
+    end
+
+    # ネストしたキーを辿って翻訳文字列を取得する
+    def t(locale, *keys)
+      keys.reduce(load(locale)) do |current, key|
+        current.fetch(key.to_sym)
+      end
+    end
+
+    # 利用可能なロケール一覧を返す
+    def available_locales
+      locale_files.keys
+    end
+
+    # 翻訳データのキャッシュをクリアする
+    def clear_cache
+      cache.clear
+    end
+
+    # ロケールごとのキャッシュを初期化または返却する
+    def cache
+      @cache ||= {}
+    end
+
+    # ロケールシンボルからファイルパスを取得する
+    def locale_path(locale)
+      locale_files[locale.to_sym]
+    end
+
+    # ロケールファイルを走査し、シンボルとパスの対応表を構築する
+    def locale_files
+      @locale_files ||= Dir[File.expand_path("../../config/locales/*.yml",
+                                             __dir__)].each_with_object({}) do |path, hash|
+        name = File.basename(path, ".yml").to_sym
+        hash[name] = path
+      end
+    end
+  end
+end

data/lib/hachiwari/results.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hachiwari
+  # 勝敗や目標勝率、表示言語など CLI の状態を保持するデータオブジェクト
+  Results = Struct.new(:wins, :losses, :target, :language) do
+    # YAML への保存や表示時に利用しやすい Hash へ変換
+    def to_h
+      { wins: wins, losses: losses, target: target, language: language }
+    end
+  end
+end

data/lib/hachiwari/status_calculator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hachiwari
+  # 勝率や必要勝数などの数値計算を担当するユーティリティ
+  class StatusCalculator
+    # 勝率（%）を小数第4位まで算出
+    def winning_percentage(results)
+      games = total_games(results)
+      return 0.0 if games.zero?
+
+      (results.wins / games.to_f * 100).round(4)
+    end
+
+    # 目標勝率を満たすまでに必要な追加勝利数を算出
+    # 既に目標を上回っている、もしくは目標が無効な場合は 0 を返す
+    def required_wins(results)
+      target = results.target.to_i
+      return 0 if target <= 0
+
+      wins = results.wins.to_i
+      losses = results.losses.to_i
+      total = wins + losses
+
+      return 0 if total.positive? && wins * 100 >= target * total
+
+      denominator = 100 - target
+      return 0 if denominator <= 0
+
+      numerator = (target * total) - (wins * 100)
+      return 0 if numerator <= 0
+
+      (numerator + denominator - 1) / denominator
+    end
+
+    # 勝率が目標を上回っている場合に、目標を下回るまでに許容される敗北数を算出
+    # それ以外の状況では 0 を返す
+    def losses_until_below_target(results)
+      target = results.target.to_i
+      return 0 if target <= 0
+
+      wins = results.wins.to_i
+      losses = results.losses.to_i
+      total = wins + losses
+      return 0 if total.zero?
+
+      numerator = (wins * 100) - (target * total)
+      return 0 if numerator.negative?
+
+      return 0 if numerator.zero? && target >= 100 && losses.positive?
+
+      return 1 if numerator.zero? && target >= 100
+
+      (numerator / target) + 1
+    end
+
+    # 総対局数（勝ち数 + 負け数）を返却
+    def total_games(results)
+      results.wins + results.losses
+    end
+  end
+end

data/lib/hachiwari/status_presenter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hachiwari
+  # 計算済みの値をユーザー向けメッセージに整形して出力する責務を担う
+  class StatusPresenter
+    # 言語に応じたテンプレートへ値を埋め込み標準出力へ表示
+    def render(results, data)
+      template = status_template(results.language)
+      puts format(template[:summary], **data)
+
+      if data[:needed].positive?
+        puts format(template[:needed], **data)
+      elsif data[:losses_to_fall].positive?
+        puts format(template[:cushion], **data)
+      end
+    end
+
+    private
+
+    # 指定ロケールのテンプレートを取得し、失敗時は日本語へフォールバック
+    def status_template(locale)
+      Hachiwari::Locales.t(locale, :status)
+    rescue KeyError
+      Hachiwari::Locales.t(:ja, :status)
+    end
+  end
+end

data/lib/hachiwari/status_runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "results"
+require_relative "status_calculator"
+require_relative "status_presenter"
+require_relative "storage"
+
+# 状態の読み書き・計算・表示を束ねる調停役
+module Hachiwari
+  class StatusRunner
+    # 依存するコンポーネントを DI で受け取り、テストしやすくする
+    def initialize(storage: Storage.new, calculator: StatusCalculator.new, presenter: StatusPresenter.new)
+      @storage = storage
+      @calculator = calculator
+      @presenter = presenter
+    end
+
+    # 引数から `Results` を生成し、保存フラグに応じて永続化と表示を行う
+    def call(input, save:)
+      # レガシーデータが残っている環境でも、試算モード含め常に最新形式へ移行
+      storage.send(:migrate_legacy_if_needed) if storage.respond_to?(:send)
+      data = normalize_input(input)
+      base = storage.load
+      results = merge_results(base, data)
+      storage.save(results) if save
+      presenter.render(results, formatted_data(results))
+      results
+    end
+
+    private
+
+    attr_reader :storage, :calculator, :presenter
+
+    # 受け取った Hash のキーをシンボル化して扱いやすくする
+    def normalize_input(input)
+      input.transform_keys { |key| key.to_sym rescue key } # rubocop:disable Style/RescueModifier
+    end
+
+    # 既存結果と入力値をマージして新しい `Results` を生成
+    def merge_results(base, input)
+      Results.new(
+        resolve_integer(input[:wins], base.wins),
+        resolve_integer(input[:losses], base.losses),
+        resolve_integer(input[:target], base.target),
+        resolve_language(input[:language], base.language)
+      )
+    end
+
+    # 数値系入力の正規化（空入力は既存値を維持）
+    def resolve_integer(value, fallback)
+      return fallback if value.nil?
+
+      string = value.to_s.strip
+      return fallback if string.empty?
+
+      string.to_i
+    end
+
+    # 言語指定の正規化（空入力は既存値を維持）
+    def resolve_language(value, fallback)
+      return fallback if value.nil?
+
+      string = value.to_s.strip
+      return fallback if string.empty?
+
+      string.to_sym
+    end
+
+    # 表示用の Hash を生成し、プレゼンターへ渡す
+    def formatted_data(results)
+      {
+        total: calculator.total_games(results),
+        wins: results.wins,
+        losses: results.losses,
+        percentage: calculator.winning_percentage(results),
+        needed: calculator.required_wins(results),
+        losses_to_fall: calculator.losses_until_below_target(results),
+        target: results.target.to_i
+      }
+    end
+  end
+end