j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-registry/src/stamp_tax_schema.rs

@@ -0,0 +1,72 @@
+use std::collections::BTreeMap;
+
+use serde::Deserialize;
+
+/// 印紙税法令根拠（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxCitationEntry {
+    pub law_name: String,
+    pub article: String,
+}
+
+/// 印紙税額のブラケット（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxBracketEntry {
+    pub label: String,
+    pub amount_from: u64,
+    pub amount_to_inclusive: Option<u64>,
+    pub tax_amount: u64,
+}
+
+/// 印紙税の特例ルール（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxSpecialRuleEntry {
+    pub code: String,
+    pub label: String,
+    pub priority: u16,
+    pub effective_from: Option<String>,
+    pub effective_until: Option<String>,
+    pub required_flags: Vec<String>,
+    pub tax_amount: Option<u64>,
+    pub rule_label: Option<String>,
+    pub brackets: Vec<StampTaxBracketEntry>,
+    pub no_amount_tax_amount: Option<u64>,
+    pub no_amount_rule_label: Option<String>,
+}
+
+/// 印紙税の文書コードごとのパラメータ（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxDocumentParamsEntry {
+    pub label: String,
+    pub citation: StampTaxCitationEntry,
+    pub charge_mode: String,
+    pub amount_usage: String,
+    pub base_rule_label: String,
+    pub base_tax_amount: Option<u64>,
+    pub brackets: Vec<StampTaxBracketEntry>,
+    pub no_amount_tax_amount: Option<u64>,
+    pub no_amount_rule_label: Option<String>,
+    pub special_rules: Vec<StampTaxSpecialRuleEntry>,
+}
+
+/// 印紙税の計算パラメータ（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxParamsEntry {
+    pub documents: BTreeMap<String, StampTaxDocumentParamsEntry>,
+}
+
+/// 印紙税の履歴エントリ（JSON）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxHistoryEntry {
+    pub effective_from: String,
+    pub effective_until: Option<String>,
+    pub params: StampTaxParamsEntry,
+}
+
+/// `stamp_tax.json` のルートスキーマ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct StampTaxRegistry {
+    #[allow(dead_code)]
+    pub domain: String,
+    pub history: Vec<StampTaxHistoryEntry>,
+}

data/vendor/rust/crates/j-law-registry/src/validator.rs

