j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-core/src/error.rs

@@ -0,0 +1,171 @@
+use thiserror::Error;
+
+/// Registry（告示JSONデータ）の不整合エラー。
+/// 起動時バリデーションで検出し、panic! で伝播させてよい層。
+#[derive(Debug, Error)]
+pub enum RegistryError {
+    #[error("法令データに適用期間の重複があります: domain={domain}, from={from}, until={until}")]
+    PeriodOverlap {
+        domain: String,
+        from: String,
+        until: String,
+    },
+
+    #[error(
+        "法令データに適用期間の空白があります: domain={domain}, end={end}, next_start={next_start}"
+    )]
+    PeriodGap {
+        domain: String,
+        end: String,
+        next_start: String,
+    },
+
+    #[error("分母にゼロが含まれています: path={path}")]
+    ZeroDenominator { path: String },
+
+    #[error("日付の形式が不正です: domain={domain}, value={value}")]
+    InvalidDateFormat { domain: String, value: String },
+
+    #[error("JSONファイルが見つかりません: {path}")]
+    FileNotFound { path: String },
+
+    #[error("JSONのパースに失敗しました: path={path}, cause={cause}")]
+    ParseError { path: String, cause: String },
+}
+
+/// ユーザー入力の不正エラー。
+#[derive(Debug, Error)]
+pub enum InputError {
+    #[error("負の金額は無効です: value={value}")]
+    NegativeAmount { value: i64 },
+
+    #[error("無効な日付です: date={date}, reason={reason}")]
+    InvalidDate { date: String, reason: String },
+
+    #[error("指定した日付は法令の適用期間外です: date={date}")]
+    DateOutOfRange { date: String },
+
+    #[error("矛盾するフラグが同時に指定されています: {flag_a} と {flag_b}")]
+    ConflictingFlags { flag_a: String, flag_b: String },
+
+    #[error("所得控除の入力が無効です: field={field}, reason={reason}")]
+    InvalidDeductionInput { field: String, reason: String },
+
+    #[error("源泉徴収入力が無効です: field={field}, reason={reason}")]
+    InvalidWithholdingInput { field: String, reason: String },
+
+    #[error("印紙税入力が無効です: field={field}, reason={reason}")]
+    InvalidStampTaxInput { field: String, reason: String },
+
+    #[error("分母にゼロが指定されました")]
+    ZeroDenominator,
+}
+
+/// 計算処理中の異常エラー。
+#[derive(Debug, Error)]
+pub enum CalculationError {
+    #[error("計算中に整数オーバーフローが発生しました: step={step}")]
+    Overflow { step: String },
+
+    #[error("このコンテキストにポリシーを適用できません: {reason}")]
+    PolicyNotApplicable { reason: String },
+}
+
+/// J-Law-Core 全体のトップレベルエラー型。
+#[derive(Debug, Error)]
+pub enum JLawError {
+    #[error(transparent)]
+    Registry(#[from] RegistryError),
+
+    #[error(transparent)]
+    Input(#[from] InputError),
+
+    #[error(transparent)]
+    Calculation(#[from] CalculationError),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn registry_error_display() {
+        let e = RegistryError::PeriodOverlap {
+            domain: "real_estate".into(),
+            from: "2024-01-01".into(),
+            until: "2024-12-31".into(),
+        };
+        assert!(e.to_string().contains("real_estate"));
+        assert!(e.to_string().contains("重複"));
+    }
+
+    #[test]
+    fn input_error_display() {
+        let e = InputError::NegativeAmount { value: -100 };
+        assert!(e.to_string().contains("-100"));
+    }
+
+    #[test]
+    fn invalid_date_display() {
+        let e = InputError::InvalidDate {
+            date: "2024-02-30".into(),
+            reason: "指定された月の日数を超えています".into(),
+        };
+        assert!(e.to_string().contains("2024-02-30"));
+        assert!(e.to_string().contains("指定された月の日数"));
+    }
+
+    #[test]
+    fn invalid_deduction_input_display() {
+        let e = InputError::InvalidDeductionInput {
+            field: "social_insurance_premium_paid".into(),
+            reason: "test".into(),
+        };
+        assert!(e.to_string().contains("social_insurance_premium_paid"));
+        assert!(e.to_string().contains("test"));
+    }
+
+    #[test]
+    fn invalid_withholding_input_display() {
+        let e = InputError::InvalidWithholdingInput {
+            field: "category".into(),
+            reason: "unknown".into(),
+        };
+        assert!(e.to_string().contains("category"));
+        assert!(e.to_string().contains("unknown"));
+    }
+
+    #[test]
+    fn invalid_stamp_tax_input_display() {
+        let e = InputError::InvalidStampTaxInput {
+            field: "document_code".into(),
+            reason: "unknown".into(),
+        };
+        assert!(e.to_string().contains("document_code"));
+        assert!(e.to_string().contains("unknown"));
+    }
+
+    #[test]
+    fn calculation_error_display() {
+        let e = CalculationError::Overflow {
+            step: "tier1".into(),
+        };
+        assert!(e.to_string().contains("tier1"));
+    }
+
+    #[test]
+    fn jlaw_error_from_input() {
+        let inner = InputError::ZeroDenominator;
+        let outer: JLawError = inner.into();
+        assert!(matches!(outer, JLawError::Input(_)));
+    }
+
+    #[test]
+    fn jlaw_error_from_calculation() {
+        let inner = CalculationError::PolicyNotApplicable {
+            reason: "test".into(),
+        };
+        let outer: JLawError = inner.into();
+        assert!(matches!(outer, JLawError::Calculation(_)));
+    }
+}

data/vendor/rust/crates/j-law-core/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod domains;
+pub mod error;
+pub mod types;
+
+pub use error::{CalculationError, InputError, JLawError, RegistryError};
+pub use types::{
+    FinalAmount, IntermediateAmount, LegalCitation, LegalDate, MultiplyOrder, Rate,
+    RoundingStrategy,
+};

data/vendor/rust/crates/j-law-core/src/types/amount.rs

@@ -0,0 +1,232 @@
+use crate::error::InputError;
+use crate::types::rounding::RoundingStrategy;
+
+/// 計算の最終結果を表す金額型（円単位・整数）。
+///
+/// 税込合計・税抜合計・税額など、ユーザーに返す確定値にのみ使う。
+/// 計算途中では [`IntermediateAmount`] を使うこと。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct FinalAmount(u64);
+
+impl FinalAmount {
+    /// 円単位の値から `FinalAmount` を作る。
+    pub fn new(yen: u64) -> Self {
+        Self(yen)
+    }
+
+    /// 円単位の値を返す。
+    pub fn as_yen(self) -> u64 {
+        self.0
+    }
+}
+
+impl std::fmt::Display for FinalAmount {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}円", self.0)
+    }
+}
+
+/// 計算途中の金額を分数で表す型。
+///
+/// `whole + numer/denom` を表す。例えば `100 + 1/3` は
+/// `IntermediateAmount { whole: 100, numer: 1, denom: 3 }`。
+///
+/// 端数処理が必要な場面では [`IntermediateAmount::finalize`] を呼ぶこと。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IntermediateAmount {
+    /// 整数部分（円）。
+    pub(crate) whole: u64,
+    /// 分子。
+    pub(crate) numer: u64,
+    /// 分母。`0` は不正値であり、コンストラクタで拒否される。
+    pub(crate) denom: u64,
+}
+
+impl IntermediateAmount {
+    /// 整数値（円）から `IntermediateAmount` を作る（端数なし）。
+    pub fn from_exact(yen: u64) -> Self {
+        Self {
+            whole: yen,
+            numer: 0,
+            denom: 1,
+        }
+    }
+
+    /// 分数形式で作る。`denom == 0` の場合はエラーを返す。
+    pub fn try_new(whole: u64, numer: u64, denom: u64) -> Result<Self, InputError> {
+        if denom == 0 {
+            return Err(InputError::ZeroDenominator);
+        }
+        Ok(Self {
+            whole,
+            numer,
+            denom,
+        })
+    }
+
+    /// 端数処理して [`FinalAmount`] に変換する。
+    ///
+    /// # エラー
+    /// `self.denom == 0` の場合は `InputError::ZeroDenominator` を返す。
+    pub fn finalize(&self, rounding: RoundingStrategy) -> Result<FinalAmount, InputError> {
+        let frac = if self.numer == 0 {
+            0
+        } else {
+            rounding.apply_ratio(self.numer, self.denom)?
+        };
+        Ok(FinalAmount::new(self.whole + frac))
+    }
+
+    /// 整数部分（円）を返す。
+    pub fn whole(&self) -> u64 {
+        self.whole
+    }
+
+    /// 分子を返す。
+    pub fn numer(&self) -> u64 {
+        self.numer
+    }
+
+    /// 分母を返す。
+    pub fn denom(&self) -> u64 {
+        self.denom
+    }
+}
+
+/// `IntermediateAmount` 同士の加算を標準トレイトで実装。
+impl std::ops::Add<&IntermediateAmount> for IntermediateAmount {
+    type Output = IntermediateAmount;
+
+    /// 加算（整数部分同士を加える）。
+    ///
+    /// 通分計算 `(a.numer * b.denom + b.numer * a.denom) / (a.denom * b.denom)` において
+    /// 乗算・加算がオーバーフローした場合は `whole = u64::MAX` をセットして返す。
+    /// 法令計算で扱う金額の範囲では通常発生しないが、
+    /// 異常入力に対して silently panic しないための安全対策。
+    fn add(self, other: &IntermediateAmount) -> IntermediateAmount {
+        // 通分: frac 部は (a.numer * b.denom + b.numer * a.denom) / (a.denom * b.denom)
+        let Some(new_denom) = self.denom.checked_mul(other.denom) else {
+            return IntermediateAmount {
+                whole: u64::MAX,
+                numer: 0,
+                denom: 1,
+            };
+        };
+        let Some(lhs) = self.numer.checked_mul(other.denom) else {
+            return IntermediateAmount {
+                whole: u64::MAX,
+                numer: 0,
+                denom: 1,
+            };
+        };
+        let Some(rhs) = other.numer.checked_mul(self.denom) else {
+            return IntermediateAmount {
+                whole: u64::MAX,
+                numer: 0,
+                denom: 1,
+            };
+        };
+        let Some(new_numer) = lhs.checked_add(rhs) else {
+            return IntermediateAmount {
+                whole: u64::MAX,
+                numer: 0,
+                denom: 1,
+            };
+        };
+        // 整数部を繰り上げながら正規化
+        let carry = new_numer / new_denom;
+        let rem = new_numer % new_denom;
+        let Some(whole) = self
+            .whole
+            .checked_add(other.whole)
+            .and_then(|w| w.checked_add(carry))
+        else {
+            return IntermediateAmount {
+                whole: u64::MAX,
+                numer: 0,
+                denom: 1,
+            };
+        };
+        IntermediateAmount {
+            whole,
+            numer: rem,
+            denom: new_denom,
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use std::ops::Add;
+
+    #[test]
+    fn final_amount_roundtrip() {
+        let a = FinalAmount::new(210_000);
+        assert_eq!(a.as_yen(), 210_000);
+    }
+
+    #[test]
+    fn from_exact_has_no_fraction() {
+        let a = IntermediateAmount::from_exact(100);
+        assert_eq!(a.whole(), 100);
+        assert_eq!(a.numer(), 0);
+    }
+
+    #[test]
+    fn try_new_rejects_zero_denom() {
+        let result = IntermediateAmount::try_new(100, 1, 0);
+        assert!(matches!(result, Err(InputError::ZeroDenominator)));
+    }
+
+    #[test]
+    fn finalize_floor() {
+        // 100 + 1/3 → Floor → 100
+        let a = IntermediateAmount::try_new(100, 1, 3).unwrap();
+        assert_eq!(a.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 100);
+    }
+
+    #[test]
+    fn finalize_ceil() {
+        // 100 + 1/3 → Ceil → 101
+        let a = IntermediateAmount::try_new(100, 1, 3).unwrap();
+        assert_eq!(a.finalize(RoundingStrategy::Ceil).unwrap().as_yen(), 101);
+    }
+
+    #[test]
+    fn finalize_half_up() {
+        // 100 + 1/2 = 100.5 → HalfUp → 101
+        let a = IntermediateAmount::try_new(100, 1, 2).unwrap();
+        assert_eq!(a.finalize(RoundingStrategy::HalfUp).unwrap().as_yen(), 101);
+
+        // 100 + 1/3 = 100.333 → HalfUp → 100
+        let b = IntermediateAmount::try_new(100, 1, 3).unwrap();
+        assert_eq!(b.finalize(RoundingStrategy::HalfUp).unwrap().as_yen(), 100);
+    }
+
+    #[test]
+    fn finalize_no_fraction() {
+        let a = IntermediateAmount::from_exact(5_000);
+        assert_eq!(a.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 5_000);
+    }
+
+    #[test]
+    fn add_two_exact() {
+        let a = IntermediateAmount::from_exact(100);
+        let b = IntermediateAmount::from_exact(200);
+        let c = a.add(&b);
+        assert_eq!(c.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 300);
+    }
+
+    #[test]
+    fn add_carries_fraction() {
+        // 0 + 2/3  +  0 + 2/3  = 4/3 → carry 1, rem 1/3
+        let a = IntermediateAmount::try_new(0, 2, 3).unwrap();
+        let b = IntermediateAmount::try_new(0, 2, 3).unwrap();
+        let c = a.add(&b);
+        assert_eq!(c.whole(), 1);
+        // finalize Floor → 1
+        assert_eq!(c.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 1);
+    }
+}

data/vendor/rust/crates/j-law-core/src/types/citation.rs

@@ -0,0 +1,82 @@
+use crate::types::date::LegalDate;
+
+/// 法令の条文参照情報。
+///
+/// `pub` な型・関数の docコメントに埋め込むことで、
+/// 実装の根拠を機械可読な形で記録する。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LegalCitation {
+    /// 法令識別子（e.g., `"reitaku-46"`, `"shotoku-tax-36"`）。
+    pub law_id: String,
+    /// 法令の正式名称。
+    pub law_name: String,
+    /// 条番号。
+    pub article: u16,
+    /// 項番号（省略可）。
+    pub paragraph: Option<u16>,
+    /// 号番号（省略可）。
+    pub item: Option<u16>,
+    /// 施行日。
+    pub effective_date: LegalDate,
+}
+
+impl LegalCitation {
+    /// 簡易コンストラクタ（条のみ指定）。
+    pub fn article_only(
+        law_id: &str,
+        law_name: &str,
+        article: u16,
+        effective_date: LegalDate,
+    ) -> Self {
+        Self {
+            law_id: law_id.to_owned(),
+            law_name: law_name.to_owned(),
+            article,
+            paragraph: None,
+            item: None,
+            effective_date,
+        }
+    }
+}
+
+impl std::fmt::Display for LegalCitation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} 第{}条", self.law_name, self.article)?;
+        if let Some(p) = self.paragraph {
+            write!(f, "第{}項", p)?;
+        }
+        if let Some(i) = self.item {
+            write!(f, "第{}号", i)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn display_article_only() {
+        let c = LegalCitation::article_only(
+            "reitaku-46",
+            "宅地建物取引業法",
+            46,
+            LegalDate::new(2024, 7, 1),
+        );
+        assert_eq!(c.to_string(), "宅地建物取引業法 第46条");
+    }
+
+    #[test]
+    fn display_with_paragraph_and_item() {
+        let c = LegalCitation {
+            law_id: "reitaku-46".into(),
+            law_name: "宅地建物取引業法".into(),
+            article: 46,
+            paragraph: Some(1),
+            item: Some(2),
+            effective_date: LegalDate::new(2024, 7, 1),
+        };
+        assert_eq!(c.to_string(), "宅地建物取引業法 第46条第1項第2号");
+    }
+}