yass-css 0.2.0

data/ext/yass/src/declarations/padding_inline_end.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeLengthPercentage;
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PaddingInlineEnd", mark)]
+pub struct YPaddingInlineEnd {
+  value: CachedValue<NonNegativeLengthPercentage>,
+}
+
+impl YPaddingInlineEnd {
+  pub fn new(value: NonNegativeLengthPercentage) -> Self {
+    Self {
+      value: CachedValue::new(value, |non_negative, ruby| {
+        YLengthPercentage::new(non_negative.0.clone()).into_value_with(ruby)
+      }),
+    }
+  }
+
+  pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+    rb_self.value.get(ruby)
+  }
+}
+
+impl DataTypeFunctions for YPaddingInlineEnd {
+  fn mark(&self, marker: &gc::Marker) {
+    self.value.mark(marker);
+  }
+}

data/ext/yass/src/declarations/padding_inline_start.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeLengthPercentage;
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PaddingInlineStart", mark)]
+pub struct YPaddingInlineStart {
+  value: CachedValue<NonNegativeLengthPercentage>,
+}
+
+impl YPaddingInlineStart {
+  pub fn new(value: NonNegativeLengthPercentage) -> Self {
+    Self {
+      value: CachedValue::new(value, |non_negative, ruby| {
+        YLengthPercentage::new(non_negative.0.clone()).into_value_with(ruby)
+      }),
+    }
+  }
+
+  pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+    rb_self.value.get(ruby)
+  }
+}
+
+impl DataTypeFunctions for YPaddingInlineStart {
+  fn mark(&self, marker: &gc::Marker) {
+    self.value.mark(marker);
+  }
+}

data/ext/yass/src/declarations/padding_left.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeLengthPercentage;
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PaddingLeft", mark)]
+pub struct YPaddingLeft {
+  value: CachedValue<NonNegativeLengthPercentage>,
+}
+
+impl YPaddingLeft {
+  pub fn new(value: NonNegativeLengthPercentage) -> Self {
+    Self {
+      value: CachedValue::new(value, |non_negative, ruby| {
+        YLengthPercentage::new(non_negative.0.clone()).into_value_with(ruby)
+      }),
+    }
+  }
+
+  pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+    rb_self.value.get(ruby)
+  }
+}
+
+impl DataTypeFunctions for YPaddingLeft {
+  fn mark(&self, marker: &gc::Marker) {
+    self.value.mark(marker);
+  }
+}

data/ext/yass/src/declarations/padding_right.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeLengthPercentage;
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PaddingRight", mark)]
+pub struct YPaddingRight {
+  value: CachedValue<NonNegativeLengthPercentage>,
+}
+
+impl YPaddingRight {
+  pub fn new(value: NonNegativeLengthPercentage) -> Self {
+    Self {
+      value: CachedValue::new(value, |non_negative, ruby| {
+        YLengthPercentage::new(non_negative.0.clone()).into_value_with(ruby)
+      }),
+    }
+  }
+
+  pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+    rb_self.value.get(ruby)
+  }
+}
+
+impl DataTypeFunctions for YPaddingRight {
+  fn mark(&self, marker: &gc::Marker) {
+    self.value.mark(marker);
+  }
+}

data/ext/yass/src/declarations/padding_top.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeLengthPercentage;
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PaddingTop", mark)]
+pub struct YPaddingTop {
+  value: CachedValue<NonNegativeLengthPercentage>,
+}
+
+impl YPaddingTop {
+  pub fn new(value: NonNegativeLengthPercentage) -> Self {
+    Self {
+      value: CachedValue::new(value, |non_negative, ruby| {
+        YLengthPercentage::new(non_negative.0.clone()).into_value_with(ruby)
+      }),
+    }
+  }
+
+  pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+    rb_self.value.get(ruby)
+  }
+}
+
+impl DataTypeFunctions for YPaddingTop {
+  fn mark(&self, marker: &gc::Marker) {
+    self.value.mark(marker);
+  }
+}

data/ext/yass/src/declarations/percentage.rs

@@ -0,0 +1,16 @@
+use magnus::{Ruby, typed_data};
+
+#[magnus::wrap(class = "Yass::Declarations::Percentage")]
+pub struct YPercentage {
+    value: f32
+}
+
+impl YPercentage {
+    pub fn new(value: f32) -> Self {
+        Self { value }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.value
+    }
+}

data/ext/yass/src/declarations/perspective.rs

