j-law-ruby 0.0.3

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

@@ -0,0 +1,280 @@
+use crate::InputError;
+
+/// 法令の施行日・基準日を表す日付型。
+///
+/// 年月日の3要素で特定される暦日（西暦）。
+/// 匿名タプル `(u16, u8, u8)` に代わる名前付き型。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LegalDate {
+    /// 年（西暦）
+    pub year: u16,
+    /// 月（1〜12）
+    pub month: u8,
+    /// 日（1〜31）
+    pub day: u8,
+}
+
+impl LegalDate {
+    /// 年・月・日からインスタンスを作成する。
+    pub fn new(year: u16, month: u8, day: u8) -> Self {
+        Self { year, month, day }
+    }
+
+    /// 暦日として妥当な年月日かを検証する。
+    pub fn validate(&self) -> Result<(), InputError> {
+        let date = self.to_date_str();
+
+        if self.year == 0 {
+            return Err(InputError::InvalidDate {
+                date,
+                reason: "年は1以上を指定してください".into(),
+            });
+        }
+
+        if !(1..=12).contains(&self.month) {
+            return Err(InputError::InvalidDate {
+                date,
+                reason: "月は1〜12で指定してください".into(),
+            });
+        }
+
+        if self.day == 0 {
+            return Err(InputError::InvalidDate {
+                date,
+                reason: "日は1以上を指定してください".into(),
+            });
+        }
+
+        let max_day = Self::days_in_month(self.year, self.month);
+        if self.day > max_day {
+            return Err(InputError::InvalidDate {
+                date,
+                reason: format!("指定された月の日数を超えています: max_day={max_day}"),
+            });
+        }
+
+        Ok(())
+    }
+
+    /// ISO 8601 形式（"YYYY-MM-DD"）の文字列に変換する。
+    ///
+    /// Registry JSON の日付文字列との比較に使用する。
+    pub fn to_date_str(&self) -> String {
+        format!("{:04}-{:02}-{:02}", self.year, self.month, self.day)
+    }
+
+    /// ISO 8601 形式（"YYYY-MM-DD"）の文字列からパースする。
+    ///
+    /// 不正な形式の場合は `None` を返す。
+    pub fn from_date_str(s: &str) -> Option<Self> {
+        let bytes = s.as_bytes();
+        if bytes.len() != 10 || bytes[4] != b'-' || bytes[7] != b'-' {
+            return None;
+        }
+
+        let year: u16 = s[0..4].parse().ok()?;
+        let month: u8 = s[5..7].parse().ok()?;
+        let day: u8 = s[8..10].parse().ok()?;
+        if year == 0 || !(1..=12).contains(&month) {
+            return None;
+        }
+        if day < 1 || day > Self::days_in_month(year, month) {
+            return None;
+        }
+
+        Some(Self { year, month, day })
+    }
+
+    /// 当該年が閏年かどうかを返す。
+    ///
+    /// グレゴリオ暦の規則: 4で割り切れる && (100で割り切れない || 400で割り切れる)
+    fn is_leap_year(year: u16) -> bool {
+        let y = year as u32;
+        y.is_multiple_of(4) && (!y.is_multiple_of(100) || y.is_multiple_of(400))
+    }
+
+    /// 指定した月の日数を返す。
+    fn days_in_month(year: u16, month: u8) -> u8 {
+        match month {
+            1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+            4 | 6 | 9 | 11 => 30,
+            2 => {
+                if Self::is_leap_year(year) {
+                    29
+                } else {
+                    28
+                }
+            }
+            _ => 0,
+        }
+    }
+
+    /// 翌日の `LegalDate` を返す。
+    ///
+    /// 月末・年末の繰り上がりを正確に処理する（chrono 不使用、純粋算術ベース）。
+    pub fn next_day(&self) -> Self {
+        let max_day = Self::days_in_month(self.year, self.month);
+        if self.day < max_day {
+            Self::new(self.year, self.month, self.day + 1)
+        } else if self.month < 12 {
+            Self::new(self.year, self.month + 1, 1)
+        } else {
+            Self::new(self.year + 1, 1, 1)
+        }
+    }
+}
+
+impl From<(u16, u8, u8)> for LegalDate {
+    /// タプル `(year, month, day)` から `LegalDate` を構築する。
+    ///
+    /// 既存コードとの互換性のために提供する。
+    fn from((year, month, day): (u16, u8, u8)) -> Self {
+        Self::new(year, month, day)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn new_and_fields() {
+        let d = LegalDate::new(2024, 8, 1);
+        assert_eq!(d.year, 2024);
+        assert_eq!(d.month, 8);
+        assert_eq!(d.day, 1);
+    }
+
+    #[test]
+    fn to_date_str_format() {
+        assert_eq!(LegalDate::new(2024, 8, 1).to_date_str(), "2024-08-01");
+        assert_eq!(LegalDate::new(2015, 1, 1).to_date_str(), "2015-01-01");
+        assert_eq!(LegalDate::new(2024, 12, 31).to_date_str(), "2024-12-31");
+    }
+
+    #[test]
+    fn validate_accepts_leap_day() {
+        assert!(LegalDate::new(2024, 2, 29).validate().is_ok());
+    }
+
+    #[test]
+    fn validate_rejects_invalid_month() {
+        let result = LegalDate::new(2024, 13, 1).validate();
+        assert!(matches!(result, Err(InputError::InvalidDate { .. })));
+        let err_str = match result {
+            Err(err) => err.to_string(),
+            Ok(()) => String::new(),
+        };
+        assert!(err_str.contains("2024-13-01"));
+    }
+
+    #[test]
+    fn validate_rejects_invalid_day() {
+        let result = LegalDate::new(2024, 2, 30).validate();
+        assert!(matches!(result, Err(InputError::InvalidDate { .. })));
+        let err_str = match result {
+            Err(err) => err.to_string(),
+            Ok(()) => String::new(),
+        };
+        assert!(err_str.contains("2024-02-30"));
+    }
+
+    #[test]
+    fn validate_rejects_year_zero() {
+        let result = LegalDate::new(0, 1, 1).validate();
+        assert!(matches!(result, Err(InputError::InvalidDate { .. })));
+        let err_str = match result {
+            Err(err) => err.to_string(),
+            Ok(()) => String::new(),
+        };
+        assert!(err_str.contains("0000-01-01"));
+    }
+
+    #[test]
+    fn from_date_str_valid() {
+        let d = LegalDate::from_date_str("2024-07-01").unwrap();
+        assert_eq!(d, LegalDate::new(2024, 7, 1));
+    }
+
+    #[test]
+    fn from_date_str_invalid() {
+        assert!(LegalDate::from_date_str("2024-7-1").is_none());
+        assert!(LegalDate::from_date_str("20240701").is_none());
+        assert!(LegalDate::from_date_str("not-a-date").is_none());
+        assert!(LegalDate::from_date_str("0000-01-01").is_none());
+    }
+
+    #[test]
+    fn from_date_str_rejects_impossible_dates() {
+        assert!(LegalDate::from_date_str("2023-02-29").is_none());
+        assert!(LegalDate::from_date_str("2024-02-29").is_some());
+        assert!(LegalDate::from_date_str("2024-04-31").is_none());
+        assert!(LegalDate::from_date_str("2024-06-31").is_none());
+        assert!(LegalDate::from_date_str("2024-13-01").is_none());
+        assert!(LegalDate::from_date_str("2024-01-00").is_none());
+    }
+
+    #[test]
+    fn is_leap_year_cases() {
+        assert!(LegalDate::is_leap_year(2000));
+        assert!(!LegalDate::is_leap_year(1900));
+        assert!(LegalDate::is_leap_year(2024));
+        assert!(!LegalDate::is_leap_year(2023));
+    }
+
+    #[test]
+    fn next_day_normal() {
+        assert_eq!(
+            LegalDate::new(2024, 7, 15).next_day(),
+            LegalDate::new(2024, 7, 16)
+        );
+    }
+
+    #[test]
+    fn next_day_month_end_30() {
+        assert_eq!(
+            LegalDate::new(2024, 6, 30).next_day(),
+            LegalDate::new(2024, 7, 1)
+        );
+    }
+
+    #[test]
+    fn next_day_month_end_31() {
+        assert_eq!(
+            LegalDate::new(2024, 7, 31).next_day(),
+            LegalDate::new(2024, 8, 1)
+        );
+    }
+
+    #[test]
+    fn next_day_year_end() {
+        assert_eq!(
+            LegalDate::new(2024, 12, 31).next_day(),
+            LegalDate::new(2025, 1, 1)
+        );
+    }
+
+    #[test]
+    fn next_day_feb_28_non_leap() {
+        assert_eq!(
+            LegalDate::new(2023, 2, 28).next_day(),
+            LegalDate::new(2023, 3, 1)
+        );
+    }
+
+    #[test]
+    fn next_day_feb_28_leap() {
+        assert_eq!(
+            LegalDate::new(2024, 2, 28).next_day(),
+            LegalDate::new(2024, 2, 29)
+        );
+    }
+
+    #[test]
+    fn next_day_feb_29_leap() {
+        assert_eq!(
+            LegalDate::new(2024, 2, 29).next_day(),
+            LegalDate::new(2024, 3, 1)
+        );
+    }
+}

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

@@ -0,0 +1,11 @@
+pub mod amount;
+pub mod citation;
+pub mod date;
+pub mod rate;
+pub mod rounding;
+
+pub use amount::{FinalAmount, IntermediateAmount};
+pub use citation::LegalCitation;
+pub use date::LegalDate;
+pub use rate::{MultiplyOrder, Rate};
+pub use rounding::RoundingStrategy;

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

@@ -0,0 +1,219 @@
+use crate::error::{CalculationError, InputError, JLawError};
+use crate::types::amount::IntermediateAmount;
+use crate::types::rounding::RoundingStrategy;
+
+/// 乗算順序の指定。
+///
+/// 端数処理が絡む計算では乗算と除算の順序で結果が変わる場合があるため、
+/// 明示的に指定できるようにしている。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MultiplyOrder {
+    /// 先に分子を掛けてから分母で割る（精度優先）。
+    MultiplyFirst,
+    /// 先に分母で割ってから分子を掛ける（オーバーフロー回避優先）。
+    DivideFirst,
+}
+
+/// 分数で表された比率（例: 5/100 = 5%）。
+///
+/// float を使わず整数分数で保持することで、法令計算に必要な
+/// 再現性のある端数処理を保証する。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rate {
+    /// 分子。
+    pub(crate) numer: u64,
+    /// 分母。0 は不正値。
+    pub(crate) denom: u64,
+}
+
+impl Rate {
+    /// 分数比率を作る。`denom == 0` の場合はエラーを返す。
+    pub fn new(numer: u64, denom: u64) -> Result<Self, InputError> {
+        if denom == 0 {
+            return Err(InputError::ZeroDenominator);
+        }
+        Ok(Self { numer, denom })
+    }
+
+    /// 分子を返す。
+    pub fn numer(&self) -> u64 {
+        self.numer
+    }
+
+    /// 分母を返す。
+    pub fn denom(&self) -> u64 {
+        self.denom
+    }
+
+    /// `amount` にこのレートを適用して新しい `IntermediateAmount` を返す。
+    ///
+    /// `amount` の整数部（`whole`）のみに適用し、端数部（`numer`/`denom`）は無視する。
+    ///
+    /// # Important
+    /// `amount.numer` / `amount.denom` が非ゼロ（端数あり）の場合、
+    /// その端数部分は計算に含まれず**黙って切り捨てられます**。
+    /// 端数を保持した状態でレートを適用したい場合は、
+    /// 事前に `amount.finalize(rounding)` を呼び出して整数化してください。
+    ///
+    /// # エラー
+    /// - `self.denom == 0` の場合は `InputError::ZeroDenominator` を返す。
+    /// - `MultiplyOrder::MultiplyFirst` で `base * self.numer` がオーバーフローした場合は
+    ///   `CalculationError::Overflow` を返す。
+    pub fn apply(
+        &self,
+        amount: &IntermediateAmount,
+        order: MultiplyOrder,
+        rounding: RoundingStrategy,
+    ) -> Result<IntermediateAmount, JLawError> {
+        if self.denom == 0 {
+            return Err(InputError::ZeroDenominator.into());
+        }
+        let base = amount.whole;
+        let result_whole = match order {
+            MultiplyOrder::MultiplyFirst => {
+                let product =
+                    base.checked_mul(self.numer)
+                        .ok_or_else(|| CalculationError::Overflow {
+                            step: format!("rate_apply: {} * {}", base, self.numer),
+                        })?;
+                rounding.apply_ratio(product, self.denom)?
+            }
+            MultiplyOrder::DivideFirst => {
+                rounding.apply_ratio(base / self.denom * self.numer, 1)?
+            }
+        };
+        Ok(IntermediateAmount::from_exact(result_whole))
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+
+    fn exact(yen: u64) -> IntermediateAmount {
+        IntermediateAmount::from_exact(yen)
+    }
+
+    #[test]
+    fn rate_5_percent_multiply_first() {
+        // 2_000_000 × 5/100 = 100_000
+        let rate = Rate::new(5, 100).unwrap();
+        let result = rate
+            .apply(
+                &exact(2_000_000),
+                MultiplyOrder::MultiplyFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        assert_eq!(
+            result.finalize(RoundingStrategy::Floor).unwrap().as_yen(),
+            100_000
+        );
+    }
+
+    #[test]
+    fn rate_4_percent_tier2() {
+        // (4_000_000 - 2_000_000) × 4/100 = 80_000
+        let rate = Rate::new(4, 100).unwrap();
+        let result = rate
+            .apply(
+                &exact(2_000_000),
+                MultiplyOrder::MultiplyFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        assert_eq!(
+            result.finalize(RoundingStrategy::Floor).unwrap().as_yen(),
+            80_000
+        );
+    }
+
+    #[test]
+    fn rate_3_percent_tier3() {
+        // (5_000_000 - 4_000_000) × 3/100 = 30_000
+        let rate = Rate::new(3, 100).unwrap();
+        let result = rate
+            .apply(
+                &exact(1_000_000),
+                MultiplyOrder::MultiplyFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        assert_eq!(
+            result.finalize(RoundingStrategy::Floor).unwrap().as_yen(),
+            30_000
+        );
+    }
+
+    #[test]
+    fn multiply_first_vs_divide_first_differ() {
+        // 10 × 1/3:
+        // MultiplyFirst: floor(10/3) = 3
+        // DivideFirst:   floor(10/3) * 1 = 3  ← 同じ
+        // 差が出るケース: 7 × 3/4
+        // MultiplyFirst: floor(21/4) = 5
+        // DivideFirst:   floor(7/4) * 3 = 1 * 3 = 3
+        let rate = Rate::new(3, 4).unwrap();
+        let mf = rate
+            .apply(
+                &exact(7),
+                MultiplyOrder::MultiplyFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        let df = rate
+            .apply(
+                &exact(7),
+                MultiplyOrder::DivideFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        assert_eq!(mf.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 5);
+        assert_eq!(df.finalize(RoundingStrategy::Floor).unwrap().as_yen(), 3);
+    }
+
+    #[test]
+    fn tax_10_percent() {
+        // 210_000 × 10/100 = 21_000
+        let rate = Rate::new(10, 100).unwrap();
+        let result = rate
+            .apply(
+                &exact(210_000),
+                MultiplyOrder::MultiplyFirst,
+                RoundingStrategy::Floor,
+            )
+            .unwrap();
+        assert_eq!(
+            result.finalize(RoundingStrategy::Floor).unwrap().as_yen(),
+            21_000
+        );
+    }
+
+    #[test]
+    fn zero_denominator_returns_error() {
+        // Rate::new(1, 0) はエラーを返す
+        let result = Rate::new(1, 0);
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            crate::error::InputError::ZeroDenominator
+        ));
+    }
+
+    #[test]
+    fn overflow_returns_calculation_error() {
+        // u64::MAX * 2 はオーバーフローする
+        let rate = Rate::new(2, 1).unwrap();
+        let result = rate.apply(
+            &exact(u64::MAX),
+            MultiplyOrder::MultiplyFirst,
+            RoundingStrategy::Floor,
+        );
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            crate::error::JLawError::Calculation(crate::error::CalculationError::Overflow { .. })
+        ));
+    }
+}

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

@@ -0,0 +1,81 @@
+/// 端数処理戦略。
+///
+/// 法令計算では端数処理の根拠を明示する必要があるため、
+/// `f64::floor` や `f64::round` を使わず、この型で整数演算する。
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RoundingStrategy {
+    /// 切り捨て（床関数）。法令計算で最も多く使われる。
+    Floor,
+    /// 四捨五入。
+    HalfUp,
+    /// 切り上げ（天井関数）。
+    Ceil,
+}
+
+impl RoundingStrategy {
+    /// `numer / denom` を整数で丸める（整数演算のみ・float不使用）。
+    ///
+    /// # エラー
+    /// `denom == 0` の場合は `InputError::ZeroDenominator` を返す。
+    pub(crate) fn apply_ratio(
+        self,
+        numer: u64,
+        denom: u64,
+    ) -> Result<u64, crate::error::InputError> {
+        if denom == 0 {
+            return Err(crate::error::InputError::ZeroDenominator);
+        }
+        Ok(match self {
+            RoundingStrategy::Floor => numer / denom,
+            RoundingStrategy::Ceil => numer.div_ceil(denom),
+            RoundingStrategy::HalfUp => {
+                // numer / denom を四捨五入: (numer * 2 + denom) / (denom * 2)
+                // オーバーフロー対策: numer + denom/2 が安全な範囲かチェック不要
+                // (denom は通常小さい値のため問題ない)
+                (numer + denom / 2) / denom
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::disallowed_methods)] // テストコードでは unwrap() 使用可能
+    use super::*;
+
+    #[test]
+    fn floor_truncates() {
+        assert_eq!(RoundingStrategy::Floor.apply_ratio(10, 3).unwrap(), 3);
+        assert_eq!(RoundingStrategy::Floor.apply_ratio(9, 3).unwrap(), 3);
+        assert_eq!(RoundingStrategy::Floor.apply_ratio(0, 5).unwrap(), 0);
+    }
+
+    #[test]
+    fn ceil_rounds_up() {
+        assert_eq!(RoundingStrategy::Ceil.apply_ratio(10, 3).unwrap(), 4);
+        assert_eq!(RoundingStrategy::Ceil.apply_ratio(9, 3).unwrap(), 3);
+        assert_eq!(RoundingStrategy::Ceil.apply_ratio(1, 5).unwrap(), 1);
+    }
+
+    #[test]
+    fn half_up_rounds() {
+        // 5 / 2 = 2.5 → 3
+        assert_eq!(RoundingStrategy::HalfUp.apply_ratio(5, 2).unwrap(), 3);
+        // 4 / 2 = 2.0 → 2
+        assert_eq!(RoundingStrategy::HalfUp.apply_ratio(4, 2).unwrap(), 2);
+        // 7 / 3 = 2.333... → 2
+        assert_eq!(RoundingStrategy::HalfUp.apply_ratio(7, 3).unwrap(), 2);
+        // 8 / 3 = 2.666... → 3
+        assert_eq!(RoundingStrategy::HalfUp.apply_ratio(8, 3).unwrap(), 3);
+    }
+
+    #[test]
+    fn zero_denominator_returns_error() {
+        let result = RoundingStrategy::Floor.apply_ratio(10, 0);
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            crate::error::InputError::ZeroDenominator
+        ));
+    }
+}

data/vendor/rust/crates/j-law-registry/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "j-law-registry"
+version = "0.0.3"
+edition = "2021"
+rust-version = "1.94"
+license = "MIT"
+publish = false
+
+[lints]
+workspace = true
+
+[dependencies]
+j-law-core = { path = "../j-law-core" }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

data/vendor/rust/crates/j-law-registry/data/consumption_tax/consumption_tax.json

@@ -0,0 +1,70 @@
+{
+  "domain": "consumption_tax",
+  "description": "消費税法第29条に基づく消費税率の歴史",
+  "history": [
+    {
+      "effective_from": "1989-04-01",
+      "effective_until": "1997-03-31",
+      "status": "superseded",
+      "citation": {
+        "law_id": "shohizei-29",
+        "law_name": "消費税法",
+        "article": 29,
+        "paragraph": null,
+        "ministry": "財務省"
+      },
+      "params": {
+        "standard_rate": { "numer": 3, "denom": 100 },
+        "reduced_rate": null
+      }
+    },
+    {
+      "effective_from": "1997-04-01",
+      "effective_until": "2014-03-31",
+      "status": "superseded",
+      "citation": {
+        "law_id": "shohizei-29",
+        "law_name": "消費税法",
+        "article": 29,
+        "paragraph": null,
+        "ministry": "財務省"
+      },
+      "params": {
+        "standard_rate": { "numer": 5, "denom": 100 },
+        "reduced_rate": null
+      }
+    },
+    {
+      "effective_from": "2014-04-01",
+      "effective_until": "2019-09-30",
+      "status": "superseded",
+      "citation": {
+        "law_id": "shohizei-29",
+        "law_name": "消費税法",
+        "article": 29,
+        "paragraph": null,
+        "ministry": "財務省"
+      },
+      "params": {
+        "standard_rate": { "numer": 8, "denom": 100 },
+        "reduced_rate": null
+      }
+    },
+    {
+      "effective_from": "2019-10-01",
+      "effective_until": null,
+      "status": "active",
+      "citation": {
+        "law_id": "shohizei-29",
+        "law_name": "消費税法",
+        "article": 29,
+        "paragraph": null,
+        "ministry": "財務省"
+      },
+      "params": {
+        "standard_rate": { "numer": 10, "denom": 100 },
+        "reduced_rate": { "numer": 8, "denom": 100 }
+      }
+    }
+  ]
+}