"""User configuration for Conservancy bookkeeping tools"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import configparser

import datetime

import decimal

import functools

import os

import re

import urllib.parse as urlparse

import requests.auth

import rt

from pathlib import Path

from typing import (

    Mapping,

    NamedTuple,

    Optional,

    Tuple,

    Type,

)

from . import books

from . import rtutil

class RTCredentials(NamedTuple):

    server: Optional[str] = None

    user: Optional[str] = None

    passwd: Optional[str] = None

    auth: Optional[str] = None

    @classmethod

    def from_env(cls) -> 'RTCredentials':

        values = dict(cls._field_defaults)

        for key in values:

            env_key = 'RT{}'.format(key.upper())

            try:

                values[key] = os.environ[env_key]

            except KeyError:

                pass

        return cls(**values)

    @classmethod

    def from_rtrc(cls) -> 'RTCredentials':

        values = dict(cls._field_defaults)

        rtrc_path = Path.home() / '.rtrc'

        try:

            with rtrc_path.open() as rtrc_file:

                for line in rtrc_file:

                    try:

                        key, value = line.split(None, 1)

                    except ValueError:

                        pass

                    else:

                        if key in values:

                            values[key] = value.rstrip('\n')

        except OSError:

            return cls()

    def __init__(self) -> None:

        self.file_config = configparser.ConfigParser()

        self.file_config.read_string("[Beancount]\n")

    def load_file(self, config_path: Optional[Path]=None) -> None:

        if config_path is None:

            config_path = self.config_file_path()

        with config_path.open() as config_file:

            self.file_config.read_file(config_file)

    def load_string(self, config_str: str) -> None:

        self.file_config.read_string(config_str)

    def _abspath(self, source: Mapping[str, str], key: str) -> Optional[Path]:

        try:

            retval = Path(source[key])

        except (KeyError, ValueError):

            ok = False

        else:

            if source is not os.environ:

                retval = retval.expanduser()

            ok = retval.is_absolute()

        return retval if ok else None

    def _dir_or_none(self, path: Path) -> Optional[Path]:

        try:

            path.mkdir(exist_ok=True)

        except OSError:

            return None

        else:

            return path

    def _path_from_environ(self, key: str, default: Optional[Path]=None) -> Path:

        retval = self._abspath(os.environ, key)

        if retval is None:

            retval = default or (Path.home() / self._ENVIRON_DEFAULT_PATHS[key])

        return retval

    def books_loader(self) -> Optional[books.Loader]:

        books_path = self.books_path()

        if books_path is None:

            return None

        else:

            return books.Loader(books_path, self.fiscal_year_begin())

    def books_path(self) -> Optional[Path]:

        return self._abspath(self.file_config['Beancount'], 'books dir')

    def cache_dir_path(self, name: str='conservancy_beancount') -> Optional[Path]:

        cache_root = self._path_from_environ('XDG_CACHE_HOME')

        return (

            self._dir_or_none(cache_root)

            and self._dir_or_none(cache_root / name)

        )

    def config_file_path(self, name: str='conservancy_beancount') -> Path:

        config_root = self._path_from_environ('XDG_CONFIG_HOME')

        return Path(config_root, name, 'config.ini')

    def fiscal_year_begin(self) -> books.FiscalYear:

        s = self.file_config.get('Beancount', 'fiscal year begin', fallback='3 1')

        match = re.match(r'([01]?[0-9])(?:\s*[-./ ]\s*([0-3]?[0-9]))?$', s.strip())

        if match is None:

            raise ValueError(f"fiscal year begin {s!r} has unknown format")

        try:

            month = int(match.group(1))

            day = int(match.group(2) or 1)

            # To check date validity we use an arbitrary year that's

            # 1. definitely using the modern calendar

            # 2. far enough in the past to not have books (pre-Unix epoch)

            # 3. not a leap year

            datetime.date(1959, month, day)

        except ValueError as e:

            raise ValueError(f"fiscal year begin {s!r} is invalid date: {e.args[0]}")

        else:

            return books.FiscalYear(month, day)

    def payment_threshold(self) -> decimal.Decimal:

        try:

            return decimal.Decimal(self.file_config['Beancount']['payment threshold'])

        except (KeyError, ValueError):

            return decimal.Decimal(10)

    def repository_path(self) -> Optional[Path]:

        retval = self._abspath(self.file_config['Beancount'], 'repository dir')

        if retval is None:

            retval = self._abspath(os.environ, 'CONSERVANCY_REPOSITORY')

        return retval

    def rt_credentials(self) -> RTCredentials:

        all_creds = zip(

            RTCredentials.from_env(),

            RTCredentials.from_rtrc(),

            RTCredentials(auth='rt'),

        )

        return RTCredentials._make(v0 or v1 or v2 for v0, v1, v2 in all_creds)

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    version='1.6.2',

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

        'rt>=2.0',

    ],

    setup_requires=[

        'pytest-mypy',

        'pytest-runner',  # Debian:python3-pytest-runner

    ],

    tests_require=[

        'mypy>=0.770',  # Debian:python3-mypy

        'pytest',  # Debian:python3-pytest

    ],

    packages=[

        'conservancy_beancount',

        'conservancy_beancount.plugin',

        'conservancy_beancount.reports',

    ],

    entry_points={

        'console_scripts': [

            'accrual-report = conservancy_beancount.reports.accrual:entry_point',

            'fund-report = conservancy_beancount.reports.fund:entry_point',

            'ledger-report = conservancy_beancount.reports.ledger:entry_point',

            'opening-balances = conservancy_beancount.tools.opening_balances:entry_point',

        ],

    },

)

"""Test Config class"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import contextlib

