j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-core/src/domains/income_tax/deduction/personal.rs

@@ -0,0 +1,324 @@
+use crate::domains::income_tax::deduction::context::IncomeDeductionContext;
+use crate::domains::income_tax::deduction::params::{
+    BasicDeductionBracket, BasicDeductionParams, DependentDeductionParams, PersonalDeductionParams,
+    SpouseDeductionParams, SpouseIncomeBracket,
+};
+use crate::domains::income_tax::deduction::types::{IncomeDeductionKind, IncomeDeductionLine};
+use crate::error::{CalculationError, JLawError};
+use crate::types::amount::FinalAmount;
+
+pub(crate) fn calculate_personal_deductions(
+    ctx: &IncomeDeductionContext,
+    params: &PersonalDeductionParams,
+) -> Result<Vec<IncomeDeductionLine>, JLawError> {
+    Ok(vec![
+        calculate_basic_deduction(ctx, &params.basic)?,
+        calculate_spouse_deduction(ctx, &params.spouse)?,
+        calculate_dependent_deduction(ctx, &params.dependent)?,
+    ])
+}
+
+fn calculate_basic_deduction(
+    ctx: &IncomeDeductionContext,
+    params: &BasicDeductionParams,
+) -> Result<IncomeDeductionLine, JLawError> {
+    let bracket = params
+        .brackets
+        .iter()
+        .find(|bracket| matches_basic_bracket(ctx.total_income_amount, bracket))
+        .ok_or_else(|| CalculationError::PolicyNotApplicable {
+            reason: format!(
+                "総所得金額等 {}円 に対応する基礎控除ブラケットが見つかりません",
+                ctx.total_income_amount
+            ),
+        })?;
+
+    Ok(IncomeDeductionLine {
+        kind: IncomeDeductionKind::Basic,
+        label: "基礎控除".into(),
+        amount: FinalAmount::new(bracket.deduction_amount),
+    })
+}
+
+fn calculate_spouse_deduction(
+    ctx: &IncomeDeductionContext,
+    params: &SpouseDeductionParams,
+) -> Result<IncomeDeductionLine, JLawError> {
+    let Some(spouse) = ctx.deductions.personal.spouse else {
+        return Ok(zero_line(IncomeDeductionKind::Spouse, "配偶者控除"));
+    };
+
+    if !spouse.is_same_household
+        || spouse.spouse_total_income_amount > params.qualifying_spouse_income_max
+    {
+        return Ok(zero_line(IncomeDeductionKind::Spouse, "配偶者控除"));
+    }
+
+    let bracket = params
+        .taxpayer_income_brackets
+        .iter()
+        .find(|bracket| matches_spouse_bracket(ctx.total_income_amount, bracket))
+        .ok_or_else(|| CalculationError::PolicyNotApplicable {
+            reason: format!(
+                "総所得金額等 {}円 に対応する配偶者控除ブラケットが見つかりません",
+                ctx.total_income_amount
+            ),
+        })?;
+
+    let amount = if spouse.is_elderly {
+        bracket.elderly_deduction_amount
+    } else {
+        bracket.deduction_amount
+    };
+
+    Ok(IncomeDeductionLine {
+        kind: IncomeDeductionKind::Spouse,
+        label: "配偶者控除".into(),
+        amount: FinalAmount::new(amount),
+    })
+}
+
+fn calculate_dependent_deduction(
+    ctx: &IncomeDeductionContext,
+    params: &DependentDeductionParams,
+) -> Result<IncomeDeductionLine, JLawError> {
+    let dependent = ctx.deductions.personal.dependent;
+    let amount = multiply_count(
+        dependent.general_count,
+        params.general_deduction_amount,
+        "dependent_general",
+    )?
+    .checked_add(multiply_count(
+        dependent.specific_count,
+        params.specific_deduction_amount,
+        "dependent_specific",
+    )?)
+    .ok_or_else(|| CalculationError::Overflow {
+        step: "dependent_total".into(),
+    })?
+    .checked_add(multiply_count(
+        dependent.elderly_cohabiting_count,
+        params.elderly_cohabiting_deduction_amount,
+        "dependent_elderly_cohabiting",
+    )?)
+    .ok_or_else(|| CalculationError::Overflow {
+        step: "dependent_total".into(),
+    })?
+    .checked_add(multiply_count(
+        dependent.elderly_other_count,
+        params.elderly_other_deduction_amount,
+        "dependent_elderly_other",
+    )?)
+    .ok_or_else(|| CalculationError::Overflow {
+        step: "dependent_total".into(),
+    })?;
+
+    Ok(IncomeDeductionLine {
+        kind: IncomeDeductionKind::Dependent,
+        label: "扶養控除".into(),
+        amount: FinalAmount::new(amount),
+    })
+}
+
+fn matches_basic_bracket(income: u64, bracket: &BasicDeductionBracket) -> bool {
+    income >= bracket.income_from
+        && match bracket.income_to_inclusive {
+            Some(to) => income <= to,
+            None => true,
+        }
+}
+
+fn matches_spouse_bracket(income: u64, bracket: &SpouseIncomeBracket) -> bool {
+    income >= bracket.taxpayer_income_from
+        && match bracket.taxpayer_income_to_inclusive {
+            Some(to) => income <= to,
+            None => true,
+        }
+}
+
+fn multiply_count(count: u16, amount: u64, step: &'static str) -> Result<u64, JLawError> {
+    u64::from(count)
+        .checked_mul(amount)
+        .ok_or_else(|| CalculationError::Overflow { step: step.into() })
+        .map_err(JLawError::from)
+}
+
+fn zero_line(kind: IncomeDeductionKind, label: &'static str) -> IncomeDeductionLine {
+    IncomeDeductionLine {
+        kind,
+        label: label.into(),
+        amount: FinalAmount::new(0),
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::domains::income_tax::deduction::context::{
+        DependentDeductionInput, ExpenseDeductionInput, IncomeDeductionInput,
+        PersonalDeductionInput, SpouseDeductionInput,
+    };
+    use crate::domains::income_tax::deduction::params::{
+        BasicDeductionBracket, DependentDeductionParams, SpouseIncomeBracket,
+    };
+    use crate::types::date::LegalDate;
+
+    fn params() -> PersonalDeductionParams {
+        PersonalDeductionParams {
+            basic: BasicDeductionParams {
+                brackets: vec![
+                    BasicDeductionBracket {
+                        label: "2,400万円以下".into(),
+                        income_from: 0,
+                        income_to_inclusive: Some(24_000_000),
+                        deduction_amount: 480_000,
+                    },
+                    BasicDeductionBracket {
+                        label: "2,400万円超2,450万円以下".into(),
+                        income_from: 24_000_001,
+                        income_to_inclusive: Some(24_500_000),
+                        deduction_amount: 320_000,
+                    },
+                    BasicDeductionBracket {
+                        label: "2,450万円超2,500万円以下".into(),
+                        income_from: 24_500_001,
+                        income_to_inclusive: Some(25_000_000),
+                        deduction_amount: 160_000,
+                    },
+                    BasicDeductionBracket {
+                        label: "2,500万円超".into(),
+                        income_from: 25_000_001,
+                        income_to_inclusive: None,
+                        deduction_amount: 0,
+                    },
+                ],
+            },
+            spouse: SpouseDeductionParams {
+                qualifying_spouse_income_max: 480_000,
+                taxpayer_income_brackets: vec![
+                    SpouseIncomeBracket {
+                        label: "900万円以下".into(),
+                        taxpayer_income_from: 0,
+                        taxpayer_income_to_inclusive: Some(9_000_000),
+                        deduction_amount: 380_000,
+                        elderly_deduction_amount: 480_000,
+                    },
+                    SpouseIncomeBracket {
+                        label: "900万円超950万円以下".into(),
+                        taxpayer_income_from: 9_000_001,
+                        taxpayer_income_to_inclusive: Some(9_500_000),
+                        deduction_amount: 260_000,
+                        elderly_deduction_amount: 320_000,
+                    },
+                    SpouseIncomeBracket {
+                        label: "950万円超1000万円以下".into(),
+                        taxpayer_income_from: 9_500_001,
+                        taxpayer_income_to_inclusive: Some(10_000_000),
+                        deduction_amount: 130_000,
+                        elderly_deduction_amount: 160_000,
+                    },
+                    SpouseIncomeBracket {
+                        label: "1000万円超".into(),
+                        taxpayer_income_from: 10_000_001,
+                        taxpayer_income_to_inclusive: None,
+                        deduction_amount: 0,
+                        elderly_deduction_amount: 0,
+                    },
+                ],
+            },
+            dependent: DependentDeductionParams {
+                general_deduction_amount: 380_000,
+                specific_deduction_amount: 630_000,
+                elderly_cohabiting_deduction_amount: 580_000,
+                elderly_other_deduction_amount: 480_000,
+            },
+        }
+    }
+
+    fn ctx(
+        total_income_amount: u64,
+        spouse: Option<SpouseDeductionInput>,
+        dependent: DependentDeductionInput,
+    ) -> IncomeDeductionContext {
+        IncomeDeductionContext {
+            total_income_amount,
+            target_date: LegalDate::new(2024, 1, 1),
+            deductions: IncomeDeductionInput {
+                personal: PersonalDeductionInput { spouse, dependent },
+                expense: ExpenseDeductionInput {
+                    social_insurance_premium_paid: 0,
+                    medical: None,
+                    life_insurance: None,
+                    donation: None,
+                },
+            },
+        }
+    }
+
+    #[test]
+    fn basic_deduction_thresholds() {
+        let cases = [
+            (24_000_000, 480_000),
+            (24_000_001, 320_000),
+            (24_500_001, 160_000),
+            (25_000_001, 0),
+        ];
+
+        for (income, expected) in cases {
+            let result = calculate_personal_deductions(
+                &ctx(income, None, DependentDeductionInput::default()),
+                &params(),
+            )
+            .unwrap();
+            assert_eq!(result[0].amount.as_yen(), expected);
+        }
+    }
+
+    #[test]
+    fn spouse_deduction_thresholds() {
+        let cases = [
+            (9_000_000, 380_000),
+            (9_000_001, 260_000),
+            (9_500_001, 130_000),
+            (10_000_001, 0),
+        ];
+
+        for (income, expected) in cases {
+            let result = calculate_personal_deductions(
+                &ctx(
+                    income,
+                    Some(SpouseDeductionInput {
+                        spouse_total_income_amount: 480_000,
+                        is_same_household: true,
+                        is_elderly: false,
+                    }),
+                    DependentDeductionInput::default(),
+                ),
+                &params(),
+            )
+            .unwrap();
+            assert_eq!(result[1].amount.as_yen(), expected);
+        }
+    }
+
+    #[test]
+    fn dependent_deduction_aggregates_all_categories() {
+        let result = calculate_personal_deductions(
+            &ctx(
+                8_000_000,
+                None,
+                DependentDeductionInput {
+                    general_count: 1,
+                    specific_count: 1,
+                    elderly_cohabiting_count: 1,
+                    elderly_other_count: 1,
+                },
+            ),
+            &params(),
+        )
+        .unwrap();
+
+        assert_eq!(result[2].amount.as_yen(), 2_070_000);
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/income_tax/deduction/types.rs

@@ -0,0 +1,61 @@
+use crate::types::amount::FinalAmount;
+
+/// 所得控除の種別。
+///
+/// # 法的根拠
+/// 所得税法 各条項
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IncomeDeductionKind {
+    /// 基礎控除。
+    Basic,
+    /// 配偶者控除。
+    Spouse,
+    /// 扶養控除。
+    Dependent,
+    /// 社会保険料控除。
+    SocialInsurance,
+    /// 医療費控除。
+    Medical,
+    /// 生命保険料控除。
+    LifeInsurance,
+    /// 寄附金控除。
+    Donation,
+}
+
+/// 所得控除の内訳1行。
+///
+/// # 法的根拠
+/// 所得税法 各条項
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IncomeDeductionLine {
+    /// 控除種別。
+    pub kind: IncomeDeductionKind,
+    /// 内訳表示用ラベル。
+    pub label: String,
+    /// 控除額（円）。
+    pub amount: FinalAmount,
+}
+
+/// 所得控除の計算結果。
+///
+/// # 法的根拠
+/// 所得税法 第73条（医療費控除）
+/// 所得税法 第74条（社会保険料控除）
+/// 所得税法 第76条（生命保険料控除）
+/// 所得税法 第78条（寄附金控除）
+/// 所得税法 第83条（配偶者控除）
+/// 所得税法 第84条（扶養控除）
+/// 所得税法 第86条（基礎控除）
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IncomeDeductionResult {
+    /// 総所得金額等（円）。
+    pub total_income_amount: FinalAmount,
+    /// 所得控除額の合計（円）。
+    pub total_deductions: FinalAmount,
+    /// 1,000円未満切り捨て前の課税所得金額（円）。
+    pub taxable_income_before_truncation: FinalAmount,
+    /// 1,000円未満切り捨て後の課税所得金額（円）。
+    pub taxable_income: FinalAmount,
+    /// 所得控除の内訳。
+    pub breakdown: Vec<IncomeDeductionLine>,
+}

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

@@ -0,0 +1,24 @@
+pub mod assessment;
+pub mod calculator;
+pub mod context;
+pub mod deduction;
+pub mod params;
+pub mod policy;
+
+pub use assessment::{
+    calculate_income_tax_assessment, IncomeTaxAssessmentContext, IncomeTaxAssessmentResult,
+};
+pub use calculator::{calculate_income_tax, IncomeTaxResult, IncomeTaxStep};
+pub use context::{IncomeTaxContext, IncomeTaxFlag};
+pub use deduction::{
+    calculate_income_deductions, BasicDeductionBracket, BasicDeductionParams,
+    DependentDeductionInput, DependentDeductionParams, DonationDeductionInput,
+    DonationDeductionParams, ExpenseDeductionInput, ExpenseDeductionParams, IncomeDeductionContext,
+    IncomeDeductionInput, IncomeDeductionKind, IncomeDeductionLine, IncomeDeductionParams,
+    IncomeDeductionResult, LifeInsuranceDeductionBracket, LifeInsuranceDeductionInput,
+    LifeInsuranceDeductionParams, MedicalDeductionInput, MedicalDeductionParams,
+    PersonalDeductionInput, PersonalDeductionParams, SocialInsuranceDeductionParams,
+    SpouseDeductionInput, SpouseDeductionParams, SpouseIncomeBracket,
+};
+pub use params::{IncomeTaxBracket, IncomeTaxParams, ReconstructionTaxParams};
+pub use policy::StandardIncomeTaxPolicy;

data/vendor/rust/crates/j-law-core/src/domains/income_tax/params.rs

@@ -0,0 +1,109 @@
+/// 所得税の税率ブラケット（1段階分）。
+///
+/// # 法的根拠
+/// 所得税法 第89条第1項（税率表）
+#[derive(Debug, Clone)]
+pub struct IncomeTaxBracket {
+    /// ブラケットの表示名（例: "195万円以下"）。
+    pub label: String,
+    /// 課税所得金額の下限（円・この金額以上）。
+    pub income_from: u64,
+    /// 課税所得金額の上限（円・この金額以下）。`None` は上限なし。
+    pub income_to_inclusive: Option<u64>,
+    /// 税率の分子（例: 5% → numer=5）。
+    pub rate_numer: u64,
+    /// 税率の分母（例: 5% → denom=100）。
+    pub rate_denom: u64,
+    /// 控除額（円）。速算表の控除額。
+    ///
+    /// 速算表方式: 税額 = 課税所得金額 × 税率 - 控除額
+    pub deduction: u64,
+}
+
+/// 復興特別所得税のパラメータ。
+///
+/// # 法的根拠
+/// 東日本大震災からの復興のための施策を実施するために必要な財源の確保に関する特別措置法
+/// 第13条（復興特別所得税の税率）
+///
+/// 2013年〜2037年の各年分の基準所得税額に対して課税される。
+#[derive(Debug, Clone)]
+pub struct ReconstructionTaxParams {
+    /// 税率の分子（例: 2.1% → numer=21）。
+    pub rate_numer: u64,
+    /// 税率の分母（例: 2.1% → denom=1000）。
+    pub rate_denom: u64,
+    /// 適用開始年（含む）。
+    pub effective_from_year: u16,
+    /// 適用終了年（含む）。
+    pub effective_to_year_inclusive: u16,
+}
+
+/// 所得税計算に使うパラメータセット。
+///
+/// `j-law-registry` がJSONからロードしてこの型に変換する。
+/// `j-law-core` の計算ロジックはこの型のみに依存する。
+///
+/// # 法的根拠
+/// 所得税法 第89条第1項（税率表）
+#[derive(Debug, Clone)]
+pub struct IncomeTaxParams {
+    /// 税率ブラケットの一覧（課税所得金額の低い方から順に並ぶ）。
+    pub brackets: Vec<IncomeTaxBracket>,
+    /// 復興特別所得税のパラメータ（適用期間外の場合は `None`）。
+    pub reconstruction_tax: Option<ReconstructionTaxParams>,
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bracket_construction() {
+        let bracket = IncomeTaxBracket {
+            label: "195万円以下".into(),
+            income_from: 0,
+            income_to_inclusive: Some(1_950_000),
+            rate_numer: 5,
+            rate_denom: 100,
+            deduction: 0,
+        };
+        assert_eq!(bracket.rate_numer, 5);
+        assert_eq!(bracket.rate_denom, 100);
+        assert_eq!(bracket.deduction, 0);
+    }
+
+    #[test]
+    fn params_with_reconstruction_tax() {
+        let params = IncomeTaxParams {
+            brackets: vec![IncomeTaxBracket {
+                label: "195万円以下".into(),
+                income_from: 0,
+                income_to_inclusive: Some(1_950_000),
+                rate_numer: 5,
+                rate_denom: 100,
+                deduction: 0,
+            }],
+            reconstruction_tax: Some(ReconstructionTaxParams {
+                rate_numer: 21,
+                rate_denom: 1000,
+                effective_from_year: 2013,
+                effective_to_year_inclusive: 2037,
+            }),
+        };
+        assert_eq!(params.brackets.len(), 1);
+        let rt = params.reconstruction_tax.as_ref().unwrap();
+        assert_eq!(rt.rate_numer, 21);
+        assert_eq!(rt.rate_denom, 1000);
+    }
+
+    #[test]
+    fn params_without_reconstruction_tax() {
+        let params = IncomeTaxParams {
+            brackets: vec![],
+            reconstruction_tax: None,
+        };
+        assert!(params.reconstruction_tax.is_none());
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/income_tax/policy.rs

@@ -0,0 +1,103 @@
+use crate::domains::income_tax::context::IncomeTaxFlag;
+use crate::types::rounding::RoundingStrategy;
+use std::collections::HashSet;
+
+/// 所得税計算のポリシーインターフェース。
+///
+/// 端数処理戦略や復興特別所得税の適用判定ロジックを差し替えられるようにする。
+/// 通常は [`StandardIncomeTaxPolicy`] を使う。
+pub trait IncomeTaxPolicy: std::fmt::Debug {
+    /// 復興特別所得税を適用するかどうかを判定する。
+    fn should_apply_reconstruction_tax(
+        &self,
+        target_year: u16,
+        flags: &HashSet<IncomeTaxFlag>,
+    ) -> bool;
+
+    /// 速算表による税額計算に使う端数処理戦略。
+    ///
+    /// 所得税法上、課税所得金額 × 税率 の計算結果の端数処理。
+    fn tax_rounding(&self) -> RoundingStrategy;
+
+    /// 復興特別所得税額の端数処理戦略。
+    ///
+    /// 基準所得税額 × 2.1% の計算結果の端数処理。
+    fn reconstruction_tax_rounding(&self) -> RoundingStrategy;
+}
+
+/// 国税庁の標準解釈に基づく所得税計算ポリシー。
+///
+/// # 法的根拠
+/// 所得税法 第89条第1項（税率）
+/// 復興財源確保法 第13条（復興特別所得税の税率）
+/// 国税通則法 第119条第1項（税額の端数処理 — 100円未満切り捨て）
+#[derive(Debug, Clone, Copy)]
+pub struct StandardIncomeTaxPolicy;
+
+impl IncomeTaxPolicy for StandardIncomeTaxPolicy {
+    fn should_apply_reconstruction_tax(
+        &self,
+        target_year: u16,
+        flags: &HashSet<IncomeTaxFlag>,
+    ) -> bool {
+        (2013..=2037).contains(&target_year)
+            && flags.contains(&IncomeTaxFlag::ApplyReconstructionTax)
+    }
+
+    fn tax_rounding(&self) -> RoundingStrategy {
+        // 所得税額は100円未満切り捨て（国税通則法 第119条第1項）。
+        // ただし速算表の計算自体は整数演算で端数が出ないため、
+        // 万一端数が発生した場合の安全策として Floor を指定する。
+        RoundingStrategy::Floor
+    }
+
+    fn reconstruction_tax_rounding(&self) -> RoundingStrategy {
+        // 復興特別所得税額は1円未満切り捨て。
+        RoundingStrategy::Floor
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn policy() -> StandardIncomeTaxPolicy {
+        StandardIncomeTaxPolicy
+    }
+
+    fn flags_with_reconstruction() -> HashSet<IncomeTaxFlag> {
+        let mut flags = HashSet::new();
+        flags.insert(IncomeTaxFlag::ApplyReconstructionTax);
+        flags
+    }
+
+    #[test]
+    fn reconstruction_tax_within_period() {
+        let flags = flags_with_reconstruction();
+        assert!(policy().should_apply_reconstruction_tax(2024, &flags));
+        assert!(policy().should_apply_reconstruction_tax(2013, &flags));
+        assert!(policy().should_apply_reconstruction_tax(2037, &flags));
+    }
+
+    #[test]
+    fn reconstruction_tax_outside_period() {
+        let flags = flags_with_reconstruction();
+        assert!(!policy().should_apply_reconstruction_tax(2012, &flags));
+        assert!(!policy().should_apply_reconstruction_tax(2038, &flags));
+    }
+
+    #[test]
+    fn reconstruction_tax_without_flag() {
+        let flags = HashSet::new();
+        assert!(!policy().should_apply_reconstruction_tax(2024, &flags));
+    }
+
+    #[test]
+    fn rounding_strategies() {
+        assert_eq!(policy().tax_rounding(), RoundingStrategy::Floor);
+        assert_eq!(
+            policy().reconstruction_tax_rounding(),
+            RoundingStrategy::Floor
+        );
+    }
+}

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

@@ -0,0 +1,5 @@
+pub mod consumption_tax;
+pub mod income_tax;
+pub mod real_estate;
+pub mod stamp_tax;
+pub mod withholding_tax;