StyledStrings

Styling

Dizelerle çalışırken, biçimlendirme ve stil genellikle ikincil bir endişe olarak ortaya çıkar.

Örneğin, bir terminale yazdırırken ANSI escape sequences çıktısında serpiştirmek isteyebilirsiniz, HTML stil yapıları (<span style="..."> vb.) benzer bir amaca hizmet eder ve devam eder. İçerikle birlikte ham stil yapıları dizeye basitçe eklemek mümkündür, ancak bu, en temel kullanım durumları dışında iyi bir şekilde uygun olmadığını hızla ortaya çıkarır. Tüm terminaller aynı ANSI kodlarını desteklemez, stil yapıları, zaten stillendirilmiş içeriğin genişliğini hesaplarken titizlikle kaldırılmalıdır ve bu, birden fazla çıktı formatını ele almaya başlamadan önceki durumdur.

Bunu aşağı akışta yaygın olarak deneyimlenmesi için bırakmak yerine, özel bir dize türünün (AnnotatedString) tanıtımıyla doğrudan ele alınmaktadır. Bu dize türü, herhangi bir AbstractString türünü sarar ve biçimlendirme bilgilerini bölgelere uygulamaya olanak tanır (örneğin, 1'den 7'ye kadar olan karakterler kalın ve kırmızıdır).

Bir dize bölgeleri, onlara Face (düşünün "yazı tipi") uygulayarak stillendirilir — stil bilgilerini tutan bir yapı. Kolaylık olması açısından, küresel yüzler sözlüğündeki yüzler (örneğin shadow) doğrudan 4d61726b646f776e2e436f64652822222c2022466163652229_40726566205374796c6564537472696e67732e46616365 vermek yerine sadece adlandırılabilir.

Bu yeteneklerin yanı sıra, AnnotatedString oluşturmak için de kullanışlı bir yol sağlıyoruz, bu da Styled String Literals içinde detaylandırılmıştır.

julia> using StyledStrings
julia> styled"{yellow:hello} {blue:there}""hello there"

Annotated Strings

Bazen bir dize ile ilgili bölgeleri tutmak için meta verileri saklamak faydalı olabilir. Bir AnnotatedString, başka bir dizeyi sarar ve bunun bölgelerinin etiketli değerlerle (:label => value) anotasyon yapılmasına olanak tanır. Tüm genel dize işlemleri, temel dizeye uygulanır. Ancak, mümkün olduğunda stil bilgileri korunur. Bu, bir 4d61726b646f776e2e436f64652822222c2022416e6e6f7461746564537472696e672229_4072656620426173652e416e6e6f7461746564537472696e67 üzerinde alt dizeler alabileceğiniz, bunları doldurabileceğiniz, diğer dizelerle birleştirebileceğiniz anlamına gelir ve meta veri anotasyonları "yolda gelir".

Bu dize türü, stil bilgilerini tutmak için :face etiketli notlar kullanan StyledStrings stdlib için temeldir.

AnnotatedString ile birleştirirken, dize açıklamalarını korumak istiyorsanız annotatedstring kullanmaya dikkat edin, string yerine.

julia> str = AnnotatedString("hello there", [(1:5, :word, :greeting), (7:11, :label, 1)])
"hello there"

julia> length(str)
11

julia> lpad(str, 14)
"   hello there"

julia> typeof(lpad(str, 7))
AnnotatedString{String}

julia> str2 = AnnotatedString(" julia", [(2:6, :face, :magenta)])
" julia"

julia> annotatedstring(str, str2)
"hello there julia"

julia> str * str2 == annotatedstring(str, str2) # *-concatenation works
true

AnnotatedString anotasyonları annotations ve annotate! fonksiyonları aracılığıyla erişilebilir ve değiştirilebilir.

Styling via AnnotatedStrings

Faces

The Face type

Bir Face, metinlerin ayarlanabileceği bir yazı tipinin ayrıntılarını belirtir. Farklı formatlar arasında iyi bir şekilde genelleştirilebilen temel özellikler kümesini kapsar, yani:

