သမိုင်းဆိုသည်မှာ လူသားတို့၏ အတိတ်ကာလကို လေ့လာသော ဘာသာရပ်ဖြစ်သည်။ စာရေးသားခြင်းကို တီထွင်ပြီးသည့်နောက်တွင် သမိုင်းပေါ်ပေါက်လာခဲ့သည်ဟုလည်း ဆိုနိုင်သည်။ သမိုင်းကို ရေးသားသော ပညာရှင်များကို သမိုင်းပညာရှင်ဟု ခေါ်ဆိုလေ့ရှိကြသည်။ ၎င်းမှာ ပြန်ပြောင်းပြောဆိုချက်များကို အသုံးပြု၍ ဆက်တိုက်ဖြစ်ပျက် ခဲ့သော အဖြစ်အပျက်များကို စစ်ဆေးခြင်းနှင့် ခွဲခြမ်းစိတ်ဖြာခြင်း ပြုသော သုတေသန နယ်ပယ် ဖြစ်ကာ တစ်ခါတရံတွင် အကျိုးအကြောင်း ဆက်နွယ်၍ ဖြစ်ပျက်ခဲ့သော အဖြစ်အပျက်များကို ဓမ္မဓိဋ္ဌာန်ကျကျ စုံစမ်းစစ်ဆေးကာ ဆုံးဖြတ်သော ပညာရပ်ပင် ဖြစ်သည်။ သမိုင်းပညာရှင်များသည် သမိုင်း၏ သဘောသဘာဝ နှင့် အသုံးဝင်မှုတို့ကို ငြင်းခုံလေ့ ရှိကြသည်။

မြန်မာ့စွယ်စုံကျမ်းမှ သမိုင်း
သမိုင်းဟူသည်မှာ အတိတ်ကဖြစ်ရပ်များကိုလေ့လာမှတ်ကျောက်တင်ထားသောစာကိုဆိုလိုသည်။ ဘုရား၊ ဂူ၊ ကျောင်း၊ တန်ဆောင်း၊ စဆွံ၊ ဓမ္မသာလာ၊ တန်တား၊ ပုဂ္ဂိုလ်ထူး၊အကြောင်းအရာထူး စသည်တို့နှင့်စပ်လျဉ်း၍ စကားပြေဖြင့် ဖြစ်စေလင်္ကာဖြင့်ဖြစ်စေ စီကုံးရေးသားထားသည်များကိုသမိုင်းဟုခေါ်သည်။

အချို့ကလည်း သမိုင်းသည်သံပိုင်းနှင့်သဘောချင်းတူပြီးလျှင် သံပိုင်းမှသမ္ပိုင်း၊ သမိုင်းဖြစ်လာသည်ဟုဆိုကြသည်။ စကားပြေဖြင့်ရေးသားထားသော သမိုင်းများအကြောင်းကို အထူးမရေးသားတော့ဘဲ လင်္ကာစပ်ဆိုထားသောသမိုင်းရေးသားနည်းကိုဖော်ပြပေအံ့။ သမိုင်းလင်္ကာစပ်ဆိုရာ၌-
 လင်္ကာစပ်ဆိုနည်းများ အတိုင်းရေး သွားသည်။
 အစမှာဖြစ်စေ၊ အဆုံးမှာဖြစ်စေ သမိုင်းဟူသောစကား များသောအားဖြင့်ပါရှိတတ်သည်။

ပုံစံအားဖြင့်သမိုင်းတန်ဆောင်၊ ကမ္ပည်းဆောင်အံ့၊ ဉာဏ်ရောင်ဖြန့်ချိ၊နှိုင်းချိန်ညှိလော့၊လောကီအရာ စသည်ဖြင့် သမိုင်း လင်္ကာမှန်းသိအောင် သမိုင်းဆိုသည့်ပုဒ်ကို
ထည့်စပ်လေ့ရှိကြသည်။ သမိုင်းဟူသည့်ပုဒ်ကိုလင်္ကာ၏ အလယ်၌သမိုင်းမှန်းသိအောင်ထည့်သွင်းစပ်ဆိုသည်လည်းရှိသည်။ ပုံစံအားဖြင့်စစ်ကိုင်းမြို့ သမိုင်းလင်္ကာတွင်
 ရန်မာန်ပယ်ခိုင်း၊မြို့စစ်ကိုင်း၏၊သမိုင်းလင်္ကာ၊ ဂုဏ်ကိုးဖြာအား ဟူ၍လည်းကောင်း၊ ရှင်ပင်သက်တော်ရဘုရားသမိုင်းတွင် မင်္ဂလာ ထုံးဆောင်၊ကပ်လုံးပြောင်စိမ့်၊ အခေါင်သာနှိုင်း၊ တပေါင်လှိုင်း၍၊တိုင်းမြန်မာပြည်၊ သမိုင်းရှည်ဖြင့်၊ ငါးမည်အင်စုံ ဟူ၍လည်းကောင်း အသီးသီးစပ်ဆိုကြသည်။

အချို့သမိုင်းလင်္ကာစာကိုယ်များ၌မူ သမိုင်းဟူသောစာပုဒ်လုံးဝ မပါပဲလည်းရှိတတ်သည်။ ပုံစံအားဖြင့်ပုဂံပညာရှိမွန်း
ကိုဆိုပုဂံမြို့ရှိဂူဘုရားစဉ်သမိုင်းလင်္ကာ၌မဉ္ဇူဘုန်းတော်၊ သောင်း လုံးကျော်သည်၊ ထိပ်ပေါ်အထွတ်၊ရွှေနားညွတ်လော့၊ ရိမဒ်ပေါက္ကံ၊ တမ္ပဝတီ၊ သီရိပစ္စယာ၊ ပုဏ္ဏဂါမ၊ပုဂါမမည်၊ ဤငါးပြည်၌၊ ဆက်ရှည်စံပယ်၊ ငါးဆယ်နှင့်ငါး၊ နရဖျားတို့၊တည်ထားပြုစု၊ ကောင်းမှုစေ့မျိုး၊ကြဲစိုက်ပျိုးသည်၊ ပုထိုးစေတီ၊လက်ချောင်းစီသို့ရ၍ ဤဖွယ်တည့်၊ များစွာရှိလည်း၊ တွေ့မိသ၍၊ မစုံစေ့ခဲ့၊ ဘုန်းဟေ့နတ်လူ၊ဉာဏ်တံချူဖြင့်၊ ဆွတ်ယူစိမ့်ငှာ၊ထိပ်ချာတင်ရွက်၊ သီကုံးဆက်သည်၊ရွှေခွက်သောတာရုံဘုရားဟူ၍ဖြစ်သည်။

သမိုင်းမဝင်၊ စာမတင်
သမိုင်းမဝင်၊ စာမတင်၊ ရွာပင်မခေါ်ရ ဟူသော စကားတစ်ရပ် ရှိသည်။ မည်သည့်မြို့ မည်သည့်ရွာ ဖြစ်စေ သမိုင်း ခေါ် ဖြစ်စဉ်ကမူ ရှိမြဲဖြစ်သည်။ လူတို့က မသိ၍သာ မြုပ်ကွယ်နေမည်။ ဖြစ်စဉ်သမိုင်းကမူ ရွှံ့အိုင်အတွင်း၌ အနားယူနေသော ပတ္တမြား ရတနာသဖွယ် ဖြစ်ရာသည်။

သမိုင်း ဟူသော ဝေါဟာရကို မြန်မာဘာသာ စစ်စစ်ဟု ဆိုသူတို့က သမိုင်း (မိုင်း = ကြီးမား) သိဖွယ်ရာကြီး တစ်ရပ်ဟု အဓိပ္ပာယ်ဆိုသည်။ သမိုင်းဆိုလျင် သိရမည်။ သိအောင်ပြုရမည်ဟု ဆိုလိုသည်။

သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်သည်ဟု ဆိုသူတို့က သမုတိ ဟူသော ပုဒ်မှလည်းကောင်း၊ သမ္မုတိ ဟူသော ပုဒ်မှလည်းကောင်း ဖြစ်သည်ဟု ဆို၏။ သမုတိမှ သံ - မညတေတိ၊ သမုတိ၊ သမ္မုတိမှ သမ္မနနံ-သမ္မုတိ ဟု ဝိဂြိုဟ် အသီးသီးဆိုကာ - သံပုဗ္ဗ မနဓာတ်ဖြင့် ကောင်းစွာသိခြင်းကိုချည်း ပြသည်။ သို့သော် သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်ခြင်း မဟုတ်ဟု ယူဆကာ ပါဠိပညာရှင်များက သမုတိ၊ သမ္မုတိ များဖြင့် အဓိပ္ပာယ် မဖော်လိုကြပေ။ နာမည်ကျော် ပါဠိသက် အဘိဓာန်များကလည်း ယင်းကို လျစ်လျူရှုခဲ့ကြသည်။

သမိုင်းဟူသည် သိမှတ်ဖွယ်ရာ စာပေ, ကဗျာဖြစ်၍ မသိမဖြစ်၊ သိကိုသိရမည့်၊ မှတ်ကို မှတ်ရမည့် အကြောင်းအရာများပင် ဖြစ်သည်။ ဘုရားသမိုင်း၊ ကျောင်းသမိုင်း၊ မြို့သမိုင်း၊ ရွာသမိုင်း၊ လူ့သမိုင်း၊ အဖွဲ့အစည်းသမိုင်း၊ အသင်းအပင်းသမိုင်း၊ စာပေသမိုင်း စသည့် အဆောက်အအုံ မြို့ရွာ အရာဝတ္ထု အစုအစည်း အားလုံး၏ သိမှတ်ဖွယ်ရာ ရှေးအစူအစဉ်များပင် ဖြစ်ကြောင်း ထင်ရှားလှပါသည်။ ထို့ကြောင့် မြန်မာနိုင်ငံတွင် သမိုင်းဟူသည် မြန်မာစာပေ၌ အရေးကြီးသော အပိုင်းတစ်ပိုင်းအဖြစ် ပါဝင်လာရသည်။ မြန်မာစာပေအတွင်းမှ သမိုင်းဟူသည်ကို နုတ်လိုက်လျှင် လက်ကျန်အနည်းငယ်မျှသာ ကြွင်းကျန်လိမ့်မည်ဟု ယူဆရပေသည်။ သမိုင်းကိုလည်း မြန်မာစာပေမှ အဆီညှစ်၍ အနှစ်ကို ထုတ်ကာ ရွေးကောက်ရသည် ဖြစ်ရာ စာပေနှင့် သမိုင်းသည် မကင်းရာ မကင်းကြောင်းပင် ဖြစ်သည်။

သမိုင်းမဝင်၍ စာမတင်ခဲ့သလို၊ စာမတင်ခဲ့၍လည်း သမိုင်းဟူ၍ မဝင် မဖြစ်ပေါ်သည်လည်း ရှိသည်။ သမိုင်းဝင်ပါလျက် စာမတင်၍လည်း သမိုင်းအစပျောက်ကာ နောက်လူတို့ မသိမမြင်ကြရသည်ကလည်း ရှိပေသည်။ အမှန်အားဖြင့်ဆိုသော် ဤအချက်က ပို၍များ၏။ စာမတင်ခဲ့ရ၍ သမိုင်းမဖြစ်ခဲ့ရသည်မှာ မြန်မာနိုင်ငံတွင် ဒုနှင့်ဒေး အများအပြားဖြစ်၏။

ကိုးကား

သမိုင်း
ပင်မ အကြောင်းအရာ ဆောင်းပါးများ