@@ -0,0 +1,204 @@
+use crate::schema::BrokerageFeeRegistry;
+use j_law_core::{LegalDate, RegistryError};
+
+/// Registry データの整合性を検証する。
+///
+/// # 検証内容
+/// - 適用期間の重複（Overlap）
+/// - 適用期間の空白（Gap）
+/// - 分母ゼロ
+///
+/// # エラー
+/// 不正なデータを検出した場合は起動時にパニックさせてよい（設定ファイルエラー）。
+pub fn validate(registry: &BrokerageFeeRegistry) -> Result<(), RegistryError> {
+    let domain = &registry.domain;
+
+    for entry in &registry.history {
+        if LegalDate::from_date_str(&entry.effective_from).is_none() {
+            return Err(RegistryError::InvalidDateFormat {
+                domain: domain.clone(),
+                value: entry.effective_from.clone(),
+            });
+        }
+        if let Some(until) = &entry.effective_until {
+            if LegalDate::from_date_str(until).is_none() {
+                return Err(RegistryError::InvalidDateFormat {
+                    domain: domain.clone(),
+                    value: until.clone(),
+                });
+            }
+        }
+
+        for tier in &entry.params.tiers {
+            if tier.rate.denom == 0 {
+                return Err(RegistryError::ZeroDenominator {
+                    path: format!("{}/{}/rate.denom", domain, tier.label),
+                });
+            }
+        }
+    }
+
+    let mut sorted = registry.history.clone();
+    sorted.sort_by(|a, b| a.effective_from.cmp(&b.effective_from));
+
+    for [current, next] in sorted.array_windows::<2>() {
+        let current_until = match &current.effective_until {
+            Some(d) => d.clone(),
+            None => continue,
+        };
+
+        if current_until >= next.effective_from {
+            return Err(RegistryError::PeriodOverlap {
+                domain: domain.clone(),
+                from: next.effective_from.clone(),
+                until: current_until.clone(),
+            });
+        }
+
+        let until_date = match LegalDate::from_date_str(&current_until) {
+            Some(d) => d,
+            None => {
+                return Err(RegistryError::InvalidDateFormat {
+                    domain: domain.clone(),
+                    value: current_until.clone(),
+                });
+            }
+        };
+        let expected_next_from = until_date.next_day().to_date_str();
+        if expected_next_from != next.effective_from {
+            return Err(RegistryError::PeriodGap {
+                domain: domain.clone(),
+                end: current_until,
+                next_start: next.effective_from.clone(),
+            });
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)] // テストコードでは unwrap 使用を許可
+mod tests {
+    use super::*;
+    use crate::schema::{BrokerageFeeRegistry, CitationEntry, HistoryEntry, ParamsEntry};
+
+    fn make_registry(entries: Vec<HistoryEntry>) -> BrokerageFeeRegistry {
+        BrokerageFeeRegistry {
+            domain: "test".into(),
+            history: entries,
+        }
+    }
+
+    fn make_entry(from: &str, until: Option<&str>) -> HistoryEntry {
+        HistoryEntry {
+            effective_from: from.into(),
+            effective_until: until.map(|s: &str| s.into()),
+            status: "active".into(),
+            citation: CitationEntry {
+                law_id: "test".into(),
+                law_name: "test law".into(),
+                article: 1,
+                paragraph: None,
+                ministry: "test".into(),
+            },
+            params: ParamsEntry {
+                tiers: vec![],
+                low_cost_special: None,
+            },
+        }
+    }
+
+    #[test]
+    fn valid_registry_passes() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-06-30")),
+            make_entry("2024-07-01", None),
+        ]);
+        assert!(validate(&reg).is_ok());
+    }
+
+    #[test]
+    fn overlap_detected() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-07-15")),
+            make_entry("2024-07-01", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodOverlap { .. }));
+    }
+
+    #[test]
+    fn gap_detected_simple() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-06-30")),
+            make_entry("2024-07-02", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodGap { .. }));
+    }
+
+    #[test]
+    fn gap_detected_month_boundary() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-06-30")),
+            make_entry("2024-08-01", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodGap { .. }));
+    }
+
+    #[test]
+    fn gap_detected_year_boundary() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2023-12-31")),
+            make_entry("2024-01-02", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodGap { .. }));
+    }
+
+    #[test]
+    fn valid_year_boundary_no_gap() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2023-12-31")),
+            make_entry("2024-01-01", None),
+        ]);
+        assert!(validate(&reg).is_ok());
+    }
+
+    #[test]
+    fn malformed_date_rejected() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-00-30")),
+            make_entry("2024-07-01", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::InvalidDateFormat { .. }));
+    }
+
+    #[test]
+    fn impossible_date_rejected() {
+        let reg: BrokerageFeeRegistry = make_registry(vec![
+            make_entry("2019-10-01", Some("2024-02-30")),
+            make_entry("2024-07-01", None),
+        ]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::InvalidDateFormat { .. }));
+    }
+
+    #[test]
+    fn zero_denom_detected() {
+        use crate::schema::{Fraction, TierParam};
+        let mut entry: HistoryEntry = make_entry("2024-07-01", None);
+        entry.params.tiers.push(TierParam {
+            label: "tier1".into(),
+            price_from: 0,
+            price_to_inclusive: Some(2_000_000),
+            rate: Fraction { numer: 5, denom: 0 },
+        });
+        let reg: BrokerageFeeRegistry = make_registry(vec![entry]);
+        let err: RegistryError = validate(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::ZeroDenominator { .. }));
+    }
+}

data/vendor/rust/crates/j-law-registry/src/withholding_tax_loader.rs