• yazı tipi
• yükseklik
• ağırlık
• eğim
• ön plan
• arka plan
• altı çizili
• üstü çizili
• ters
• miras almak

Belirli niteliklerin bu biçimlerinin ayrıntıları için Face docstring'ine bakın, ancak özellikle ilginç olan inherit'dir çünkü diğer 4d61726b646f776e2e436f64652822222c2022466163652229_40726566205374796c6564537472696e67732e46616365'lerden nitelikleri devralmanıza olanak tanır.

The global faces dictionary

Belirli stillere atıfta bulunmayı daha uygun hale getirmek için, Dict{Symbol, Face} adlı küresel bir yapı vardır. Bu yapı, Face'leri sadece isimle anılmasını sağlar. Paketler, bu sözlüğe yüzler eklemek için addface! fonksiyonunu kullanabilir ve yüklenen yüzler kolayca customized olarak kullanılabilir.

Paket ön ek kuralına iki tür muafiyet vardır:

• varsayılan değer olan yüzler sözlüğünün bir parçası olan temel yüzlerin kümesi
• Julia'nın kendi standart kütüphanesi tarafından tanıtılan yüzler, yani JuliaSyntaxHighlighting

Basic faces

Temel yüzler, yaygın olarak uygulanabilir genel bir fikri temsil etmek amacıyla tasarlanmıştır.

Belirli bir niteliğe sahip metin ayarlamak için bold, light, italic, underline, strikethrough ve inverse yüzlerini kullanıyoruz.

16 terminal renkleri için ayrıca adlandırılmış yüzler de vardır: siyah, kırmızı, yeşil, sarı, mavi, macenta, cyan, beyaz, parlak_siyah/gri, parlak_kırmızı, parlak_yeşil, parlak_mavi, parlak_macenta, parlak_cyan ve parlak_beyaz.

Gölgelendirilmiş metin için (yani, soluk ama orada) shadow yüzü vardır. Seçili bir bölgeyi belirtmek için region yüzü vardır. Benzer şekilde, vurgulama ve öne çıkarma için emphasis ve highlight yüzleri tanımlanmıştır. Ayrıca, kod benzeri metinler için code de vardır.

Mesajların ciddiyetini görsel olarak belirtmek için hata, uyarı, başarı, bilgi, not ve ipuçları yüzleri tanımlanmıştır.

Customisation of faces (Faces.toml)

Küresel yüz sözlüğündeki isim yüzlerinin özelleştirilebilir olması iyidir. Temalar ve estetikler hoş, ayrıca erişilebilirlik nedenleriyle de önemlidir. Bir TOML dosyası, yüz sözlüğündeki mevcut girişle birleştirilen Face spesifikasyonları listesine ayrıştırılabilir.

Bir Face TOML formatında şu şekilde temsil edilir:

[facename]
attribute = "value"
...

[package.facename]
attribute = "value"

Örneğin, eğer gölge yüzü okunması çok zor ise, şöyle daha parlak hale getirilebilir:

[shadow]
foreground = "white"

Başlatıldığında, ilk Julia depo altında bulunan config/faces.toml dosyası (genellikle ~/.julia) yüklenir.

Applying faces to a AnnotatedString

Gelenek gereği, AnnotatedString'nin :face nitelikleri, şu anda geçerli olan Face'ler hakkında bilgi tutar. Bu, global yüz sözlüğündeki bir Symbol ile adlandırılan bir 4d61726b646f776e2e436f64652822222c2022466163652229_40726566205374796c6564537472696e67732e46616365, bir 4d61726b646f776e2e436f64652822222c2022466163652229_40726566205374796c6564537472696e67732e46616365 veya bunların bir vektörü şeklinde birden fazla biçimde verilebilir.