eval_neutral.txt at the repository root is unchanged; this is a categorised copy carrying provenance

Dr. Ing. h.c. F. Porsche AG, kısaca Porsche AG veya sadece Porsche (okunuşu: Porşe) 1947 yılında Ferdinand Porsche'nın oğlu Ferry Porsche tarafından Stuttgart'ta kurulmuş olan spor araba firmasıdır.

İlk modelleri 1948 yılında çıkan Porsche 356'dır. Ferdinand Porsche 356 tasarımını yaparken oğluna yardım etmiş ve 1951 yılında ölmüştür.

1963 yılında araba yarışlarında müthiş başarılar elde edecek Porsche 911'i piyasaya sunarlar. 6 silindirli, arkadan motorlu bir spor arabasıdır ve rallilerde de büyük başarılar kazanır.

Bu süre içerisinde Volkswagen ile yakınlaşılır.  Şirketin %30,9'u Volkswagen'e aittir. Birçok projede ortaklaşa çalışmalarda bulunurlar. (1969 VW-Porsche 914, 1976 Porsche 924 (Audi bazı parçaları kullanmıştır) ve 2002 Porsche Cayenne (motoru da başta olmak üzere birçok teknik aksamı ve ergonomik çizgileri Volkswagen Touareg'de kullanılmıştır). 2003 yılında Ferdinand Porsche'nin torunu, Ferdinand Piech Volkswagen'in CEO'su olarak bu iki şirketin "ailesel" anlamda birleşmesini sağlamıştır. Porsche, 1950-1963 yılları arasında Porsche Traktör adıyla traktör, 1987-1989 yılları arasında uçak motorları üretmiştir.

Porsche LeMans'ı 16 kez kazanmış, Formula 1'de McLaren'in motorunu yaratmış, Paris Dakar Rallisi'nin de zirvedeki isimlerinden biri olmuştur.

Volkswagen AG, Porsche'nin %52,2 hissesini satın almıştır.

Seat, Daewoo ve Subaru başta olmak üzere birçok otomotiv firması danışman olarak Porsche firmasıyla anlaşma yapmışlardır.

Modelleri

Hâlen üretilmekte olan modeller
 Porsche Taycan (2019-Günümüz)
 Porsche 918 Spyder (2013-Günümüz)
 Porsche Boxster (1996-Günümüz)
 Porsche Cayman (2006-Günümüz)
 Porsche 911 (1964-Günümüz)
 Porsche Panamera (2010-Günümüz)
 Porsche Cayenne (2004-Günümüz)
 Porsche 911 GT3 (1998-Günümüz)
Üretimden Kaldırılmış Modeller
 Porsche 356 (1948-1965)
 Porsche 550 Spyder (1953-1957)
 Porsche 912 (1965-1969)
 Porsche 914 (1969-1975)
 Porsche 924 (1976-1988)
 Porsche 928 (1978-1995)
 Porsche 944 (1982-1991)
 Porsche 959 (1986-1988)
 Porsche 968 (1992-1995)
 Porsche Carrera GT (2004-2006)

Yarış modelleri
 Porsche 64
 Porsche 360 Cisitalia
 Porsche 550 Spyder
 Porsche 718
 Porsche 804
 Porsche 904
 Porsche 906
 Porsche 907
 Porsche 908
 Porsche 909 Bergspyder
 Porsche 910
 Porsche 911
 Porsche 911 GT1
 Porsche 911 GT2
 Porsche 911 GT3
 Porsche 914
 Porsche 917
 Porsche 918 RSR
 Porsche 934
 Porsche 935
 Porsche 936
 Porsche 924
 Porsche 944
 Porsche 956
 Porsche 959
 Porsche 961
 Porsche-March 89 P
 Porsche RS Spyder

Motor sporlarında Porsche
 14 Üreticiler ve Takımlar Dünya şampiyonluğu (1964, 1969, 1970, 1971, 1976, 1977, 1978, 1979, 1982, 1983, 1984, 1985, 1986, 1994)
 8 Uzun Mesafe Dünya Şampiyonluğu
 3 IMSA Supercar-Series (1991, 1992, 1993)
 6 Alman Yarış Şampiyonluğu (1977, 1979, 1982, 1983, 1984, 1985)
 20 Avrupa Tırmanış Şampiyonluğu
 20 Daytona 24 Saat Şampiyonluğu (1968, 1970, 1971, 1973, 1975, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1989, 1991, 1995, 2003)
 15 IMSA Supercar-Race (ABD)
 16 Le Mans 24 Saat (1970, 1971, 1976, 1977, 1979, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1994, 1996, 1997, 1998)
 17 Sebring 12 Saat (1960, 1968, 1971, 1973, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988)
 11 Targa Florio (1956, 1959, 1960, 1963, 1964, 1966, 1967, 1968, 1969, 1970, 1973)
 4 Rallye Monte Carlo (1968, 1969, 1970, 1978)
 2 Paris-Dakar Rallisi (1984, 1986)
 1 Formula 1 zaferi (1962 Fransa Grand Prix)

TAG-Porsche motorlu McLaren otomobilleri
 3 Formula 1 Pilotlar Dünya Şampiyonluğu (1984, 1985, 1986)
 2 Formula 1 üreticiler Dünya Şampiyonluğu (1984, 1985)
 25 Formula 1 zaferi (1984, 12 galibiyet; 1985, 6 galibiyet; 1986, 4 galibiyet; 1987, 3 galibiyet)

Notlar

Dış bağlantılar
 Resmî Porsche web sitesi (Birçok dilde)
 Porsche Türkiye

1947'de kurulan şirketler
Stuttgart
Baden-Württemberg'te ekonomi
Almanya merkezli otomotiv şirketleri
Otomobil markaları
Otomobil üreticileri
Traktör üreticileri
Volkswagen grubu
Alman markaları
Lüks markalar


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import re
from cpt.packager import ConanMultiPackager
from cpt.ci_manager import CIManager
from cpt.printer import Printer

class BuilderSettings(object):
    @property
    def username(self):
        """ Set catchorg as package's owner
        """
        return os.getenv("CONAN_USERNAME", "catchorg")

    @property
    def login_username(self):
        """ Set Bintray login username
        """
        return os.getenv("CONAN_LOGIN_USERNAME", "horenmar")

    @property
    def upload(self):
        """ Set Catch2 repository to be used on upload.
            The upload server address could be customized by env var
            CONAN_UPLOAD. If not defined, the method will check the branch name.
            Only devel or CONAN_STABLE_BRANCH_PATTERN will be accepted.
            The devel branch will be pushed to testing channel, because it does
            not match the stable pattern. Otherwise it will upload to stable
            channel.
        """
        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/catch2")

    @property
    def upload_only_when_stable(self):
        """ Force to upload when running over tag branch
        """
        return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "True").lower() in ["true", "1", "yes"]

    @property
    def stable_branch_pattern(self):
        """ Only upload the package the branch name is like a tag
        """
        return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+")

    @property
    def reference(self):
        """ Read project version from branch create Conan reference
        """
        return os.getenv("CONAN_REFERENCE", "catch2/{}".format(self._version))

    @property
    def channel(self):
        """ Default Conan package channel when not stable
        """
        return os.getenv("CONAN_CHANNEL", "testing")

    @property
    def _version(self):
        """ Get version name from cmake file
        """
        pattern = re.compile(r"project\(Catch2 LANGUAGES CXX VERSION (\d+\.\d+\.\d+)\)")
        version = "latest"
        with open("CMakeLists.txt") as file:
            for line in file:
                result = pattern.search(line)
                if result:
                    version = result.group(1)
        return version

    @property
    def _branch(self):
        """ Get branch name from CI manager
        """
        printer = Printer(None)
        ci_manager = CIManager(printer)
        return ci_manager.get_branch()

if __name__ == "__main__":
    settings = BuilderSettings()
    builder = ConanMultiPackager(
        reference=settings.reference,
        channel=settings.channel,
        upload=settings.upload,
        upload_only_when_stable=False,
        stable_branch_pattern=settings.stable_branch_pattern,
        login_username=settings.login_username,
        username=settings.username,
        test_folder=os.path.join(".conan", "test_package"))
    builder.add()
    builder.run()


log
===

A Rust library providing a lightweight logging *facade*.

[![Build status](https://img.shields.io/github/actions/workflow/status/rust-lang/log/main.yml?branch=master)](https://github.com/rust-lang/log/actions)
[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
![License](https://img.shields.io/crates/l/log.svg)

* [`log` documentation](https://docs.rs/log)

A logging facade provides a single logging API that abstracts over the actual
logging implementation. Libraries can use the logging API provided by this
crate, and the consumer of those libraries can choose the logging
implementation that is most suitable for its use case.

## Minimum supported `rustc`

See the `rust-version` field in `Cargo.toml` for the current minimum Rust toolchain version.

This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.

## Usage

### In libraries

Libraries should link only to the `log` crate, and use the provided macros to
log whatever information will be useful to downstream consumers:

```toml
[dependencies]
log = "0.4"
```

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    trace!("Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!("Razor located: {razor}");
                yak.shave(razor);
                break;
            }
            Err(err) => {
                warn!("Unable to locate a razor: {err}, retrying");
            }
        }
    }
}
```

### In executables

In order to produce log output, executables have to use a logger implementation compatible with the facade.
There are many available implementations to choose from, here are some options:

* Simple minimal loggers:
    * [`env_logger`](https://docs.rs/env_logger/*/env_logger/)
    * [`colog`](https://docs.rs/colog/*/colog/)
    * [`simple_logger`](https://docs.rs/simple_logger/*/simple_logger/)
    * [`simplelog`](https://docs.rs/simplelog/*/simplelog/)
    * [`pretty_env_logger`](https://docs.rs/pretty_env_logger/*/pretty_env_logger/)
    * [`stderrlog`](https://docs.rs/stderrlog/*/stderrlog/)
    * [`flexi_logger`](https://docs.rs/flexi_logger/*/flexi_logger/)
    * [`call_logger`](https://docs.rs/call_logger/*/call_logger/)
    * [`std-logger`](https://docs.rs/std-logger/*/std_logger/)
    * [`structured-logger`](https://docs.rs/structured-logger/latest/structured_logger/)
    * [`clang_log`](https://docs.rs/clang_log/latest/clang_log)
    * [`ftail`](https://docs.rs/ftail/latest/ftail/)
* Complex configurable frameworks:
    * [`log4rs`](https://docs.rs/log4rs/*/log4rs/)
    * [`logforth`](https://docs.rs/logforth/*/logforth/)
    * [`fern`](https://docs.rs/fern/*/fern/)
    * [`spdlog-rs`](https://docs.rs/spdlog-rs/*/spdlog/)
* Adaptors for other facilities:
    * [`syslog`](https://docs.rs/syslog/*/syslog/)
    * [`systemd-journal-logger`](https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/)
    * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
    * [`android_log`](https://docs.rs/android_log/*/android_log/)
    * [`win_dbg_logger`](https://docs.rs/win_dbg_logger/*/win_dbg_logger/)
    * [`db_logger`](https://docs.rs/db_logger/*/db_logger/)
    * [`log-to-defmt`](https://docs.rs/log-to-defmt/*/log_to_defmt/)
    * [`logcontrol-log`](https://docs.rs/logcontrol-log/*/logcontrol_log/)
* For WebAssembly binaries:
    * [`console_log`](https://docs.rs/console_log/*/console_log/)
* For dynamic libraries:
    * You may need to construct [an FFI-safe wrapper over `log`](https://github.com/rust-lang/log/issues/421) to initialize in your libraries.
* Utilities:
    * [`log_err`](https://docs.rs/log_err/*/log_err/)
    * [`log-reload`](https://docs.rs/log-reload/*/log_reload/)
    * [`alterable_logger`](https://docs.rs/alterable_logger/*/alterable_logger)
    * [`context-logger`](https://docs.rs/context-logger/*/context_logger)

Executables should choose a logger implementation and initialize it early in the
runtime of the program. Logger implementations will typically include a
function to do this. Any log messages generated before the logger is
initialized will be ignored.

The executable itself may use the `log` crate to log as well.

## Structured logging

If you enable the `kv` feature, you can associate structured data with your log records:

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    // `yak:serde` will capture `yak` using its `serde::Serialize` impl
    //
    // You could also use `:?` for `Debug`, or `:%` for `Display`. For a
    // full list, see the `log` crate documentation
    trace!(target = "yak_events", yak:serde; "Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!(razor; "Razor located");
                yak.shave(razor);
                break;
            }
            Err(e) => {
                // `e:err` will capture `e` using its `std::error::Error` impl
                warn!(e:err; "Unable to locate a razor, retrying");
            }
        }
    }
}
```


use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

#[cfg(feature = "std")]
use log::set_boxed_logger;
#[cfg(not(feature = "std"))]
fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), log::SetLoggerError> {
    log::set_logger(Box::leak(logger))
}

struct State {
    last_log: Mutex<Option<Level>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log.lock().unwrap() = Some(record.level());
    }

    fn flush(&self) {}
}

fn main() {
    let me = Arc::new(State {
        last_log: Mutex::new(None),
    });
    let a = me.clone();
    set_boxed_logger(Box::new(Logger(me))).unwrap();

    test(&a, LevelFilter::Off);
    test(&a, LevelFilter::Error);
    test(&a, LevelFilter::Warn);
    test(&a, LevelFilter::Info);
    test(&a, LevelFilter::Debug);
    test(&a, LevelFilter::Trace);
}

fn test(a: &State, filter: LevelFilter) {
    log::set_max_level(filter);
    error!("");
    last(&a, t(Level::Error, filter));
    warn!("");
    last(&a, t(Level::Warn, filter));
    info!("");
    last(&a, t(Level::Info, filter));

    debug!("");
    if cfg!(debug_assertions) {
        last(&a, t(Level::Debug, filter));
    } else {
        last(&a, None);
    }

    trace!("");
    last(&a, None);

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
}

fn last(state: &State, expected: Option<Level>) {
    let mut lvl = state.last_log.lock().unwrap();
    assert_eq!(*lvl, expected);
    *lvl = None;
}


from __future__ import annotations

import re
import sys

import pytest

import click
from click._compat import _ansi_re
from click._compat import strip_ansi
from click._compat import term_len
from click._textwrap import _truncate_visible

ESC = "\033"

# Inventory of every escape sequence Click itself emits. ``strip_ansi`` must
# keep removing all of them.
CLICK_EMITTED = [
    # SGR foreground/background, the basic 16 colors.
    f"{ESC}[30m",
    f"{ESC}[37m",
    f"{ESC}[40m",
    f"{ESC}[47m",
    # SGR 256-color and true-color (Click renders these with semicolons).
    f"{ESC}[38;5;200m",
    f"{ESC}[48;5;91m",
    f"{ESC}[38;2;255;12;128m",
    f"{ESC}[48;2;135;0;175m",
    # SGR attributes and their resets.
    f"{ESC}[1m",
    f"{ESC}[22m",
    f"{ESC}[4m",
    f"{ESC}[24m",
    f"{ESC}[53m",
    f"{ESC}[55m",
    f"{ESC}[9m",
    f"{ESC}[29m",
    # Reset-all appended by style().
    f"{ESC}[0m",
    # Screen clear and cursor home from click.clear().
    f"{ESC}[2J",
    f"{ESC}[1;1H",
    # Cursor hide/show around the progress bar.
    f"{ESC}[?25l",
    f"{ESC}[?25h",
]

# CSI sequences Click never emits but may receive from other tooling.
CSI_FOREIGN = [
    # Colon-delimited (ISO 8613-6) true-color and 256-color SGR.
    f"{ESC}[38:2:255:0:0m",
    f"{ESC}[38:5:200m",
    f"{ESC}[1;38:2::255:0:0m",  # empty colon field is a valid parameter
    # SGR mouse reporting (the ``<`` parameter byte is 0x3C).
    f"{ESC}[<0;30;40M",
    f"{ESC}[<0;30;40m",
    # Private-mode set/reset with a multi-digit parameter.
    f"{ESC}[?1049h",
    f"{ESC}[?1049l",
    # Cursor-shape select: an intermediate byte (space, 0x20) before final ``q``.
    f"{ESC}[0 q",
    f"{ESC}[2 q",
    # Set scrolling region: a non-``m`` letter final byte.
    f"{ESC}[1;24r",
    # Function-key / bracketed-paste codes ending in ``~`` (0x7E).
    f"{ESC}[3~",
    f"{ESC}[200~",
    # Empty parameter list (``ESC [ m`` is a valid reset).
    f"{ESC}[m",
]

# The previous pattern, kept here to prove the new one is a superset.
_LEGACY_ANSI_RE = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")

def test_is_jupyter_kernel_output():
    class JupyterKernelFakeStream:
        pass

    # implementation detail, aka cheapskate test
    JupyterKernelFakeStream.__module__ = "ipykernel.faked"
    assert click._compat._is_jupyter_kernel_output(stream=JupyterKernelFakeStream())

@pytest.mark.parametrize(
    "stream",
    [None, sys.stdin, sys.stderr, sys.stdout],
)
@pytest.mark.parametrize(
    ("color", "expected_override"),
    [
        (True, False),
        (False, True),
        (None, None),
    ],
)
@pytest.mark.parametrize(
    ("isatty", "is_jupyter", "expected"),
    [
        (True, False, False),
        (False, True, False),
        (False, False, True),
    ],
)
def test_should_strip_ansi(
    monkeypatch,
    stream,
    color: bool | None,
    expected_override: bool | None,
    isatty: bool,
    is_jupyter: bool,
    expected: bool,
) -> None:
    monkeypatch.setattr(click._compat, "isatty", lambda x: isatty)
    monkeypatch.setattr(
        click._compat, "_is_jupyter_kernel_output", lambda x: is_jupyter
    )

    if expected_override is not None:
        expected = expected_override
    assert click._compat.should_strip_ansi(stream=stream, color=color) == expected

@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_strip_ansi_removes_full_sequence(seq):
    """Every complete CSI sequence is stripped, alone or wrapped in text."""
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"
    assert term_len(f"a{seq}b") == 2

@pytest.mark.parametrize("final", ["m", "H", "J", "A", "z"])
@pytest.mark.parametrize("params", ["", "0", "1;2", ";", "?25", "0;0;0"])
def test_strip_ansi_is_superset_of_legacy(params, final):
    """Everything the legacy pattern stripped, the CSI grammar still strips."""
    seq = f"{ESC}[{params}{final}"
    assert _LEGACY_ANSI_RE.fullmatch(seq) is not None
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"

@pytest.mark.parametrize(
    ("text", "expected"),
    [
        (f"{ESC}[31mred{ESC}[0m", "red"),
        (f"a{ESC}[38:2:1:2:3mb{ESC}[0mc", "abc"),
        (f"{ESC}[?25l{ESC}[2Jhidden{ESC}[?25h", "hidden"),
        (f"{ESC}[<0;1;1Mclick{ESC}[<0;1;1m", "click"),
        # Several adjacent sequences around each visible character.
        (f"{ESC}[1m{ESC}[31mA{ESC}[0m {ESC}[32mB{ESC}[0m", "A B"),
        # Real terminal captures ported from the boltons strip_ansi tests.
        # ANSI art fragment (its doctest example).
        (f"{ESC}[0m{ESC}[1;36mart{ESC}[46;34m\xdc", "art\xdc"),
        # `ls` color output, ending on a dangling SGR with no text after it.
        (
            f"ls\r\n{ESC}[00m{ESC}[01;31mfile.zip{ESC}[00m\r\n{ESC}[01;31m",
            "ls\r\nfile.zip\r\n",
        ),
        # Tab-separated colorized fields.
        (f"\t{ESC}[0;35mIP{ESC}[0m\t{ESC}[0;36m192.1.0.2{ESC}[0m", "\tIP\t192.1.0.2"),
        # A styled cell inside a box-drawing table.
        (
            f"╒══════╕\n│ {ESC}[1mCell{ESC}[0m │\n╘══════╛",
            "╒══════╕\n│ Cell │\n╘══════╛",
        ),
        # Kaomoji with a bolded run.
        (f"(╯°□°)╯︵ {ESC}[1m┻━┻{ESC}[0m", "(╯°□°)╯︵ ┻━┻"),
    ],
)
def test_strip_ansi_mixed_content(text, expected):
    assert strip_ansi(text) == expected
    assert term_len(text) == len(expected)

def test_strip_ansi_stops_at_final_byte():
    """The match ends at the first final byte."""
    assert strip_ansi(f"{ESC}[31mX{ESC}[0mY") == "XY"
    assert strip_ansi(f"{ESC}[1m{ESC}[31mZ") == "Z"
    # The final ``m`` ends the sequence; the following ``;1m`` is plain text.
    assert strip_ansi(f"{ESC}[m;1m") == ";1m"

@pytest.mark.parametrize(
    "text",
    [
        "",
        "plain text",
        "100% [done]",
        "array[0] = 1",
        "a;b;c",
        # Looks like SGR parameters but lacks the ESC introducer.
        "[38;5;200m not an escape",
        "[0m",
    ],
)
def test_strip_ansi_leaves_plain_text(text):
    """Text that merely resembles an escape sequence is never stripped."""
    assert strip_ansi(text) == text
    assert term_len(text) == len(text)

@pytest.mark.parametrize(
    "text",
    [
        f"{ESC}",  # lone ESC
        f"{ESC}[",  # CSI introducer with no final byte
        f"{ESC}[31",  # parameters but no final byte
        f"{ESC}[38:2:1",  # colon parameters, truncated
        f"{ESC}[0 ",  # intermediate byte but no final byte
    ],
)
def test_strip_ansi_leaves_incomplete_sequences(text):
    """An unterminated sequence (missing its final byte) is left untouched."""
    assert strip_ansi(text) == text

def test_strip_ansi_is_idempotent():
    text = f"{ESC}[38:2:1:2:3mhi{ESC}[0m {ESC}[<0;1;1mthere{ESC}[?25h"
    once = strip_ansi(text)
    assert once == "hi there"
    assert strip_ansi(once) == once

@pytest.mark.parametrize(
    ("text", "visible"),
    [
        ("", 0),
        ("plain", 5),
        (f"{ESC}[31mred{ESC}[0m", 3),
        (f"{ESC}[38;2;1;2;3mrgb{ESC}[0m", 3),
        (f"{ESC}[38:2:1:2:3mrgb{ESC}[0m", 3),
        (f"{ESC}[<0;1;1Mx{ESC}[<0;1;1m", 1),
        (f"{ESC}[0 qq", 1),
        (f"{ESC}[?25lvisible{ESC}[?25h", 7),
        (f"{ESC}[1m{ESC}[4m{ESC}[31mhello{ESC}[0m", 5),
    ],
)
def test_term_len(text, visible):
    assert term_len(text) == visible

@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_ansi_re_matches_whole_sequence(seq):
    """``_ansi_re`` matches a complete sequence end to end as one token."""
    m = _ansi_re.match(seq)
    assert m is not None
    assert m.start() == 0
    assert m.end() == len(seq)

@pytest.mark.parametrize(
    ("text", "n", "expected"),
    [
        # No escapes: behaves like a plain prefix slice.
        ("abcdef", 3, "abc"),
        ("abc", 10, "abc"),
        ("abc", 0, ""),
        ("abc", -1, ""),
        # A leading escape is kept and does not count toward the budget.
        (f"{ESC}[31mabcdef{ESC}[0m", 3, f"{ESC}[31mabc"),
        # A colon true-color escape stays intact; the cut lands after 3 chars.
        (f"{ESC}[38:2:1:2:3mabcdef", 3, f"{ESC}[38:2:1:2:3mabc"),
        # A trailing escape past the cut is not pulled in.
        (f"{ESC}[31mabc{ESC}[0m", 3, f"{ESC}[31mabc"),
    ],
)
def test_truncate_visible(text, n, expected):
    out = _truncate_visible(text, n)
    assert out == expected
    assert term_len(out) <= max(n, 0)


# Advanced Groups and Context

```{currentmodule} click
```

In addition to the capabilities covered in the previous section, Groups have
more advanced capabilities that leverage the Context.

```{contents}
---
depth: 1
local: true
---
```

## Callback Invocation

For a regular command, the callback is executed whenever the command runs.
If the script is the only command, it will always fire (unless a parameter
callback prevents it.  This for instance happens if someone passes
`--help` to the script).

For groups, the situation looks different. In this case, the callback fires
whenever a subcommand fires.  What this means in practice is that an outer
command runs when an inner command runs:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    def cli(debug):
        click.echo(f"Debug mode is {'on' if debug else 'off'}")

    @cli.command()  # @cli, not @click!
    def sync():
        click.echo('Syncing')

Here is what this looks like:

.. click:run::

    invoke(cli, prog_name='tool.py')
    println()
    invoke(cli, prog_name='tool.py', args=['--debug', 'sync'])
```

## Nested Handling and Contexts

As you can see from the earlier example, the basic command group accepts a
debug argument which is passed to its callback, but not to the sync
command itself.  The sync command only accepts its own arguments.

This allows tools to act completely independent of each other, but how
does one command talk to a nested one?  The answer to this is the
{class}`Context`.

Each time a command is invoked, a new context is created and linked with the
parent context.  Normally, you can't see these contexts, but they are
there.  Contexts are passed to parameter callbacks together with the
value automatically.  Commands can also ask for the context to be passed
by marking themselves with the {func}`pass_context` decorator.  In that
case, the context is passed as first argument.

The context can also carry a program specified object that can be
used for the program's purposes.  What this means is that you can build a
script like this:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    @click.pass_context
    def cli(ctx, debug):
        # ensure that ctx.obj exists and is a dict (in case `cli()` is called
        # by means other than the `if` block below)
        ctx.ensure_object(dict)

        ctx.obj['DEBUG'] = debug

    @cli.command()
    @click.pass_context
    def sync(ctx):
        click.echo(f"Debug is {'on' if ctx.obj['DEBUG'] else 'off'}")

    if __name__ == '__main__':
        cli(obj={})
```

If the object is provided, each context will pass the object onwards to
its children, but at any level a context's object can be overridden.  To
reach to a parent, `context.parent` can be used.

In addition to that, instead of passing an object down, nothing stops the
application from modifying global state.  For instance, you could just flip
a global `DEBUG` variable and be done with it.

## Decorating Commands

As you have seen in the earlier example, a decorator can change how a
command is invoked.  What actually happens behind the scenes is that
callbacks are always invoked through the {meth}`Context.invoke` method
which automatically invokes a command correctly (by either passing the
context or not).

This is very useful when you want to write custom decorators.  For
instance, a common pattern would be to configure an object representing
state and then storing it on the context and then to use a custom
decorator to find the most recent object of this sort and pass it as first
argument.

For instance, the {func}`pass_obj` decorator can be implemented like this:

```{eval-rst}
.. click:example::

    from functools import update_wrapper

    def pass_obj(f):
        @click.pass_context
        def new_func(ctx, *args, **kwargs):
            return ctx.invoke(f, ctx.obj, *args, **kwargs)
        return update_wrapper(new_func, f)
```

The {meth}`Context.invoke` command will automatically invoke the function
in the correct way, so the function will either be called with`f(ctx,
obj)` or `f(obj)` depending on whether or not it itself is decorated with
{func}`pass_context`.

This is a very powerful concept that can be used to build very complex
nested applications; see {ref}`complex-guide` for more information.

(command-chaining)=

## Command Chaining

It is useful to invoke more than one subcommand in one call. For example,
`my-app validate build upload` would invoke `validate`, then `build`, then
`upload`. To implement this, pass `chain=True` when creating a group.

```{eval-rst}
.. click:example::

    @click.group(chain=True)
    def cli():
        pass

    @cli.command('validate')
    def validate():
        click.echo('validate')

    @cli.command('build')
    def build():
        click.echo('build')

You can invoke it like this:

.. click:run::

    invoke(cli, prog_name='my-app', args=['validate', 'build'])
```

When using chaining, there are a few restrictions:

- Only the last command may use `nargs=-1` on an argument, otherwise the
  parser will not be able to find further commands.
- It is not possible to nest groups below a chain group.
- On the command line, options must be specified before arguments for each
  command in the chain.
- The {attr}`Context.invoked_subcommand` attribute will be `'*'` because the
  parser doesn't know the full list of commands that will run yet.

(command-pipelines)=

## Command Pipelines

When using chaining, a common pattern is to have each command process the
result of the previous command.

A straightforward way to do this is to use {func}`make_pass_decorator` to pass
a context object to each command, and store and read the data on that object.

```{eval-rst}
.. click:example::

    pass_ns = click.make_pass_decorator(dict, ensure=True)

    @click.group(chain=True)
    @click.argument("name")
    @pass_ns
    def cli(ns, name):
        ns["name"] = name

    @cli.command
    @pass_ns
    def lower(ns):
        ns["name"] = ns["name"].lower()

    @cli.command
    @pass_ns
    def show(ns):
        click.echo(ns["name"])

.. click:run::

    invoke(cli, prog_name="process", args=["Click", "show", "lower", "show"])
```

Another way to do this is to collect data returned by each command, then process
it at the end of the chain. Use the group's {meth}`~Group.result_callback`
decorator to register a function that is called after the chain is finished. It
is passed the list of return values as well as any parameters registered on the
group.

A command can return anything, including a function. Here's an example of that,
where each subcommand creates a function that processes the input, then the
result callback calls each function. The command takes a file, processes each
line, then outputs it. If no subcommands are given, it outputs the contents
of the file unchanged.

```python
@click.group(chain=True, invoke_without_command=True)
@click.argument("fin", type=click.File("r"))
def cli(fin):
    pass

@cli.result_callback()
def process_pipeline(processors, fin):
    iterator = (x.rstrip("\r\n") for x in input)

    for processor in processors:
        iterator = processor(iterator)

    for item in iterator:
        click.echo(item)

@cli.command("upper")
def make_uppercase():
    def processor(iterator):
        for line in iterator:
            yield line.upper()
    return processor

@cli.command("lower")
def make_lowercase():
    def processor(iterator):
        for line in iterator:
            yield line.lower()
    return processor

@cli.command("strip")
def make_strip():
    def processor(iterator):
        for line in iterator:
            yield line.strip()
    return processor
```

That's a lot in one go, so let's go through it step by step.

1. The first thing is to make a {func}`group` that is chainable.  In
   addition to that we also instruct Click to invoke even if no
   subcommand is defined.  If this would not be done, then invoking an
   empty pipeline would produce the help page instead of running the
   result callbacks.
2. The next thing we do is to register a result callback on our group.
   This callback will be invoked with an argument which is the list of
   all return values of all subcommands and then the same keyword
   parameters as our group itself.  This means we can access the input
   file easily there without having to use the context object.
3. In this result callback we create an iterator of all the lines in the
   input file and then pass this iterator through all the returned
   callbacks from all subcommands and finally we print all lines to
   stdout.

After that point we can register as many subcommands as we want and each
subcommand can return a processor function to modify the stream of lines.

One important thing of note is that Click shuts down the context after
each callback has been run.  This means that for instance file types
cannot be accessed in the `processor` functions as the files will already
be closed there.  This limitation is unlikely to change because it would
make resource handling much more complicated.  For such it's recommended
to not use the file type and manually open the file through
{func}`open_file`.

For a more complex example that also improves upon handling of the pipelines,
see the [imagepipe example](https://github.com/pallets/click/tree/main/examples/imagepipe)
in the Click repository. It implements a pipeline based image editing tool
that has a nice internal structure.

## Overriding Defaults

By default, the default value for a parameter is pulled from the
`default` flag that is provided when it's defined, but that's not the
only place defaults can be loaded from.  The other place is the
{attr}`Context.default_map` (a dictionary) on the context.  This allows
defaults to be loaded from a configuration file to override the regular
defaults.

This is useful if you plug in some commands from another package but
you're not satisfied with the defaults.

The default map can be nested arbitrarily for each subcommand:

```python

    default_map = {
        "debug": True,  # default for a top level option
        "runserver": {"port": 5000}  # default for a subcommand
    }
```

The default map can be provided when the script is invoked, or
overridden at any point by commands. For instance, a top-level command
could load the defaults from a configuration file.

Example usage:

```{eval-rst}
.. click:example::

    import click

    @click.group()
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli(default_map={
            'runserver': {
                'port': 5000
            }
        })

And in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'], default_map={
        'runserver': {
            'port': 5000
        }
    })
```

### Multi-value parameters

When a `default_map` value is a string for a parameter with `nargs > 1` or a
{class}`Tuple` type, the string is split automatically, the same way an
environment variable would be. By default, values are split on whitespace. See
[Multiple Options from Environment
Values](options.md#multiple-options-from-environment-values) for details on
splitting behavior.

```python
default_map = {
    "draw": {
        "point": "3 4",  # split into ("3", "4") for nargs=2
        "color": "red",  # passed as-is for nargs=1
    }
}
```

You can also pass an already-structured tuple or list, which will be used as-is
without splitting:

```python
default_map = {
    "draw": {
        "point": (3, 4),  # used directly
    }
}
```

## Context Defaults

```{versionadded} 2.0
```

Starting with Click 2.0 you can override defaults for contexts not just
when calling your script, but also in the decorator that declares a
command.  For instance given the previous example which defines a custom
`default_map` this can also be accomplished in the decorator now.

This example does the same as the previous example:

```{eval-rst}
.. click:example::

    import click

    CONTEXT_SETTINGS = dict(
        default_map={'runserver': {'port': 5000}}
    )

    @click.group(context_settings=CONTEXT_SETTINGS)
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli()

And again the example in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'])
```

## Command Return Values

```{versionadded} 3.0
```

One of the new introductions in Click 3.0 is the full support for return
values from command callbacks.  This enables a whole range of features
that were previously hard to implement.

In essence any command callback can now return a value.  This return value
is bubbled to certain receivers.  One usecase for this has already been
show in the example of {ref}`command-chaining` where it has been
demonstrated that chained groups can have callbacks that process
all return values.

When working with command return values in Click, this is what you need to
know:

- The return value of a command callback is generally returned from the
  {meth}`Command.invoke` method.  The exception to this rule has to
  do with {class}`Group`s:

  - In a group the return value is generally the return value of the
    subcommand invoked.  The only exception to this rule is that the
    return value is the return value of the group callback if it's
    invoked without arguments and `invoke_without_command` is enabled.
  - If a group is set up for chaining then the return value is a list
    of all subcommands' results.
  - Return values of groups can be processed through a
    {attr}`Group.result_callback`.  This is invoked with the
    list of all return values in chain mode, or the single return
    value in case of non chained commands.

- The return value is bubbled through from the {meth}`Context.invoke`
  and {meth}`Context.forward` methods.  This is useful in situations
  where you internally want to call into another command.

- Click does not have any hard requirements for the return values and
  does not use them itself.  This allows return values to be used for
  custom decorators or workflows (like in the command chaining
  example).

- When a Click script is invoked as command line application (through
  {meth}`Command.main`) the return value is ignored unless the
  `standalone_mode` is disabled in which case it's bubbled through.


#![allow(dead_code, unused_imports)]

use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

struct State {
    last_log_level: Mutex<Option<Level>>,
    last_log_location: Mutex<Option<u32>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log_level.lock().unwrap() = Some(record.level());
        *self.0.last_log_location.lock().unwrap() = record.line();
    }
    fn flush(&self) {}
}

#[test]
fn test_integration() {
    // These tests don't really make sense when static
    // max level filtering is applied
    #[cfg(not(any(
        feature = "max_level_off",
        feature = "max_level_error",
        feature = "max_level_warn",
        feature = "max_level_info",
        feature = "max_level_debug",
        feature = "max_level_trace",
        feature = "release_max_level_off",
        feature = "release_max_level_error",
        feature = "release_max_level_warn",
        feature = "release_max_level_info",
        feature = "release_max_level_debug",
        feature = "release_max_level_trace",
    )))]
    {
        let me = Arc::new(State {
            last_log_level: Mutex::new(None),
            last_log_location: Mutex::new(None),
        });
        let a = me.clone();
        let logger = Logger(me);

        test_filter(&logger, &a, LevelFilter::Off);
        test_filter(&logger, &a, LevelFilter::Error);
        test_filter(&logger, &a, LevelFilter::Warn);
        test_filter(&logger, &a, LevelFilter::Info);
        test_filter(&logger, &a, LevelFilter::Debug);
        test_filter(&logger, &a, LevelFilter::Trace);

        test_line_numbers(&logger, &a);
    }
}