@@ -0,0 +1,310 @@
+use std::str::FromStr;
+
+use crate::withholding_tax_schema::{WithholdingTaxHistoryEntry, WithholdingTaxRegistry};
+use j_law_core::domains::withholding_tax::params::{
+    WithholdingTaxCategoryParams, WithholdingTaxMethod, WithholdingTaxParams,
+};
+use j_law_core::domains::withholding_tax::WithholdingTaxCategory;
+use j_law_core::types::date::LegalDate;
+use j_law_core::{InputError, JLawError, RegistryError};
+
+/// `withholding_tax.json` をロードして `target_date` に対応するパラメータを返す。
+///
+/// # 法的根拠
+/// 所得税法 第204条第1項
+///
+/// # エラー
+/// - `target_date` がどの有効期間にも該当しない → `InputError::DateOutOfRange`
+pub fn load_withholding_tax_params(
+    target_date: LegalDate,
+) -> Result<WithholdingTaxParams, JLawError> {
+    target_date.validate()?;
+
+    let json_str = include_str!("../data/withholding_tax/withholding_tax.json");
+
+    let registry: WithholdingTaxRegistry =
+        serde_json::from_str(json_str).map_err(|e| RegistryError::ParseError {
+            path: "withholding_tax/withholding_tax.json".into(),
+            cause: e.to_string(),
+        })?;
+    validate_periods(&registry)?;
+
+    let date_str = target_date.to_date_str();
+    let entry = find_entry(&registry, &date_str).ok_or_else(|| InputError::DateOutOfRange {
+        date: date_str.clone(),
+    })?;
+
+    to_params(entry)
+}
+
+/// `WithholdingTaxRegistry` の適用期間の整合性を検証する。
+///
+/// # 検証内容
+/// - 適用期間の重複（Overlap）
+/// - 適用期間の空白（Gap）
+///
+/// 分母ゼロは `to_params()` で個別にチェックする。
+fn validate_periods(registry: &WithholdingTaxRegistry) -> Result<(), RegistryError> {
+    let domain = &registry.domain;
+
+    let mut sorted = registry.history.clone();
+    sorted.sort_by(|a, b| a.effective_from.cmp(&b.effective_from));
+
+    for [current, next] in sorted.array_windows::<2>() {
+        let current_until = match &current.effective_until {
+            Some(d) => d.clone(),
+            None => {
+                return Err(RegistryError::PeriodOverlap {
+                    domain: domain.clone(),
+                    from: next.effective_from.clone(),
+                    until: "open-ended".into(),
+                });
+            }
+        };
+
+        if current_until >= next.effective_from {
+            return Err(RegistryError::PeriodOverlap {
+                domain: domain.clone(),
+                from: next.effective_from.clone(),
+                until: current_until.clone(),
+            });
+        }
+
+        let until_date = LegalDate::from_date_str(&current_until).ok_or_else(|| {
+            RegistryError::InvalidDateFormat {
+                domain: domain.clone(),
+                value: current_until.clone(),
+            }
+        })?;
+        let expected_next_from = until_date.next_day().to_date_str();
+        if expected_next_from != next.effective_from {
+            return Err(RegistryError::PeriodGap {
+                domain: domain.clone(),
+                end: current_until,
+                next_start: next.effective_from.clone(),
+            });
+        }
+    }
+
+    Ok(())
+}
+
+fn find_entry<'a>(
+    registry: &'a WithholdingTaxRegistry,
+    date_str: &str,
+) -> Option<&'a WithholdingTaxHistoryEntry> {
+    registry.history.iter().find(|entry| {
+        let from_ok = entry.effective_from.as_str() <= date_str;
+        let until_ok = match &entry.effective_until {
+            Some(until) => date_str <= until.as_str(),
+            None => true,
+        };
+        from_ok && until_ok
+    })
+}
+
+fn to_params(entry: &WithholdingTaxHistoryEntry) -> Result<WithholdingTaxParams, JLawError> {
+    let categories = entry
+        .params
+        .categories
+        .iter()
+        .map(|category| {
+            if category.method.base_rate.denom == 0 {
+                return Err(RegistryError::ZeroDenominator {
+                    path: format!(
+                        "withholding_tax/withholding_tax.json/{}/method/base_rate/denom",
+                        category.code
+                    ),
+                }
+                .into());
+            }
+            if category.method.excess_rate.denom == 0 {
+                return Err(RegistryError::ZeroDenominator {
+                    path: format!(
+                        "withholding_tax/withholding_tax.json/{}/method/excess_rate/denom",
+                        category.code
+                    ),
+                }
+                .into());
+            }
+            if category.method.kind != "two_tier" {
+                return Err(RegistryError::ParseError {
+                    path: format!("withholding_tax/withholding_tax.json/{}", category.code),
+                    cause: format!("未知の計算方式です: {}", category.method.kind),
+                }
+                .into());
+            }
+
+            Ok(WithholdingTaxCategoryParams {
+                category: parse_category_code(&category.code)?,
+                label: category.label.clone(),
+                method: WithholdingTaxMethod::TwoTier {
+                    threshold: category.method.threshold,
+                    base_rate_numer: category.method.base_rate.numer,
+                    base_rate_denom: category.method.base_rate.denom,
+                    excess_rate_numer: category.method.excess_rate.numer,
+                    excess_rate_denom: category.method.excess_rate.denom,
+                },
+                submission_prize_exemption_threshold: category.submission_prize_exemption_threshold,
+            })
+        })
+        .collect::<Result<Vec<_>, JLawError>>()?;
+
+    Ok(WithholdingTaxParams { categories })
+}
+
+fn parse_category_code(code: &str) -> Result<WithholdingTaxCategory, JLawError> {
+    WithholdingTaxCategory::from_str(code).map_err(|err| {
+        RegistryError::ParseError {
+            path: format!("withholding_tax/withholding_tax.json/{code}"),
+            cause: err.to_string(),
+        }
+        .into()
+    })
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::withholding_tax_schema::{
+        WithholdingTaxCategoryEntry, WithholdingTaxCitationEntry, WithholdingTaxFraction,
+        WithholdingTaxHistoryEntry, WithholdingTaxParamsEntry, WithholdingTaxRegistry,
+        WithholdingTaxTwoTierMethodEntry,
+    };
+
+    fn make_registry(entries: Vec<WithholdingTaxHistoryEntry>) -> WithholdingTaxRegistry {
+        WithholdingTaxRegistry {
+            domain: "withholding_tax".into(),
+            history: entries,
+        }
+    }
+
+    fn make_entry(from: &str, until: Option<&str>) -> WithholdingTaxHistoryEntry {
+        WithholdingTaxHistoryEntry {
+            effective_from: from.into(),
+            effective_until: until.map(|s| s.into()),
+            status: "active".into(),
+            citation: WithholdingTaxCitationEntry {
+                law_name: "所得税法".into(),
+                article: 204,
+                paragraph: Some(1),
+            },
+            params: WithholdingTaxParamsEntry { categories: vec![] },
+        }
+    }
+
+    #[test]
+    fn registry_validation_passes_for_current_data() {
+        let json_str = include_str!("../data/withholding_tax/withholding_tax.json");
+        let registry: WithholdingTaxRegistry = serde_json::from_str(json_str).unwrap();
+        assert!(validate_periods(&registry).is_ok());
+    }
+
+    #[test]
+    fn registry_validation_detects_overlap() {
+        let reg = make_registry(vec![
+            make_entry("2013-01-01", Some("2030-01-15")),
+            make_entry("2030-01-01", None),
+        ]);
+        let err = validate_periods(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodOverlap { .. }));
+    }
+
+    #[test]
+    fn registry_validation_detects_gap() {
+        let reg = make_registry(vec![
+            make_entry("2013-01-01", Some("2029-12-31")),
+            make_entry("2030-01-03", None),
+        ]);
+        let err = validate_periods(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodGap { .. }));
+    }
+
+    #[test]
+    fn registry_validation_detects_open_ended_before_next() {
+        let reg = make_registry(vec![
+            make_entry("2013-01-01", None),
+            make_entry("2030-01-01", None),
+        ]);
+        let err = validate_periods(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodOverlap { .. }));
+    }
+
+    #[test]
+    fn load_2026_params() {
+        let params = load_withholding_tax_params(LegalDate::new(2026, 1, 1)).unwrap();
+        assert_eq!(params.categories.len(), 3);
+    }
+
+    #[test]
+    fn manuscript_category_has_exemption_threshold() {
+        let params = load_withholding_tax_params(LegalDate::new(2026, 1, 1)).unwrap();
+        let manuscript = params
+            .categories
+            .iter()
+            .find(|category| category.category == WithholdingTaxCategory::ManuscriptAndLecture)
+            .unwrap();
+        assert_eq!(
+            manuscript.submission_prize_exemption_threshold,
+            Some(50_000)
+        );
+    }
+
+    #[test]
+    fn date_before_period_is_out_of_range() {
+        let result = load_withholding_tax_params(LegalDate::new(2012, 12, 31));
+        assert!(matches!(
+            result,
+            Err(JLawError::Input(InputError::DateOutOfRange { .. }))
+        ));
+    }
+
+    #[test]
+    fn date_after_period_is_out_of_range() {
+        let result = load_withholding_tax_params(LegalDate::new(2038, 1, 1));
+        assert!(matches!(
+            result,
+            Err(JLawError::Input(InputError::DateOutOfRange { .. }))
+        ));
+    }
+
+    #[test]
+    fn invalid_category_code_is_registry_parse_error() {
+        let entry = WithholdingTaxHistoryEntry {
+            effective_from: "2013-01-01".into(),
+            effective_until: Some("2037-12-31".into()),
+            status: "active".into(),
+            citation: WithholdingTaxCitationEntry {
+                law_name: "所得税法".into(),
+                article: 204,
+                paragraph: Some(1),
+            },
+            params: WithholdingTaxParamsEntry {
+                categories: vec![WithholdingTaxCategoryEntry {
+                    code: "unknown_category".into(),
+                    label: "未知カテゴリ".into(),
+                    method: WithholdingTaxTwoTierMethodEntry {
+                        kind: "two_tier".into(),
+                        threshold: 1_000_000,
+                        base_rate: WithholdingTaxFraction {
+                            numer: 1021,
+                            denom: 10_000,
+                        },
+                        excess_rate: WithholdingTaxFraction {
+                            numer: 2042,
+                            denom: 10_000,
+                        },
+                    },
+                    submission_prize_exemption_threshold: None,
+                }],
+            },
+        };
+
+        let result = to_params(&entry);
+        assert!(matches!(
+            result,
+            Err(JLawError::Registry(RegistryError::ParseError { .. }))
+        ));
+    }
+}