show(::IO, ::MIME"text/plain", ::AnnotatedString) ve show(::IO, ::MIME"text/html", ::AnnotatedString) yöntemleri, genel stil belirlenirken :face niteliklerine bakar ve hepsini bir araya getirir.

AnnotatedString oluşturulurken :face niteliklerini sağlayabilir, bunları sonrasında özellikler listesine ekleyebilir veya kullanışlı Styled String literals'i kullanabilirsiniz.

julia> str1 = AnnotatedString("blue text", [(1:9, :face, :blue)])"blue text"
julia> str2 = styled"{blue:blue text}""blue text"
julia> str1 == str2true
julia> sprint(print, str1, context = :color => true)"\e[34mblue text\e[39m"
julia> sprint(show, MIME("text/html"), str1, context = :color => true)"<span style=\"color: #195eb3\">blue text</span>"

Styled String Literals

AnnotatedString ile Face'lerin uygulanmasıyla, styled"..." stilinde bir dize literal'i, içeriğin ve niteliklerin özel bir dil bilgisi aracılığıyla kolayca ifade edilmesine olanak tanır.

styled"..." literal içinde, süslü parantezler normal kullanımda özel karakterler olarak kabul edilir ve kaçış karakteri ile kullanılmalıdır (\{, \}). Bu, (iç içe) {annotations...:text} yapıları ile notasyonları ifade etmek için kullanılmalarına olanak tanır.

annotations... bileşeni, üç tür anotasyonun virgülle ayrılmış bir listesidir.

• Yüz isimleri
• Satır içi Yüz ifadeleri (anahtar=değer,...)
• ana=değer çiftleri

İnterpolasyon, yalnızca satır içi yüz anahtarları için mümkün değildir.

Daha fazla bilgi için, styled"..." docstring'inin genişletilmiş yardımına bakın.

Örnek olarak, yukarıda bahsedilen yerleşik yüzlerin listesini şu şekilde gösterebiliriz:

julia> println(styled"
The basic font-style attributes are {bold:bold}, {light:light}, {italic:italic},
{underline:underline}, and {strikethrough:strikethrough}.

In terms of color, we have named faces for the 16 standard terminal colors:
 {black:■} {red:■} {green:■} {yellow:■} {blue:■} {magenta:■} {cyan:■} {white:■}
 {bright_black:■} {bright_red:■} {bright_green:■} {bright_yellow:■} {bright_blue:■} {bright_magenta:■} {bright_cyan:■} {bright_white:■}

Since {code:bright_black} is effectively grey, we define two aliases for it:
{code:grey} and {code:gray} to allow for regional spelling differences.

To flip the foreground and background colors of some text, you can use the
{code:inverse} face, for example: {magenta:some {inverse:inverse} text}.

The intent-based basic faces are {shadow:shadow} (for dim but visible text),
{region:region} for selections, {emphasis:emphasis}, and {highlight:highlight}.
As above, {code:code} is used for code-like text.

Lastly, we have the 'message severity' faces: {error:error}, {warning:warning},
{success:success}, {info:info}, {note:note}, and {tip:tip}.

Remember that all these faces (and any user or package-defined ones) can
arbitrarily nest and overlap, {region,tip:like {bold,italic:so}}.")

 The basic font-style attributes are bold, light, italic,
 underline, and strikethrough.

 In terms of color, we have named faces for the 16 standard terminal colors:
  ■ ■ ■ ■ ■ ■ ■ ■
  ■ ■ ■ ■ ■ ■ ■ ■

 Since bright_black is effectively grey, we define two aliases for it:
 grey and gray to allow for regional spelling differences.

 To flip the foreground and background colors of some text, you can use the
 inverse face, for example: some inverse text.

 The intent-based basic faces are shadow (for dim but visible text),
 region for selections, emphasis, and highlight.
 As above, code is used for code-like text.

 Lastly, we have the 'message severity' faces: error, warning,
 success, info, note, and tip.

 Remember that all these faces (and any user or package-defined ones) can
 arbitrarily nest and overlap, like so.

API reference

Styling and Faces

@styled_str -> AnnotatedString

styled"The {bold:{italic:quick} {(foreground=#cd853f):brown} fox} jumped over the {link={https://en.wikipedia.org/wiki/Laziness}:lazy} dog"

styledstring = { styled | interpolated | escaped | plain } ;

specialchar = '{' | '}' | '$' | '\"' ;
anychar = [\u0-\u1fffff] ;
plain = { anychar - specialchar } ;
escaped = '\\', specialchar ;

interpolated = '$', ? expr ? | '$(', ? expr ?, ')' ;

styled = '{', ws, annotations, ':', content, '}' ;
content = { interpolated | plain | escaped | styled } ;
annotations = annotation | annotations, ws, ',', ws, annotation ;
annotation = face | inlineface | keyvalue ;
ws = { ' ' | '\t' | '\n' } ; (* boşluk *)

face = facename | interpolated ;
facename = [A-Za-z0-9_]+ ;

inlineface = '(', ws, [ faceprop ], { ws, ',', faceprop }, ws, ')' ;
faceprop = [a-z]+, ws, '=', ws, ( [^,)]+ | interpolated) ;