fn test_filter(logger: &dyn Log, a: &State, filter: LevelFilter) {
    // tests to ensure logs with a level beneath 'max_level' are filtered out
    log::set_max_level(filter);
    error!(logger: logger, "");
    last(a, t(Level::Error, filter));
    warn!(logger: logger, "");
    last(a, t(Level::Warn, filter));
    info!(logger: logger, "");
    last(a, t(Level::Info, filter));
    debug!(logger: logger, "");
    last(a, t(Level::Debug, filter));
    trace!(logger: logger, "");
    last(a, t(Level::Trace, filter));

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
    fn last(state: &State, expected: Option<Level>) {
        let lvl = state.last_log_level.lock().unwrap().take();
        assert_eq!(lvl, expected);
    }
}

fn test_line_numbers(logger: &dyn Log, state: &State) {
    log::set_max_level(LevelFilter::Trace);

    info!(logger: logger, ""); // ensure check_line function follows log macro
    check_log_location(state);

    #[track_caller]
    fn check_log_location(state: &State) {
        let location = std::panic::Location::caller().line(); // get function calling location
        let line_number = state.last_log_location.lock().unwrap().take().unwrap(); // get location of most recent log
        assert_eq!(line_number, location - 1);
    }
}


Sa
Ferdinand von Saar (1833–1906)
Umberto Saba (1883–1957)
Robert Sabatier (1923–2012)
Ernesto Sabato (1911–2011)
Rolf D. Sabel (* 1949)
Martin Sabrow (* 1954)
Mário de Sá-Carneiro (1890–1916)
Leopold von Sacher-Masoch (1836–1895)
Hans Sachs (1494–1576)
Nelly Sachs (1891–1970)
Jonathan Sacks (1948–2020)
Oliver Sacks (1933–2015)
Vita Sackville-West (1892–1962)
Donatien-Alphonse-François, Marquis de Sade (1740–1814)
Abu’Abdellah Mosharrefo’d–Din ben Mosleho’d–Din Sa’di (zwischen 1213 und 1219 – 1292)
Douglas Sadownick (* 1959)
Rüdiger Safranski (* 1945)
Carl Sagan (1934–1996)
Françoise Sagan (1935–2004)
Hans Sahl (1902–1993)
Marshall Sahlins (1930–2021)
Edward Said (1935–2003)
SAID (1947–2021)
Angela Saini (* 1980)
Assoto Saint (1957–1994)
Antoine de Saint-Exupéry (1900–1944)
At-Tayyib Salih (1929–2009)
J. D. Salinger (1919–2010)
James Sallis (* 1944)
Sally Salminen (1906–1976)
Ernst von Salomon (1902–1972)
Sallust (86–35 v. Chr.)
Felix Salten (1869–1945)
James Salter (1925–2015)
Gaston Salvatore (1941–2015), CL / D
R. A. Salvatore (* 1959)
Lydie Salvayre (* 1948), FR
Jewgenij Samjatin (1884–1937)
Jeffrey L. Sammons (1936–2021), US
José Luis Sampedro (1917–2013), ES
Clara Sánchez (* 1955), ES
Rafael Sánchez Ferlosio (1927–2019), ES
George Sand (1804–1876)
Margit Sandemo (1924–2018)
Gregor Sander (* 1968)
Maurice-Yves Sandoz (1892–1958), CH
Cícero Sandroni (* 1935), BR
Edoardo Sanguineti (1930–2010)
Eric San Juan (* 1973), US
José Saramago (1922–2010)
Stephan Sarek (* 1957), D
Ken Saro-Wiwa (1941–1995)
William Saroyan (1908–1981)
Nathalie Sarraute (1900–1999), FR
Joseba Sarrionandia (* 1958)
Andrew Sarris (1928–2012), US
Joachim Sartorius (* 1946)
Jean-Paul Sartre (1905–1980)
Saskia Sassen (* 1949)
Alfonso Sastre (1926–2021), E
John Saul (* 1942)
Annie Saumont (1927–2017)
Dan Savage (* 1964)
Jon Savage (* 1953)
Richard Henry Savage (1846–1903)
Walter Savage Landor (1775–1864)
Sam Savage (1940–2019)
Roberto Saviano (* 1979)
Alberto Savinio (1891–1952)
Dorothy L. Sayers (1893–1957)
Şara Sayın (1926–2017)
Steven Saylor (* 1956)

