Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Support @supports (fixes #14786)

Browse source
This commit is contained in:
Manish Goregaokar 2016-12-29 19:09:53 -08:00
parent cdf14730ff
commit 1b0842e228
5 changed files with 296 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

1
components/style/lib.rs
View file

@ -122,6 +122,7 @@ pub mod sequential;
pub mod sink;
pub mod str;
pub mod stylesheets;
pub mod supports;
pub mod thread_state;
pub mod timer;
pub mod traversal;

68
components/style/stylesheets.rs
View file

@ -28,6 +28,7 @@ use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use style_traits::ToCss;
use stylist::FnvHashMap;
use supports::SupportsCondition;
use values::specified::url::SpecifiedUrl;
use viewport::ViewportRule;
@ -215,6 +216,7 @@ pub enum CssRule {
FontFace(Arc<RwLock<FontFaceRule>>),
Viewport(Arc<RwLock<ViewportRule>>),
Keyframes(Arc<RwLock<KeyframesRule>>),
Supports(Arc<RwLock<SupportsRule>>),
}
#[allow(missing_docs)]
@ -274,6 +276,7 @@ impl CssRule {
CssRule::Keyframes(_) => CssRuleType::Keyframes,
CssRule::Namespace(_) => CssRuleType::Namespace,
CssRule::Viewport(_) => CssRuleType::Viewport,
CssRule::Supports(_) => CssRuleType::Supports,
}
}
@ -290,9 +293,10 @@ impl CssRule {
///
/// Note that only some types of rules can contain rules. An empty slice is
/// used for others.
///
/// This will not recurse down unsupported @supports rules
pub fn with_nested_rules_and_mq<F, R>(&self, mut f: F) -> R
where F: FnMut(&[CssRule], Option<&MediaList>) -> R
{
where F: FnMut(&[CssRule], Option<&MediaList>) -> R {
match *self {
CssRule::Import(ref lock) => {
let rule = lock.read();
@ -315,6 +319,16 @@ impl CssRule {
let rules = &media_rule.rules.read().0;
f(rules, Some(&mq))
}
CssRule::Supports(ref lock) => {
let supports_rule = lock.read();
let enabled = supports_rule.enabled;
if enabled {
let rules = &supports_rule.rules.read().0;
f(rules, None)
} else {
f(&[], None)
}
}
}
}
@ -367,6 +381,7 @@ impl ToCss for CssRule {
CssRule::Viewport(ref lock) => lock.read().to_css(dest),
CssRule::Keyframes(ref lock) => lock.read().to_css(dest),
CssRule::Media(ref lock) => lock.read().to_css(dest),
CssRule::Supports(ref lock) => lock.read().to_css(dest),
}
}
}
@ -441,7 +456,12 @@ impl ToCss for KeyframesRule {
try!(dest.write_str(&*self.name.to_string()));
try!(dest.write_str(" { "));
let iter = self.keyframes.iter();
let mut first = true;
for lock in iter {
if !first {
try!(dest.write_str(" "));
}
first = false;
let keyframe = lock.read();
try!(keyframe.to_css(dest));
}
@ -460,9 +480,34 @@ impl ToCss for MediaRule {
// Serialization of MediaRule is not specced.
// https://drafts.csswg.org/cssom/#serialize-a-css-rule CSSMediaRule
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(dest.write_str("@media ("));
try!(dest.write_str("@media "));
try!(self.media_queries.read().to_css(dest));
try!(dest.write_str(") {"));
try!(dest.write_str(" {"));
for rule in self.rules.read().0.iter() {
try!(dest.write_str(" "));
try!(rule.to_css(dest));
}
dest.write_str(" }")
}
}
#[derive(Debug)]
/// An @supports rule
pub struct SupportsRule {
/// The parsed condition
pub condition: SupportsCondition,
/// Child rules
pub rules: Arc<RwLock<CssRules>>,
/// The result of evaluating the condition
pub enabled: bool,
}
impl ToCss for SupportsRule {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(dest.write_str("@supports "));
try!(self.condition.to_css(dest));
try!(dest.write_str(" {"));
for rule in self.rules.read().0.iter() {
try!(dest.write_str(" "));
try!(rule.to_css(dest));
@ -712,6 +757,7 @@ rule_filter! {
effective_font_face_rules(FontFace => FontFaceRule),
effective_viewport_rules(Viewport => ViewportRule),
effective_keyframes_rules(Keyframes => KeyframesRule),
effective_supports_rules(Supports => SupportsRule),
}
/// The stylesheet loader is the abstraction used to trigger network requests
@ -758,6 +804,8 @@ enum AtRulePrelude {
FontFace,
/// A @media rule prelude, with its media queries.
Media(Arc<RwLock<MediaList>>),
/// An @supports rule, with its conditional
Supports(SupportsCondition),
/// A @viewport rule prelude.
Viewport,
/// A @keyframes rule, with its animation name.
@ -913,6 +961,10 @@ impl<'a, 'b> AtRuleParser for NestedRuleParser<'a, 'b> {
let media_queries = parse_media_query_list(input);
Ok(AtRuleType::WithBlock(AtRulePrelude::Media(Arc::new(RwLock::new(media_queries)))))
},
"supports" => {
let cond = SupportsCondition::parse(input)?;
Ok(AtRuleType::WithBlock(AtRulePrelude::Supports(cond)))
},
"font-face" => {
Ok(AtRuleType::WithBlock(AtRulePrelude::FontFace))
},
@ -949,6 +1001,14 @@ impl<'a, 'b> AtRuleParser for NestedRuleParser<'a, 'b> {
rules: self.parse_nested_rules(input),
}))))
}
AtRulePrelude::Supports(cond) => {
let enabled = cond.eval(self.context);
Ok(CssRule::Supports(Arc::new(RwLock::new(SupportsRule {
condition: cond,
rules: self.parse_nested_rules(input),
enabled: enabled,
}))))
}
AtRulePrelude::Viewport => {
Ok(CssRule::Viewport(Arc::new(RwLock::new(
try!(ViewportRule::parse(input, self.context))))))

5
components/style/stylist.rs
View file

@ -408,14 +408,15 @@ impl Stylist {
fn mq_eval_changed(rules: &[CssRule], before: &Device, after: &Device) -> bool {
for rule in rules {
if rule.with_nested_rules_and_mq(|rules, mq| {
let changed = rule.with_nested_rules_and_mq(|rules, mq| {
if let Some(mq) = mq {
if mq.evaluate(before) != mq.evaluate(after) {
return true
}
}
mq_eval_changed(rules, before, after)
}) {
});
if changed {
return true
}
}

227
components/style/supports.rs Normal file
View file

@ -0,0 +1,227 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! [@supports rules](https://drafts.csswg.org/css-conditional-3/#at-supports)
use cssparser::{parse_important, Parser, Token};
use parser::ParserContext;
use properties::{PropertyDeclaration, PropertyId};
use std::fmt;
use style_traits::ToCss;
#[derive(Debug)]
/// An @supports condition
///
/// https://drafts.csswg.org/css-conditional-3/#at-supports
pub enum SupportsCondition {
/// `not (condition)`
Not(Box<SupportsCondition>),
/// `(condition)`
Parenthesized(Box<SupportsCondition>),
/// `(condition) and (condition) and (condition) ..`
And(Vec<SupportsCondition>),
/// `(condition) or (condition) or (condition) ..`
Or(Vec<SupportsCondition>),
/// `property-ident: value` (value can be any tokens)
Declaration(Declaration),
/// `(any tokens)` or `func(any tokens)`
FutureSyntax(String),
}
impl SupportsCondition {
/// Parse a condition
///
/// https://drafts.csswg.org/css-conditional/#supports_condition
pub fn parse(input: &mut Parser) -> Result<SupportsCondition, ()> {
if let Ok(_) = input.try(|i| i.expect_ident_matching("not")) {
let inner = SupportsCondition::parse_in_parens(input)?;
return Ok(SupportsCondition::Not(Box::new(inner)));
}
let in_parens = SupportsCondition::parse_in_parens(input)?;
let (keyword, wrapper) = match input.next() {
Err(()) => {
// End of input
return Ok(SupportsCondition::Parenthesized(Box::new(in_parens)))
}
Ok(Token::Ident(ident)) => {
match_ignore_ascii_case! { ident,
"and" => ("and", SupportsCondition::And as fn(_) -> _),
"or" => ("or", SupportsCondition::Or as fn(_) -> _),
_ => return Err(())
}
}
_ => return Err(())
};
let mut conditions = Vec::with_capacity(2);
conditions.push(in_parens);
loop {
conditions.push(SupportsCondition::parse_in_parens(input)?);
if input.try(|input| input.expect_ident_matching(keyword)).is_err() {
// Did not find the expected keyword.
// If we found some other token,
// it will be rejected by `Parser::parse_entirely` somewhere up the stack.
return Ok(wrapper(conditions))
}
}
}
/// https://drafts.csswg.org/css-conditional-3/#supports_condition_in_parens
fn parse_in_parens(input: &mut Parser) -> Result<SupportsCondition, ()> {
let pos = input.position();
match input.next()? {
Token::ParenthesisBlock => {
input.parse_nested_block(|input| {
// `input.try()` not needed here since the alternative uses `consume_all()`.
parse_condition_or_declaration(input).or_else(|()| {
consume_all(input);
Ok(SupportsCondition::FutureSyntax(input.slice_from(pos).to_owned()))
})
})
}
Token::Function(_) => {
input.parse_nested_block(|i| Ok(consume_all(i))).unwrap();
Ok(SupportsCondition::FutureSyntax(input.slice_from(pos).to_owned()))
}
_ => Err(())
}
}
/// Evaluate a supports condition
pub fn eval(&self, cx: &ParserContext) -> bool {
match *self {
SupportsCondition::Not(ref cond) => !cond.eval(cx),
SupportsCondition::Parenthesized(ref cond) => cond.eval(cx),
SupportsCondition::And(ref vec) => vec.iter().all(|c| c.eval(cx)),
SupportsCondition::Or(ref vec) => vec.iter().any(|c| c.eval(cx)),
SupportsCondition::Declaration(ref decl) => decl.eval(cx),
SupportsCondition::FutureSyntax(_) => false
}
}
}
/// supports_condition | declaration
/// https://drafts.csswg.org/css-conditional/#dom-css-supports-conditiontext-conditiontext
pub fn parse_condition_or_declaration(input: &mut Parser) -> Result<SupportsCondition, ()> {
input.try(SupportsCondition::parse).or_else(|()| {
Declaration::parse(input).map(SupportsCondition::Declaration)
})
}
impl ToCss for SupportsCondition {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
where W: fmt::Write {
match *self {
SupportsCondition::Not(ref cond) => {
dest.write_str("not (")?;
cond.to_css(dest)?;
dest.write_str(")")
}
SupportsCondition::Parenthesized(ref cond) => {
dest.write_str("(")?;
cond.to_css(dest)?;
dest.write_str(")")
}
SupportsCondition::And(ref vec) => {
let mut first = true;
for cond in vec {
if !first {
dest.write_str(" and ")?;
}
first = false;
dest.write_str("(")?;
cond.to_css(dest)?;
dest.write_str(")")?;
}
Ok(())
}
SupportsCondition::Or(ref vec) => {
let mut first = true;
for cond in vec {
if !first {
dest.write_str(" or ")?;
}
first = false;
dest.write_str("(")?;
cond.to_css(dest)?;
dest.write_str(")")?;
}
Ok(())
}
SupportsCondition::Declaration(ref decl) => decl.to_css(dest),
SupportsCondition::FutureSyntax(ref s) => dest.write_str(&s),
}
}
}
#[derive(Debug)]
/// A possibly-invalid property declaration
pub struct Declaration {
/// The property name
prop: String,
/// The property value
val: String,
}
impl ToCss for Declaration {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
where W: fmt::Write {
dest.write_str(&self.prop)?;
dest.write_str(":")?;
// no space, the `val` already contains any possible spaces
dest.write_str(&self.val)
}
}
/// Slurps up input till exhausted, return string from source position
fn parse_anything(input: &mut Parser) -> String {
let pos = input.position();
consume_all(input);
input.slice_from(pos).to_owned()
}
/// consume input till done
fn consume_all(input: &mut Parser) {
while let Ok(_) = input.next() {}
}
impl Declaration {
/// Parse a declaration
pub fn parse(input: &mut Parser) -> Result<Declaration, ()> {
let prop = input.expect_ident()?.into_owned();
input.expect_colon()?;
let val = parse_anything(input);
Ok(Declaration { prop: prop, val: val })
}
/// Determine if a declaration parses
///
/// https://drafts.csswg.org/css-conditional-3/#support-definition
pub fn eval(&self, cx: &ParserContext) -> bool {
use properties::PropertyDeclarationParseResult::*;
let id = if let Ok(id) = PropertyId::parse((&*self.prop).into()) {
id
} else {
return false
};
let mut input = Parser::new(&self.val);
let mut list = Vec::new();
let res = PropertyDeclaration::parse(id, cx, &mut input,
&mut list, /* in_keyframe */ false);
let _ = input.try(parse_important);
if !input.is_exhausted() {
return false;
}
match res {
UnknownProperty => false,
ExperimentalProperty => false, // only happens for experimental props
// that haven't been enabled
InvalidValue => false,
AnimationPropertyInKeyframeBlock => unreachable!(),
ValidOrIgnoredDeclaration => true,
}
}
}

2
rust-stable-version
View file

@ -1 +1 @@
1.12.0
1.13.0