data/vendor/rust/crates/j-law-registry/src/withholding_tax_schema.rs

@@ -0,0 +1,61 @@
+use serde::Deserialize;
+
+/// JSON の分数表現 `{ "numer": N, "denom": N }`。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxFraction {
+    pub numer: u64,
+    pub denom: u64,
+}
+
+/// 二段階税率方式の定義。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxTwoTierMethodEntry {
+    pub kind: String,
+    pub threshold: u64,
+    pub base_rate: WithholdingTaxFraction,
+    pub excess_rate: WithholdingTaxFraction,
+}
+
+/// カテゴリ単位のパラメータ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxCategoryEntry {
+    pub code: String,
+    pub label: String,
+    pub method: WithholdingTaxTwoTierMethodEntry,
+    pub submission_prize_exemption_threshold: Option<u64>,
+}
+
+/// 1世代の計算パラメータ群。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxParamsEntry {
+    pub categories: Vec<WithholdingTaxCategoryEntry>,
+}
+
+/// 法令引用情報。
+#[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
+pub struct WithholdingTaxCitationEntry {
+    pub law_name: String,
+    pub article: u16,
+    pub paragraph: Option<u16>,
+}
+
+/// 1世代の履歴エントリ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxHistoryEntry {
+    pub effective_from: String,
+    pub effective_until: Option<String>,
+    #[allow(dead_code)]
+    pub status: String,
+    #[allow(dead_code)]
+    pub citation: WithholdingTaxCitationEntry,
+    pub params: WithholdingTaxParamsEntry,
+}
+
+/// `withholding_tax.json` のルートスキーマ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct WithholdingTaxRegistry {
+    #[allow(dead_code)]
+    pub domain: String,
+    pub history: Vec<WithholdingTaxHistoryEntry>,
+}