Sc
Giorgio Scerbanenco (1911–1969)
Andrea Schacht (1956–2017)
Carlo Schäfer (1964–2015)
Rafik Schami (* 1946)
Sydney Schanberg (1934–2016)
Frieda Schanz (1859–1944)
Frank Schätzing (* 1957), D
Karl Herbert Scheer
Paul Scheerbart (1863–1915)
Leopold Schefer (1784–1862)
Joseph Victor von Scheffel (1826–1886)
Ursel Scheffler (* 1938), D
Wolfgang Scheffler (1929–2008), D
Susanne Scheibler
Jonathan Schell (1943–2014), US
Peter Schellenbaum (1939–2018), CH
Bernardin Schellenberger (* 1944), D
Caroline Schelling (1763–1809)
Friedrich Schelling (1775–1854)
Andreas Schendel (* 1971), D
Daniela Schenk (* 1964), CH
Johannes Schenk (1941–2006)
Joan Schenkar (* 1952), USA
Max von Schenkendorf (1783–1817)
Walter Schenker (1943–2018)
Karl Adolf Scherer (1929–2008)
Marie-Luise Scherer (1938–2022), D
René Schérer (1922–2023), FR
Ronald M. Schernikau (1960–1991), D
Manfred Scheuch (1929–2016), AT
Mario Scheuermann (1948–2015), D
Christian Scheuß (* 1966), D
Jakob van Schevichaven (1866–1935)
Taras Grigorjewitsch Schewtschenko (1814–1861)
Alfred Schickel (1933–2015)
Gotthard B. Schicker (1946–2017)
Claudia Beate Schill (1952–2022)
Friedrich Schiller (1759–1805)
Helmut Schiller (* 1938), D
Lawrence Schimel (* 1971), US
Jochen Schimmang (* 1948)
Annemarie Schimmel (1922–2003)
Roland Schimmelpfennig (* 1967)
Ferdinand von Schirach (* 1964)
Frank Schirrmacher (1959–2014)
Wolfgang Schivelbusch (1941–2023)
Peter Schjeldahl (1942–2022)
Johannes Schlaf (1862–1941)
Evelyn Schlag (* 1952)
Einar Schleef (1944–2001)
August Wilhelm Schlegel (1767–1845)
Dorothea von Schlegel (1763–1839)
Friedrich von Schlegel (1772–1829)
Johann Elias Schlegel (1719–1749)
Carl Ludwig Schleich (1859–1922)
Friedrich Schleiermacher (1768–1834)
Klaus Schlesinger (1937–2001)
Christoph Schlingensief (1960–2010), D
Bernhard Schlink (* 1944), D
Joachim Schlör (* 1960), D
Andreas Schlüter (* 1958)
Ann-Helena Schlüter
Herman Schmalenbach (1885–1950), D
Werner Schmalenbach (1920–2010), D/CH
Dagmar Isabell Schmidbauer (* 1962), D
Wolfgang Schmidbauer (* 1941), D
Alfred Schmidt (1931–2012), D
Arno Schmidt (1914–1979), D
Christian Schmidt (1980), D
Helmut Schmidt (1918–2015), D
Helwig Schmidt-Glintzer (* 1948), D
Kathrin Schmidt (* 1958), D
Rudolf Schmidt (1875–1943), D
Wendelin Schmidt-Dengler (1942–2008), AT
Gerhard Schmidtchen (1925–2022), D
Wieland Schmied (1929–2014), AT
Marion Schmitt (* 1959)
Philipp Schmitz (1935–2015)
Johann Gottfried Schnabel (1692–1744/1748)
Siegfried Schnabl (1927–2015), D
Friedrich Schnack (1888–1977)
Harald Schneider (* 1962)
Karla Schneider (* 1938), D
Peter Schneider (* 1940), D
Reinhold Schneider (1903–1958), D
Wolfgang Schneider (1938–2003), D
Robert Wolfgang Schnell (1916–1986), D
Helmut Schnelle (1932–2015), D
Arthur Schnitzler (1862–1931), AT
Wolfdietrich Schnurre (1920–1989), D
Axel Schock (* 1965), D
Wilfried F. Schoeller (1941–2020), D
Christel Schöllhammer (* 1938), D
Peter Schoenen (1952–2014), D
Sigmar Schollak (1930–2012), D
Peter Scholl-Latour (1924–2014), D/FR
Eike Schönfeld (* 1949), D
Dietmar Schönherr (1926–2014)
Johannes Schönherr (1894–1961)
Karl Schönherr (1867–1943)
Katja Schönherr (* 1982)
Renate Schoof (* 1950) D
Adele Schopenhauer (1797–1849)
Arthur Schopenhauer (1788–1860)
Roberto Schopflocher (1923–2016)
Eberhard Schorsch (1935–1991)
Carl E. Schorske (1915–2015), US
Claudia Schoppmann (* 1958), D
Justus Georg Schottelius (1612–1676)
Julie Schrader (1881–1939), D
Daniel Schreiber (* 1977), D
Hermann Schreiber (1920–2014)
Hermann Schreiber (1929–2020)
Jürgen Schreiber (1947–2022), D
Karl-Heinz Schreiber (1949–2014)
Klaus Peter Schreiner (1930–2017), D
Peter Schreiner (* 1953), D
Angelika Schrobsdorff (1927–2016)
Rudolf Alexander Schröder (1878–1962), D
Willy Schrödter (1878–1971)
Raoul Schrott (* 1964), AT
Jürg Schubiger (1936–2014), CH
Bernd Schuh (* 1948), D
Jean-Jacques Schuhl (* 1941), FR
Herbert Schui (1940–2016), D
Budd Schulberg (1914–2009), US
Herbert Schuldt (* 1941)
Horst Schüler-Springorum (1928–2015), D
Sarah Schulman (* 1958), US
Bruno Schulz (1892–1942), PL
Frank Schulz (* 1957), D
Franz Schulz (1897–1971), AT/US
Hagen Schulze (1943–2014), D
Micha Schulze (* 1967), D
Hans-Eugen Schulze (1922–2013), D
Ingo Schulze (* 1962), D
Dirk Schümer (* 1962), D
Romy Schurhammer (1936–2019), D
Maik T. Schurkus (* 1970), D
Wolfram Schütte (* 1939), D
Silke Schütze (* 1961), D
Stephan Schütze (1771–1839), D
James Schuyler (1923–1991), USA
Gustav Schwab (1792–1850), D
Werner Schwab (1958–1994), AT
Brigitte Schwaiger (1949–2010), AT
Marcel Schwander (1929–2010), CH
Delmore Schwartz (1913–1966), US
Lynne Sharon Schwartz (* 1939), US
Alice Schwarzer (* 1942), D
Alfred Otto Schwede (1915–1987), D
Michael Schweer
Albert Schweitzer (1875–1965), D / FR
Rolf Schwendter (1939–2013), AT
Hermann Schweppenhäuser (1928–2015), D
Malin Schwerdtfeger (* 1972), D
Ulrike Schwieren-Höger (* 1951), D
Peter Schwindt (* 1964), D
Monique Schwitter (* 1972), CH / D
Kurt Schwitters (1887–1948), D
Leonardo Sciascia (1921–1989), IT
C. R. Scott (* 1984), D
Gil Scott-Heron (1949–2011), US
Melissa Scott (* 1960), US
Michael Scott (* 1959), IRL
Sir Walter Scott (1771–1832)
Lisa Scottoline (* 1955), US
Joseph Medlicott Scriven (1820–1886)
Roger Scruton (1944–2020), GB
Madeleine de Scudéry (1607–1701)

