yass-css 0.2.0

data/ext/yass/src/rules/font_face_rule.rs

@@ -0,0 +1,206 @@
+use cssparser::{SourceLocation, UnicodeRange};
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{font_face::{FontDisplay, FontStretchRange, FontStyle, FontWeightRange, Source}, servo_arc::Arc, shared_lock::{Locked, SharedRwLock}, stylesheets::FontFaceRule, values::{computed::font::FamilyName, generics::NonNegative, specified::{Percentage, font::MetricsOverride}}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::percentage::YPercentage, general::{YSourceLocation, YUnicodeRange}, optional_cached_value::OptionalCachedValue, rules::fonts::{family::YFontFamilyName, metrics::{YFontMetricsOverride, YFontMetricsOverrideNormal}, source::font_source_to_value, stretch::YFontStretchRange, style::font_style_to_value, weight::YFontWeightRange}};
+
+fn metrics_override_to_value(metrics_override: &MetricsOverride, ruby: &Ruby) -> Value {
+    match *metrics_override {
+        MetricsOverride::Override(percentage) => {
+            YFontMetricsOverride::new(percentage.0).into_value_with(ruby)
+        },
+
+        MetricsOverride::Normal => {
+            YFontMetricsOverrideNormal::new().into_value_with(ruby)
+        },
+    }
+}
+
+fn font_display_to_id(font_display: &FontDisplay, ruby: &Ruby) -> Id {
+    match font_display {
+        FontDisplay::Auto => ruby.intern("auto"),
+        FontDisplay::Block => ruby.intern("block"),
+        FontDisplay::Swap => ruby.intern("swap"),
+        FontDisplay::Fallback => ruby.intern("fallback"),
+        FontDisplay::Optional => ruby.intern("optional"),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::FontFaceRule", mark)]
+pub struct YFontFaceRule {
+    ascent_override: OptionalCachedValue<MetricsOverride>,
+    descent_override: OptionalCachedValue<MetricsOverride>,
+    display: OptionalCachedValue<FontDisplay>,
+    family: OptionalCachedValue<FamilyName>,
+    language_override: Option<u32>,
+    line_gap_override: OptionalCachedValue<MetricsOverride>,
+    size_adjust: OptionalCachedValue<NonNegative<Percentage>>,
+    sources: Option<CachedValueList<Source>>,
+    font_stretch_range: OptionalCachedValue<FontStretchRange>,
+    style: OptionalCachedValue<FontStyle>,
+    unicode_range: Option<CachedValueList<UnicodeRange>>,
+    weight: OptionalCachedValue<FontWeightRange>,
+    source_location: CachedValue<SourceLocation>,
+}
+
+impl YFontFaceRule {
+    pub fn new(rule: Arc<Locked<FontFaceRule>>, lock: SharedRwLock) -> Self {
+        let guard = lock.read();
+        let font_face_rule = rule.read_with(&guard);
+
+        Self {
+            ascent_override: OptionalCachedValue::new(font_face_rule.descriptors.ascent_override, |ascent_override, ruby| {
+                metrics_override_to_value(ascent_override, ruby)
+            }),
+
+            descent_override: OptionalCachedValue::new(font_face_rule.descriptors.descent_override, |descent_override, ruby| {
+                metrics_override_to_value(descent_override, ruby)
+            }),
+
+            display: OptionalCachedValue::new(font_face_rule.descriptors.font_display, |display, ruby| {
+                font_display_to_id(display, ruby).into_value_with(ruby)
+            }),
+
+            // @TODO: Why do we have to clone twice here??
+            family: OptionalCachedValue::new(font_face_rule.descriptors.font_family.clone(), |family, ruby| {
+                YFontFamilyName::new(family.clone()).into_value_with(ruby)
+            }),
+
+            language_override: font_face_rule.descriptors.font_language_override.map(|lo| lo.0),
+
+            line_gap_override: OptionalCachedValue::new(font_face_rule.descriptors.line_gap_override, |line_gap_override, ruby| {
+                metrics_override_to_value(line_gap_override, ruby)
+            }),
+
+            size_adjust: OptionalCachedValue::new(font_face_rule.descriptors.size_adjust, |size_adjust, ruby| {
+                YPercentage::new(size_adjust.0.get()).into_value_with(ruby)
+            }),
+
+            sources: if font_face_rule.descriptors.src.is_some() {
+                Some(
+                    CachedValueList::new(font_face_rule.descriptors.src.as_ref().unwrap().0.clone(), |source, _ctx, ruby| {
+                        font_source_to_value(source, ruby)
+                    })
+                )
+            } else {
+                None
+            },
+
+            font_stretch_range: OptionalCachedValue::new(font_face_rule.descriptors.font_stretch.clone(), |stretch, ruby| {
+                YFontStretchRange::new(stretch.clone()).into_value_with(ruby)
+            }),
+
+            style: OptionalCachedValue::new(font_face_rule.descriptors.font_style.clone(), |style, ruby| {
+                font_style_to_value(style, ruby)
+            }),
+
+            unicode_range: if font_face_rule.descriptors.unicode_range.is_some() {
+                Some(
+                    CachedValueList::new(font_face_rule.descriptors.unicode_range.as_ref().unwrap().clone(), |range, _ctx, ruby| {
+                        YUnicodeRange::new(range.start, range.end).into_value_with(ruby)
+                    })
+                )
+            } else {
+                None
+            },
+
+            weight: OptionalCachedValue::new(font_face_rule.descriptors.font_weight.clone(), |weight, ruby| {
+                YFontWeightRange::new(weight.clone()).into_value_with(ruby)
+            }),
+
+            source_location: CachedValue::new(font_face_rule.source_location, |source_location, ruby| {
+                YSourceLocation::new(source_location.line, source_location.column).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn ascent_override(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.ascent_override.get(ruby)
+    }
+
+    pub fn descent_override(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.descent_override.get(ruby)
+    }
+
+    pub fn display(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.display.get(ruby)
+    }
+
+    pub fn family(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.family.get(ruby)
+    }
+
+    pub fn language_override(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<u32> {
+        rb_self.language_override
+    }
+
+    pub fn line_gap_override(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.line_gap_override.get(ruby)
+    }
+
+    pub fn size_adjust(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.size_adjust.get(ruby)
+    }
+
+    pub fn sources(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<Option<RArray>, Error> {
+        if let Some(sources) = &rb_self.sources {
+            if let Ok(arr) = sources.to_a(ruby) {
+                return Ok(Some(arr));
+            }
+        }
+
+        Ok(None)
+    }
+
+    pub fn font_stretch_range(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.font_stretch_range.get(ruby)
+    }
+
+    pub fn style(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.style.get(ruby)
+    }
+
+    pub fn unicode_range(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<Option<RArray>, Error> {
+        if let Some(unicode_range) = &rb_self.unicode_range {
+            if let Ok(items) = unicode_range.to_a(ruby) {
+                return Ok(Some(items));
+            }
+        }
+
+        Ok(None)
+    }
+
+    pub fn weight(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.weight.get(ruby)
+    }
+
+    pub fn source_location(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.source_location.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontFaceRule {
+    fn mark(&self, marker: &gc::Marker) {
+        self.ascent_override.mark(marker);
+        self.descent_override.mark(marker);
+        self.display.mark(marker);
+        self.family.mark(marker);
+
+        self.line_gap_override.mark(marker);
+        self.size_adjust.mark(marker);
+
+        if let Some(sources) = &self.sources {
+            sources.mark(marker);
+        }
+
+        self.font_stretch_range.mark(marker);
+        self.style.mark(marker);
+
+        if let Some(unicode_range) = &self.unicode_range {
+            unicode_range.mark(marker);
+        }
+
+        self.weight.mark(marker);
+    }
+}

data/ext/yass/src/rules/fonts/family.rs

@@ -0,0 +1,98 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use ::style::values::{computed::font::{FamilyName, FontFamilyList, FontFamilyNameSyntax, GenericFontFamily, SingleFontFamily}, specified::FontFamily};
+
+use crate::cached_value_list::CachedValueList;
+
+pub fn make_font_family(font_family: &FontFamily, ruby: &Ruby) -> Value {
+    match font_family {
+        FontFamily::Values(values) => YFontFamilyValues::new(values.clone()).into_value_with(ruby),
+        FontFamily::System(_) => YFontFamilySystem::new().into_value_with(ruby),
+    }
+}
+
+pub fn make_single_font_family(value: &SingleFontFamily, _ctx: &Option<()>, ruby: &Ruby) -> Value {
+    match value {
+        SingleFontFamily::FamilyName(name) => YFontFamilyName::new(name.clone()).into_value_with(ruby),
+        SingleFontFamily::Generic(generic) => {
+            YFontFamilyGeneric::new(*generic).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Font::Family::Values", mark)]
+pub struct YFontFamilyValues {
+    values: CachedValueList<SingleFontFamily>
+}
+
+impl YFontFamilyValues {
+    pub fn new(values: FontFamilyList) -> Self {
+        Self {
+            values: CachedValueList::new(values.iter().cloned().collect(), make_single_font_family),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontFamilyValues {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::Family::System")]
+pub struct YFontFamilySystem {}
+
+impl YFontFamilySystem {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::Family::Name")]
+pub struct YFontFamilyName {
+    family_name: FamilyName,
+}
+
+impl YFontFamilyName {
+    pub fn new(family_name: FamilyName) -> Self {
+        Self { family_name }
+    }
+
+    pub fn name(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> String {
+        rb_self.family_name.name.to_string()
+    }
+
+    pub fn syntax(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.family_name.syntax {
+            FontFamilyNameSyntax::Quoted => ruby.intern("quoted"),
+            FontFamilyNameSyntax::Identifiers => ruby.intern("identifiers"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::Family::Generic")]
+pub struct YFontFamilyGeneric {
+    generic: GenericFontFamily,
+}
+
+impl YFontFamilyGeneric {
+    pub fn new(generic: GenericFontFamily) -> Self {
+        Self { generic }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.generic {
+            GenericFontFamily::None => ruby.intern("none"),
+            GenericFontFamily::Serif => ruby.intern("serif"),
+            GenericFontFamily::SansSerif => ruby.intern("sans_serif"),
+            GenericFontFamily::Monospace => ruby.intern("monospace"),
+            GenericFontFamily::Cursive => ruby.intern("cursive"),
+            GenericFontFamily::Fantasy => ruby.intern("fantasy"),
+            GenericFontFamily::SystemUi => ruby.intern("system_ui"),
+        }
+    }
+}

data/ext/yass/src/rules/fonts/init.rs

@@ -0,0 +1,81 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::rules::fonts::{
+    family::{YFontFamilyGeneric, YFontFamilyName, YFontFamilyValues}, metrics::YFontMetricsOverride, source::{
+        YFontFaceSourceFormatKeyword,
+        YFontFaceSourceFormatString,
+        YFontSourceLocal,
+        YFontSourceUrl,
+    }, stretch::{YFontStretch, YFontStretchKeyword, YFontStretchRange}, style::YFontStyleOblique, weight::YFontWeightRange
+};
+
+pub fn init(ruby: &Ruby, yass_module: &RModule) -> Result<(), Error> {
+    let font_module = yass_module.define_module("Font")?;
+    let family_module = font_module.define_module("Family")?;
+
+    let font_family_name_class = family_module.define_class("Name", ruby.class_object())?;
+    font_family_name_class.define_method("name", method!(YFontFamilyName::name, 0))?;
+    font_family_name_class.define_method("syntax", method!(YFontFamilyName::syntax, 0))?;
+
+    let font_family_generic_class = family_module.define_class("Generic", ruby.class_object())?;
+    font_family_generic_class.define_method("value", method!(YFontFamilyGeneric::value, 0))?;
+
+    let font_family_values_class = family_module.define_class("Values", ruby.class_object())?;
+    font_family_values_class.define_method("values", method!(YFontFamilyValues::values, 0))?;
+
+    let _font_family_system_class: magnus::RClass = family_module.define_class("System", ruby.class_object())?;
+
+    let font_metrics_module = font_module.define_module("Metrics")?;
+
+    let font_metrics_override_class = font_metrics_module.define_class("Override", ruby.class_object())?;
+    font_metrics_override_class.define_method("value", method!(YFontMetricsOverride::value, 0))?;
+
+    let _font_metrics_override_normal_class = font_metrics_module.define_class("OverrideNormal", ruby.class_object())?;
+
+    let font_source_format_module = font_module.define_module("SourceFormat")?;
+
+    let font_source_format_keyword_class = font_source_format_module.define_class("Keyword", ruby.class_object())?;
+    font_source_format_keyword_class.define_method("value", method!(YFontFaceSourceFormatKeyword::value, 0))?;
+
+    let font_source_format_string_class = font_source_format_module.define_class("String", ruby.class_object())?;
+    font_source_format_string_class.define_method("value", method!(YFontFaceSourceFormatString::value, 0))?;
+
+    let font_source_module = font_module.define_module("Source")?;
+
+    let font_source_url_class = font_source_module.define_class("Url", ruby.class_object())?;
+    font_source_url_class.define_method("specified_url", method!(YFontSourceUrl::specified_url, 0))?;
+    font_source_url_class.define_method("format_hint", method!(YFontSourceUrl::format_hint, 0))?;
+
+    let font_source_local_class = font_source_module.define_class("Local", ruby.class_object())?;
+    font_source_local_class.define_method("family_name", method!(YFontSourceLocal::family_name, 0))?;
+
+    let font_stretch_module = yass_module.define_module("FontStretch")?;
+
+    let font_stretch_range_class = font_stretch_module.define_class("Range", ruby.class_object())?;
+    font_stretch_range_class.define_method("begin", method!(YFontStretchRange::begin, 0))?;
+    font_stretch_range_class.define_method("end", method!(YFontStretchRange::end, 0))?;
+
+    let font_stretch_stretch_class = font_stretch_module.define_class("Stretch", ruby.class_object())?;
+    font_stretch_stretch_class.define_method("value", method!(YFontStretch::value, 0))?;
+
+    let font_stretch_keyword_class = font_stretch_module.define_class("Keyword", ruby.class_object())?;
+    font_stretch_keyword_class.define_method("value", method!(YFontStretchKeyword::value, 0))?;
+
+    let font_style_module = yass_module.define_module("FontStyle")?;
+
+    let _font_style_italic_class = font_style_module.define_class("Italic", ruby.class_object())?;
+
+    let font_style_oblique_class = font_style_module.define_class("Oblique", ruby.class_object())?;
+    font_style_oblique_class.define_method("angle1", method!(YFontStyleOblique::angle1, 0))?;
+    font_style_oblique_class.define_method("angle2", method!(YFontStyleOblique::angle2, 0))?;
+
+    let font_weight_module = yass_module.define_module("FontWeight")?;
+
+    let _font_weight_normal_class = font_weight_module.define_class("Normal", ruby.class_object())?;
+
+    let font_weight_range_class = font_weight_module.define_class("Range", ruby.class_object())?;
+    font_weight_range_class.define_method("begin", method!(YFontWeightRange::begin, 0))?;
+    font_weight_range_class.define_method("end", method!(YFontWeightRange::end, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/rules/fonts/metrics.rs

@@ -0,0 +1,26 @@
+use magnus::{Ruby, typed_data};
+use style::values::specified::Percentage;
+
+#[magnus::wrap(class = "Yass::Font::Metrics::Override")]
+pub struct YFontMetricsOverride {
+    percentage: Percentage
+}
+
+impl YFontMetricsOverride {
+    pub fn new(percentage: Percentage) -> Self {
+        Self { percentage }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.percentage.get()
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::Metrics::OverrideNormal")]
+pub struct YFontMetricsOverrideNormal {}
+
+impl YFontMetricsOverrideNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

data/ext/yass/src/rules/fonts/mod.rs

@@ -0,0 +1,7 @@
+pub mod family;
+pub mod init;
+pub mod metrics;
+pub mod source;
+pub mod stretch;
+pub mod style;
+pub mod weight;

data/ext/yass/src/rules/fonts/source.rs

@@ -0,0 +1,126 @@
+use magnus::{DataTypeFunctions, IntoValue, RString, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{font_face::{FontFaceSourceFormat, FontFaceSourceFormatKeyword, Source, UrlSource}, values::{computed::font::FamilyName}};
+
+use crate::{cached_value::CachedValue, optional_cached_value::OptionalCachedValue, rules::fonts::family::YFontFamilyName};
+
+pub fn font_source_to_value(source: &Source, ruby: &Ruby) -> Value {
+    match source {
+        Source::Url(url_source) => {
+            YFontSourceUrl::new(url_source.clone()).into_value_with(ruby)
+        },
+
+        Source::Local(family_name) => {
+            YFontSourceLocal::new(family_name.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+pub fn font_source_format_to_value(source_format: &FontFaceSourceFormat, ruby: &Ruby) -> Value {
+    match source_format {
+        FontFaceSourceFormat::Keyword(keyword) => {
+            YFontFaceSourceFormatKeyword::new(*keyword).into_value_with(ruby)
+        },
+
+        FontFaceSourceFormat::String(str) => {
+            YFontFaceSourceFormatString::new(str.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::SourceFormat::Keyword")]
+pub struct YFontFaceSourceFormatKeyword {
+    keyword: FontFaceSourceFormatKeyword
+}
+
+impl YFontFaceSourceFormatKeyword {
+    pub fn new(keyword: FontFaceSourceFormatKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.keyword {
+            FontFaceSourceFormatKeyword::None => ruby.intern("none"),
+            FontFaceSourceFormatKeyword::Collection => ruby.intern("collection"),
+            FontFaceSourceFormatKeyword::EmbeddedOpentype => ruby.intern("embedded_opentype"),
+            FontFaceSourceFormatKeyword::Opentype => ruby.intern("opentype"),
+            FontFaceSourceFormatKeyword::Svg => ruby.intern("svg"),
+            FontFaceSourceFormatKeyword::Truetype => ruby.intern("truetype"),
+            FontFaceSourceFormatKeyword::Woff => ruby.intern("woff"),
+            FontFaceSourceFormatKeyword::Woff2 => ruby.intern("woff2"),
+            FontFaceSourceFormatKeyword::Unknown => ruby.intern("unknown"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Font::SourceFormat::String")]
+pub struct YFontFaceSourceFormatString {
+    str: String
+}
+
+impl YFontFaceSourceFormatString {
+    pub fn new(str: String) -> Self {
+        Self { str }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> RString {
+        ruby.str_new(&rb_self.str)
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Font::Source::Url", mark)]
+pub struct YFontSourceUrl {
+    specified_url: String,
+    format_hint: OptionalCachedValue<FontFaceSourceFormat>,
+}
+
+impl YFontSourceUrl {
+    pub fn new(url_source: UrlSource) -> Self {
+        Self {
+            specified_url: url_source.url.as_str().to_string(),
+            format_hint: OptionalCachedValue::new(url_source.format_hint, |format_hint, ruby| {
+                font_source_format_to_value(format_hint, ruby).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn specified_url(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> RString {
+        ruby.str_new(&rb_self.specified_url)
+    }
+
+    pub fn format_hint(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.format_hint.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontSourceUrl {
+    fn mark(&self, marker: &gc::Marker) {
+        self.format_hint.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Font::Source::Local", mark)]
+pub struct YFontSourceLocal {
+    family_name: CachedValue<FamilyName>
+}
+
+impl YFontSourceLocal {
+    pub fn new(family_name: FamilyName) -> Self {
+        Self {
+            family_name: CachedValue::new(family_name, |family_name, ruby| {
+                YFontFamilyName::new(family_name.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn family_name(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.family_name.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontSourceLocal {
+    fn mark(&self, marker: &gc::Marker) {
+        self.family_name.mark(marker);
+    }
+}

data/ext/yass/src/rules/fonts/stretch.rs

@@ -0,0 +1,96 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{font_face::FontStretchRange, values::specified::{FontStretch, Percentage, font::FontStretchKeyword}};
+
+use crate::{cached_value::CachedValue, rules::fonts::family::YFontFamilySystem};
+
+pub fn font_stretch_to_value(stretch: &FontStretch, ruby: &Ruby) -> Value {
+    match stretch {
+        FontStretch::Stretch(non_negative) => {
+            YFontStretch::new(&non_negative.0).into_value_with(ruby)
+        },
+
+        FontStretch::Keyword(font_stretch_keyword) => {
+            YFontStretchKeyword::new(*font_stretch_keyword).into_value_with(ruby)
+        },
+
+        FontStretch::System(_) => {
+            YFontFamilySystem::new().into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::FontStretch::Range", mark)]
+pub struct YFontStretchRange {
+    begin: CachedValue<FontStretch>,
+    end: CachedValue<FontStretch>,
+}
+
+impl YFontStretchRange {
+    pub fn new(range: FontStretchRange) -> Self {
+        Self {
+            begin: CachedValue::new(range.0, |stretch, ruby| {
+                font_stretch_to_value(stretch, ruby)
+            }),
+
+            end: CachedValue::new(range.1, |stretch, ruby| {
+                font_stretch_to_value(stretch, ruby)
+            }),
+        }
+    }
+
+    pub fn begin(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.begin.get(ruby)
+    }
+
+    pub fn end(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.end.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontStretchRange {
+    fn mark(&self, marker: &gc::Marker) {
+        self.begin.mark(marker);
+        self.end.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::FontStretch::Stretch")]
+pub struct YFontStretch {
+    value: f32
+}
+
+impl YFontStretch {
+    pub fn new(percentage: &Percentage) -> Self {
+        Self { value: percentage.get() }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.value
+    }
+}
+
+#[magnus::wrap(class = "Yass::FontStretch::Keyword")]
+pub struct YFontStretchKeyword {
+    keyword: FontStretchKeyword
+}
+
+impl YFontStretchKeyword {
+    pub fn new(keyword: FontStretchKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.keyword {
+            FontStretchKeyword::Normal => ruby.intern("normal"),
+            FontStretchKeyword::Condensed => ruby.intern("condensed"),
+            FontStretchKeyword::UltraCondensed => ruby.intern("ultra_condensed"),
+            FontStretchKeyword::ExtraCondensed => ruby.intern("extra_condensed"),
+            FontStretchKeyword::SemiCondensed => ruby.intern("semi_condensed"),
+            FontStretchKeyword::SemiExpanded => ruby.intern("semi_expanded"),
+            FontStretchKeyword::Expanded => ruby.intern("expanded"),
+            FontStretchKeyword::ExtraExpanded => ruby.intern("extra_expanded"),
+            FontStretchKeyword::UltraExpanded => ruby.intern("ultra_expanded"),
+        }
+    }
+}