caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-05-13 20:46:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

Make clippy happier and remove Str

Browse Source
This commit is contained in:
Laurenz 2021-11-15 16:59:49 +01:00
parent 8a38899c98
commit 63c274e7f6
34 changed files with 340 additions and 427 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/eval/array.rs
View File

@ -70,7 +70,7 @@ impl Array {
/// Clear the array.
pub fn clear(&mut self) {
if Rc::strong_count(&mut self.0) == 1 {
if Rc::strong_count(&self.0) == 1 {
Rc::make_mut(&mut self.0).clear();
} else {
*self = Self::new();

40
src/eval/dict.rs
View File

@ -4,9 +4,9 @@ use std::iter::FromIterator;
use std::ops::{Add, AddAssign};
use std::rc::Rc;
use super::{Str, Value};
use super::Value;
use crate::diag::StrResult;
use crate::util::RcExt;
use crate::util::{EcoString, RcExt};
/// Create a new [`Dict`] from key-value pairs.
#[allow(unused_macros)]
@ -21,7 +21,7 @@ macro_rules! dict {
/// A dictionary from strings to values with clone-on-write value semantics.
#[derive(Default, Clone, PartialEq)]
pub struct Dict(Rc<BTreeMap<Str, Value>>);
pub struct Dict(Rc<BTreeMap<EcoString, Value>>);
impl Dict {
/// Create a new, empty dictionary.
@ -30,7 +30,7 @@ impl Dict {
}
/// Create a new dictionary from a mapping of strings to values.
pub fn from_map(map: BTreeMap<Str, Value>) -> Self {
pub fn from_map(map: BTreeMap<EcoString, Value>) -> Self {
Self(Rc::new(map))
}
@ -45,7 +45,7 @@ impl Dict {
}
/// Borrow the value the given `key` maps to.
pub fn get(&self, key: Str) -> StrResult<&Value> {
pub fn get(&self, key: EcoString) -> StrResult<&Value> {
self.0.get(&key).ok_or_else(|| missing_key(&key))
}
@ -53,18 +53,18 @@ impl Dict {
///
/// This inserts the key with [`None`](Value::None) as the value if not
/// present so far.
pub fn get_mut(&mut self, key: Str) -> &mut Value {
Rc::make_mut(&mut self.0).entry(key.into()).or_default()
pub fn get_mut(&mut self, key: EcoString) -> &mut Value {
Rc::make_mut(&mut self.0).entry(key).or_default()
}
/// Insert a mapping from the given `key` to the given `value`.
pub fn insert(&mut self, key: Str, value: Value) {
Rc::make_mut(&mut self.0).insert(key.into(), value);
pub fn insert(&mut self, key: EcoString, value: Value) {
Rc::make_mut(&mut self.0).insert(key, value);
}
/// Clear the dictionary.
pub fn clear(&mut self) {
if Rc::strong_count(&mut self.0) == 1 {
if Rc::strong_count(&self.0) == 1 {
Rc::make_mut(&mut self.0).clear();
} else {
*self = Self::new();
@ -72,14 +72,14 @@ impl Dict {
}
/// Iterate over pairs of references to the contained keys and values.
pub fn iter(&self) -> std::collections::btree_map::Iter<Str, Value> {
pub fn iter(&self) -> std::collections::btree_map::Iter<EcoString, Value> {
self.0.iter()
}
}
/// The missing key access error message.
#[cold]
fn missing_key(key: &Str) -> String {
fn missing_key(key: &EcoString) -> String {
format!("dictionary does not contain key: {:?}", key)
}
@ -119,21 +119,21 @@ impl AddAssign for Dict {
}
}
impl Extend<(Str, Value)> for Dict {
fn extend<T: IntoIterator<Item = (Str, Value)>>(&mut self, iter: T) {
impl Extend<(EcoString, Value)> for Dict {
fn extend<T: IntoIterator<Item = (EcoString, Value)>>(&mut self, iter: T) {
Rc::make_mut(&mut self.0).extend(iter);
}
}
impl FromIterator<(Str, Value)> for Dict {
fn from_iter<T: IntoIterator<Item = (Str, Value)>>(iter: T) -> Self {
impl FromIterator<(EcoString, Value)> for Dict {
fn from_iter<T: IntoIterator<Item = (EcoString, Value)>>(iter: T) -> Self {
Self(Rc::new(iter.into_iter().collect()))
}
}
impl IntoIterator for Dict {
type Item = (Str, Value);
type IntoIter = std::collections::btree_map::IntoIter<Str, Value>;
type Item = (EcoString, Value);
type IntoIter = std::collections::btree_map::IntoIter<EcoString, Value>;
fn into_iter(self) -> Self::IntoIter {
Rc::take(self.0).into_iter()
@ -141,8 +141,8 @@ impl IntoIterator for Dict {
}
impl<'a> IntoIterator for &'a Dict {
type Item = (&'a Str, &'a Value);
type IntoIter = std::collections::btree_map::Iter<'a, Str, Value>;
type Item = (&'a EcoString, &'a Value);
type IntoIter = std::collections::btree_map::Iter<'a, EcoString, Value>;
fn into_iter(self) -> Self::IntoIter {
self.iter()

11
src/eval/function.rs
View File

@ -1,7 +1,7 @@
use std::fmt::{self, Debug, Formatter, Write};
use std::rc::Rc;
use super::{Cast, EvalContext, Str, Value};
use super::{Cast, EvalContext, Value};
use crate::diag::{At, TypResult};
use crate::syntax::{Span, Spanned};
use crate::util::EcoString;
@ -52,7 +52,10 @@ impl Debug for Function {
impl PartialEq for Function {
fn eq(&self, other: &Self) -> bool {
// We cast to thin pointers for comparison.
Rc::as_ptr(&self.0) as *const () == Rc::as_ptr(&other.0) as *const ()
std::ptr::eq(
Rc::as_ptr(&self.0) as *const (),
Rc::as_ptr(&other.0) as *const (),
)
}
}
@ -71,7 +74,7 @@ pub struct Arg {
/// The span of the whole argument.
pub span: Span,
/// The name of the argument (`None` for positional arguments).
pub name: Option<Str>,
pub name: Option<EcoString>,
/// The value of the argument.
pub value: Spanned<Value>,
}
@ -173,7 +176,7 @@ impl Args {
}
/// Reinterpret these arguments as actually being a dictionary key.
pub fn into_key(self) -> TypResult<Str> {
pub fn into_key(self) -> TypResult<EcoString> {
self.into_castable("key")
}

19
src/eval/mod.rs
View File

@ -5,8 +5,6 @@ mod array;
#[macro_use]
mod dict;
#[macro_use]
mod str;
#[macro_use]
mod value;
mod capture;
mod function;
@ -15,7 +13,6 @@ mod scope;
mod template;
mod walk;
pub use self::str::*;
pub use array::*;
pub use capture::*;
pub use dict::*;
@ -31,6 +28,8 @@ use std::io;
use std::mem;
use std::path::PathBuf;
use unicode_segmentation::UnicodeSegmentation;
use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
use crate::geom::{Angle, Fractional, Length, Relative};
use crate::image::ImageStore;
@ -38,7 +37,7 @@ use crate::loading::Loader;
use crate::source::{SourceId, SourceStore};
use crate::syntax::ast::*;
use crate::syntax::{Span, Spanned};
use crate::util::RefMutExt;
use crate::util::{EcoString, RefMutExt};
use crate::Context;
/// Evaluate a parsed source file into a module.
@ -210,7 +209,7 @@ impl Eval for Lit {
LitKind::Angle(v, unit) => Value::Angle(Angle::with_unit(v, unit)),
LitKind::Percent(v) => Value::Relative(Relative::new(v / 100.0)),
LitKind::Fractional(v) => Value::Fractional(Fractional::new(v)),
LitKind::Str(ref v) => Value::Str(v.into()),
LitKind::Str(ref v) => Value::Str(v.clone()),
})
}
}
@ -239,7 +238,7 @@ impl Eval for DictExpr {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
self.items()
.map(|x| Ok((x.name().take().into(), x.expr().eval(ctx)?)))
.map(|x| Ok((x.name().take(), x.expr().eval(ctx)?)))
.collect()
}
}
@ -401,7 +400,7 @@ impl Eval for CallArgs {
CallArg::Named(named) => {
items.push(Arg {
span,
name: Some(named.name().take().into()),
name: Some(named.name().take()),
value: Spanned::new(named.expr().eval(ctx)?, named.expr().span()),
});
}
@ -600,7 +599,7 @@ impl Eval for ForExpr {
match (key, value, iter) {
(None, v, Value::Str(string)) => {
iter!(for (v => value) in string.iter());
iter!(for (v => value) in string.graphemes(true));
}
(None, v, Value::Array(array)) => {
iter!(for (v => value) in array.into_iter());
@ -629,7 +628,7 @@ impl Eval for ImportExpr {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let path = self.path();
let resolved = path.eval(ctx)?.cast::<Str>().at(path.span())?;
let resolved = path.eval(ctx)?.cast::<EcoString>().at(path.span())?;
let file = ctx.import(&resolved, path.span())?;
let module = &ctx.modules[&file];
@ -659,7 +658,7 @@ impl Eval for IncludeExpr {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let path = self.path();
let resolved = path.eval(ctx)?.cast::<Str>().at(path.span())?;
let resolved = path.eval(ctx)?.cast::<EcoString>().at(path.span())?;
let file = ctx.import(&resolved, path.span())?;
let module = &ctx.modules[&file];
Ok(Value::Template(module.template.clone()))

16
src/eval/ops.rs
View File

@ -1,7 +1,9 @@
use std::cmp::Ordering;
use std::convert::TryFrom;
use super::Value;
use crate::diag::StrResult;
use crate::util::EcoString;
use Value::*;
/// Bail with a type mismatch error.
@ -150,8 +152,8 @@ pub fn mul(lhs: Value, rhs: Value) -> StrResult<Value> {
(Fractional(a), Float(b)) => Fractional(a * b),
(Int(a), Fractional(b)) => Fractional(a as f64 * b),
(Str(a), Int(b)) => Str(a.repeat(b)?),
(Int(a), Str(b)) => Str(b.repeat(a)?),
(Str(a), Int(b)) => Str(repeat_str(a, b)?),
(Int(a), Str(b)) => Str(repeat_str(b, a)?),
(Array(a), Int(b)) => Array(a.repeat(b)?),
(Int(a), Array(b)) => Array(b.repeat(a)?),
(Template(a), Int(b)) => Template(a.repeat(b)?),
@ -161,6 +163,16 @@ pub fn mul(lhs: Value, rhs: Value) -> StrResult<Value> {
})
}
/// Repeat a string a number of times.
fn repeat_str(string: EcoString, n: i64) -> StrResult<EcoString> {
let n = usize::try_from(n)
.ok()
.and_then(|n| string.len().checked_mul(n).map(|_| n))
.ok_or_else(|| format!("cannot repeat this string {} times", n))?;
Ok(string.repeat(n))
}
/// Compute the quotient of two values.
pub fn div(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {

164
src/eval/str.rs
View File

@ -1,164 +0,0 @@
use std::borrow::Borrow;
use std::convert::TryFrom;
use std::fmt::{self, Debug, Formatter, Write};
use std::ops::{Add, AddAssign, Deref};
use unicode_segmentation::UnicodeSegmentation;
use crate::diag::StrResult;
use crate::util::EcoString;
/// Create a new [`Str`] from a format string.
macro_rules! format_str {
($($tts:tt)*) => {{
use std::fmt::Write;
let mut s = $crate::eval::Str::new();
write!(s, $($tts)*).unwrap();
s
}};
}
/// A string value with inline storage and clone-on-write semantics.
#[derive(Default, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct Str(EcoString);
impl Str {
/// Create a new, empty string.
pub fn new() -> Self {
Self::default()
}
/// Whether the string is empty.
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
/// The length of the string in bytes.
pub fn len(&self) -> i64 {
self.0.len() as i64
}
/// Borrow this as a string slice.
pub fn as_str(&self) -> &str {
self.0.as_str()
}
/// Return an iterator over the grapheme clusters as strings.
pub fn iter(&self) -> impl Iterator<Item = Str> + '_ {
self.graphemes(true).map(Into::into)
}
/// Repeat this string `n` times.
pub fn repeat(&self, n: i64) -> StrResult<Self> {
let n = usize::try_from(n)
.ok()
.and_then(|n| self.0.len().checked_mul(n).map(|_| n))
.ok_or_else(|| format!("cannot repeat this string {} times", n))?;
Ok(self.0.repeat(n).into())
}
}
impl Deref for Str {
type Target = str;
fn deref(&self) -> &str {
self.0.deref()
}
}
impl Debug for Str {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
f.write_char('"')?;
for c in self.chars() {
match c {
'\\' => f.write_str(r"\\")?,
'"' => f.write_str(r#"\""#)?,
'\n' => f.write_str(r"\n")?,
'\r' => f.write_str(r"\r")?,
'\t' => f.write_str(r"\t")?,
_ => f.write_char(c)?,
}
}
f.write_char('"')
}
}
impl Add for Str {
type Output = Self;
fn add(mut self, rhs: Self) -> Self::Output {
self += rhs;
self
}
}
impl AddAssign for Str {
fn add_assign(&mut self, rhs: Self) {
self.0.push_str(rhs.as_str());
}
}
impl Write for Str {
fn write_str(&mut self, s: &str) -> fmt::Result {
self.0.write_str(s)
}
fn write_char(&mut self, c: char) -> fmt::Result {
self.0.write_char(c)
}
}
impl AsRef<str> for Str {
fn as_ref(&self) -> &str {
self
}
}
impl Borrow<str> for Str {
fn borrow(&self) -> &str {
self
}
}
impl From<char> for Str {
fn from(c: char) -> Self {
Self(c.into())
}
}
impl From<&str> for Str {
fn from(s: &str) -> Self {
Self(s.into())
}
}
impl From<String> for Str {
fn from(s: String) -> Self {
Self(s.into())
}
}
impl From<EcoString> for Str {
fn from(s: EcoString) -> Self {
Self(s)
}
}
impl From<&EcoString> for Str {
fn from(s: &EcoString) -> Self {
Self(s.clone())
}
}
impl From<Str> for EcoString {
fn from(s: Str) -> Self {
s.0
}
}
impl From<&Str> for EcoString {
fn from(s: &Str) -> Self {
s.0.clone()
}
}

13
src/eval/template.rs
View File

@ -5,7 +5,6 @@ use std::mem;
use std::ops::{Add, AddAssign};
use std::rc::Rc;
use super::Str;
use crate::diag::StrResult;
use crate::geom::{Align, Dir, GenAxis, Length, Linear, Sides, Size};
use crate::layout::{BlockLevel, BlockNode, InlineLevel, InlineNode, PageNode};
@ -214,20 +213,20 @@ impl AddAssign for Template {
}
}
impl Add<Str> for Template {
impl Add<EcoString> for Template {
type Output = Self;
fn add(mut self, rhs: Str) -> Self::Output {
Rc::make_mut(&mut self.0).push(TemplateNode::Text(rhs.into()));
fn add(mut self, rhs: EcoString) -> Self::Output {
Rc::make_mut(&mut self.0).push(TemplateNode::Text(rhs));
self
}
}
impl Add<Template> for Str {
impl Add<Template> for EcoString {
type Output = Template;
fn add(self, mut rhs: Template) -> Self::Output {
Rc::make_mut(&mut rhs.0).insert(0, TemplateNode::Text(self.into()));
Rc::make_mut(&mut rhs.0).insert(0, TemplateNode::Text(self));
rhs
}
}
@ -491,7 +490,7 @@ impl ParBuilder {
self.children.last_mut()
{
if prev_align == curr_align && Rc::ptr_eq(prev_props, curr_props) {
prev_text.push_str(&curr_text);
prev_text.push_str(curr_text);
return;
}
}

26
src/eval/value.rs
View File

@ -3,7 +3,7 @@ use std::cmp::Ordering;
use std::fmt::{self, Debug, Formatter};
use std::rc::Rc;
use super::{ops, Array, Dict, Function, Str, Template};
use super::{ops, Array, Dict, Function, Template};
use crate::diag::StrResult;
use crate::geom::{Angle, Color, Fractional, Length, Linear, Relative, RgbaColor};
use crate::syntax::Spanned;
@ -35,7 +35,7 @@ pub enum Value {
/// A color value: `#f79143ff`.
Color(Color),
/// A string: `"string"`.
Str(Str),
Str(EcoString),
/// An array of values: `(1, "hi", 12cm)`.
Array(Array),
/// A dictionary value: `(color: #f79143, pattern: dashed)`.
@ -63,7 +63,7 @@ impl Value {
Self::Linear(_) => Linear::TYPE_NAME,
Self::Fractional(_) => Fractional::TYPE_NAME,
Self::Color(_) => Color::TYPE_NAME,
Self::Str(_) => Str::TYPE_NAME,
Self::Str(_) => EcoString::TYPE_NAME,
Self::Array(_) => Array::TYPE_NAME,
Self::Dict(_) => Dict::TYPE_NAME,
Self::Template(_) => Template::TYPE_NAME,
@ -81,8 +81,8 @@ impl Value {
}
/// Return the debug representation of the value.
pub fn repr(&self) -> Str {
format_str!("{:?}", self)
pub fn repr(&self) -> EcoString {
format_eco!("{:?}", self)
}
/// Join the value with another value.
@ -163,17 +163,12 @@ impl From<String> for Value {
}
}
impl From<EcoString> for Value {
fn from(v: EcoString) -> Self {
Self::Str(v.into())
}
}
impl From<Dynamic> for Value {
fn from(v: Dynamic) -> Self {
Self::Dyn(v)
}
}
/// A dynamic value.
#[derive(Clone)]
pub struct Dynamic(Rc<dyn Bounds>);
@ -338,7 +333,8 @@ macro_rules! dynamic {
}
castable! {
$type: <Self as $crate::eval::Type>::TYPE_NAME,
$type,
Expected: <Self as $crate::eval::Type>::TYPE_NAME,
$($tts)*
@this: Self => this.clone(),
}
@ -354,8 +350,8 @@ macro_rules! dynamic {
/// Make a type castable from a value.
macro_rules! castable {
(
$type:ty:
$expected:expr,
$type:ty,
Expected: $expected:expr,
$($pattern:pat => $out:expr,)*
$(@$dyn_in:ident: $dyn_type:ty => $dyn_out:expr,)*
) => {
@ -398,7 +394,7 @@ primitive! { Relative: "relative", Relative }
primitive! { Linear: "linear", Linear, Length(v) => v.into(), Relative(v) => v.into() }
primitive! { Fractional: "fractional", Fractional }
primitive! { Color: "color", Color }
primitive! { Str: "string", Str }
primitive! { EcoString: "string", Str }
primitive! { Array: "array", Array }
primitive! { Dict: "dictionary", Dict }
primitive! { Template: "template", Template }

18
src/eval/walk.rs
View File

@ -1,12 +1,12 @@
use std::rc::Rc;
use super::{Eval, EvalContext, Str, Template, Value};
use super::{Eval, EvalContext, Template, Value};
use crate::diag::TypResult;
use crate::geom::Spec;
use crate::layout::BlockLevel;
use crate::library::{GridNode, ParChild, ParNode, TrackSizing};
use crate::syntax::ast::*;
use crate::util::BoolExt;
use crate::util::{BoolExt, EcoString};
/// Walk markup, filling the currently built template.
pub trait Walk {
@ -39,8 +39,8 @@ impl Walk for MarkupNode {
Self::Enum(enum_) => enum_.walk(ctx)?,
Self::Expr(expr) => match expr.eval(ctx)? {
Value::None => {}
Value::Int(v) => ctx.template.text(format_str!("{}", v)),
Value::Float(v) => ctx.template.text(format_str!("{}", v)),
Value::Int(v) => ctx.template.text(format_eco!("{}", v)),
Value::Float(v) => ctx.template.text(format_eco!("{}", v)),
Value::Str(v) => ctx.template.text(v),
Value::Template(v) => ctx.template += v,
// For values which can't be shown "naturally", we print the
@ -108,7 +108,7 @@ impl Walk for HeadingNode {
impl Walk for ListNode {
fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
let body = self.body().eval(ctx)?;
walk_item(ctx, Str::from('•'), body);
walk_item(ctx, EcoString::from('•'), body);
Ok(())
}
}
@ -116,19 +116,19 @@ impl Walk for ListNode {
impl Walk for EnumNode {
fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
let body = self.body().eval(ctx)?;
let label = format_str!("{}.", self.number().unwrap_or(1));
let label = format_eco!("{}.", self.number().unwrap_or(1));
walk_item(ctx, label, body);
Ok(())
}
}
fn walk_item(ctx: &mut EvalContext, label: Str, body: Template) {
fn walk_item(ctx: &mut EvalContext, label: EcoString, body: Template) {
ctx.template += Template::from_block(move |style| {
let label = ParNode {
dir: style.dir,
leading: style.leading(),
children: vec![ParChild::Text(
(&label).into(),
label.clone(),
style.aligns.inline,
Rc::clone(&style.text),
)],
@ -138,7 +138,7 @@ fn walk_item(ctx: &mut EvalContext, label: Str, body: Template) {
GridNode {
tracks: Spec::new(vec![TrackSizing::Auto; 2], vec![]),
gutter: Spec::new(vec![TrackSizing::Linear(spacing.into())], vec![]),
children: vec![label.pack(), body.to_stack(&style).pack()],
children: vec![label.pack(), body.to_stack(style).pack()],
}
});
}

10
src/export/pdf.rs
View File

@ -100,7 +100,7 @@ impl<'a> PdfExporter<'a> {
let mut resources = pages.resources();
let mut fonts = resources.fonts();
for (refs, f) in self.refs.fonts().zip(self.font_map.pdf_indices()) {
let name = format!("F{}", f);
let name = format_eco!("F{}", f);
fonts.pair(Name(name.as_bytes()), refs.type0_font);
}
@ -108,7 +108,7 @@ impl<'a> PdfExporter<'a> {
let mut images = resources.x_objects();
for (id, im) in self.refs.images().zip(self.image_map.pdf_indices()) {
let name = format!("Im{}", im);
let name = format_eco!("Im{}", im);
images.pair(Name(name.as_bytes()), id);
}
@ -153,7 +153,7 @@ impl<'a> PdfExporter<'a> {
fn write_pages(&mut self) {
for (id, page) in self.refs.contents().zip(self.frames) {
self.write_page(id, &page);
self.write_page(id, page);
}
}
@ -199,7 +199,7 @@ impl<'a> PdfExporter<'a> {
face_id = Some(text.face_id);
size = text.size;
let name = format!("F{}", self.font_map.map(text.face_id));
let name = format_eco!("F{}", self.font_map.map(text.face_id));
content.set_font(Name(name.as_bytes()), size.to_pt() as f32);
}
@ -541,7 +541,7 @@ fn encode_image(img: &Image) -> ImageResult<(Vec<u8>, Filter, ColorSpace)> {
// 8-bit gray PNG.
(ImageFormat::Png, DynamicImage::ImageLuma8(luma)) => {
let data = deflate(&luma.as_raw());
let data = deflate(luma.as_raw());
(data, Filter::FlateDecode, ColorSpace::DeviceGray)
}

6
src/export/subset.rs
View File

@ -36,7 +36,7 @@ struct Subsetter<'a> {
impl<'a> Subsetter<'a> {
/// Parse the font header and create a new subsetter.
fn new(data: &'a [u8], index: u32, glyphs: &'a HashSet<u16>) -> Option<Self> {
let mut s = Stream::new(&data);
let mut s = Stream::new(data);
let mut magic = s.read::<Magic>()?;
if magic == Magic::Collection {
@ -46,7 +46,7 @@ impl<'a> Subsetter<'a> {
let offsets = s.read_array32::<Offset32>(num_faces)?;
let offset = offsets.get(index)?.to_usize();
s = Stream::new_at(&data, offset)?;
s = Stream::new_at(data, offset)?;
magic = s.read::<Magic>()?;
if magic == Magic::Collection {
return None;
@ -117,7 +117,7 @@ impl<'a> Subsetter<'a> {
let len = data.len();
w.write(TableRecord {
tag: *tag,
checksum: checksum(&data),
checksum: checksum(data),
offset: offset as u32,
length: len as u32,
});

24
src/font.rs
View File

@ -317,30 +317,6 @@ pub enum VerticalFontMetric {
Linear(Linear),
}
/// A generic or named font family.
#[derive(Clone, Eq, PartialEq, Hash)]
pub enum FontFamily {
/// A family that has "serifs", small strokes attached to letters.
Serif,
/// A family in which glyphs do not have "serifs", small attached strokes.
SansSerif,
/// A family in which (almost) all glyphs are of equal width.
Monospace,
/// A specific family with a name.
Named(String),
}
impl Debug for FontFamily {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
f.pad(match self {
Self::Serif => "serif",
Self::SansSerif => "sans-serif",
Self::Monospace => "monospace",
Self::Named(s) => s,
})
}
}
/// Properties of a single font face.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct FaceInfo {

5
src/lib.rs
View File

@ -27,6 +27,8 @@
//! [layouted]: layout::layout
//! [PDF]: export::pdf
#[macro_use]
pub mod util;
#[macro_use]
pub mod diag;
#[macro_use]
@ -43,7 +45,6 @@ pub mod parse;
pub mod source;
pub mod style;
pub mod syntax;
pub mod util;
use std::rc::Rc;
@ -182,7 +183,7 @@ impl ContextBuilder {
loader,
#[cfg(feature = "layout-cache")]
layouts: LayoutCache::new(self.policy, self.max_size),
std: self.std.unwrap_or(library::new()),
std: self.std.unwrap_or_else(library::new),
style: self.style.unwrap_or_default(),
}
}

4
src/library/deco.rs
View File

@ -36,14 +36,14 @@ fn line_impl(args: &mut Args, kind: LineKind) -> TypResult<Value> {
/// `link`: Typeset text as a link.
pub fn link(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let url = args.expect::<Str>("url")?;
let url = args.expect::<EcoString>("url")?;
let body = args.find().unwrap_or_else(|| {
let mut template = Template::new();
template.text(url.trim_start_matches("mailto:").trim_start_matches("tel:"));
template
});
Ok(Value::Template(body.decorate(Decoration::Link(url.into()))))
Ok(Value::Template(body.decorate(Decoration::Link(url))))
}
/// A decoration for a frame.

11
src/library/grid.rs
View File

@ -3,7 +3,8 @@ use super::prelude::*;
/// `grid`: Arrange children into a grid.
pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
castable! {
Vec<TrackSizing>: "integer or (auto, linear, fractional, or array thereof)",
Vec<TrackSizing>,
Expected: "integer or (auto, linear, fractional, or array thereof)",
Value::Auto => vec![TrackSizing::Auto],
Value::Length(v) => vec![TrackSizing::Linear(v.into())],
Value::Relative(v) => vec![TrackSizing::Linear(v.into())],
@ -17,7 +18,8 @@ pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
TrackSizing: "auto, linear, or fractional",
TrackSizing,
Expected: "auto, linear, or fractional",
Value::Auto => Self::Auto,
Value::Length(v) => Self::Linear(v.into()),
Value::Relative(v) => Self::Linear(v.into()),
@ -43,10 +45,7 @@ pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
GridNode {
tracks: tracks.clone(),
gutter: gutter.clone(),
children: children
.iter()
.map(|child| child.to_stack(&style).pack())
.collect(),
children: children.iter().map(|child| child.to_stack(style).pack()).collect(),
}
})))
}

2
src/library/image.rs
View File

@ -6,7 +6,7 @@ use crate::image::ImageId;
/// `image`: An image.
pub fn image(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let path = args.expect::<Spanned<Str>>("path to image file")?;
let path = args.expect::<Spanned<EcoString>>("path to image file")?;
let width = args.named("width")?;
let height = args.named("height")?;

6
src/library/mod.rs
View File

@ -23,12 +23,12 @@ mod prelude {
pub use std::rc::Rc;
pub use crate::diag::{At, TypResult};
pub use crate::eval::{Args, EvalContext, Str, Template, Value};
pub use crate::eval::{Args, EvalContext, Template, Value};
pub use crate::frame::*;
pub use crate::geom::*;
pub use crate::layout::*;
pub use crate::syntax::{Span, Spanned};
pub use crate::util::OptionExt;
pub use crate::util::{EcoString, OptionExt};
}
pub use self::image::*;
@ -47,8 +47,8 @@ pub use transform::*;
pub use utility::*;
use crate::eval::{Scope, Value};
use crate::font::FontFamily;
use crate::geom::*;
use crate::style::FontFamily;
/// Construct a scope containing all standard library definitions.
pub fn new() -> Scope {

2
src/library/pad.rs
View File

@ -19,7 +19,7 @@ pub fn pad(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
Ok(Value::Template(Template::from_block(move |style| {
PadNode {
padding,
child: body.to_stack(&style).pack(),
child: body.to_stack(style).pack(),
}
})))
}

3
src/library/page.rs
View File

@ -4,7 +4,8 @@ use crate::style::{Paper, PaperClass};
/// `page`: Configure pages.
pub fn page(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
castable! {
Paper: "string",
Paper,
Expected: "string",
Value::Str(string) => Paper::from_name(&string).ok_or("unknown paper")?,
}

2
src/library/par.rs
View File

@ -34,7 +34,7 @@ pub fn par(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
/// `lang`: Configure the language.
pub fn lang(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let iso = args.find::<Str>();
let iso = args.find::<EcoString>();
let dir = if let Some(dir) = args.named::<Spanned<Dir>>("dir")? {
if dir.v.axis() == SpecAxis::Horizontal {
Some(dir.v)

3
src/library/spacing.rs
View File

@ -24,7 +24,8 @@ pub enum Spacing {
}
castable! {
Spacing: "linear or fractional",
Spacing,
Expected: "linear or fractional",
Value::Length(v) => Self::Linear(v.into()),
Value::Relative(v) => Self::Linear(v.into()),
Value::Linear(v) => Self::Linear(v),

3
src/library/stack.rs
View File

@ -11,7 +11,8 @@ pub fn stack(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
Child: "linear, fractional or template",
Child,
Expected: "linear, fractional or template",
Value::Length(v) => Self::Spacing(Spacing::Linear(v.into())),
Value::Relative(v) => Self::Spacing(Spacing::Linear(v.into())),
Value::Linear(v) => Self::Spacing(Spacing::Linear(v)),

152
src/library/text.rs
View File

@ -7,48 +7,42 @@ use ttf_parser::Tag;
use super::prelude::*;
use crate::font::{
Face, FaceId, FontFamily, FontStore, FontStretch, FontStyle, FontVariant, FontWeight,
Face, FaceId, FontStore, FontStretch, FontStyle, FontVariant, FontWeight,
VerticalFontMetric,
};
use crate::geom::{Dir, Em, Length, Point, Size};
use crate::style::{
FontFeatures, NumberPosition, NumberType, NumberWidth, Style, TextStyle,
FontFamily, FontFeatures, NumberPosition, NumberType, NumberWidth, Style,
StylisticSet, TextStyle,
};
use crate::util::SliceExt;
use crate::util::{EcoString, SliceExt};
/// `font`: Configure the font.
pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
struct FontDef(Rc<Vec<FontFamily>>);
struct FamilyDef(Rc<Vec<String>>);
struct FeatureList(Vec<(Tag, u32)>);
struct StylisticSet(Option<u8>);
castable! {
FontDef: "font family or array of font families",
Value::Str(string) => Self(Rc::new(vec![FontFamily::Named(string.to_lowercase())])),
Value::Array(values) => Self(Rc::new(
values
.into_iter()
.filter_map(|v| v.cast().ok())
.collect()
)),
@family: FontFamily => Self(Rc::new(vec![family.clone()])),
Vec<FontFamily>,
Expected: "string, generic family or array thereof",
Value::Str(string) => vec![FontFamily::Named(string.to_lowercase())],
Value::Array(values) => {
values.into_iter().filter_map(|v| v.cast().ok()).collect()
},
@family: FontFamily => vec![family.clone()],
}
castable! {
FamilyDef: "string or array of strings",
Value::Str(string) => Self(Rc::new(vec![string.to_lowercase()])),
Value::Array(values) => Self(Rc::new(
values
.into_iter()
.filter_map(|v| v.cast().ok())
.map(|string: Str| string.to_lowercase())
.collect()
)),
Vec<EcoString>,
Expected: "string or array of strings",
Value::Str(string) => vec![string.to_lowercase()],
Value::Array(values) => values
.into_iter()
.filter_map(|v| v.cast().ok())
.map(|string: EcoString| string.to_lowercase())
.collect(),
}
castable! {
FontStyle: "string",
FontStyle,
Expected: "string",
Value::Str(string) => match string.as_str() {
"normal" => Self::Normal,
"italic" => Self::Italic,
@ -58,7 +52,8 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
FontWeight: "integer or string",
FontWeight,
Expected: "integer or string",
Value::Int(v) => v.try_into().map_or(Self::BLACK, Self::from_number),
Value::Str(string) => match string.as_str() {
"thin" => Self::THIN,
@ -75,12 +70,14 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
FontStretch: "relative",
FontStretch,
Expected: "relative",
Value::Relative(v) => Self::from_ratio(v.get() as f32),
}
castable! {
VerticalFontMetric: "linear or string",
VerticalFontMetric,
Expected: "linear or string",
Value::Length(v) => Self::Linear(v.into()),
Value::Relative(v) => Self::Linear(v.into()),
Value::Linear(v) => Self::Linear(v),
@ -95,7 +92,8 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
StylisticSet: "none or integer",
StylisticSet,
Expected: "none or integer",
Value::None => Self(None),
Value::Int(v) => match v {
1 ..= 20 => Self(Some(v as u8)),
@ -104,7 +102,8 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
NumberType: "auto or string",
NumberType,
Expected: "auto or string",
Value::Auto => Self::Auto,
Value::Str(string) => match string.as_str() {
"lining" => Self::Lining,
@ -114,7 +113,8 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
NumberWidth: "auto or string",
NumberWidth,
Expected: "auto or string",
Value::Auto => Self::Auto,
Value::Str(string) => match string.as_str() {
"proportional" => Self::Proportional,
@ -124,7 +124,8 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
NumberPosition: "string",
NumberPosition,
Expected: "string",
Value::Str(string) => match string.as_str() {
"normal" => Self::Normal,
"subscript" => Self::Subscript,
@ -134,44 +135,39 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
}
castable! {
FeatureList: "array of strings or dictionary mapping tags to integers",
Value::Array(values) => Self(
values
.into_iter()
.filter_map(|v| v.cast().ok())
.map(|string: Str| (Tag::from_bytes_lossy(string.as_bytes()), 1))
.collect()
),
Value::Dict(values) => Self(
values
.into_iter()
.filter_map(|(k, v)| {
let tag = Tag::from_bytes_lossy(k.as_bytes());
let num = v.cast::<i64>().ok()?.try_into().ok()?;
Some((tag, num))
})
.collect()
),
Vec<(Tag, u32)>,
Expected: "array of strings or dictionary mapping tags to integers",
Value::Array(values) => values
.into_iter()
.filter_map(|v| v.cast().ok())
.map(|string: EcoString| (Tag::from_bytes_lossy(string.as_bytes()), 1))
.collect(),
Value::Dict(values) => values
.into_iter()
.filter_map(|(k, v)| {
let tag = Tag::from_bytes_lossy(k.as_bytes());
let num = v.cast::<i64>().ok()?.try_into().ok()?;
Some((tag, num))
})
.collect(),
}
let list = args.named("family")?.or_else(|| {
let families: Vec<_> = args.all().collect();
(!families.is_empty()).then(|| FontDef(Rc::new(families)))
(!families.is_empty()).then(|| families)
});
let serif = args.named("serif")?;
let sans_serif = args.named("sans-serif")?;
let monospace = args.named("monospace")?;
let fallback = args.named("fallback")?;
let size = args.named::<Linear>("size")?.or_else(|| args.find());
let style = args.named("style")?;
let weight = args.named("weight")?;
let stretch = args.named("stretch")?;
let fill = args.named("fill")?.or_else(|| args.find());
let size = args.named::<Linear>("size")?.or_else(|| args.find());
let top_edge = args.named("top-edge")?;
let bottom_edge = args.named("bottom-edge")?;
let fill = args.named("fill")?.or_else(|| args.find());
let kerning = args.named("kerning")?;
let smallcaps = args.named("smallcaps")?;
let alternates = args.named("alternates")?;
@ -199,22 +195,6 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let f = move |style_: &mut Style| {
let text = style_.text_mut();
if let Some(FontDef(list)) = &list {
text.families_mut().list = list.clone();
}
if let Some(FamilyDef(serif)) = &serif {
text.families_mut().serif = serif.clone();
}
if let Some(FamilyDef(sans_serif)) = &sans_serif {
text.families_mut().sans_serif = sans_serif.clone();
}
if let Some(FamilyDef(monospace)) = &monospace {
text.families_mut().monospace = monospace.clone();
}
if let Some(size) = size {
text.size = size.resolve(text.size);
}
@ -223,16 +203,21 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
text.fill = Paint::Color(fill);
}
set!(text.fallback => fallback);
set!(text.variant.style => style);
set!(text.variant.weight => weight);
set!(text.variant.stretch => stretch);
set!(text.top_edge => top_edge);
set!(text.bottom_edge => bottom_edge);
set!(text.fallback => fallback);
set!(text.families_mut().list => list.clone());
set!(text.families_mut().serif => serif.clone());
set!(text.families_mut().sans_serif => sans_serif.clone());
set!(text.families_mut().monospace => monospace.clone());
set!(text.features_mut().kerning => kerning);
set!(text.features_mut().smallcaps => smallcaps);
set!(text.features_mut().alternates => alternates);
set!(text.features_mut().stylistic_set => stylistic_set);
set!(text.features_mut().ligatures.standard => ligatures);
set!(text.features_mut().ligatures.discretionary => discretionary_ligatures);
set!(text.features_mut().ligatures.historical => historical_ligatures);
@ -241,14 +226,7 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
set!(text.features_mut().numbers.position => number_position);
set!(text.features_mut().numbers.slashed_zero => slashed_zero);
set!(text.features_mut().numbers.fractions => fractions);
if let Some(StylisticSet(stylistic_set)) = stylistic_set {
text.features_mut().stylistic_set = stylistic_set;
}
if let Some(FeatureList(features)) = &features {
text.features_mut().raw = features.clone();
}
set!(text.features_mut().raw => features.clone());
};
Ok(if let Some(body) = body {
@ -638,12 +616,10 @@ fn tags(features: &FontFeatures) -> Vec<Feature> {
feat(b"salt", 1);
}
let set_tag;
if let Some(set) = features.stylistic_set {
if matches!(set, 1 ..= 20) {
set_tag = [b's', b's', b'0' + set / 10, b'0' + set % 10];
feat(&set_tag, 1);
}
let storage;
if let StylisticSet(Some(set @ 1 ..= 20)) = features.stylistic_set {
storage = [b's', b's', b'0' + set / 10, b'0' + set % 10];
feat(&storage, 1);
}
if !features.ligatures.standard {

14
src/library/utility.rs
View File

@ -77,8 +77,8 @@ pub fn float(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
pub fn str(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let Spanned { v, span } = args.expect("value")?;
Ok(Value::Str(match v {
Value::Int(v) => format_str!("{}", v),
Value::Float(v) => format_str!("{}", v),
Value::Int(v) => format_eco!("{}", v),
Value::Float(v) => format_eco!("{}", v),
Value::Str(v) => v,
v => bail!(span, "cannot convert {} to string", v.type_name()),
}))
@ -87,7 +87,7 @@ pub fn str(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
/// `rgb`: Create an RGB(A) color.
pub fn rgb(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
Ok(Value::Color(Color::Rgba(
if let Some(string) = args.find::<Spanned<Str>>() {
if let Some(string) = args.find::<Spanned<EcoString>>() {
match RgbaColor::from_str(&string.v) {
Ok(color) => color,
Err(_) => bail!(string.span, "invalid hex string"),
@ -98,7 +98,7 @@ pub fn rgb(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let b = args.expect("blue component")?;
let a = args.eat()?.unwrap_or(Spanned::new(1.0, Span::detached()));
let f = |Spanned { v, span }: Spanned<f64>| {
if 0.0 <= v && v <= 1.0 {
if (0.0 ..= 1.0).contains(&v) {
Ok((v * 255.0).round() as u8)
} else {
bail!(span, "value must be between 0.0 and 1.0");
@ -182,19 +182,19 @@ pub fn range(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
/// `lower`: Convert a string to lowercase.
pub fn lower(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
Ok(args.expect::<Str>("string")?.to_lowercase().into())
Ok(args.expect::<EcoString>("string")?.to_lowercase().into())
}
/// `upper`: Convert a string to uppercase.
pub fn upper(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
Ok(args.expect::<Str>("string")?.to_uppercase().into())
Ok(args.expect::<EcoString>("string")?.to_uppercase().into())
}
/// `len`: The length of a string, an array or a dictionary.
pub fn len(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
let Spanned { v, span } = args.expect("collection")?;
Ok(Value::Int(match v {
Value::Str(v) => v.len(),
Value::Str(v) => v.len() as i64,
Value::Array(v) => v.len(),
Value::Dict(v) => v.len(),
v => bail!(

2
src/loading/fs.rs
View File

@ -119,7 +119,7 @@ impl FsLoader {
let path = path.strip_prefix(".").unwrap_or(path);
if let Ok(file) = File::open(path) {
if let Ok(mmap) = unsafe { Mmap::map(&file) } {
self.faces.extend(FaceInfo::parse(&path, &mmap));
self.faces.extend(FaceInfo::parse(path, &mmap));
}
}
}

14
src/parse/parser.rs
View File

@ -242,7 +242,7 @@ impl<'s> Parser<'s> {
self.eat();
rescan = false;
} else if required {
self.push_error(format!("expected {}", end));
self.push_error(format_eco!("expected {}", end));
}
}
@ -327,8 +327,8 @@ impl Parser<'_> {
pub fn unexpected(&mut self) {
match self.peek() {
Some(found) => {
let msg = format!("unexpected {}", found);
let error = NodeKind::Error(ErrorPos::Full, msg.into());
let msg = format_eco!("unexpected {}", found);
let error = NodeKind::Error(ErrorPos::Full, msg);
self.perform(error, Self::eat);
}
None => self.push_error("unexpected end of file"),
@ -339,8 +339,8 @@ impl Parser<'_> {
pub fn expected(&mut self, thing: &str) {
match self.peek() {
Some(found) => {
let msg = format!("expected {}, found {}", thing, found);
let error = NodeKind::Error(ErrorPos::Full, msg.into());
let msg = format_eco!("expected {}, found {}", thing, found);
let error = NodeKind::Error(ErrorPos::Full, msg);
self.perform(error, Self::eat);
}
None => self.expected_at(thing),
@ -400,8 +400,8 @@ impl Marker {
/// Insert an error message that `what` was expected at the marker position.
pub fn expected(self, p: &mut Parser, what: &str) {
let msg = format!("expected {}", what);
let error = NodeKind::Error(ErrorPos::Full, msg.into());
let msg = format_eco!("expected {}", what);
let error = NodeKind::Error(ErrorPos::Full, msg);
p.children.insert(self.0, GreenData::new(error, 0).into());
}

2
src/parse/scanner.rs
View File

@ -119,7 +119,7 @@ impl<'s> Scanner<'s> {
/// The full source string.
#[inline]
pub fn src(&self) -> &'s str {
&self.src
self.src
}
/// Slice out part of the source string.

28
src/parse/tokens.rs
View File

@ -239,7 +239,7 @@ impl<'s> Tokens<'s> {
self.s.eat_assert('{');
let sequence = self.s.eat_while(|c| c.is_ascii_alphanumeric());
if self.s.eat_if('}') {
if let Some(c) = resolve_hex(&sequence) {
if let Some(c) = resolve_hex(sequence) {
NodeKind::UnicodeEscape(c)
} else {
NodeKind::Error(
@ -270,7 +270,7 @@ impl<'s> Tokens<'s> {
None => NodeKind::Ident(read.into()),
}
} else {
NodeKind::Text("#".into())
NodeKind::Text('#'.into())
}
}
@ -284,7 +284,7 @@ impl<'s> Tokens<'s> {
} else if self.s.check_or(true, char::is_whitespace) {
NodeKind::Minus
} else {
NodeKind::Text("-".into())
NodeKind::Text('-'.into())
}
}
@ -340,7 +340,7 @@ impl<'s> Tokens<'s> {
NodeKind::Raw(Rc::new(resolve_raw(
column,
backticks,
self.s.get(start .. end).into(),
self.s.get(start .. end),
)))
} else {
let remaining = backticks - found;
@ -349,11 +349,10 @@ impl<'s> Tokens<'s> {
NodeKind::Error(
ErrorPos::End,
if found == 0 {
format!("expected {} {}", remaining, noun)
format_eco!("expected {} {}", remaining, noun)
} else {
format!("expected {} more {}", remaining, noun)
}
.into(),
format_eco!("expected {} more {}", remaining, noun)
},
)
}
}
@ -397,11 +396,10 @@ impl<'s> Tokens<'s> {
NodeKind::Error(
ErrorPos::End,
if !display || (!escaped && dollar) {
"expected closing dollar sign"
"expected closing dollar sign".into()
} else {
"expected closing bracket and dollar sign"
}
.into(),
"expected closing bracket and dollar sign".into()
},
)
}
}
@ -413,7 +411,7 @@ impl<'s> Tokens<'s> {
"auto" => NodeKind::Auto,
"true" => NodeKind::Bool(true),
"false" => NodeKind::Bool(false),
id => keyword(id).unwrap_or(NodeKind::Ident(id.into())),
id => keyword(id).unwrap_or_else(|| NodeKind::Ident(id.into())),
}
}
@ -461,9 +459,7 @@ impl<'s> Tokens<'s> {
"in" => NodeKind::Length(f, LengthUnit::In),
"deg" => NodeKind::Angle(f, AngularUnit::Deg),
"rad" => NodeKind::Angle(f, AngularUnit::Rad),
_ => {
return NodeKind::Unknown(all.into());
}
_ => NodeKind::Unknown(all.into()),
}
} else {
NodeKind::Unknown(all.into())

64
src/style/mod.rs
View File

@ -4,12 +4,14 @@ mod paper;
pub use paper::*;
use std::fmt::{self, Debug, Formatter};
use std::rc::Rc;
use ttf_parser::Tag;
use crate::font::*;
use crate::geom::*;
use crate::util::EcoString;
/// Defines a set of properties a template can be instantiated with.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
@ -192,7 +194,7 @@ impl TextStyle {
&[]
};
head.iter().chain(core).chain(tail).map(String::as_str)
head.iter().chain(core).chain(tail).map(EcoString::as_str)
}
/// Access the `families` style mutably.
@ -232,33 +234,57 @@ impl Default for TextStyle {
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct FamilyStyle {
/// The user-defined list of font families.
pub list: Rc<Vec<FontFamily>>,
pub list: Vec<FontFamily>,
/// Definition of serif font families.
pub serif: Rc<Vec<String>>,
pub serif: Vec<EcoString>,
/// Definition of sans-serif font families.
pub sans_serif: Rc<Vec<String>>,
pub sans_serif: Vec<EcoString>,
/// Definition of monospace font families used for raw text.
pub monospace: Rc<Vec<String>>,
pub monospace: Vec<EcoString>,
/// Base fonts that are tried as last resort.
pub base: Rc<Vec<String>>,
pub base: Vec<EcoString>,
}
impl Default for FamilyStyle {
fn default() -> Self {
Self {
list: Rc::new(vec![FontFamily::SansSerif]),
serif: Rc::new(vec!["ibm plex serif".into()]),
sans_serif: Rc::new(vec!["ibm plex sans".into()]),
monospace: Rc::new(vec!["ibm plex mono".into()]),
base: Rc::new(vec![
list: vec![FontFamily::SansSerif],
serif: vec!["ibm plex serif".into()],
sans_serif: vec!["ibm plex sans".into()],
monospace: vec!["ibm plex mono".into()],
base: vec![
"ibm plex sans".into(),
"latin modern math".into(),
"twitter color emoji".into(),
]),
],
}
}
}
/// A generic or named font family.
#[derive(Clone, Eq, PartialEq, Hash)]
pub enum FontFamily {
/// A family that has "serifs", small strokes attached to letters.
Serif,
/// A family in which glyphs do not have "serifs", small attached strokes.
SansSerif,
/// A family in which (almost) all glyphs are of equal width.
Monospace,
/// A specific family with a name.
Named(EcoString),
}
impl Debug for FontFamily {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
f.pad(match self {
Self::Serif => "serif",
Self::SansSerif => "sans-serif",
Self::Monospace => "monospace",
Self::Named(s) => s,
})
}
}
/// Whether various kinds of ligatures should appear.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct FontFeatures {
@ -269,7 +295,7 @@ pub struct FontFeatures {
/// Whether to apply stylistic alternates. ("salt")
pub alternates: bool,
/// Which stylistic set to apply. ("ss01" - "ss20")
pub stylistic_set: Option<u8>,
pub stylistic_set: StylisticSet,
/// Configuration of ligature features.
pub ligatures: LigatureFeatures,
/// Configuration of numbers features.
@ -284,7 +310,7 @@ impl Default for FontFeatures {
kerning: true,
smallcaps: false,
alternates: false,
stylistic_set: None,
stylistic_set: StylisticSet::default(),
ligatures: LigatureFeatures::default(),
numbers: NumberFeatures::default(),
raw: vec![],
@ -292,6 +318,16 @@ impl Default for FontFeatures {
}
}
/// A stylistic set in a font face.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct StylisticSet(pub Option<u8>);
impl Default for StylisticSet {
fn default() -> Self {
Self(None)
}
}
/// Whether various kinds of ligatures should appear.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct LigatureFeatures {

8
src/syntax/ast.rs
View File

@ -65,9 +65,9 @@ impl Markup {
NodeKind::Emph => Some(MarkupNode::Emph),
NodeKind::Text(s) => Some(MarkupNode::Text(s.clone())),
NodeKind::UnicodeEscape(c) => Some(MarkupNode::Text((*c).into())),
NodeKind::EnDash => Some(MarkupNode::Text("\u{2013}".into())),
NodeKind::EmDash => Some(MarkupNode::Text("\u{2014}".into())),
NodeKind::NonBreakingSpace => Some(MarkupNode::Text("\u{00A0}".into())),
NodeKind::EnDash => Some(MarkupNode::Text('\u{2013}'.into())),
NodeKind::EmDash => Some(MarkupNode::Text('\u{2014}'.into())),
NodeKind::NonBreakingSpace => Some(MarkupNode::Text('\u{00A0}'.into())),
NodeKind::Math(math) => Some(MarkupNode::Math(math.as_ref().clone())),
NodeKind::Raw(raw) => Some(MarkupNode::Raw(raw.as_ref().clone())),
NodeKind::Heading => node.cast().map(MarkupNode::Heading),
@ -175,7 +175,7 @@ impl EnumNode {
self.0
.children()
.find_map(|node| match node.kind() {
NodeKind::EnumNumbering(num) => Some(num.clone()),
NodeKind::EnumNumbering(num) => Some(*num),
_ => None,
})
.expect("enum node is missing number")

4
src/syntax/mod.rs
View File

@ -30,7 +30,7 @@ impl Green {
fn data(&self) -> &GreenData {
match self {
Green::Node(n) => &n.data,
Green::Token(t) => &t,
Green::Token(t) => t,
}
}
@ -55,7 +55,7 @@ impl Green {
/// The node's children.
pub fn children(&self) -> &[Green] {
match self {
Green::Node(n) => &n.children(),
Green::Node(n) => n.children(),
Green::Token(_) => &[],
}
}

5
src/syntax/span.rs
View File

@ -88,6 +88,11 @@ impl Span {
Self { end, ..self }
}
/// Whether the span is a single point.
pub fn is_empty(self) -> bool {
self.start == self.end
}
/// The byte length of the spanned region.
pub fn len(self) -> usize {
self.end - self.start

83
src/util/eco_string.rs
View File

@ -2,11 +2,21 @@ use std::borrow::Borrow;
use std::cmp::Ordering;
use std::fmt::{self, Debug, Display, Formatter, Write};
use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::ops::{Add, AddAssign, Deref};
use std::rc::Rc;
use super::RcExt;
/// Create a new [`EcoString`] from a format string.
macro_rules! format_eco {
($($tts:tt)*) => {{
use std::fmt::Write;
let mut s = $crate::util::EcoString::new();
write!(s, $($tts)*).unwrap();
s
}};
}
/// An economical string with inline storage and clone-on-write semantics.
#[derive(Clone)]
pub struct EcoString(Repr);
@ -142,14 +152,38 @@ impl EcoString {
}
}
/// Convert the string to lowercase.
pub fn to_lowercase(&self) -> Self {
if let Repr::Small { mut buf, len } = self.0 {
if self.is_ascii() {
buf[.. usize::from(len)].make_ascii_lowercase();
return Self(Repr::Small { buf, len });
}
}
self.as_str().to_lowercase().into()
}
/// Convert the string to uppercase.
pub fn to_uppercase(&self) -> Self {
if let Repr::Small { mut buf, len } = self.0 {
if self.is_ascii() {
buf[.. usize::from(len)].make_ascii_uppercase();
return Self(Repr::Small { buf, len });
}
}
self.as_str().to_uppercase().into()
}
/// Repeat this string `n` times.
pub fn repeat(&self, n: usize) -> Self {
if n == 0 {
return Self::new();
}
if let Repr::Small { buf, len } = &self.0 {
let prev = usize::from(*len);
if let Repr::Small { buf, len } = self.0 {
let prev = usize::from(len);
let new = prev.saturating_mul(n);
if new <= LIMIT {
let src = &buf[.. prev];
@ -193,7 +227,18 @@ impl Default for EcoString {
impl Debug for EcoString {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
Debug::fmt(self.as_str(), f)
f.write_char('"')?;
for c in self.chars() {
match c {
'\\' => f.write_str(r"\\")?,
'"' => f.write_str(r#"\""#)?,
'\n' => f.write_str(r"\n")?,
'\r' => f.write_str(r"\r")?,
'\t' => f.write_str(r"\t")?,
_ => f.write_char(c)?,
}
}
f.write_char('"')
}
}
@ -253,6 +298,21 @@ impl Write for EcoString {
}
}
impl Add for EcoString {
type Output = Self;
fn add(mut self, rhs: Self) -> Self::Output {
self += rhs;
self
}
}
impl AddAssign for EcoString {
fn add_assign(&mut self, rhs: Self) {
self.push_str(rhs.as_str());
}
}
impl AsRef<str> for EcoString {
fn as_ref(&self) -> &str {
self
@ -382,6 +442,21 @@ mod tests {
assert_eq!(&v[.. 2], "ab");
}
#[test]
fn test_str_case() {
assert_eq!(EcoString::new().to_uppercase(), "");
assert_eq!(EcoString::from("abc").to_uppercase(), "ABC");
assert_eq!(EcoString::from("AΣ").to_lowercase(), "aς");
assert_eq!(
EcoString::from("a").repeat(100).to_uppercase(),
EcoString::from("A").repeat(100)
);
assert_eq!(
EcoString::from("Ö").repeat(20).to_lowercase(),
EcoString::from("ö").repeat(20)
);
}
#[test]
fn test_str_repeat() {
// Test with empty string.

1
src/util/mod.rs
View File

@ -1,5 +1,6 @@
//! Utilities.
#[macro_use]
mod eco_string;
mod mac_roman;