Se
Charles Sealsfield (1793–1864)
W. G. Sebald (1944–2001)
David Sedaris (* 1956)
Eve Kosofsky Sedgwick (1950–2009)
Annette Seemann (* 1959)
Peter Seewald (* 1954)
Giorgos Seferis (1900–1971)
Erich Segal (1937–2010)
Tom Segev (* 1945)
Anna Seghers (1900–1983)
Jan Seghers (* 1958)
Georg Seidel (1945–1990)
Heinrich Seidel (1842–1906)
Heinrich Wolfgang Seidel (1876–1945)
Ina Seidel (1885–1974)
Oskar Seidlin (1911–1984)
John Seigenthaler senior (1927–2014)
Lutz Seiler (* 1963), D
Susanne Seitz (* 1964)
Martin Selber (1924–2006)
Erich Selbmann (1926–2006)
Fritz Selbmann (1899–1975)
Dirk Seliger (* 1970)
Rafael Seligmann (* 1947)
Shyam Selvadurai (* 1965)
Friedrich Hermann Semmig (1820–1897)
Jeanne Berta Semmig (1867–1958)
Jaime Semprun (1947–2010)
Jorge Semprún (1923–2011)
Amartya Sen (* 1933)
Maurice Sendak (1928–2012)
Ramón J. Sender (1901–1982)
Nedim Şener (* 1966)
Richard Sennett (* 1943)
Zafer Şenocak (* 1961)
Luis Sepúlveda (1949–2020)
Lucius Annaeus Seneca (55 v. Chr. – 40 n. Chr.)
Seo Jeong-in (* 1936)
Seo Young-eun (* 1943)
Wolf Serno (* 1944)
Walter Serner (1889–1942)
Michel Serres (1930–2019)
Clemens J. Setz (* 1982)
Wolfram Setz (1941–2023)
Bernhard Setzwein (* 1960)
Johann Gottfried Seume (1763–1810)
Beppe Severgnini (* 1956)
Ruth Seydewitz (1905–1989)
Napoleon Seyfarth (1953–2000)
Joachim Seyppel (1919–2012)
Hilal Sezgin (* 1970)