import decimal

import operator

import os

import re

from pathlib import Path

import pytest

from . import testutil

from conservancy_beancount import config as config_mod

RT_AUTH_METHODS = frozenset(['basic', 'gssapi', 'rt'])

RT_ENV_KEYS = (

    'RTSERVER',

    'RTUSER',

    'RTPASSWD',

    'RTAUTH',

)

RT_ENV_CREDS = (

    'https://example.org/envrt',

    'envuser',

    'env  password',

    'gssapi',

)

RT_FILE_CREDS = (

    'https://example.org/filert',

    'fileuser',

    'file  password',

    'basic',

)

RT_GENERIC_CREDS = config_mod.RTCredentials(

    'https://example.org/genericrt',

    'genericuser',

    'generic password',

    None,

)

@pytest.fixture

def rt_environ():

    return dict(zip(RT_ENV_KEYS, RT_ENV_CREDS))

def _update_environ(updates):

    for key, value in updates.items():

        if value is None:

            os.environ.pop(key, None)

        else:

            os.environ[key] = str(value)

    ('3 ', 3, 1),

    ('  4', 4, 1),

    (' 5 ', 5, 1),

    ('6 1', 6, 1),

    ('  06  03  ', 6, 3),

    ('6-05', 6, 5),

    ('06 - 10', 6, 10),

    ('6/15', 6, 15),

    ('06  /  20', 6, 20),

    ('10.25', 10, 25),

    (' 10 . 30 ', 10, 30),

])

def test_fiscal_year_begin(value, month, day):

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nfiscal year begin = {value}\n')

    assert config.fiscal_year_begin() == (month, day)

@pytest.mark.parametrize('value', [

    'text',

    '1900',

    '13',

    '010',

    '2 30',

    '4-31',

])

def test_bad_fiscal_year_begin(value):

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nfiscal year begin = {value}\n')

    with pytest.raises(ValueError):

        config.fiscal_year_begin()

def test_default_fiscal_year_begin():

    config = config_mod.Config()

    actual = config.fiscal_year_begin()

    assert actual.month == 3

    assert actual.day == 1

def test_books_loader():

    books_path = testutil.test_path('books')

    config = config_mod.Config()

    config.load_string(f'[Beancount]\nbooks dir = {books_path}\n')

    loader = config.books_loader()

    entries, errors, _ = loader.load_fy_range(2020, 2020)

    assert entries

    assert not errors

def test_books_loader_without_books():

    assert config_mod.Config().books_loader() is None