@@ -0,0 +1,72 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::NonNegative, specified::{Length, Perspective}};
+
+use crate::{cached_value::CachedValue, declarations::length::length_to_value};
+
+fn make_perspective_value(value: &Perspective, ruby: &Ruby) -> Value {
+    match value {
+        Perspective::Length(non_negative) => {
+            YPerspectiveLength::new(non_negative.clone()).into_value_with(ruby)
+        }
+        Perspective::None => YPerspectiveNone::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Perspective", mark)]
+pub struct YPerspective {
+    value: CachedValue<Perspective>,
+}
+
+impl YPerspective {
+    pub fn new(perspective: Perspective) -> Self {
+        Self {
+            value: CachedValue::new(perspective, make_perspective_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YPerspective {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Perspective::None")]
+pub struct YPerspectiveNone {}
+
+impl YPerspectiveNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Perspective::Length", mark)]
+pub struct YPerspectiveLength {
+    length: CachedValue<NonNegative<Length>>,
+}
+
+impl YPerspectiveLength {
+    pub fn new(non_negative_length: NonNegative<Length>) -> Self {
+        Self {
+            length: CachedValue::new(non_negative_length, |value, ruby| {
+                length_to_value(&value.0, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YPerspectiveLength {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length.mark(marker);
+    }
+}

data/ext/yass/src/declarations/perspective_origin.rs

@@ -0,0 +1,41 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::position::Position, specified::{PositionComponent, position::{HorizontalPositionKeyword, VerticalPositionKeyword}}};
+
+use crate::{cached_value::CachedValue, declarations::{horizontal_position_component::make_horizontal_position_component, vertical_position_component::make_vertical_position_component}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PerspectiveOrigin", mark)]
+pub struct YPerspectiveOrigin {
+    horizontal: CachedValue<PositionComponent<HorizontalPositionKeyword>>,
+    vertical: CachedValue<PositionComponent<VerticalPositionKeyword>>,
+}
+
+impl YPerspectiveOrigin {
+    pub fn new(position: Box<Position<PositionComponent<HorizontalPositionKeyword>, PositionComponent<VerticalPositionKeyword>>>) -> Self {
+        let position = *position;
+        Self {
+            horizontal: CachedValue::new(position.horizontal, |component, ruby| {
+                make_horizontal_position_component(component, ruby)
+            }),
+
+            vertical: CachedValue::new(position.vertical, |component, ruby| {
+                make_vertical_position_component(component, ruby)
+            }),
+        }
+    }
+
+    pub fn horizontal(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.horizontal.get(ruby)
+    }
+
+    pub fn vertical(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.vertical.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YPerspectiveOrigin {
+    fn mark(&self, marker: &gc::Marker) {
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+    }
+}

data/ext/yass/src/declarations/pointer_events.rs

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::PointerEvents;
+
+#[magnus::wrap(class = "Yass::Declarations::PointerEvents")]
+pub struct YPointerEvents {
+    pointer_events: PointerEvents
+}
+
+impl YPointerEvents {
+    pub fn new(pointer_events: PointerEvents) -> Self {
+        Self { pointer_events }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.pointer_events {
+            PointerEvents::Auto => ruby.intern("auto"),
+            PointerEvents::None => ruby.intern("none"),
+        }
+    }
+}

data/ext/yass/src/declarations/position.rs

@@ -0,0 +1,23 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::PositionProperty;
+
+#[magnus::wrap(class = "Yass::Declarations::Position")]
+pub struct YPosition {
+    position_property: PositionProperty
+}
+
+impl YPosition {
+    pub fn new(position_property: PositionProperty) -> Self {
+        Self { position_property }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.position_property {
+            PositionProperty::Static => ruby.intern("static"),
+            PositionProperty::Relative => ruby.intern("relative"),
+            PositionProperty::Absolute => ruby.intern("absolute"),
+            PositionProperty::Fixed => ruby.intern("fixed"),
+            PositionProperty::Sticky => ruby.intern("sticky"),
+        }
+    }
+}

data/ext/yass/src/declarations/position_area.rs

@@ -0,0 +1,82 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::PositionArea;
+use style::values::specified::position::PositionAreaKeyword;
+
+#[magnus::wrap(class = "Yass::Declarations::PositionArea")]
+pub struct YPositionArea {
+    position_area: PositionArea
+}
+
+impl YPositionArea {
+    pub fn new(position_area: PositionArea) -> Self {
+        Self { position_area }
+    }
+
+    pub fn first(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        keyword_to_sym(rb_self.position_area.first, ruby)
+    }
+
+    pub fn second(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        keyword_to_sym(rb_self.position_area.second, ruby)
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.position_area.is_none()
+    }
+}
+
+fn keyword_to_sym(keyword: PositionAreaKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        PositionAreaKeyword::None => ruby.intern("none"),
+        PositionAreaKeyword::Center => ruby.intern("center"),
+        PositionAreaKeyword::SpanAll => ruby.intern("span_all"),
+        PositionAreaKeyword::Start => ruby.intern("start"),
+        PositionAreaKeyword::End => ruby.intern("end"),
+        PositionAreaKeyword::SpanStart => ruby.intern("span_start"),
+        PositionAreaKeyword::SpanEnd => ruby.intern("span_end"),
+        PositionAreaKeyword::Left => ruby.intern("left"),
+        PositionAreaKeyword::Right => ruby.intern("right"),
+        PositionAreaKeyword::Top => ruby.intern("top"),
+        PositionAreaKeyword::Bottom => ruby.intern("bottom"),
+        PositionAreaKeyword::XStart => ruby.intern("x_start"),
+        PositionAreaKeyword::XEnd => ruby.intern("x_end"),
+        PositionAreaKeyword::YStart => ruby.intern("y_start"),
+        PositionAreaKeyword::YEnd => ruby.intern("y_end"),
+        PositionAreaKeyword::BlockStart => ruby.intern("block_start"),
+        PositionAreaKeyword::BlockEnd => ruby.intern("block_end"),
+        PositionAreaKeyword::InlineStart => ruby.intern("inline_start"),
+        PositionAreaKeyword::InlineEnd => ruby.intern("inline_end"),
+        PositionAreaKeyword::SpanLeft => ruby.intern("span_left"),
+        PositionAreaKeyword::SpanRight => ruby.intern("span_right"),
+        PositionAreaKeyword::SpanTop => ruby.intern("span_top"),
+        PositionAreaKeyword::SpanBottom => ruby.intern("span_bottom"),
+        PositionAreaKeyword::SpanXStart => ruby.intern("span_x_start"),
+        PositionAreaKeyword::SpanXEnd => ruby.intern("span_x_end"),
+        PositionAreaKeyword::SpanYStart => ruby.intern("span_y_start"),
+        PositionAreaKeyword::SpanYEnd => ruby.intern("span_y_end"),
+        PositionAreaKeyword::SpanBlockStart => ruby.intern("span_block_start"),
+        PositionAreaKeyword::SpanBlockEnd => ruby.intern("span_block_end"),
+        PositionAreaKeyword::SpanInlineStart => ruby.intern("span_inline_start"),
+        PositionAreaKeyword::SpanInlineEnd => ruby.intern("span_inline_end"),
+        PositionAreaKeyword::SelfStart => ruby.intern("self_start"),
+        PositionAreaKeyword::SelfEnd => ruby.intern("self_end"),
+        PositionAreaKeyword::SpanSelfStart => ruby.intern("span_self_start"),
+        PositionAreaKeyword::SpanSelfEnd => ruby.intern("span_self_end"),
+        PositionAreaKeyword::SelfXStart => ruby.intern("self_x_start"),
+        PositionAreaKeyword::SelfXEnd => ruby.intern("self_x_end"),
+        PositionAreaKeyword::SelfYStart => ruby.intern("self_y_start"),
+        PositionAreaKeyword::SelfYEnd => ruby.intern("self_y_end"),
+        PositionAreaKeyword::SelfBlockStart => ruby.intern("self_block_start"),
+        PositionAreaKeyword::SelfBlockEnd => ruby.intern("self_block_end"),
+        PositionAreaKeyword::SelfInlineStart => ruby.intern("self_inline_start"),
+        PositionAreaKeyword::SelfInlineEnd => ruby.intern("self_inline_end"),
+        PositionAreaKeyword::SpanSelfXStart => ruby.intern("span_self_x_start"),
+        PositionAreaKeyword::SpanSelfXEnd => ruby.intern("span_self_x_end"),
+        PositionAreaKeyword::SpanSelfYStart => ruby.intern("span_self_y_start"),
+        PositionAreaKeyword::SpanSelfYEnd => ruby.intern("span_self_y_end"),
+        PositionAreaKeyword::SpanSelfBlockStart => ruby.intern("span_self_block_start"),
+        PositionAreaKeyword::SpanSelfBlockEnd => ruby.intern("span_self_block_end"),
+        PositionAreaKeyword::SpanSelfInlineStart => ruby.intern("span_self_inline_start"),
+        PositionAreaKeyword::SpanSelfInlineEnd => ruby.intern("span_self_inline_end"),
+    }
+}

data/ext/yass/src/declarations/position_try_fallbacks.rs

@@ -0,0 +1,175 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{computed::PositionTryFallbacks, specified::position::{DashedIdentAndOrTryTactic, PositionArea, PositionAreaKeyword, PositionTryFallbacksItem, PositionTryFallbacksTryTacticKeyword}};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::PositionTryFallbacks", mark)]
+pub struct YPositionTryFallbacks {
+    values: CachedValueList<PositionTryFallbacksItem>,
+    is_none: bool,
+}
+
+impl YPositionTryFallbacks {
+    pub fn new(position_try_fallbacks: PositionTryFallbacks) -> Self {
+        Self {
+            values: CachedValueList::new(position_try_fallbacks.0.to_vec(), |item, _ctx, ruby| {
+                make_position_try_fallbacks_item(item, ruby)
+            }),
+
+            is_none: position_try_fallbacks.is_none(),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.is_none
+    }
+}
+
+impl DataTypeFunctions for YPositionTryFallbacks {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::PositionTryFallbacks::IdentAndOrTactic")]
+pub struct YPositionTryFallbacksIdentAndOrTactic {
+    ident: Option<String>,
+    try_tactics: Vec<PositionTryFallbacksTryTacticKeyword>,
+}
+
+impl YPositionTryFallbacksIdentAndOrTactic {
+    pub fn new(dashed_ident_and_or_try_tactic: DashedIdentAndOrTryTactic) -> Self {
+        Self {
+            ident: if dashed_ident_and_or_try_tactic.ident.is_empty() {
+                None
+            } else {
+                Some(dashed_ident_and_or_try_tactic.ident.0.to_string())
+            },
+
+            try_tactics: dashed_ident_and_or_try_tactic.try_tactic.iter().cloned().collect(),
+        }
+    }
+
+    pub fn ident(ruby: &Ruby, rb_self: &Self) -> Option<RString> {
+        rb_self.ident.as_ref().map(|ident| ruby.str_new(ident))
+    }
+
+    pub fn has_ident(_ruby: &Ruby, rb_self: &Self) -> bool {
+        rb_self.ident.is_some()
+    }
+
+    pub fn try_tactics(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.try_tactics.len());
+
+        for keyword in rb_self.try_tactics.iter() {
+            result.push(try_tactic_keyword_to_sym(*keyword, ruby))?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn has_try_tactics(_ruby: &Ruby, rb_self: &Self) -> bool {
+        !rb_self.try_tactics.is_empty()
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::PositionTryFallbacks::PositionArea")]
+pub struct YPositionTryFallbacksPositionArea {
+    position_area: PositionArea,
+}
+
+impl YPositionTryFallbacksPositionArea {
+    pub fn new(position_area: PositionArea) -> Self {
+        Self { position_area }
+    }
+
+    pub fn first(ruby: &Ruby, rb_self: &Self) -> Id {
+        position_area_keyword_to_sym(rb_self.position_area.first, ruby)
+    }
+
+    pub fn second(ruby: &Ruby, rb_self: &Self) -> Id {
+        position_area_keyword_to_sym(rb_self.position_area.second, ruby)
+    }
+}
+
+fn make_position_try_fallbacks_item(position_try_fallbacks_item: &PositionTryFallbacksItem, ruby: &Ruby) -> Value {
+    match position_try_fallbacks_item {
+        PositionTryFallbacksItem::IdentAndOrTactic(dashed_ident_and_or_try_tactic) => {
+            YPositionTryFallbacksIdentAndOrTactic::new(dashed_ident_and_or_try_tactic.clone()).into_value_with(ruby)
+        }
+        PositionTryFallbacksItem::PositionArea(position_area) => {
+            YPositionTryFallbacksPositionArea::new(position_area.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+fn try_tactic_keyword_to_sym(try_tactic_keyword: PositionTryFallbacksTryTacticKeyword, ruby: &Ruby) -> Id {
+    match try_tactic_keyword {
+        PositionTryFallbacksTryTacticKeyword::FlipBlock => ruby.intern("flip_block"),
+        PositionTryFallbacksTryTacticKeyword::FlipInline => ruby.intern("flip_inline"),
+        PositionTryFallbacksTryTacticKeyword::FlipStart => ruby.intern("flip_start"),
+        PositionTryFallbacksTryTacticKeyword::FlipX => ruby.intern("flip_x"),
+        PositionTryFallbacksTryTacticKeyword::FlipY => ruby.intern("flip_y"),
+    }
+}
+
+fn position_area_keyword_to_sym(position_area_keyword: PositionAreaKeyword, ruby: &Ruby) -> Id {
+    match position_area_keyword {
+        PositionAreaKeyword::None => ruby.intern("none"),
+        PositionAreaKeyword::Center => ruby.intern("center"),
+        PositionAreaKeyword::SpanAll => ruby.intern("span_all"),
+        PositionAreaKeyword::Start => ruby.intern("start"),
+        PositionAreaKeyword::End => ruby.intern("end"),
+        PositionAreaKeyword::SpanStart => ruby.intern("span_start"),
+        PositionAreaKeyword::SpanEnd => ruby.intern("span_end"),
+        PositionAreaKeyword::Left => ruby.intern("left"),
+        PositionAreaKeyword::Right => ruby.intern("right"),
+        PositionAreaKeyword::Top => ruby.intern("top"),
+        PositionAreaKeyword::Bottom => ruby.intern("bottom"),
+        PositionAreaKeyword::XStart => ruby.intern("x_start"),
+        PositionAreaKeyword::XEnd => ruby.intern("x_end"),
+        PositionAreaKeyword::YStart => ruby.intern("y_start"),
+        PositionAreaKeyword::YEnd => ruby.intern("y_end"),
+        PositionAreaKeyword::BlockStart => ruby.intern("block_start"),
+        PositionAreaKeyword::BlockEnd => ruby.intern("block_end"),
+        PositionAreaKeyword::InlineStart => ruby.intern("inline_start"),
+        PositionAreaKeyword::InlineEnd => ruby.intern("inline_end"),
+        PositionAreaKeyword::SpanLeft => ruby.intern("span_left"),
+        PositionAreaKeyword::SpanRight => ruby.intern("span_right"),
+        PositionAreaKeyword::SpanTop => ruby.intern("span_top"),
+        PositionAreaKeyword::SpanBottom => ruby.intern("span_bottom"),
+        PositionAreaKeyword::SpanXStart => ruby.intern("span_x_start"),
+        PositionAreaKeyword::SpanXEnd => ruby.intern("span_x_end"),
+        PositionAreaKeyword::SpanYStart => ruby.intern("span_y_start"),
+        PositionAreaKeyword::SpanYEnd => ruby.intern("span_y_end"),
+        PositionAreaKeyword::SpanBlockStart => ruby.intern("span_block_start"),
+        PositionAreaKeyword::SpanBlockEnd => ruby.intern("span_block_end"),
+        PositionAreaKeyword::SpanInlineStart => ruby.intern("span_inline_start"),
+        PositionAreaKeyword::SpanInlineEnd => ruby.intern("span_inline_end"),
+        PositionAreaKeyword::SelfStart => ruby.intern("self_start"),
+        PositionAreaKeyword::SelfEnd => ruby.intern("self_end"),
+        PositionAreaKeyword::SpanSelfStart => ruby.intern("span_self_start"),
+        PositionAreaKeyword::SpanSelfEnd => ruby.intern("span_self_end"),
+        PositionAreaKeyword::SelfXStart => ruby.intern("self_x_start"),
+        PositionAreaKeyword::SelfXEnd => ruby.intern("self_x_end"),
+        PositionAreaKeyword::SelfYStart => ruby.intern("self_y_start"),
+        PositionAreaKeyword::SelfYEnd => ruby.intern("self_y_end"),
+        PositionAreaKeyword::SelfBlockStart => ruby.intern("self_block_start"),
+        PositionAreaKeyword::SelfBlockEnd => ruby.intern("self_block_end"),
+        PositionAreaKeyword::SelfInlineStart => ruby.intern("self_inline_start"),
+        PositionAreaKeyword::SelfInlineEnd => ruby.intern("self_inline_end"),
+        PositionAreaKeyword::SpanSelfXStart => ruby.intern("span_self_x_start"),
+        PositionAreaKeyword::SpanSelfXEnd => ruby.intern("span_self_x_end"),
+        PositionAreaKeyword::SpanSelfYStart => ruby.intern("span_self_y_start"),
+        PositionAreaKeyword::SpanSelfYEnd => ruby.intern("span_self_y_end"),
+        PositionAreaKeyword::SpanSelfBlockStart => ruby.intern("span_self_block_start"),
+        PositionAreaKeyword::SpanSelfBlockEnd => ruby.intern("span_self_block_end"),
+        PositionAreaKeyword::SpanSelfInlineStart => ruby.intern("span_self_inline_start"),
+        PositionAreaKeyword::SpanSelfInlineEnd => ruby.intern("span_self_inline_end"),
+    }
+}