Sg
Manlio Sgalambro (1924–2014)

Sh
Elif Shafak (* 1971)
Peter Shaffer (1926–2016)
William Shakespeare (1564–1616)
Meir Shalev (1948–2023)
Zeruya Shalev (* 1959)
Ralph Shallis († 1995)
Sidney Shapiro (1915–2014)
Tom Sharpe (1928–2013)
George Bernard Shaw (1856–1950)
Irwin Shaw (1913–1984)
Patricia Shaw (* 1929)
Robert Sheckley (1928–2005)
Maurice Sheehy (1928–1991)
Mary Wollstonecraft Shelley (1797–1851)
Percy Bysshe Shelley (1792–1822)
Lucius Shepard (1947–2014)
Richard Brinsley Sheridan (1751–1816)
Randy Shilts (1951–1994)
Shin Kyong-nim (* 1936)
Vladimir Shlapentokh (1926–2015)

Si
Jules Siber (1871–1943)
Gertrud Siche-Tarnowski
Barbara Sichtermann (* 1943)
Enzo Siciliano (1934–2006)
Wolfram Siebeck (1928–2016)
Wolf Jobst Siedler (1926–2013)
Martin Siems (1948–2020)
Hans Siemsen (1891–1969)
Henryk Sienkiewicz (1846–1916)
Christian Sigrist (1935–2015)
Volkmar Sigusch (1940–2023)
Arthur Silbergleit (1881–1943)
Alan Sillitoe (1928–2010)
Ignazio Silone (1900–1978)
Charles Silverstein (1935–2023)
Clifford D. Simak (1904–1988)
Georges Simenon (1903–1989)
Charles Simic (1938–2023)
Georg Simmel (1858–1918)
Johannes Mario Simmel (1924–2009)
Claude Simon (1913–2005)
Erik Simon (* 1950)
Simonides von Amorgos (7. Jahrhundert v. Chr.)
Simonides von Keos (557 oder 556 – 468 oder 467 v. Chr.)
Konstantin Simonow (1915–1979)
N. F. Simpson (1919–2011)
Hüseyin Şimşek (* 1962)
Sin Kyong-suk (* 1963)
Upton Sinclair (1878–1968)
Isaac B. Singer (1904–1991)
Khushwant Singh (1915–2014)
Saut Situmorang (* 1966)
Sitor Situmorang (1924–2014)
Edith Sitwell (1887–1964)

Sj–So
Arne Sjöberg Paul Brinkmann (1934–1997)
Maj Sjöwall (1935–2020)
Maya Skiba (* 1989)
Hamid Skif (1951–2011)
Scipio Slataper (1888–1915)
Henry Slesar (1927–2002)
Ondreij Sliacki (1849–1921)
Joshua Slocum (1844–1909)
Joan Slonczewski (* 1956)
Peter Sloterdijk (* 1947)
Clark Ashton Smith (1893–1961)
Cordwainer Smith Paul Linebarger (1913–1966)
Emma Smith (1923–2018)
Lillian Smith (1897–1966)
Martin Cruz Smith (* 1942)
Stevie Smith (1902–1971)
Wilbur Smith (1933–2021)
Ján Smrek (1898–1982)
Timothy Snyder (* 1969)
Dava Sobel (* 1947), US
Jehoschua Sobol (* 1939)
Ernst Solèr (1960–2008)
Philippe Sollers (1936–2023)
Franco Solo (Verlagspseudonym, verschiedene Autoren)
Alexander Solschenizyn (1918–2008)
Nicolaus Sombart (1923–2008)
Werner Sombart (1863–1941)
Volker Sommer (* 1954)
Hugo Sonnenschein (1889–1953)
Marco Sonnleitner (* 1965)
Susan Sontag (1933–2004)
Michael Sontheimer (* 1955)
Sophokles (497/96–≈406 v.a.Z.)
Osvaldo Soriano (1943–1997)
Flavio Soriga (* 1975)
Wladimir Sorokin (* 1955)
Dido Sotiriou (1909–2004)
Philippe Soupault (1897–1990)
Ivan Southall (1921–2008)
Johannes K. Soyener (1945–2018)
Jura Soyfer (1912–1939)
Wole Soyinka (* 1934)

Sp
Tom Spanbauer (* 1946), US
Muriel Spark (1918–2006), GB
Nicholas Sparks (* 1965), US
Bernd Späth (* 1950), D
Gerold Späth (* 1939), CH
Stephen Spender (1909–1995), GB
Tilman Spengler (* 1947), D
Manès Sperber (1905–1984), AT
Martin Sperr (1944–2002), D
Monika Sperr (1941–1984), D
Dieter Spethmann (1926–2016), D
Art Spiegelman (* 1948), US
Erik Spiekermann (* 1947), D
Arndt Spieth (* 1962), D
Erica Spindler (* 1957), US
Jerry Spinelli (* 1941), US
Burkhard Spinnen (* 1956), D
Carl Spitteler (1845–1924), CH
Robert L. Spitzer (1932–2015), US
Heinrich Spoerl (1887–1955), D
C.M. Spoerri (* 1983), CH
Donald Spoto (1941–2023), US/DK
Hans-Hermann Sprado (1956–2014), D
Johanna Spyri (1827–1901), CH

St

Sta – Ste
 Reiner Stach (* 1951), D
 Emerich von Stadion (1838–1901), AT
 Anne Louise Germaine de Staël (1766–1817)
 Helmut Stalder (* 1966), CH
 George Stambolian (1938–1991), US
 Peter Stamm (* 1963), CH
 Regula Stämpfli (* 1962), CH
 Henry Morton Stanley (1841–1904), GB
 Pietro Stanzano (1928–1968), IT
 Andrzej Stasiuk (* 1960), PL
 Joseph Staten, US
 Edward St Aubyn (* 1960), GB
 Toralf Staud (* 1972), D
 Robert Stauffer (* 1936), D
 Michael Stavarič (* 1972), AT
 John Stave (1929–1993), D
 Jerzy Stefan Stawiński (1921–2010), PL
 Bernhard Stecher (* 1961), A
 Danielle Steel (* 1947), US
 Verena Stefan (1947–2017), CH
 Jón Kalman Stefánsson (* 1963)
 Hansjakob Stehle (1927–2015), D
 Robert Steigerwald (1925–2016), D
 Gertrude Stein (1874–1946), US
 Peter Steinacker (1943–2015), D
 Thomas von Steinaecker (* 1977), D
 Peter Steinbach (Drehbuchautor) (1938–2019), D
 Peter Steinbach (Historiker) (* 1948), D
 John Steinbeck (1902–1968), US
 Guido Steinberg (* 1968), D
 Karl Steinbuch (1917–2005)
 George Steiner (1929–2020), US
 Jens Steiner (* 1975), CH
 Jörg Steiner (1930–2013), CH
 Andreas Steinhöfel (* 1962), D
 Klaus Steiniger (1932–2016), D
 Ronen Steinke (* 1983), D
 Marlene Stenten (1935–2019), D
 Neal Stephenson (* 1959), US
 Carola Stern (1925–2006), D
 Fritz Stern (1926–2016), US
 Horst Stern (1922–2019), D
 Carl Sternheim (1878–1942)
 Norbert Sternmut (* 1958)
 Andreas Sternweiler (* 1957), D
 Julius Stettenheim (1831–1916)
 Johann Kaspar Steube (1747–1795)
 Karl Steuerwald (1905–1989), D
 Wallace Stevens (1879–1955), US
 Robert Louis Stevenson (1850–1894)
 Samuel M. Steward (1909–1993), US
 Fred Mustard Stewart
 Mary Stewart (1916–2014), GB