keyvalue = key, ws, '=', ws, value ;
key = ( [^\0${}=,:], [^\0=,:]* ) | interpolated ;
value = simplevalue | curlybraced | interpolated ;
curlybraced = '{' { escaped | plain } '}' ;
simplevalue = [^${},:], [^,:]* ;

faceprop = ( 'face', ws, '=', ws, ( ? string ? | interpolated ) ) |
           ( 'height', ws, '=', ws, ( ? number ? | interpolated ) ) |
           ( 'weight', ws, '=', ws, ( symbol | interpolated ) ) |
           ( 'slant', ws, '=', ws, ( symbol | interpolated ) ) |
           ( ( 'foreground' | 'fg' | 'background' | 'bg' ),
               ws, '=', ws, ( simplecolor | interpolated ) ) |
           ( 'underline', ws, '=', ws, ( underline | interpolated ) ) |
           ( 'strikethrough', ws, '=', ws, ( bool | interpolated ) ) |
           ( 'inverse', ws, '=', ws, ( bool | interpolated ) ) |
           ( 'inherit', ws, '=', ws, ( inherit | interpolated ) ) ;

nothing = 'nothing' ;
bool = 'true' | 'false' ;
symbol = [^ ,)]+ ;
hexcolor = ('#' | '0x'), [0-9a-f]{6} ;
simplecolor = hexcolor | symbol | nothing ;

underline = nothing | bool | simplecolor | underlinestyled;
underlinestyled = '(', ws, ('' | nothing | simplecolor | interpolated), ws,
                  ',', ws, ( symbol | interpolated ), ws ')' ;

inherit = ( '[', inheritval, { ',', inheritval }, ']' ) | inheritval;
inheritval = ws, ':'?, symbol ;

styled(content::AbstractString) -> AnnotatedString

addface!(name::Symbol => default::Face)

julia> addface!(:mypkg_myface => Face(slant=:italic, underline=true))
Face (örnek)
         slant: italic
     underline: true

withfaces(f, kv::Pair...)
withfaces(f, kvpair_itr)

julia> withfaces(:yellow => Face(foreground=:red), :green => :blue) do
           println(styled"{yellow:red} ve {green:blue} karışımı {magenta:purple} yapar")
       end
kırmızı ve mavi karışımı mor yapar

struct SimpleColor

SimpleColor(name::Symbol)  # örn. :red
SimpleColor(rgb::RGBTuple) # örn. (r=1, b=2, g=3)
SimpleColor(r::Integer, b::Integer, b::Integer)
SimpleColor(rgb::UInt32)   # örn. 0x123456

parse(::Type{SimpleColor}, rgb::String)

tryparse(::Type{SimpleColor}, rgb::String)

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

merge(initial::Face, others::Face...)