Sti – Sty
Vicki Stiefel, US
Caspar von Stieler (1632–1707)
Helm Stierlin (1926–2021), D
Adalbert Stifter (1805–1868), D
Klaus Stiller (* 1941), D
Michael Stiller (1945–2016), D
Julius Stinde (1841–1905), D
Conradine Stinde (1856–1925), D
Helene Stöcker (1869–1943), D
Juliana von Stockhausen (1899–1998), D
Charles Warren Stoddard (1843–1909), GB
Dejan Stojanović (* 1959), US, SR
Ceija Stojka (1933–2013), AT
Bram Stoker (1847–1912), GB
Clifford Stoll (* 1950), US
Michael Stolleis (1941–2021), D
Robert Stoller (1925–1991), US
Aryeh Lev Stollman (* 1954), US
Manfred Stolpe (1936–2019), D
Irving Stone (1903–1989), US
Hans Joachim Störig (1915–2012), D
Theodor Storm (1817–1888), D
Rex Stout (1886–1975), US
Horst Stowasser (1951–2009)
Lytton Strachey (1880–1932), GB
August Stramm (1874–1915), D
Giovanni Francisco Straparola (~1480–~1558)
Botho Strauß (* 1944), D
Emil Strauß (1866–1960), D
Leo Strauss (1899–1973)
Werner Streletz (* 1949), D
Carlo Strenger (1958–2019), CH/ISR
Jan Stressenreuter (1961–2018), D
Johan August Strindberg (1849–1912)
Erwin Strittmatter (1912–1994), D
Eva Strittmatter (1930–2011), D
Tina Stroheker (* 1948), D
Anna Stroka (1923–2020), PL
Gisbert Strotdrees (* 1960), D
Arkadi Strugazki, RUS
Boris Strugazki, RUS
Ulf G. Stuberger (1949–2015), D
Heinz Stübig (1939–2021), D
Benjamin von Stuckrad-Barre (* 1975), D
Giani Stuparich (1891–1961), IT
Howard O. Sturgis (1855–1920), GB
Jakob Stutz (1801–1871), SCHW
William Styron (1925–2006), US

Su–Sz
Andreas Suchanek (* 1982)
Hermann Sudermann (1857–1928)
Eugène Sue (1804–1859)
Hannes Sulzenbacher (* 1968)
Alain Claude Sulzer (* 1953)
Ingo Sundmacher (* 1965)
Sung Suk-je (* 1960)
Wolfgang Suppan (1933–2015)
Peter Surava (1912–1995)
Manil Suri (* 1959)
Arno Surminski (* 1934)
Ida Sury (1911–2004), CH
Patrick Süskind (* 1949)
Ron Suresha (* 1958)
Paul Sussman (1968–2012)
Rosemary Sutcliff (1920–1992)
Martin Suter (* 1948)
Bertha von Suttner (1843–1914)
Italo Svevo (1861–1928)
Leonie Swann (* 1975)
Emanuel Swedenborg (1688–1772)
Matthew Sweeney (1952–2018)
Jonathan Swift (1667–1745)
Algernon Charles Swinburne (1837–1909)
John Addington Symonds (1840–1893)
Arthur William Symons (1865–1945)
Julian Symons (1912–1994)
John Millington Synge (1871–1909)
Michael Szameit (1950–2014)
Thomas Szasz (1920–2012)
Antal Szerb (1901–1945)

S


Asatro är en modern beteckning på de religiösa traditioner och seder som utövades av invånarna i Skandinavien från folkvandringstiden och under vikingatiden fram till religionsskiftet. Kunskapen om asatron bygger huvudsakligen på nedteckningar från kristen medeltid, men som förutsätts spegla en äldre muntlig tradition. Svenska akademiens ordbok definierar asatro som ”en nordisk naturreligion där polyteism och naturväsen är centrala inslag utbredd i nord-germanska länder innan kristendomens införande”.

Begreppet asatro
Begreppet asatro myntades under 1800-talet, då den nationalromantiska, samnordiska synen på vikingatiden skapades, och ett stort intresse för förkristen mytologi väcktes också i Tyskland (med Richard Wagners operasvit som främsta exempel). SAOB:s första belägg för begreppet är från 1820.
Under medeltiden användes benämningen fornsed (medeltida stavning: forn siðr eller fornum sid) –  – för att beskriva tron och sederna innan kristendomen.

Som synonym för asatro används ofta fornnordisk religion, men detta begrepp omfattar även andra förkristna nordiska religioner, såsom samisk religion, finsk religion och Nerthuskult. En del svenska akademiker har därför börjat använda begreppet fornskandinavisk religion som synonym till asatro för att avgränsa mot just samisk och finsk religion. Asatro avser religionen som fanns i perioden precis innan kristendomens införande, medan de förkristna religiösa uttrycken som fanns under bronsålder och stenålder i Norden skiljde sig från asatron.

Skriftliga och arkeologiska källor

Det som är känt om asatrons trosuppfattningar kommer främst från kristna källor, antingen isländska sagor nedtecknade efter kristnandet genomförts på Island, eller från kristna grannar som verkat samtidigt som asatron varit levande i Skandinavien, till exempel Adam av Bremen. Även Cornelius Tacitus skrev om germanerna och deras trosuppfattningar. De viktigaste källorna till nordisk mytologi är den poetiska Eddan och Snorres Edda från 1200-talet.

Det finns även arkeologiska källor som ger oss ledtrådar till hur och var asatron utövas. Ortnamn ger ofta vägledning om vilka gudar och gudinnor som dyrkades på en viss plats och sambandet mellan dessa. I nordiska ortnamn ingår följande gudars namn: Tor, Njord, Ull, Frö, Oden, Ti (Tyr), Frigg, Fröja, med binamnet Härn (isländska "Hörn"), Vrind (isländska Rind), möjligen också Vidar, Balder, Höder och Skade. Av gudomlighetsnamn används gud, as, dis, troligen också van, medan det i personnamnen ingår Tor, Frö, Oden, möjligen också Ti, liksom gud, as, ragn (gudamakt), dis, alv samt benämningar på valkyrior. Guden Ull har efterlämnat spår i ett stort antal svenska ortnamn som Ulleråker och Ullevi. Så trots att Ull har en undanträngd roll i Eddorna, så tycks han haft en viktig roll i de lokala offerkulterna.

Bakgrund
Asatron utgjorde aldrig ett sammanhängande religiöst system, varför man kan säga att Snorre Sturlasson med sin Edda var den som först sammanförde berättelserna till en helhet. Den förkristna nordiska asatron var alltså aldrig någon enhetlig religion i modern bemärkelse utan var snarare en etnisk religion eller naturreligion, som saknade grundare och fastställda lärosatser. Mytologin fungerade troligen som en sorts teoretisk överbyggnad till kulten, som hade mycket lite att göra med tro och mer med handlande, traditioner och värderingar i samband med naturen, vädret, årstiderna och mänsklig verksamhet.

Asatro tillhör de polyteistiska religionerna, och förutom gudar tror man även på olika naturväsen. Asatron är en del av en större familj av indoeuropeiska religioner där man även finner grekisk, romersk och slavisk fornreligion. Det finns även motsvarigheter till asatrons panteon i den indiska hinduismen. En teori hävdar att olika indoeuropeiska stammar (indier, greker, italiker, kelter, slaver, germaner) har ett gemensamt ursprung, möjligen från områden i närheten av Svarta Havet och att dessa sedan utvandrat till övriga Europa samt Asien. Detta är en förklaring till likheten i religion och språk mellan dessa olika länder. Se urindoeuropéer.

Religionshistorikern Georges Dumézil menade att det urindoeuropeiska samhället varit uppdelat i tre delar, liknande det indiska kastsystemet. Detta kallade han trefunktionalitetssystemet. Detta tretal menade han även gestaltade sig i de indoeuropeiska gudsuppfattningen; de indoeuropeiska religionerna, menade han, hade alltid tre gudar som motsvarade den romerska mytologins Jupiter (övergud), Mars (krigsgud) och Quirinus (samhällsbeskyddaren och jordbruksgud). Han utvecklade sedan resonemanget med att uppställa ett schema över tretalens respektive egenskaper:
Den första stod för suveränitet, intelligens och helighet, och fungerade fredsbevarande.
Det andra för kraft och styrka, särskilt avseende krig, och fungerade som rättvisans princip.
Det tredje för tillgivenhet, samhällets bevarande, odling och jordbruk.
I ”De nordiska gudarna: en undersökning av den skandinaviska religionen” (1939) överförde han tretalssystemet till Eddan, och menade att det motsvarade Oden, Tor och Frej i den nordiska mytologin där Frej motsvarade jordbruket, Oden överguden och Tor var en krigsgud.

Under folkvandringstiden, efter Roms fall, vällde de germanska folken in över den europeiska kontinenten. De hade inte undgått påverkan från medelhavskulturerna men sin gamla tro tog de med sig och med dem spred den sig över Europa. Omkring år 500–750 ersattes denna tro gradvis av kristendomen i anglosaxarnas England och merovingernas Frankrike, och liksom senare i Skandinavien verkade de båda trossystemen parallellt med varandra under den tiden. Under denna period, alltså strax innan vikingatiden inletts, hade asatron sin största utbredning: Samma eller likartade gudar dyrkades över hela norra och västra Europa.
Dock försökte aldrig anhängarna till asatron att omvända de kristna och det var dömt att bli en tidsfråga innan de konverterade till kristendomen. I Norden dröjde kristnandet dock omkring 500 år längre än på kontinenten: Först kristnades Norge (900–1000), sedan Island (år 1000, enligt sagorna genom ett alltingsbeslut), Danmark, och sist Sverige av alla germanska områden; även om kristnandet framskred i olika takt i olika delar av länderna. Att nordborna blev kristna tolkas som ett tecken på deras integrering i det europeiska värdesystemet: även om den personliga övertygelsen lät vänta på sig underlättade det handeln att låta döpa sig.

Under seklerna som följde kristnandet, innan den kristna undervisningen hunnit etablera den kristna andan, levde dessutom skaldekonsten fortfarande vid hoven. Skalder kunde använda kenningar, hänsyftningar till den nordiska mytologin, och veta att han blev omedelbart förstådd; "dvärgarnas skepp" var skaldekonsten; "Fröjas tårar" var guldet; "valkyriornas eld" svärdet, "korpens öl" blodet, etc.

Asatron har karaktär av ursprunglig nordeuropeisk religion som dominerade större delen av Nordeuropa, alltså Skandinavien, England, Tyskland, Nederländerna och Belgien, bland andra. Det mesta vi vet om denna tro härstammar dock från Norden och i synnerhet Island. Det är inte säkert att övriga germanska folk omfattade exakt samma trosföreställningar som de forntida nordborna. Troligen varierade asatrons sedvänjor och myter avsevärt mellan de olika germanska folken och över tid. Att de religiösa föreställningarna i hela Skandinavien dock varit väsentligen desamma finns det dock mycket som tyder på. Skandinavien kristnades dessutom bortåt 500 år senare än exempelvis Tyskland och England. Mest hårdnackade i den gamla tron var folken i Sverige, som höll fast vid den "forna seden" ända in på 1100-talet, och det finns till och med vittnesmål om att människor åkallade asarna så sent som på 1500-talet i Småland.

Kosmologi

I eddadikten Valans spådom, Völuspá, återges, via en völva (spåkvinna), myter om skapelsen, konflikterna i världen och världsundergången. Forskningen har diskuterat om Snorres text ger uttryck för en cyklisk världshistoria eller om den med ett definitivt världsslut är påverkad av kristendomen. Völvan berättar om den ursprungliga tomheten, Ginnungagap, om universums tillkomst (kosmogoni) och skapelsen av Ask och Embla, de första människorna (antropogoni), samt om striderna mellan gudar och jättar som leder fram till undergången, Ragnarök. Snorres Edda beskriver att världen uppstod i Ginnungagap, ett svalg där hetta och frost smälte samman till jätten Ymer och kon Audhumbla. Audhumbla slickade sedan fram mannen Bure ur isen. Bures sonsöner Oden, Vile och Ve dräpte därefter Ymer och skapade världen av hans kropp.

Den övergripande mytologiska berättelsen handlar om en kosmisk maktkamp mellan gudarna och kaoskrafter. Gudarna representerade den ordnade världen, kulturen och civilisationen, som ständigt hotades av naturens krafter, representerade av jättarna och kaosmonster (till exempel Fenrisulven och Midgårdsormen). Men minst lika viktigt är Asgårds beroende av den hemliga kunskap som jättar och andra demoniska väsen besitter och de allianser, och äktenskap, som knyts mellan dessa två världar.

Snorre ger i sin Edda detaljerade upplysningar om hur universums är beskaffat: Midgård kallas människornas värld, i Asgård lever gudarna. Utgård kallas den utanförvärld där de demoniska väsendena håller till och där Jotunheim finns. Runt jorden ringlar sig Midgårdsormen, och utanför detta vidunder finns det personifierade världshavet, Ägir. I världens mitt står trädet Yggdrasil. Det symboliserar strukturen i kosmos med sina rötter i Hels underjord och grenar som sträcker sig långt upp till gudarna. Vid trädets fot ligger jätten Mimers brunn, vars vatten förmedlar kunskap om det som varit och det som komma skall. De tre nornorna Urd (det förflutna), Verdandi (det nuvarande) och Skuld (det som komma skall) och spinner ödestrådarna. Hel är namnet både på det underjordiska dödsriket och på dess härskarinna. De som fallit i strid hämtas av valkyrior och kommer till Odens Valhall eller till Freja Folkvang. I det sista slaget, Ragnarök, kommer de härskande gudarna att falla och världen kommer att gå under i en eld, varefter en ny och bättre värld kommer att uppstå ur den gamla.

Kultplatser

Kulten under järnåldern verkar mestadels ha utövats i hemmen, men skriftliga källor, bland annat Adam av Bremen, nämner att det skall ha funnits tempelbyggnader i Norden under vikingatiden, i alla fall i Uppsala. Vid utgrävningar i Uppåkra strax söder om Lund har man funnit rester efter ett tempel som stått här i flera hundra år före nedläggningen i slutet av 900-talet. Då hela byggnadens yta kunnat grävas fram och då platsen är oskadad från senare nedgrävningar har för första gången ett fornnordiskt tempel kunnat studeras i sin helhet rent arkeologiskt.
Mycket vanligare var de så kallade "vina", heliga platser utomhus. Detta återspeglas bland annat i många av de ortnamn som innehåller efterledet -vi, som till exempel Ullevi. 2007 undersöktes ett vi från vendeltid i Lilla Ullevi fullständigt. Viet i Lilla Ullevi bestod av olika lämningar, naturliga såväl som människoskapade; centralt fanns den så kallade hargen, en stenkonstruktion som ligger på viets högsta punkt. I hargen låg en plattform som antagligen fungerat som altare. Plattformen har efterlämnat spår i form av fyra kraftiga stolphål. Söder om stenkonstruktionen fanns ett stort antal stolphål, och arkeologerna antar att det kan ha varit en offerplats på grund av de många fynd av amulettringar som man gjort där. Ringar förekom även i hargen, där man funnit närmare 70 stycken järnringar, många med mindre ringar hängande i den största ringen. Ringar antas också ha betytt mycket i den nordiska kulten då de fungerat som dörringar på kultbyggnader, vilket man sett i templet i Uppåkra, och som också är avbildat på Sparlösastenen. Det isländska sagomaterialet bekräftar också ringarnas betydelse i kulten.

Blot

Blot är ett offer i nordisk religion som syftar till att vinna gudars eller alvers välvilja så att de uppfyller dess önskemål, som genomför blotet. Ordet är släkt med gotiskans blôtan i meningen "dyrka, tillbedja", och forntyskans bluozan, i betydelsen "offra" och "stärka". Troligen har ordet ursprungsbetydelsen "åkalla med besvärjelse eller offer". Religionsprofessor Britt-Mari Näsström härleder ordet till en indoeuropeisk rot *bhle som betyder ”svälla, vara svullen” och i överförd bemärkelse ”tillta, öka”. Det betyder att offret i sig ökar den offrandes egendom.
Offerritualerna verkar ha skett på två sätt; antingen frambar man offret till gudarna eller så tog man del av offergåvan genom att förtära den offrade maten och drycken. Det finns flera berättelser från norra Europa om stora offerfester med mat och dryck.

De isländska sagorna talar om tre årliga blot: höstblot, midvinterblot och vårblot.

Namngivna blothögtider
 Disablot (början av februari)
 Segerblot (vårdagjämningen)
 Midsommarblot (midsommar)
 Skördeblot (augusti–september)
 Höstblot (mitten av oktober)
 Alvablot (november/allhelgona)
 Midvinterblot (januari)

Asatron efter kristnandet

Sedan Nordeuropa kristnats och asatron förbjudits, allra sist i Sverige, levde en del av dess trosuppfattningar vidare i folktro och i folksagor, "Prins Hatt under jorden" är till exempel ursprungligen berättelser om guden Höder. En dikt från Trollkyrka i Tiveden redogör även för hur ett hemligt offer utfördes.
Men det finns också indikationer att asatron levde kvar länge i hemlighet; under digerdödens härjningar på 1300-talet berättas det att flera områden återgick till hedendomen i försök att hejda pestens härjningar, och det finns kätterimål från 1500-talet mot svenskar som dyrkat Oden. Myten om Odens jakt, liksom föreställningar om Tor, Fröja (Freja), Locke (Loke), Frigg och så vidare visar att allmogen långt fram på 1800- och början av 1900-talet hade kunskaper om den forna religionen. Man har också visat att så kallade älvkvarnar använts för offer långt in på 1800-talet.

Andra sedvänjor som kan tolkas som rester av asatro, är till exempel riten rörande Kornguden i Vånga, som var en helgonbild i Norra Vånga i Västergötland. Helgonbilden togs ut till åkrarna för att säkerställa att skörden blev god. 1826 försökte stiftet förhindra denna sed genom att undanskaffa helgonbilden men enligt Västgöta-Bengtsson så ska Vångaborna ha gjort sig en ny Korngud. Det är dock inget ovanligt att kristen helgondyrkan tett sig på detta vis, och flera exempel finns från kontinenten varför det inte med självklarhet går att göra kopplingen till asatron.
Ebbe Schön skriver i sin bok Asa-Tors hammare om hur rester av asatron levde kvar i folksagor ännu i början av 1900-talet.

Även om de högre gudarna i asatron så småningom försvann, så levde dess mindre väsen vidare i folktrons föreställningar om älvor, vättar, och tomtar och i tron på skogsrået, näcken, havsfrun med flera in i våra dagar och gör så alltjämt på sina ställen. När bonden satte ut en skål gröt till tomten på julnatten för att denne skulle se till djuren på gården, så utförde han en rit med urgamla anor, det som på vikingatid och tidig medeltid kallades blot.

Folktrons föreställningar om avlidnas själar och naturföreteelsernas andar återfinns i liknande skepnad hos många folk, och att de hos nordbor och övriga germaner varit väsentligen de samma intygas dels av överensstämmande folktro från yngre tid, dels av de gemensamma benämningarna för älva, mara, huldra, dvärg och näck. Om de germanska folkens gudatro finns några underrättelser ända från vår tideräknings början, och ett för dessa gemensamt drag är att utom träd, floder och berg vanligen tre, ibland fyra gudar uppges ha dyrkats: Caesar anger solen, Vulcanus (elden) och månen, Tacitus anger Mercurius, Hercules och Mars. I det saxiska doplöftet från 800-talet avsvärjs "Thuner och Woden och Saxnot och alla de onda makter, som är i deras sällskap".

Modern asatro

I slutet av 1800-talet blommade återigen ett intresse för asatron upp. En andra våg kom på 1920-talet, och en tredje kom i samband med det ökande intresset för naturreligioner under 1960-talet. I dag finns det flera organisationer som sprider kunskap om mytologin, religionen och religiösa sammankomster, huvudsakligen i Skandinavien, England och USA. Det isländska ordet ásatrú har blivit det vanligaste ordet internationellt men även Odinism (efter det isländska/fornnordiska namnet på Oden) förekommer. Nordiska Asasamfundet (NAS), det största samfundet för Asatro i Sverige använder beteckningen asatro för religionen. I Skandinavien används ibland även beteckningen forn sed för denna religion av Samfundet Forn Sed Sverige.

Forskningshistoria kring asatro
Friedrich Max Müller (1823–1900) var en tysk språkforskare som var intresserad av möjliga förbindelse mellan språk, religion och mytologi. Müller menade att naturfenomen blev till gudar genom en missuppfattning av naturlagarna. Müllers resonemang kan spåras i flera verk från 1800-talets slut, där de nordiska gudarna kom att förklaras som naturfenomen. Inom mytforskning kallas detta för den naturmytologiska skolan. Från 1800-talets slut fick den naturmytologiska skolan kritik. Norske Sophus Bugge (1833–1907) och tyske Eugen Mogk kom att representera en ny källkritisk riktning i forskningen och menade att de nordiska myterna först och främst var en produkt Nordens möte med kristendomen. I Bugges huvudverk, De nordiske Gude- og Heltesagns Oprindelse, menade han att den nordiska mytologin hade skapats i möte med kristendomens texter och litterära traditioner. Han menade vidare att asatron hade inspirerats av keltiska och anglosaxiska traditioner med lån från grekisk och romersk mytologi. På 2000-talet har Bugges teori ingen stark ställning. Gro Steinsland menar dock att Bugges forskning "banade väg för den källkritiska debatten som uppstod och som fortfarande förs". Bugges kommenterade utgåva av Den eldre Edda (1867) betraktas fortfarande som ett standardverk för de som arbetar källkritiskt med eddadikterna.

Källtexter
Följande texter och föremål utgör historiska källor till kunskap om den nordiska mytologins innehåll, som de i olika utsträckning nämner och behandlar:

 Tacitus: Germania (ca 98 e.kr.)
 Snorre Sturlason:
 Codex Regius (”Kungliga boken”) eller Poetiska Eddan (ca 800 e.kr.)
 Prosaiska Eddan  (ca 1200 e.kr.)
 Saxo Grammaticus: Gesta Danorum (ca 1200 e.kr.)
 Runstenar
 Beowulfskvädet
 Tjodolf av Hvin:
 Ynglingasagan
 Haustlong
 Eilif Gudrunarson: Thórsdrápa
 Adam av Bremen: Gesta Hammaburgensis ecclesiae pontificum

Referenser