From 966af0030a246dfa407d5d17a66020cd331f326d Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Wed, 28 Jan 2015 16:29:35 +0100 Subject: [PATCH 1/5] Upgrade to rust-cssparser master. * Use associated types * Avoid mutation to gather parsing results. --- components/servo/Cargo.lock | 2 +- components/style/font_face.rs | 48 +++++---- components/style/lib.rs | 1 - components/style/namespaces.rs | 49 --------- components/style/parser.rs | 22 +++- components/style/properties/mod.rs.mako | 55 +++++----- components/style/selector_matching.rs | 8 +- components/style/selectors.rs | 31 ++---- components/style/stylesheets.rs | 128 ++++++++++++++++-------- ports/cef/Cargo.lock | 2 +- ports/gonk/Cargo.lock | 2 +- 11 files changed, 183 insertions(+), 165 deletions(-) delete mode 100644 components/style/namespaces.rs diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock index 66267664a09..01445776c3c 100644 --- a/components/servo/Cargo.lock +++ b/components/servo/Cargo.lock @@ -134,7 +134,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#2a8c9f2c5f568495bae16f44b799be39b8efad39" +source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/components/style/font_face.rs b/components/style/font_face.rs index d4d18f7960b..0dde375d602 100644 --- a/components/style/font_face.rs +++ b/components/style/font_face.rs @@ -52,13 +52,21 @@ pub struct FontFaceRule { pub fn parse_font_face_block(context: &ParserContext, input: &mut Parser) -> Result { - let parser = FontFaceRuleParser { - context: context, - family: None, - src: None, - }; - match DeclarationListParser::new(input, parser).run() { - FontFaceRuleParser { family: Some(family), src: Some(src), .. } => { + let mut family = None; + let mut src = None; + for declaration in DeclarationListParser::new(input, FontFaceRuleParser { context: context }) { + match declaration { + Err(()) => {} + Ok(FontFaceDescriptorDeclaration::Family(value)) => { + family = Some(value); + } + Ok(FontFaceDescriptorDeclaration::Src(value)) => { + src = Some(value); + } + } + } + match (family, src) { + (Some(family), Some(src)) => { Ok(FontFaceRule { family: family, sources: src, @@ -68,30 +76,36 @@ pub fn parse_font_face_block(context: &ParserContext, input: &mut Parser) } } +enum FontFaceDescriptorDeclaration { + Family(String), + Src(Vec), +} + struct FontFaceRuleParser<'a, 'b: 'a> { context: &'a ParserContext<'b>, - family: Option, - src: Option>, } /// Default methods reject all at rules. -impl<'a, 'b> AtRuleParser<(), ()> for FontFaceRuleParser<'a, 'b> {} +impl<'a, 'b> AtRuleParser for FontFaceRuleParser<'a, 'b> { + type Prelude = (); + type AtRule = FontFaceDescriptorDeclaration; +} -impl<'a, 'b> DeclarationParser<()> for FontFaceRuleParser<'a, 'b> { - fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<(), ()> { +impl<'a, 'b> DeclarationParser for FontFaceRuleParser<'a, 'b> { + type Declaration = FontFaceDescriptorDeclaration; + + fn parse_value(&self, name: &str, input: &mut Parser) -> Result { match_ignore_ascii_case! { name, "font-family" => { - self.family = Some(try!(parse_one_non_generic_family_name(input))); - Ok(()) + Ok(FontFaceDescriptorDeclaration::Family(try!(parse_one_non_generic_family_name(input)))) }, "src" => { - self.src = Some(try!(input.parse_comma_separated(|input| { + Ok(FontFaceDescriptorDeclaration::Src(try!(input.parse_comma_separated(|input| { parse_one_src(self.context, input) - }))); - Ok(()) + })))) } _ => Err(()) } diff --git a/components/style/lib.rs b/components/style/lib.rs index a9863bc1589..0ad51ef559e 100644 --- a/components/style/lib.rs +++ b/components/style/lib.rs @@ -68,7 +68,6 @@ pub mod selectors; pub mod selector_matching; #[macro_use] pub mod values; pub mod properties; -pub mod namespaces; pub mod node; pub mod media_queries; pub mod font_face; diff --git a/components/style/namespaces.rs b/components/style/namespaces.rs deleted file mode 100644 index 53b6467db9c..00000000000 --- a/components/style/namespaces.rs +++ /dev/null @@ -1,49 +0,0 @@ -/* 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/. */ - -use cssparser::Parser; -use std::collections::HashMap; -use string_cache::{Atom, Namespace}; -use parser::ParserContext; - - -#[derive(Clone)] -pub struct NamespaceMap { - pub default: Option, - pub prefix_map: HashMap, -} - - -impl NamespaceMap { - pub fn new() -> NamespaceMap { - NamespaceMap { default: None, prefix_map: HashMap::new() } - } -} - - -pub fn parse_namespace_rule(context: &mut ParserContext, input: &mut Parser) - -> Result<(Option, Namespace), ()> { - let prefix = input.try(|input| input.expect_ident()).ok().map(|p| p.into_owned()); - let url = try!(input.expect_url_or_string()); - try!(input.expect_exhausted()); - - let namespace = Namespace(Atom::from_slice(url.as_slice())); - let is_duplicate = match prefix { - Some(ref prefix) => { - context.namespaces.prefix_map.insert(prefix.clone(), namespace.clone()).is_some() - } - None => { - let has_default = context.namespaces.default.is_some(); - if !has_default { - context.namespaces.default = Some(namespace.clone()); - } - has_default - } - }; - if is_duplicate { - Err(()) // "Duplicate @namespace rule" - } else { - Ok((prefix, namespace)) - } -} diff --git a/components/style/parser.rs b/components/style/parser.rs index 6619ffd06dd..5219c667dac 100644 --- a/components/style/parser.rs +++ b/components/style/parser.rs @@ -3,12 +3,19 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +use std::collections::HashMap; +use string_cache::Namespace; use cssparser::{Parser, SourcePosition}; use url::{Url, UrlParser}; use log; use stylesheets::Origin; -use namespaces::NamespaceMap; + + +pub struct NamespaceMap { + pub default: Option, + pub prefix_map: HashMap, +} pub struct ParserContext<'a> { @@ -17,6 +24,19 @@ pub struct ParserContext<'a> { pub namespaces: NamespaceMap, } +impl<'a> ParserContext<'a> { + pub fn new(stylesheet_origin: Origin, base_url: &'a Url) -> ParserContext<'a> { + ParserContext { + stylesheet_origin: stylesheet_origin, + base_url: base_url, + namespaces: NamespaceMap { + default: None, + prefix_map: HashMap::new() + } + } + } +} + impl<'a> ParserContext<'a> { pub fn in_user_agent_stylesheet(&self) -> bool { diff --git a/components/style/properties/mod.rs.mako b/components/style/properties/mod.rs.mako index fe58a488f9b..54a02289ca8 100644 --- a/components/style/properties/mod.rs.mako +++ b/components/style/properties/mod.rs.mako @@ -21,7 +21,6 @@ use values::specified::BorderStyle; use values::computed; use selector_matching::DeclarationBlock; use parser::ParserContext; -use namespaces::NamespaceMap; use stylesheets::Origin; use self::property_bit_field::PropertyBitField; @@ -2325,57 +2324,57 @@ pub struct PropertyDeclarationBlock { pub fn parse_style_attribute(input: &str, base_url: &Url) -> PropertyDeclarationBlock { - let context = ParserContext { - stylesheet_origin: Origin::Author, - base_url: base_url, - namespaces: NamespaceMap::new(), - }; + let context = ParserContext::new(Origin::Author, base_url); parse_property_declaration_list(&context, &mut Parser::new(input)) } struct PropertyDeclarationParser<'a, 'b: 'a> { context: &'a ParserContext<'b>, - important_declarations: Vec, - normal_declarations: Vec, } /// Default methods reject all at rules. -impl<'a, 'b> AtRuleParser<(), ()> for PropertyDeclarationParser<'a, 'b> {} +impl<'a, 'b> AtRuleParser for PropertyDeclarationParser<'a, 'b> { + type Prelude = (); + type AtRule = (Vec, bool); +} -impl<'a, 'b> DeclarationParser<()> for PropertyDeclarationParser<'a, 'b> { - fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<(), ()> { +impl<'a, 'b> DeclarationParser for PropertyDeclarationParser<'a, 'b> { + type Declaration = (Vec, bool); + + fn parse_value(&self, name: &str, input: &mut Parser) -> Result<(Vec, bool), ()> { let mut results = vec![]; - let important = try!(input.parse_entirely(|input| { - match PropertyDeclaration::parse(name, self.context, input, &mut results) { - PropertyDeclarationParseResult::ValidOrIgnoredDeclaration => {} - _ => return Err(()) - } - Ok(input.try(parse_important).is_ok()) - })); - if important { - self.important_declarations.push_all(results.as_slice()); - } else { - self.normal_declarations.push_all(results.as_slice()); + match PropertyDeclaration::parse(name, self.context, input, &mut results) { + PropertyDeclarationParseResult::ValidOrIgnoredDeclaration => {} + _ => return Err(()) } - Ok(()) + let important = input.try(parse_important).is_ok(); + Ok((results, important)) } } pub fn parse_property_declaration_list(context: &ParserContext, input: &mut Parser) -> PropertyDeclarationBlock { + let mut important_declarations = Vec::new(); + let mut normal_declarations = Vec::new(); let parser = PropertyDeclarationParser { context: context, - important_declarations: vec![], - normal_declarations: vec![], }; - let parser = DeclarationListParser::new(input, parser).run(); + for declaration in DeclarationListParser::new(input, parser) { + if let Ok((results, important)) = declaration { + if important { + important_declarations.push_all(results.as_slice()); + } else { + normal_declarations.push_all(results.as_slice()); + } + } + } PropertyDeclarationBlock { - important: Arc::new(deduplicate_property_declarations(parser.important_declarations)), - normal: Arc::new(deduplicate_property_declarations(parser.normal_declarations)), + important: Arc::new(deduplicate_property_declarations(important_declarations)), + normal: Arc::new(deduplicate_property_declarations(normal_declarations)), } } diff --git a/components/style/selector_matching.rs b/components/style/selector_matching.rs index 3809fd7f818..9b81f20060a 100644 --- a/components/style/selector_matching.rs +++ b/components/style/selector_matching.rs @@ -1166,16 +1166,12 @@ mod tests { /// Helper method to get some Rules from selector strings. /// Each sublist of the result contains the Rules for one StyleRule. fn get_mock_rules(css_selectors: &[&str]) -> Vec> { - use namespaces::NamespaceMap; use selectors::parse_selector_list; use stylesheets::Origin; css_selectors.iter().enumerate().map(|(i, selectors)| { - let context = ParserContext { - stylesheet_origin: Origin::Author, - namespaces: NamespaceMap::new(), - base_url: &Url::parse("about:blank").unwrap(), - }; + let url = Url::parse("about:blank").unwrap(); + let context = ParserContext::new(Origin::Author, &url); parse_selector_list(&context, &mut Parser::new(*selectors)) .unwrap().into_iter().map(|s| { Rule { diff --git a/components/style/selectors.rs b/components/style/selectors.rs index a4c4b0bea53..98eb186eb67 100644 --- a/components/style/selectors.rs +++ b/components/style/selectors.rs @@ -12,7 +12,6 @@ use string_cache::{Atom, Namespace}; use url::Url; use parser::ParserContext; -use namespaces::NamespaceMap; use stylesheets::Origin; @@ -196,11 +195,8 @@ fn compute_specificity(mut selector: &CompoundSelector, pub fn parse_author_origin_selector_list_from_str(input: &str) -> Result { - let context = ParserContext { - stylesheet_origin: Origin::Author, - namespaces: NamespaceMap::new(), - base_url: &Url::parse("about:blank").unwrap(), - }; + let url = Url::parse("about:blank").unwrap(); + let context = ParserContext::new(Origin::Author, &url); parse_selector_list(&context, &mut Parser::new(input)) .map(|s| SelectorList { selectors: s }) } @@ -647,7 +643,6 @@ fn parse_pseudo_element(name: &str) -> Result { mod tests { use std::sync::Arc; use cssparser::Parser; - use namespaces::NamespaceMap; use stylesheets::Origin; use string_cache::Atom; use parser::ParserContext; @@ -655,16 +650,11 @@ mod tests { use super::*; fn parse(input: &str) -> Result, ()> { - parse_ns(input, NamespaceMap::new()) + parse_ns(input, &ParserContext::new(Origin::Author, &Url::parse("about:blank").unwrap())) } - fn parse_ns(input: &str, namespaces: NamespaceMap) -> Result, ()> { - let context = ParserContext { - stylesheet_origin: Origin::Author, - namespaces: namespaces, - base_url: &Url::parse("about:blank").unwrap(), - }; - parse_selector_list(&context, &mut Parser::new(input)) + fn parse_ns(input: &str, context: &ParserContext) -> Result, ()> { + parse_selector_list(context, &mut Parser::new(input)) } fn specificity(a: u32, b: u32, c: u32) -> u32 { @@ -728,8 +718,9 @@ mod tests { }))); // Default namespace does not apply to attribute selectors // https://github.com/mozilla/servo/pull/1652 - let mut namespaces = NamespaceMap::new(); - assert_eq!(parse_ns("[Foo]", namespaces.clone()), Ok(vec!(Selector { + let url = Url::parse("about:blank").unwrap(); + let mut context = ParserContext::new(Origin::Author, &url); + assert_eq!(parse_ns("[Foo]", &context), Ok(vec!(Selector { compound_selectors: Arc::new(CompoundSelector { simple_selectors: vec!(SimpleSelector::AttrExists(AttrSelector { name: Atom::from_slice("Foo"), @@ -743,8 +734,8 @@ mod tests { }))); // Default namespace does not apply to attribute selectors // https://github.com/mozilla/servo/pull/1652 - namespaces.default = Some(ns!(MathML)); - assert_eq!(parse_ns("[Foo]", namespaces.clone()), Ok(vec!(Selector { + context.namespaces.default = Some(ns!(MathML)); + assert_eq!(parse_ns("[Foo]", &context), Ok(vec!(Selector { compound_selectors: Arc::new(CompoundSelector { simple_selectors: vec!(SimpleSelector::AttrExists(AttrSelector { name: Atom::from_slice("Foo"), @@ -757,7 +748,7 @@ mod tests { specificity: specificity(0, 1, 0), }))); // Default namespace does apply to type selectors - assert_eq!(parse_ns("e", namespaces), Ok(vec!(Selector { + assert_eq!(parse_ns("e", &context), Ok(vec!(Selector { compound_selectors: Arc::new(CompoundSelector { simple_selectors: vec!( SimpleSelector::Namespace(ns!(MathML)), diff --git a/components/style/stylesheets.rs b/components/style/stylesheets.rs index 7d9aeaf0297..bfe6c48cc66 100644 --- a/components/style/stylesheets.rs +++ b/components/style/stylesheets.rs @@ -2,6 +2,7 @@ * 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/. */ +use std::cell::Cell; use std::iter::Iterator; use std::ascii::AsciiExt; use url::Url; @@ -10,11 +11,10 @@ use encoding::EncodingRef; use cssparser::{Parser, decode_stylesheet_bytes, QualifiedRuleParser, AtRuleParser, RuleListParser, AtRuleType}; -use string_cache::Namespace; +use string_cache::{Atom, Namespace}; use selectors::{Selector, parse_selector_list}; use parser::ParserContext; use properties::{PropertyDeclarationBlock, parse_property_declaration_list}; -use namespaces::{NamespaceMap, parse_namespace_rule}; use media_queries::{self, Device, MediaQueryList, parse_media_query_list}; use font_face::{FontFaceRule, Source, parse_font_face_block, iter_font_face_rules_inner}; @@ -85,18 +85,26 @@ impl Stylesheet { } pub fn from_str<'i>(css: &'i str, base_url: Url, origin: Origin) -> Stylesheet { - let mut context = ParserContext { - stylesheet_origin: origin, - base_url: &base_url, - namespaces: NamespaceMap::new() + let rule_parser = TopLevelRuleParser { + context: ParserContext::new(origin, &base_url), + state: Cell::new(State::Start), }; - let rule_parser = MainRuleParser { - context: &mut context, - state: State::Start, - }; - let rules = RuleListParser::new_for_stylesheet(&mut Parser::new(css), rule_parser) - .filter_map(|result| result.ok()) - .collect(); + let mut input = Parser::new(css); + let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser); + let mut rules = Vec::new(); + while let Some(result) = iter.next() { + if let Ok(rule) = result { + if let CSSRule::Namespace(ref prefix, ref namespace) = rule { + if let Some(prefix) = prefix.as_ref() { + iter.parser.context.namespaces.prefix_map.insert( + prefix.clone(), namespace.clone()); + } else { + iter.parser.context.namespaces.default = Some(namespace.clone()); + } + } + rules.push(rule); + } + } Stylesheet { origin: origin, rules: rules, @@ -105,24 +113,19 @@ impl Stylesheet { } -fn parse_nested_rules(context: &mut ParserContext, input: &mut Parser) -> Vec { - let parser = MainRuleParser { - context: context, - state: State::Body, - }; - RuleListParser::new_for_nested_rule(input, parser) +fn parse_nested_rules(context: &ParserContext, input: &mut Parser) -> Vec { + RuleListParser::new_for_nested_rule(input, NestedRuleParser { context: context }) .filter_map(|result| result.ok()) .collect() } -struct MainRuleParser<'a, 'b: 'a> { - context: &'a mut ParserContext<'b>, - state: State, +struct TopLevelRuleParser<'a> { + context: ParserContext<'a>, + state: Cell, } - -#[derive(Eq, PartialEq, Ord, PartialOrd)] +#[derive(Eq, PartialEq, Ord, PartialOrd, Copy)] enum State { Start = 1, Imports = 2, @@ -137,14 +140,17 @@ enum AtRulePrelude { } -impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { - fn parse_prelude(&mut self, name: &str, input: &mut Parser) +impl<'a> AtRuleParser for TopLevelRuleParser<'a> { + type Prelude = AtRulePrelude; + type AtRule = CSSRule; + + fn parse_prelude(&self, name: &str, input: &mut Parser) -> Result, ()> { match_ignore_ascii_case! { name, "charset" => { - if self.state <= State::Start { + if self.state.get() <= State::Start { // Valid @charset rules are just ignored - self.state = State::Imports; + self.state.set(State::Imports); let charset = try!(input.expect_string()).into_owned(); return Ok(AtRuleType::WithoutBlock(CSSRule::Charset(charset))) } else { @@ -152,8 +158,8 @@ impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { } }, "import" => { - if self.state <= State::Imports { - self.state = State::Imports; + if self.state.get() <= State::Imports { + self.state.set(State::Imports); // TODO: support @import return Err(()) // "@import is not supported yet" } else { @@ -161,10 +167,12 @@ impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { } }, "namespace" => { - if self.state <= State::Namespaces { - self.state = State::Namespaces; - let (prefix, namespace) = try!(parse_namespace_rule(self.context, input)); - return Ok(AtRuleType::WithoutBlock(CSSRule::Namespace(prefix, namespace))) + if self.state.get() <= State::Namespaces { + self.state.set(State::Namespaces); + + let prefix = input.try(|input| input.expect_ident()).ok().map(|p| p.into_owned()); + let url = Namespace(Atom::from_slice(try!(input.expect_url_or_string()).as_slice())); + return Ok(AtRuleType::WithoutBlock(CSSRule::Namespace(prefix, url))) } else { return Err(()) // "@namespace must be before any rule but @charset and @import" } @@ -172,8 +180,46 @@ impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { _ => {} } - self.state = State::Body; + self.state.set(State::Body); + AtRuleParser::parse_prelude(&NestedRuleParser { context: &self.context }, name, input) + } + #[inline] + fn parse_block(&self, prelude: AtRulePrelude, input: &mut Parser) -> Result { + AtRuleParser::parse_block(&NestedRuleParser { context: &self.context }, prelude, input) + } +} + + +impl<'a> QualifiedRuleParser for TopLevelRuleParser<'a> { + type Prelude = Vec; + type QualifiedRule = CSSRule; + + #[inline] + fn parse_prelude(&self, input: &mut Parser) -> Result, ()> { + self.state.set(State::Body); + QualifiedRuleParser::parse_prelude(&NestedRuleParser { context: &self.context }, input) + } + + #[inline] + fn parse_block(&self, prelude: Vec, input: &mut Parser) -> Result { + QualifiedRuleParser::parse_block(&NestedRuleParser { context: &self.context }, + prelude, input) + } +} + + +struct NestedRuleParser<'a, 'b: 'a> { + context: &'a ParserContext<'b>, +} + + +impl<'a, 'b> AtRuleParser for NestedRuleParser<'a, 'b> { + type Prelude = AtRulePrelude; + type AtRule = CSSRule; + + fn parse_prelude(&self, name: &str, input: &mut Parser) + -> Result, ()> { match_ignore_ascii_case! { name, "media" => { let media_queries = parse_media_query_list(input); @@ -186,7 +232,7 @@ impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { } } - fn parse_block(&mut self, prelude: AtRulePrelude, input: &mut Parser) -> Result { + fn parse_block(&self, prelude: AtRulePrelude, input: &mut Parser) -> Result { match prelude { AtRulePrelude::FontFace => { parse_font_face_block(self.context, input).map(CSSRule::FontFace) @@ -202,13 +248,15 @@ impl<'a, 'b> AtRuleParser for MainRuleParser<'a, 'b> { } -impl<'a, 'b> QualifiedRuleParser, CSSRule> for MainRuleParser<'a, 'b> { - fn parse_prelude(&mut self, input: &mut Parser) -> Result, ()> { - self.state = State::Body; +impl<'a, 'b> QualifiedRuleParser for NestedRuleParser<'a, 'b> { + type Prelude = Vec; + type QualifiedRule = CSSRule; + + fn parse_prelude(&self, input: &mut Parser) -> Result, ()> { parse_selector_list(self.context, input) } - fn parse_block(&mut self, prelude: Vec, input: &mut Parser) -> Result { + fn parse_block(&self, prelude: Vec, input: &mut Parser) -> Result { Ok(CSSRule::Style(StyleRule { selectors: prelude, declarations: parse_property_declaration_list(self.context, input) diff --git a/ports/cef/Cargo.lock b/ports/cef/Cargo.lock index 58ea35e0a11..e69571d5b05 100644 --- a/ports/cef/Cargo.lock +++ b/ports/cef/Cargo.lock @@ -132,7 +132,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#2a8c9f2c5f568495bae16f44b799be39b8efad39" +source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/gonk/Cargo.lock b/ports/gonk/Cargo.lock index b0c2ca1424a..5316849f37d 100644 --- a/ports/gonk/Cargo.lock +++ b/ports/gonk/Cargo.lock @@ -103,7 +103,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#2a8c9f2c5f568495bae16f44b799be39b8efad39" +source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", From 493a9e6a89d1f70374cfd27052819d61be305ba0 Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Wed, 28 Jan 2015 20:35:12 +0100 Subject: [PATCH 2/5] Bring CSS parse error reporting back. (Still off by default. Enable with `RUST_LOG=style`.) --- components/servo/Cargo.lock | 2 +- components/style/font_face.rs | 11 +++++-- components/style/properties/mod.rs.mako | 22 +++++++++----- components/style/stylesheets.rs | 39 +++++++++++++++++-------- ports/cef/Cargo.lock | 2 +- ports/gonk/Cargo.lock | 2 +- 6 files changed, 53 insertions(+), 25 deletions(-) diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock index 01445776c3c..987d2052091 100644 --- a/components/servo/Cargo.lock +++ b/components/servo/Cargo.lock @@ -134,7 +134,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" +source = "git+https://github.com/servo/rust-cssparser#42714934cbe83dab349190695503a09ae23f9528" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/components/style/font_face.rs b/components/style/font_face.rs index 0dde375d602..a731f9462e0 100644 --- a/components/style/font_face.rs +++ b/components/style/font_face.rs @@ -9,7 +9,7 @@ use properties::longhands::font_family::parse_one_family; use properties::computed_values::font_family::FontFamily; use media_queries::Device; use url::{Url, UrlParser}; -use parser::ParserContext; +use parser::{ParserContext, log_css_error}; pub fn iter_font_face_rules_inner(rules: &[CSSRule], device: &Device, @@ -54,9 +54,14 @@ pub fn parse_font_face_block(context: &ParserContext, input: &mut Parser) -> Result { let mut family = None; let mut src = None; - for declaration in DeclarationListParser::new(input, FontFaceRuleParser { context: context }) { + let mut iter = DeclarationListParser::new(input, FontFaceRuleParser { context: context }); + while let Some(declaration) = iter.next() { match declaration { - Err(()) => {} + Err(range) => { + let message = format!("Unsupported @font-face descriptor declaration: '{}'", + iter.input.slice(range)); + log_css_error(iter.input, range.start, &*message); + } Ok(FontFaceDescriptorDeclaration::Family(value)) => { family = Some(value); } diff --git a/components/style/properties/mod.rs.mako b/components/style/properties/mod.rs.mako index 54a02289ca8..fada051ebc1 100644 --- a/components/style/properties/mod.rs.mako +++ b/components/style/properties/mod.rs.mako @@ -20,7 +20,7 @@ use geom::SideOffsets2D; use values::specified::BorderStyle; use values::computed; use selector_matching::DeclarationBlock; -use parser::ParserContext; +use parser::{ParserContext, log_css_error}; use stylesheets::Origin; use self::property_bit_field::PropertyBitField; @@ -2363,12 +2363,20 @@ pub fn parse_property_declaration_list(context: &ParserContext, input: &mut Pars let parser = PropertyDeclarationParser { context: context, }; - for declaration in DeclarationListParser::new(input, parser) { - if let Ok((results, important)) = declaration { - if important { - important_declarations.push_all(results.as_slice()); - } else { - normal_declarations.push_all(results.as_slice()); + let mut iter = DeclarationListParser::new(input, parser); + while let Some(declaration) = iter.next() { + match declaration { + Ok((results, important)) => { + if important { + important_declarations.push_all(results.as_slice()); + } else { + normal_declarations.push_all(results.as_slice()); + } + } + Err(range) => { + let message = format!("Unsupported property declaration: '{}'", + iter.input.slice(range)); + log_css_error(iter.input, range.start, &*message); } } } diff --git a/components/style/stylesheets.rs b/components/style/stylesheets.rs index bfe6c48cc66..1eaa8e838f7 100644 --- a/components/style/stylesheets.rs +++ b/components/style/stylesheets.rs @@ -13,7 +13,7 @@ use cssparser::{Parser, decode_stylesheet_bytes, QualifiedRuleParser, AtRuleParser, RuleListParser, AtRuleType}; use string_cache::{Atom, Namespace}; use selectors::{Selector, parse_selector_list}; -use parser::ParserContext; +use parser::{ParserContext, log_css_error}; use properties::{PropertyDeclarationBlock, parse_property_declaration_list}; use media_queries::{self, Device, MediaQueryList, parse_media_query_list}; use font_face::{FontFaceRule, Source, parse_font_face_block, iter_font_face_rules_inner}; @@ -93,16 +93,22 @@ impl Stylesheet { let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser); let mut rules = Vec::new(); while let Some(result) = iter.next() { - if let Ok(rule) = result { - if let CSSRule::Namespace(ref prefix, ref namespace) = rule { - if let Some(prefix) = prefix.as_ref() { - iter.parser.context.namespaces.prefix_map.insert( - prefix.clone(), namespace.clone()); - } else { - iter.parser.context.namespaces.default = Some(namespace.clone()); + match result { + Ok(rule) => { + if let CSSRule::Namespace(ref prefix, ref namespace) = rule { + if let Some(prefix) = prefix.as_ref() { + iter.parser.context.namespaces.prefix_map.insert( + prefix.clone(), namespace.clone()); + } else { + iter.parser.context.namespaces.default = Some(namespace.clone()); + } } + rules.push(rule); + } + Err(range) => { + let message = format!("Invalid rule: '{}'", iter.input.slice(range)); + log_css_error(iter.input, range.start, &*message); } - rules.push(rule); } } Stylesheet { @@ -114,9 +120,18 @@ impl Stylesheet { fn parse_nested_rules(context: &ParserContext, input: &mut Parser) -> Vec { - RuleListParser::new_for_nested_rule(input, NestedRuleParser { context: context }) - .filter_map(|result| result.ok()) - .collect() + let mut iter = RuleListParser::new_for_nested_rule(input, NestedRuleParser { context: context }); + let mut rules = Vec::new(); + while let Some(result) = iter.next() { + match result { + Ok(rule) => rules.push(rule), + Err(range) => { + let message = format!("Unsupported rule: '{}'", iter.input.slice(range)); + log_css_error(iter.input, range.start, &*message); + } + } + } + rules } diff --git a/ports/cef/Cargo.lock b/ports/cef/Cargo.lock index e69571d5b05..9c4623d5343 100644 --- a/ports/cef/Cargo.lock +++ b/ports/cef/Cargo.lock @@ -132,7 +132,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" +source = "git+https://github.com/servo/rust-cssparser#42714934cbe83dab349190695503a09ae23f9528" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/gonk/Cargo.lock b/ports/gonk/Cargo.lock index 5316849f37d..bfbd4abf01e 100644 --- a/ports/gonk/Cargo.lock +++ b/ports/gonk/Cargo.lock @@ -103,7 +103,7 @@ dependencies = [ [[package]] name = "cssparser" version = "0.2.0" -source = "git+https://github.com/servo/rust-cssparser#f4214c9a7bfafd6f40a62b0726aa0bde900ef0dc" +source = "git+https://github.com/servo/rust-cssparser#42714934cbe83dab349190695503a09ae23f9528" dependencies = [ "encoding 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", From d13d36f57f4da7d51bfce0bcefc0d52fdacfb693 Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Wed, 28 Jan 2015 21:46:51 +0100 Subject: [PATCH 3/5] End the libstyle 'pub use' madness. --- components/gfx/display_list/mod.rs | 2 +- components/gfx/font.rs | 2 +- components/gfx/font_cache_task.rs | 2 +- components/layout/block.rs | 7 ++- components/layout/construct.rs | 4 +- components/layout/context.rs | 2 +- components/layout/css/matching.rs | 14 +++--- components/layout/css/node_style.rs | 2 +- components/layout/display_list_builder.rs | 7 +-- components/layout/flow.rs | 2 +- components/layout/fragment.rs | 7 +-- components/layout/incremental.rs | 2 +- components/layout/inline.rs | 2 +- components/layout/layout_task.rs | 8 ++-- components/layout/list_item.rs | 2 +- components/layout/model.rs | 27 ++++++------ components/layout/table.rs | 6 ++- components/layout/table_caption.rs | 2 +- components/layout/table_cell.rs | 3 +- components/layout/table_colgroup.rs | 4 +- components/layout/table_row.rs | 4 +- components/layout/table_rowgroup.rs | 2 +- components/layout/table_wrapper.rs | 6 ++- components/layout/text.rs | 4 +- components/layout/traversal.rs | 2 +- components/layout/util.rs | 4 +- components/layout/wrapper.rs | 7 +-- components/script/dom/bindings/trace.rs | 2 +- components/script/dom/cssstyledeclaration.rs | 4 +- components/script/dom/element.rs | 39 +++++++++-------- components/script/dom/htmlstyleelement.rs | 5 +-- components/script/dom/node.rs | 23 +++++----- components/script/layout_interface.rs | 2 +- components/style/font_face.rs | 2 +- components/style/lib.rs | 43 +++++++------------ components/style/properties/mod.rs.mako | 45 +++++++++----------- components/style/selector_matching.rs | 10 ++--- components/style/selectors.rs | 15 +------ components/style/values.rs | 2 + 39 files changed, 159 insertions(+), 169 deletions(-) diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs index c0495a2f479..b54d7a553b5 100644 --- a/components/gfx/display_list/mod.rs +++ b/components/gfx/display_list/mod.rs @@ -40,7 +40,7 @@ use util::smallvec::{SmallVec, SmallVec8}; use std::fmt; use std::slice::Iter; use std::sync::Arc; -use style::ComputedValues; +use style::properties::ComputedValues; use style::computed_values::{border_style, cursor, filter, mix_blend_mode, pointer_events}; // It seems cleaner to have layout code not mention Azure directly, so let's just reexport this for diff --git a/components/gfx/font.rs b/components/gfx/font.rs index 366deb5e589..15eebedbc09 100644 --- a/components/gfx/font.rs +++ b/components/gfx/font.rs @@ -11,7 +11,7 @@ use std::cell::RefCell; use util::cache::HashCache; use util::smallvec::{SmallVec, SmallVec8}; use style::computed_values::{font_stretch, font_variant, font_weight}; -use style::style_structs::Font as FontStyle; +use style::properties::style_structs::Font as FontStyle; use std::sync::Arc; use std::hash::Hash; diff --git a/components/gfx/font_cache_task.rs b/components/gfx/font_cache_task.rs index 6084f54c710..782c68dd4b2 100644 --- a/components/gfx/font_cache_task.rs +++ b/components/gfx/font_cache_task.rs @@ -18,7 +18,7 @@ use platform::font_template::FontTemplateData; use servo_net::resource_task::{ResourceTask, load_whole_resource}; use util::task::spawn_named; use util::str::LowercaseString; -use style::Source; +use style::font_face::Source; /// A list of font templates that make up a given font family. struct FontFamily { diff --git a/components/layout/block.rs b/components/layout/block.rs index d1ffc16a111..f7f7dde2b48 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -57,10 +57,9 @@ use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize}; use servo_util::opts; use std::cmp::{max, min}; use std::fmt; -use style::ComputedValues; -use style::computed_values::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone}; -use style::computed_values::{LengthOrPercentage, box_sizing, display, float}; -use style::computed_values::{overflow, position}; +use style::properties::ComputedValues; +use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone}; +use style::computed_values::{overflow, position, box_sizing, display, float}; use std::sync::Arc; /// Information specific to floated blocks. diff --git a/components/layout/construct.rs b/components/layout/construct.rs index eb241630dba..c94ec8e9296 100644 --- a/components/layout/construct.rs +++ b/components/layout/construct.rs @@ -56,7 +56,7 @@ use std::mem; use std::sync::atomic::Ordering; use style::computed_values::{caption_side, display, empty_cells, float, list_style_position}; use style::computed_values::{position}; -use style::{self, ComputedValues}; +use style::properties::{ComputedValues, make_inline}; use std::sync::Arc; use url::Url; @@ -707,7 +707,7 @@ impl<'a> FlowConstructor<'a> { // `baz` had better not be absolutely positioned! let mut style = (*node.style()).clone(); if style.get_box().display != display::T::inline { - style = Arc::new(style::make_inline(&*style)) + style = Arc::new(make_inline(&*style)) } // If this is generated content, then we need to initialize the accumulator with the diff --git a/components/layout/context.rs b/components/layout/context.rs index e3df7a1a8b5..29a96358ff5 100644 --- a/components/layout/context.rs +++ b/components/layout/context.rs @@ -19,7 +19,7 @@ use std::cell::Cell; use std::mem; use std::ptr; use std::sync::{Arc, Mutex}; -use style::Stylist; +use style::selector_matching::Stylist; use url::Url; struct LocalLayoutContext { diff --git a/components/layout/css/matching.rs b/components/layout/css/matching.rs index 0f1931c3efb..6a491eabd79 100644 --- a/components/layout/css/matching.rs +++ b/components/layout/css/matching.rs @@ -19,8 +19,12 @@ use std::mem; use std::hash::{Hash, Hasher, Writer}; use std::slice::Iter; use string_cache::{Atom, Namespace}; -use style::{self, PseudoElement, ComputedValues, DeclarationBlock, Stylist, TElement, TNode}; -use style::{CommonStyleAffectingAttributeMode, CommonStyleAffectingAttributes, cascade}; +use style::selectors::PseudoElement; +use style::selector_matching::{Stylist, DeclarationBlock}; +use style::node::{TElement, TNode}; +use style::properties::{ComputedValues, cascade}; +use style::selector_matching::{CommonStyleAffectingAttributeMode, CommonStyleAffectingAttributes}; +use style::selector_matching::{common_style_affecting_attributes, rare_style_affecting_attributes}; use std::sync::Arc; pub struct ApplicableDeclarations { @@ -156,7 +160,7 @@ pub struct StyleSharingCandidateCache { fn create_common_style_affecting_attributes_from_element(element: &LayoutElement) -> CommonStyleAffectingAttributes { let mut flags = CommonStyleAffectingAttributes::empty(); - for attribute_info in style::common_style_affecting_attributes().iter() { + for attribute_info in common_style_affecting_attributes().iter() { match attribute_info.mode { CommonStyleAffectingAttributeMode::IsPresent(flag) => { if element.get_attr(&ns!(""), &attribute_info.atom).is_some() { @@ -276,7 +280,7 @@ impl StyleSharingCandidate { // FIXME(pcwalton): It's probably faster to iterate over all the element's attributes and // use the {common, rare}-style-affecting-attributes tables as lookup tables. - for attribute_info in style::common_style_affecting_attributes().iter() { + for attribute_info in common_style_affecting_attributes().iter() { match attribute_info.mode { CommonStyleAffectingAttributeMode::IsPresent(flag) => { if self.common_style_affecting_attributes.contains(flag) != @@ -303,7 +307,7 @@ impl StyleSharingCandidate { } } - for attribute_name in style::rare_style_affecting_attributes().iter() { + for attribute_name in rare_style_affecting_attributes().iter() { if element.get_attr(&ns!(""), attribute_name).is_some() { return false } diff --git a/components/layout/css/node_style.rs b/components/layout/css/node_style.rs index d2cbf029b1a..a153447f7a3 100644 --- a/components/layout/css/node_style.rs +++ b/components/layout/css/node_style.rs @@ -7,7 +7,7 @@ use wrapper::{PseudoElementType, ThreadSafeLayoutNode}; use std::mem; -use style::ComputedValues; +use style::properties::ComputedValues; use std::sync::Arc; /// Node mixin providing `style` method that returns a `NodeStyle` diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs index 1c81e65459b..6ec6f4a317b 100644 --- a/components/layout/display_list_builder.rs +++ b/components/layout/display_list_builder.rs @@ -47,12 +47,13 @@ use std::default::Default; use std::iter::repeat; use std::num::Float; use style::values::specified::{AngleOrCorner, HorizontalDirection, VerticalDirection}; -use style::computed::{Image, LinearGradient, LengthOrPercentage}; +use style::values::computed::{Image, LinearGradient, LengthOrPercentage}; +use style::values::RGBA; use style::computed_values::filter::Filter; use style::computed_values::{background_attachment, background_repeat, border_style, overflow}; use style::computed_values::{position, visibility}; -use style::style_structs::Border; -use style::{ComputedValues, RGBA}; +use style::properties::style_structs::Border; +use style::properties::ComputedValues; use std::num::ToPrimitive; use std::sync::Arc; use std::sync::mpsc::channel; diff --git a/components/layout/flow.rs b/components/layout/flow.rs index c87088bf829..9ca0446b9c4 100644 --- a/components/layout/flow.rs +++ b/components/layout/flow.rs @@ -60,7 +60,7 @@ use std::raw; use std::sync::atomic::{AtomicUint, Ordering}; use std::slice::IterMut; use style::computed_values::{clear, empty_cells, float, position, text_align}; -use style::ComputedValues; +use style::properties::ComputedValues; use std::sync::Arc; /// Virtual methods that make up a float context. diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index 2b802c43cdd..9ca946d8ded 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -46,9 +46,10 @@ use std::str::FromStr; use std::sync::{Arc, Mutex}; use std::sync::mpsc::Sender; use string_cache::Atom; -use style::{ComputedValues, TElement, TNode, cascade_anonymous}; -use style::computed_values::{LengthOrPercentage, LengthOrPercentageOrAuto}; -use style::computed_values::{LengthOrPercentageOrNone, clear, mix_blend_mode, overflow_wrap}; +use style::properties::{ComputedValues, cascade_anonymous}; +use style::node::{TElement, TNode}; +use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone}; +use style::computed_values::{clear, mix_blend_mode, overflow_wrap}; use style::computed_values::{position, text_align, text_decoration, vertical_align, white_space}; use style::computed_values::{word_break}; use text::TextRunScanner; diff --git a/components/layout/incremental.rs b/components/layout/incremental.rs index 1b89015e6aa..2ad6177c497 100644 --- a/components/layout/incremental.rs +++ b/components/layout/incremental.rs @@ -8,7 +8,7 @@ use flow::{IS_ABSOLUTELY_POSITIONED}; use std::fmt; use std::sync::Arc; use style::computed_values::float; -use style::ComputedValues; +use style::properties::ComputedValues; bitflags! { #[doc = "Individual layout actions that may be necessary after restyling."] diff --git a/components/layout/inline.rs b/components/layout/inline.rs index c864b56e111..b90d2f71f93 100644 --- a/components/layout/inline.rs +++ b/components/layout/inline.rs @@ -36,7 +36,7 @@ use std::ops::{Add, Sub, Mul, Div, Rem, Neg, Shl, Shr, Not, BitOr, BitAnd, BitXo use std::u16; use style::computed_values::{overflow, text_align, text_justify, text_overflow, vertical_align}; use style::computed_values::{white_space}; -use style::ComputedValues; +use style::properties::ComputedValues; use std::sync::Arc; // From gfxFontConstants.h in Firefox diff --git a/components/layout/layout_task.rs b/components/layout/layout_task.rs index 53491dfdc5e..9523585785f 100644 --- a/components/layout/layout_task.rs +++ b/components/layout/layout_task.rs @@ -65,9 +65,11 @@ use std::ops::{Deref, DerefMut}; use std::sync::mpsc::{channel, Sender, Receiver, Select}; use std::mem; use std::ptr; +use style::selector_matching::Stylist; use style::computed_values::{filter, mix_blend_mode}; -use style::{StylesheetOrigin, Stylesheet, Stylist, TNode, iter_font_face_rules}; -use style::{MediaType, Device}; +use style::stylesheets::{Origin, Stylesheet, iter_font_face_rules}; +use style::node::TNode; +use style::media_queries::{MediaType, Device}; use std::sync::{Arc, Mutex, MutexGuard}; use url::Url; @@ -488,7 +490,7 @@ impl LayoutTask { final_url, protocol_encoding_label, Some(environment_encoding), - StylesheetOrigin::Author); + Origin::Author); self.handle_add_stylesheet(sheet, possibly_locked_rw_data); } diff --git a/components/layout/list_item.rs b/components/layout/list_item.rs index 4c6bc9bc3b7..c14588c3d02 100644 --- a/components/layout/list_item.rs +++ b/components/layout/list_item.rs @@ -21,7 +21,7 @@ use gfx::display_list::DisplayList; use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use servo_util::opts; -use style::ComputedValues; +use style::properties::ComputedValues; use style::computed_values::list_style_type; use std::sync::Arc; diff --git a/components/layout/model.rs b/components/layout/model.rs index b83585906ad..1cbb54aa99a 100644 --- a/components/layout/model.rs +++ b/components/layout/model.rs @@ -8,10 +8,9 @@ use fragment::Fragment; -use style::computed_values as computed; use geom::SideOffsets2D; -use style::computed_values::{LengthOrPercentageOrAuto, LengthOrPercentage}; -use style::ComputedValues; +use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone, LengthOrPercentage}; +use style::properties::ComputedValues; use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalMargin; use std::cmp::{max, min}; @@ -333,14 +332,14 @@ pub enum MaybeAuto { impl MaybeAuto { #[inline] - pub fn from_style(length: computed::LengthOrPercentageOrAuto, containing_length: Au) + pub fn from_style(length: LengthOrPercentageOrAuto, containing_length: Au) -> MaybeAuto { match length { - computed::LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto, - computed::LengthOrPercentageOrAuto::Percentage(percent) => { + LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto, + LengthOrPercentageOrAuto::Percentage(percent) => { MaybeAuto::Specified(containing_length.scale_by(percent)) } - computed::LengthOrPercentageOrAuto::Length(length) => MaybeAuto::Specified(length) + LengthOrPercentageOrAuto::Length(length) => MaybeAuto::Specified(length) } } @@ -366,18 +365,18 @@ impl MaybeAuto { } } -pub fn specified_or_none(length: computed::LengthOrPercentageOrNone, containing_length: Au) -> Option { +pub fn specified_or_none(length: LengthOrPercentageOrNone, containing_length: Au) -> Option { match length { - computed::LengthOrPercentageOrNone::None => None, - computed::LengthOrPercentageOrNone::Percentage(percent) => Some(containing_length.scale_by(percent)), - computed::LengthOrPercentageOrNone::Length(length) => Some(length), + LengthOrPercentageOrNone::None => None, + LengthOrPercentageOrNone::Percentage(percent) => Some(containing_length.scale_by(percent)), + LengthOrPercentageOrNone::Length(length) => Some(length), } } -pub fn specified(length: computed::LengthOrPercentage, containing_length: Au) -> Au { +pub fn specified(length: LengthOrPercentage, containing_length: Au) -> Au { match length { - computed::LengthOrPercentage::Length(length) => length, - computed::LengthOrPercentage::Percentage(p) => containing_length.scale_by(p) + LengthOrPercentage::Length(length) => length, + LengthOrPercentage::Percentage(p) => containing_length.scale_by(p) } } diff --git a/components/layout/table.rs b/components/layout/table.rs index 533d5166dbd..791ce834ccd 100644 --- a/components/layout/table.rs +++ b/components/layout/table.rs @@ -25,8 +25,10 @@ use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use std::cmp::max; use std::fmt; -use style::{ComputedValues, CSSFloat}; -use style::computed_values::{LengthOrPercentageOrAuto, table_layout}; +use style::properties::ComputedValues; +use style::values::CSSFloat; +use style::values::computed::{LengthOrPercentageOrAuto}; +use style::computed_values::table_layout; use std::sync::Arc; /// A table flow corresponded to the table's internal table fragment under a table wrapper flow. diff --git a/components/layout/table_caption.rs b/components/layout/table_caption.rs index 17512755f87..d539d1b6c6f 100644 --- a/components/layout/table_caption.rs +++ b/components/layout/table_caption.rs @@ -17,7 +17,7 @@ use geom::{Point2D, Rect}; use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use std::fmt; -use style::ComputedValues; +use style::properties::ComputedValues; use std::sync::Arc; /// A table formatting context. diff --git a/components/layout/table_cell.rs b/components/layout/table_cell.rs index dd6a74d5efd..5a11243dd38 100644 --- a/components/layout/table_cell.rs +++ b/components/layout/table_cell.rs @@ -19,7 +19,8 @@ use geom::{Point2D, Rect}; use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use std::fmt; -use style::{UnsignedIntegerAttribute, ComputedValues}; +use style::properties::ComputedValues; +use style::legacy::UnsignedIntegerAttribute; use std::sync::Arc; /// A table formatting context. diff --git a/components/layout/table_colgroup.rs b/components/layout/table_colgroup.rs index f828bcc658a..8dfe070da03 100644 --- a/components/layout/table_colgroup.rs +++ b/components/layout/table_colgroup.rs @@ -17,8 +17,8 @@ use geom::{Point2D, Rect}; use servo_util::geometry::{Au, ZERO_RECT}; use std::cmp::max; use std::fmt; -use style::computed_values::LengthOrPercentageOrAuto; -use style::ComputedValues; +use style::values::computed::LengthOrPercentageOrAuto; +use style::properties::ComputedValues; use std::sync::Arc; /// A table formatting context. diff --git a/components/layout/table_row.rs b/components/layout/table_row.rs index 0b4f06cee4d..317e0909735 100644 --- a/components/layout/table_row.rs +++ b/components/layout/table_row.rs @@ -23,8 +23,8 @@ use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use std::cmp::max; use std::fmt; -use style::ComputedValues; -use style::computed_values::LengthOrPercentageOrAuto; +use style::properties::ComputedValues; +use style::values::computed::LengthOrPercentageOrAuto; use std::sync::Arc; /// A single row of a table. diff --git a/components/layout/table_rowgroup.rs b/components/layout/table_rowgroup.rs index be014330208..377684b6917 100644 --- a/components/layout/table_rowgroup.rs +++ b/components/layout/table_rowgroup.rs @@ -19,7 +19,7 @@ use geom::{Point2D, Rect}; use servo_util::geometry::Au; use servo_util::logical_geometry::LogicalRect; use std::fmt; -use style::ComputedValues; +use style::properties::ComputedValues; use std::sync::Arc; /// A table formatting context. diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs index 6cb69a8b216..99f10710ff8 100644 --- a/components/layout/table_wrapper.rs +++ b/components/layout/table_wrapper.rs @@ -28,8 +28,10 @@ use servo_util::geometry::Au; use std::cmp::{max, min}; use std::fmt; use std::ops::Add; -use style::{ComputedValues, CSSFloat}; -use style::computed_values::{table_layout, LengthOrPercentageOrAuto}; +use style::properties::ComputedValues; +use style::computed_values::table_layout; +use style::values::CSSFloat; +use style::values::computed::LengthOrPercentageOrAuto; use std::sync::Arc; #[derive(Copy, RustcEncodable, Show)] diff --git a/components/layout/text.rs b/components/layout/text.rs index 7727c59a7c6..4c900b01449 100644 --- a/components/layout/text.rs +++ b/components/layout/text.rs @@ -22,10 +22,10 @@ use servo_util::range::Range; use servo_util::smallvec::{SmallVec, SmallVec1}; use std::collections::DList; use std::mem; -use style::ComputedValues; use style::computed_values::{line_height, text_orientation, text_rendering, text_transform}; use style::computed_values::{white_space}; -use style::style_structs::Font as FontStyle; +use style::properties::ComputedValues; +use style::properties::style_structs::Font as FontStyle; use std::sync::Arc; /// A stack-allocated object for scanning an inline flow into `TextRun`-containing `TextFragment`s. diff --git a/components/layout/traversal.rs b/components/layout/traversal.rs index c76c654dcf5..d0123afdcf7 100644 --- a/components/layout/traversal.rs +++ b/components/layout/traversal.rs @@ -19,7 +19,7 @@ use wrapper::{PreorderDomTraversal, PostorderDomTraversal}; use servo_util::bloom::BloomFilter; use servo_util::opts; use servo_util::tid::tid; -use style::TNode; +use style::node::TNode; use std::cell::RefCell; use std::mem; diff --git a/components/layout/util.rs b/components/layout/util.rs index 206590d7c23..e04bbfbbd7e 100644 --- a/components/layout/util.rs +++ b/components/layout/util.rs @@ -17,7 +17,7 @@ use script::layout_interface::{LayoutChan, TrustedNodeAddress}; use script_traits::UntrustedNodeAddress; use std::mem; use std::cell::{Ref, RefMut}; -use style::ComputedValues; +use style::properties::ComputedValues; use style; use std::sync::Arc; @@ -176,7 +176,7 @@ pub trait ToGfxColor { fn to_gfx_color(&self) -> gfx::color::Color; } -impl ToGfxColor for style::computed_values::RGBA { +impl ToGfxColor for style::values::RGBA { fn to_gfx_color(&self) -> gfx::color::Color { gfx::color::rgba(self.red, self.green, self.blue, self.alpha) } diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs index da89ab15e4a..039073e8795 100644 --- a/components/layout/wrapper.rs +++ b/components/layout/wrapper.rs @@ -66,9 +66,10 @@ use std::mem; use std::sync::mpsc::Sender; use string_cache::{Atom, Namespace}; use style::computed_values::{content, display, white_space}; -use style::{NamespaceConstraint, AttrSelector, IntegerAttribute}; -use style::{LengthAttribute, PropertyDeclarationBlock, SimpleColorAttribute}; -use style::{TElement, TElementAttributes, TNode, UnsignedIntegerAttribute}; +use style::selectors::{NamespaceConstraint, AttrSelector}; +use style::legacy::{LengthAttribute, SimpleColorAttribute, UnsignedIntegerAttribute, IntegerAttribute}; +use style::node::{TElement, TElementAttributes, TNode}; +use style::properties::PropertyDeclarationBlock; use url::Url; /// Allows some convenience methods on generic layout nodes. diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index d2af1ebe968..d814b3b6d12 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -58,7 +58,7 @@ use std::io::timer::Timer; use std::rc::Rc; use std::sync::mpsc::{Receiver, Sender}; use string_cache::{Atom, Namespace}; -use style::PropertyDeclarationBlock; +use style::properties::PropertyDeclarationBlock; use url::Url; diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs index 49a6bfbeae3..2de0942f968 100644 --- a/components/script/dom/cssstyledeclaration.rs +++ b/components/script/dom/cssstyledeclaration.rs @@ -17,8 +17,8 @@ use dom::node::{window_from_node, document_from_node, NodeDamage, Node}; use dom::window::Window; use util::str::DOMString; use string_cache::Atom; -use style::{is_supported_property, longhands_from_shorthand, parse_style_attribute}; -use style::PropertyDeclaration; +use style::properties::{is_supported_property, longhands_from_shorthand, parse_style_attribute}; +use style::properties::PropertyDeclaration; use std::ascii::AsciiExt; use std::borrow::ToOwned; diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs index 540916c027e..84f3d88ac7d 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -50,8 +50,11 @@ use dom::node::{window_from_node}; use dom::nodelist::NodeList; use dom::virtualmethods::{VirtualMethods, vtable_for}; use devtools_traits::AttrInfo; -use style::{self, SimpleColorAttribute, UnsignedIntegerAttribute}; -use style::{IntegerAttribute, LengthAttribute, matches}; +use style::legacy::{SimpleColorAttribute, UnsignedIntegerAttribute, IntegerAttribute, LengthAttribute}; +use style::selector_matching::matches; +use style::properties::{PropertyDeclarationBlock, PropertyDeclaration, parse_style_attribute}; +use style::selectors::parse_author_origin_selector_list_from_str; +use style; use util::namespace; use util::str::{DOMString, LengthOrPercentageOrAuto}; @@ -74,7 +77,7 @@ pub struct Element { namespace: Namespace, prefix: Option, attrs: DOMRefCell>>, - style_attribute: DOMRefCell>, + style_attribute: DOMRefCell>, attr_list: MutNullableJS, class_list: MutNullableJS, } @@ -152,7 +155,7 @@ pub trait RawLayoutElementHelpers { -> Option; fn local_name<'a>(&'a self) -> &'a Atom; fn namespace<'a>(&'a self) -> &'a Namespace; - fn style_attribute<'a>(&'a self) -> &'a DOMRefCell>; + fn style_attribute<'a>(&'a self) -> &'a DOMRefCell>; } #[inline] @@ -363,7 +366,7 @@ impl RawLayoutElementHelpers for Element { &self.namespace } - fn style_attribute<'a>(&'a self) -> &'a DOMRefCell> { + fn style_attribute<'a>(&'a self) -> &'a DOMRefCell> { &self.style_attribute } } @@ -402,13 +405,13 @@ pub trait ElementHelpers<'a> { fn prefix(self) -> &'a Option; fn attrs(&self) -> Ref>>; fn attrs_mut(&self) -> RefMut>>; - fn style_attribute(self) -> &'a DOMRefCell>; + fn style_attribute(self) -> &'a DOMRefCell>; fn summarize(self) -> Vec; fn is_void(self) -> bool; fn remove_inline_style_property(self, property: DOMString); - fn update_inline_style(self, property_decl: style::PropertyDeclaration, style_priority: StylePriority); - fn get_inline_style_declaration(self, property: &Atom) -> Option; - fn get_important_inline_style_declaration(self, property: &Atom) -> Option; + fn update_inline_style(self, property_decl: PropertyDeclaration, style_priority: StylePriority); + fn get_inline_style_declaration(self, property: &Atom) -> Option; + fn get_important_inline_style_declaration(self, property: &Atom) -> Option; } impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { @@ -446,7 +449,7 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { self.extended_deref().attrs.borrow_mut() } - fn style_attribute(self) -> &'a DOMRefCell> { + fn style_attribute(self) -> &'a DOMRefCell> { &self.extended_deref().style_attribute } @@ -503,7 +506,7 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { }); } - fn update_inline_style(self, property_decl: style::PropertyDeclaration, style_priority: StylePriority) { + fn update_inline_style(self, property_decl: PropertyDeclaration, style_priority: StylePriority) { let mut inline_declarations = self.style_attribute().borrow_mut(); if let &mut Some(ref mut declarations) = &mut *inline_declarations { let existing_declarations = if style_priority == StylePriority::Important { @@ -528,13 +531,13 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { (vec!(), vec!(property_decl)) }; - *inline_declarations = Some(style::PropertyDeclarationBlock { + *inline_declarations = Some(PropertyDeclarationBlock { important: Arc::new(important), normal: Arc::new(normal), }); } - fn get_inline_style_declaration(self, property: &Atom) -> Option { + fn get_inline_style_declaration(self, property: &Atom) -> Option { let inline_declarations = self.style_attribute.borrow(); inline_declarations.as_ref().and_then(|declarations| { declarations.normal @@ -545,7 +548,7 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { }) } - fn get_important_inline_style_declaration(self, property: &Atom) -> Option { + fn get_important_inline_style_declaration(self, property: &Atom) -> Option { let inline_declarations = self.style_attribute.borrow(); inline_declarations.as_ref().and_then(|declarations| { declarations.important @@ -1117,7 +1120,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> { // http://dom.spec.whatwg.org/#dom-element-matches fn Matches(self, selectors: DOMString) -> Fallible { - match style::parse_author_origin_selector_list_from_str(selectors.as_slice()) { + match parse_author_origin_selector_list_from_str(selectors.as_slice()) { Err(()) => Err(Syntax), Ok(ref selectors) => { let root: JSRef = NodeCast::from_ref(self); @@ -1128,7 +1131,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> { // https://dom.spec.whatwg.org/#dom-element-closest fn Closest(self, selectors: DOMString) -> Fallible>> { - match style::parse_author_origin_selector_list_from_str(selectors.as_slice()) { + match parse_author_origin_selector_list_from_str(selectors.as_slice()) { Err(()) => Err(Syntax), Ok(ref selectors) => { let root: JSRef = NodeCast::from_ref(self); @@ -1173,7 +1176,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> { let doc = document_from_node(*self).root(); let base_url = doc.r().url().clone(); let value = attr.value(); - let style = Some(style::parse_style_attribute(value.as_slice(), &base_url)); + let style = Some(parse_style_attribute(value.as_slice(), &base_url)); *self.style_attribute.borrow_mut() = style; if node.is_in_doc() { @@ -1312,7 +1315,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> { } } -impl<'a> style::TElement<'a> for JSRef<'a, Element> { +impl<'a> style::node::TElement<'a> for JSRef<'a, Element> { #[allow(unsafe_blocks)] fn get_attr(self, namespace: &Namespace, attr: &Atom) -> Option<&'a str> { self.get_attribute(namespace.clone(), attr).root().map(|attr| { diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs index 5769ed56142..e39915ad848 100644 --- a/components/script/dom/htmlstyleelement.rs +++ b/components/script/dom/htmlstyleelement.rs @@ -14,7 +14,7 @@ use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node}; use dom::virtualmethods::VirtualMethods; use layout_interface::{LayoutChan, Msg}; use util::str::DOMString; -use style::{StylesheetOrigin, Stylesheet}; +use style::stylesheets::{Origin, Stylesheet}; #[dom_struct] pub struct HTMLStyleElement { @@ -55,8 +55,7 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> { let url = win.page().get_url(); let data = node.GetTextContent().expect("Element.textContent must be a string"); - let sheet = Stylesheet::from_str(data.as_slice(), url, - StylesheetOrigin::Author); + let sheet = Stylesheet::from_str(data.as_slice(), url, Origin::Author); let LayoutChan(ref layout_chan) = win.page().layout_chan; layout_chan.send(Msg::AddStylesheet(sheet)); } diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs index bd262ae2aaa..6c19a95e525 100644 --- a/components/script/dom/node.rs +++ b/components/script/dom/node.rs @@ -48,7 +48,11 @@ use devtools_traits::NodeInfo; use script_traits::UntrustedNodeAddress; use util::geometry::Au; use util::str::{DOMString, null_str_as_empty}; -use style::{matches, SelectorList}; +use style::selectors::{Selector, AttrSelector, NamespaceConstraint}; +use style::selectors::parse_author_origin_selector_list_from_str; +use style::selector_matching::matches; +use style::properties::ComputedValues; +use style; use js::jsapi::{JSContext, JSObject, JSTracer, JSRuntime}; use js::jsfriendapi; @@ -60,7 +64,6 @@ use std::cell::{Cell, RefCell, Ref, RefMut}; use std::default::Default; use std::iter::{FilterMap, Peekable}; use std::mem; -use style::{self, ComputedValues}; use std::sync::Arc; use uuid; use string_cache::QualName; @@ -376,12 +379,12 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> { } pub struct QuerySelectorIterator<'a> { - selectors: SelectorList, + selectors: Vec, iterator: TreeIterator<'a>, } impl<'a> QuerySelectorIterator<'a> { - unsafe fn new(iter: TreeIterator<'a>, selectors: SelectorList) -> QuerySelectorIterator<'a> { + unsafe fn new(iter: TreeIterator<'a>, selectors: Vec) -> QuerySelectorIterator<'a> { QuerySelectorIterator { selectors: selectors, iterator: iter, @@ -746,7 +749,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> { // http://dom.spec.whatwg.org/#dom-parentnode-queryselector fn query_selector(self, selectors: DOMString) -> Fallible>> { // Step 1. - match style::parse_author_origin_selector_list_from_str(selectors.as_slice()) { + match parse_author_origin_selector_list_from_str(selectors.as_slice()) { // Step 2. Err(()) => return Err(Syntax), // Step 3. @@ -768,7 +771,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> { // Step 1. let nodes; let root = self.ancestors().last().unwrap_or(self.clone()); - match style::parse_author_origin_selector_list_from_str(selectors.as_slice()) { + match parse_author_origin_selector_list_from_str(selectors.as_slice()) { // Step 2. Err(()) => return Err(Syntax), // Step 3. @@ -2229,7 +2232,7 @@ impl<'a> VirtualMethods for JSRef<'a, Node> { } } -impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> { +impl<'a> style::node::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> { fn parent_node(self) -> Option> { // FIXME(zwarich): Remove this when UFCS lands and there is a better way // of disambiguating methods. @@ -2304,7 +2307,7 @@ impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> { ElementCast::to_ref(self).unwrap() } - fn match_attr(self, attr: &style::AttrSelector, test: F) -> bool + fn match_attr(self, attr: &AttrSelector, test: F) -> bool where F: Fn(&str) -> bool { let name = { @@ -2315,11 +2318,11 @@ impl<'a> style::TNode<'a, JSRef<'a, Element>> for JSRef<'a, Node> { } }; match attr.namespace { - style::NamespaceConstraint::Specific(ref ns) => { + NamespaceConstraint::Specific(ref ns) => { self.as_element().get_attribute(ns.clone(), name).root() .map_or(false, |attr| test(attr.r().value().as_slice())) }, - style::NamespaceConstraint::Any => { + NamespaceConstraint::Any => { self.as_element().get_attributes(name).into_iter() .map(|attr| attr.root()) .any(|attr| test(attr.r().value().as_slice())) diff --git a/components/script/layout_interface.rs b/components/script/layout_interface.rs index e4c6231b649..4dfa9ac658a 100644 --- a/components/script/layout_interface.rs +++ b/components/script/layout_interface.rs @@ -16,7 +16,7 @@ use util::geometry::Au; use std::any::Any; use std::sync::mpsc::{channel, Receiver, Sender}; use std::boxed::BoxAny; -use style::Stylesheet; +use style::stylesheets::Stylesheet; use url::Url; pub use dom::node::TrustedNodeAddress; diff --git a/components/style/font_face.rs b/components/style/font_face.rs index a731f9462e0..6012e0618ea 100644 --- a/components/style/font_face.rs +++ b/components/style/font_face.rs @@ -6,7 +6,7 @@ use cssparser::{Token, Parser, DeclarationListParser, AtRuleParser, DeclarationP use std::ascii::AsciiExt; use stylesheets::CSSRule; use properties::longhands::font_family::parse_one_family; -use properties::computed_values::font_family::FontFamily; +use computed_values::font_family::FontFamily; use media_queries::Device; use url::{Url, UrlParser}; use parser::{ParserContext, log_css_error}; diff --git a/components/style/lib.rs b/components/style/lib.rs index 0ad51ef559e..2c5380216f8 100644 --- a/components/style/lib.rs +++ b/components/style/lib.rs @@ -35,40 +35,27 @@ extern crate lazy_static; extern crate util; -pub use media_queries::{Device, MediaType}; -pub use stylesheets::{Stylesheet, iter_font_face_rules}; -pub use selector_matching::{Stylist}; -pub use selector_matching::{DeclarationBlock, CommonStyleAffectingAttributes}; -pub use selector_matching::{CommonStyleAffectingAttributeInfo, CommonStyleAffectingAttributeMode}; -pub use selector_matching::{matches, matches_simple_selector, common_style_affecting_attributes}; -pub use selector_matching::{rare_style_affecting_attributes}; -pub use selector_matching::{RECOMMENDED_SELECTOR_BLOOM_FILTER_SIZE, SELECTOR_WHITESPACE}; -pub use properties::{cascade, cascade_anonymous, longhands_from_shorthand}; -pub use properties::{is_supported_property, make_inline}; -pub use properties::{PropertyDeclaration}; -pub use properties::{computed_values, ComputedValues, style_structs}; -pub use properties::{PropertyDeclarationBlock, parse_style_attribute}; // Style attributes -pub use properties::{DeclaredValue, PropertyDeclarationParseResult}; -pub use values::CSSFloat; -pub use values::specified::{Angle, AngleOrCorner, HorizontalDirection, VerticalDirection}; -pub use values::computed; -pub use node::{TElement, TElementAttributes, TNode}; -pub use selectors::{PseudoElement, SelectorList}; -pub use selectors::{AttrSelector, NamespaceConstraint}; -pub use selectors::{SimpleSelector, parse_author_origin_selector_list_from_str}; -pub use cssparser::{Color, RGBA}; -pub use legacy::{IntegerAttribute, LengthAttribute}; -pub use legacy::{SimpleColorAttribute, UnsignedIntegerAttribute}; -pub use font_face::Source; -pub use stylesheets::Origin as StylesheetOrigin; - pub mod stylesheets; pub mod parser; pub mod selectors; pub mod selector_matching; #[macro_use] pub mod values; -pub mod properties; +#[macro_use] pub mod properties; pub mod node; pub mod media_queries; pub mod font_face; pub mod legacy; + +macro_rules! reexport_computed_values { + ( $( $name: ident )+ ) => { + pub mod computed_values { + $( + pub use properties::longhands::$name::computed_value as $name; + )+ + // Don't use a side-specific name needlessly: + pub use properties::longhands::border_top_style::computed_value as border_style; + } + } +} +longhand_properties_idents!(reexport_computed_values); + diff --git a/components/style/properties/mod.rs.mako b/components/style/properties/mod.rs.mako index fada051ebc1..92af5f05bb0 100644 --- a/components/style/properties/mod.rs.mako +++ b/components/style/properties/mod.rs.mako @@ -22,6 +22,7 @@ use values::computed; use selector_matching::DeclarationBlock; use parser::{ParserContext, log_css_error}; use stylesheets::Origin; +use computed_values; use self::property_bit_field::PropertyBitField; @@ -2629,43 +2630,43 @@ impl ComputedValues { } #[inline] - pub fn content_inline_size(&self) -> computed_values::LengthOrPercentageOrAuto { + pub fn content_inline_size(&self) -> computed::LengthOrPercentageOrAuto { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.height } else { box_style.width } } #[inline] - pub fn content_block_size(&self) -> computed_values::LengthOrPercentageOrAuto { + pub fn content_block_size(&self) -> computed::LengthOrPercentageOrAuto { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.width } else { box_style.height } } #[inline] - pub fn min_inline_size(&self) -> computed_values::LengthOrPercentage { + pub fn min_inline_size(&self) -> computed::LengthOrPercentage { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.min_height } else { box_style.min_width } } #[inline] - pub fn min_block_size(&self) -> computed_values::LengthOrPercentage { + pub fn min_block_size(&self) -> computed::LengthOrPercentage { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.min_width } else { box_style.min_height } } #[inline] - pub fn max_inline_size(&self) -> computed_values::LengthOrPercentageOrNone { + pub fn max_inline_size(&self) -> computed::LengthOrPercentageOrNone { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.max_height } else { box_style.max_width } } #[inline] - pub fn max_block_size(&self) -> computed_values::LengthOrPercentageOrNone { + pub fn max_block_size(&self) -> computed::LengthOrPercentageOrNone { let box_style = self.get_box(); if self.writing_mode.is_vertical() { box_style.max_width } else { box_style.max_height } } #[inline] - pub fn logical_padding(&self) -> LogicalMargin { + pub fn logical_padding(&self) -> LogicalMargin { let padding_style = self.get_padding(); LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new( padding_style.padding_top, @@ -2687,7 +2688,7 @@ impl ComputedValues { } #[inline] - pub fn logical_margin(&self) -> LogicalMargin { + pub fn logical_margin(&self) -> LogicalMargin { let margin_style = self.get_margin(); LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new( margin_style.margin_top, @@ -2698,7 +2699,7 @@ impl ComputedValues { } #[inline] - pub fn logical_position(&self) -> LogicalMargin { + pub fn logical_position(&self) -> LogicalMargin { // FIXME(SimonSapin): should be the writing mode of the containing block, maybe? let position_style = self.get_positionoffsets(); LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new( @@ -3169,6 +3170,17 @@ macro_rules! css_properties_accessors { } } + +macro_rules! longhand_properties_idents { + ($macro_name: ident) => { + $macro_name! { + % for property in LONGHANDS: + ${property.ident} + % endfor + } + } +} + pub fn longhands_from_shorthand(shorthand: &str) -> Option> { match shorthand { % for property in SHORTHANDS: @@ -3181,18 +3193,3 @@ pub fn longhands_from_shorthand(shorthand: &str) -> Option> { _ => None, } } - -// Only re-export the types for computed values. -pub mod computed_values { - % for property in LONGHANDS: - pub use super::longhands::${property.ident}::computed_value as ${property.ident}; - % endfor - // Don't use a side-specific name needlessly: - pub use super::longhands::border_top_style::computed_value as border_style; - - pub use cssparser::RGBA; - pub use values::computed::{ - LengthOrPercentage, - LengthOrPercentageOrAuto, - LengthOrPercentageOrNone}; -} diff --git a/components/style/selector_matching.rs b/components/style/selector_matching.rs index 9b81f20060a..f1c96e2ec95 100644 --- a/components/style/selector_matching.rs +++ b/components/style/selector_matching.rs @@ -21,8 +21,7 @@ use media_queries::Device; use node::{TElement, TElementAttributes, TNode}; use properties::{PropertyDeclaration, PropertyDeclarationBlock}; use selectors::{CaseSensitivity, Combinator, CompoundSelector, LocalName}; -use selectors::{PseudoElement, SelectorList, SimpleSelector}; -use selectors::{get_selector_list_selectors}; +use selectors::{PseudoElement, SimpleSelector, Selector}; use stylesheets::{Stylesheet, iter_stylesheet_media_rules, iter_stylesheet_style_rules, Origin}; @@ -549,14 +548,15 @@ impl DeclarationBlock { } } -pub fn matches<'a,E,N>(selector_list: &SelectorList, +pub fn matches<'a,E,N>(selector_list: &Vec, element: &N, parent_bf: &Option>) -> bool where E: TElement<'a>, N: TNode<'a,E> { - get_selector_list_selectors(selector_list).iter().any(|selector| + selector_list.iter().any(|selector| { selector.pseudo_element.is_none() && - matches_compound_selector(&*selector.compound_selectors, element, parent_bf, &mut false)) + matches_compound_selector(&*selector.compound_selectors, element, parent_bf, &mut false) + }) } /// Determines whether the given element matches the given single or compound selector. diff --git a/components/style/selectors.rs b/components/style/selectors.rs index 98eb186eb67..1ab50f943e4 100644 --- a/components/style/selectors.rs +++ b/components/style/selectors.rs @@ -111,17 +111,6 @@ pub enum NamespaceConstraint { } -/// Re-exported to script, but opaque. -pub struct SelectorList { - selectors: Vec -} - -/// Public to the style crate, but not re-exported to script -pub fn get_selector_list_selectors<'a>(selector_list: &'a SelectorList) -> &'a [Selector] { - selector_list.selectors.as_slice() -} - - fn compute_specificity(mut selector: &CompoundSelector, pseudo_element: &Option) -> u32 { struct Specificity { @@ -193,12 +182,10 @@ fn compute_specificity(mut selector: &CompoundSelector, -pub fn parse_author_origin_selector_list_from_str(input: &str) - -> Result { +pub fn parse_author_origin_selector_list_from_str(input: &str) -> Result, ()> { let url = Url::parse("about:blank").unwrap(); let context = ParserContext::new(Origin::Author, &url); parse_selector_list(&context, &mut Parser::new(input)) - .map(|s| SelectorList { selectors: s }) } /// Parse a comma-separated list of Selectors. diff --git a/components/style/values.rs b/components/style/values.rs index 2772bb7dcde..82e7a543f6e 100644 --- a/components/style/values.rs +++ b/components/style/values.rs @@ -4,6 +4,8 @@ #![allow(non_camel_case_types)] +pub use cssparser::RGBA; + macro_rules! define_css_keyword_enum { ($name: ident: $( $css: expr => $variant: ident ),+,) => { From 6e95bd8e50e79360b04b7b92bf36ad01dfdf242e Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Wed, 28 Jan 2015 23:09:35 +0100 Subject: [PATCH 4/5] style::properties : move generated file out of source tree, use new-style Cargo build script. --- components/servo/Cargo.lock | 6 ++++ components/style/.gitignore | 2 -- components/style/Cargo.toml | 5 +-- components/style/build.rs | 31 +++++++++++++++++++ components/style/lib.rs | 7 ++++- components/style/makefile.cargo | 8 ----- .../mod.rs.mako => properties.mako.rs} | 2 ++ 7 files changed, 48 insertions(+), 13 deletions(-) delete mode 100644 components/style/.gitignore create mode 100644 components/style/build.rs delete mode 100644 components/style/makefile.cargo rename components/style/{properties/mod.rs.mako => properties.mako.rs} (99%) diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock index 987d2052091..fc43f530cdc 100644 --- a/components/servo/Cargo.lock +++ b/components/servo/Cargo.lock @@ -553,6 +553,11 @@ dependencies = [ "log 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "mod_path" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "mozjs-sys" version = "0.0.0" @@ -753,6 +758,7 @@ dependencies = [ "geom 0.1.0 (git+https://github.com/servo/rust-geom)", "lazy_static 0.1.6 (git+https://github.com/Kimundi/lazy-static.rs)", "matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", + "mod_path 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "plugins 0.0.1", "string_cache 0.0.0 (git+https://github.com/servo/string-cache)", "string_cache_macros 0.0.0 (git+https://github.com/servo/string-cache)", diff --git a/components/style/.gitignore b/components/style/.gitignore deleted file mode 100644 index 1f18fa1546d..00000000000 --- a/components/style/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -properties/mod.rs -properties/mod.rs.tmp diff --git a/components/style/Cargo.toml b/components/style/Cargo.toml index f5c8bae0939..e37df0d38bc 100644 --- a/components/style/Cargo.toml +++ b/components/style/Cargo.toml @@ -3,7 +3,7 @@ name = "style" version = "0.0.1" authors = ["The Servo Project Developers"] -build = "make -f makefile.cargo" +build = "build.rs" [lib] name = "style" @@ -34,4 +34,5 @@ git = "https://github.com/servo/string-cache" text_writer = "0.1.1" encoding = "0.2" matches = "0.1" -url = "*" \ No newline at end of file +url = "*" +mod_path = "0.1" diff --git a/components/style/build.rs b/components/style/build.rs new file mode 100644 index 00000000000..27c71469e4c --- /dev/null +++ b/components/style/build.rs @@ -0,0 +1,31 @@ +/* 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/. */ + +use std::os; +use std::path::Path; +use std::io::process::{Command, ProcessExit, StdioContainer}; +use std::io::File; + + +fn main() { + let python = if Command::new("python2.7").arg("--version").status() == Ok(ProcessExit::ExitStatus(0)) { + "python2.7" + } else { + "python" + }; + let style = Path::new(file!()).dir_path(); + let mako = style.join("Mako-0.9.1.zip"); + let template = style.join("properties.mako.rs"); + let result = Command::new(python) + .env("PYTHONPATH", mako.as_str().unwrap()) + .env("TEMPLATE", template.as_str().unwrap()) + .arg("-c") + .arg("from os import environ; from mako.template import Template; print(Template(filename=environ['TEMPLATE']).render())") + .stderr(StdioContainer::InheritFd(2)) + .output() + .unwrap(); + assert_eq!(result.status, ProcessExit::ExitStatus(0)); + let out = Path::new(os::getenv("OUT_DIR").unwrap()); + File::create(&out.join("properties.rs")).unwrap().write(&*result.output).unwrap(); +} diff --git a/components/style/lib.rs b/components/style/lib.rs index 2c5380216f8..527b9ff587f 100644 --- a/components/style/lib.rs +++ b/components/style/lib.rs @@ -34,13 +34,18 @@ extern crate lazy_static; extern crate util; +#[plugin] #[no_link] extern crate mod_path; + pub mod stylesheets; pub mod parser; pub mod selectors; pub mod selector_matching; #[macro_use] pub mod values; -#[macro_use] pub mod properties; + +// Generated from the properties.mako.rs template by build.rs +mod_path! properties (concat!(env!("OUT_DIR"), "/properties.rs")); + pub mod node; pub mod media_queries; pub mod font_face; diff --git a/components/style/makefile.cargo b/components/style/makefile.cargo deleted file mode 100644 index f797dee7237..00000000000 --- a/components/style/makefile.cargo +++ /dev/null @@ -1,8 +0,0 @@ -MAKO_ZIP = Mako-0.9.1.zip -PYTHON = $(shell which python2.7 2>/dev/null || echo python) - -all: properties/mod.rs - -properties/mod.rs: properties/mod.rs.mako - PYTHONPATH=$(MAKO_ZIP) $(PYTHON) -c "from mako.template import Template; print(Template(filename='$<').render())" > $@.tmp - mv $@.tmp $@ diff --git a/components/style/properties/mod.rs.mako b/components/style/properties.mako.rs similarity index 99% rename from components/style/properties/mod.rs.mako rename to components/style/properties.mako.rs index 92af5f05bb0..6dc140c993c 100644 --- a/components/style/properties/mod.rs.mako +++ b/components/style/properties.mako.rs @@ -4,6 +4,8 @@ // This file is a Mako template: http://www.makotemplates.org/ +#![macro_use] + use std::ascii::AsciiExt; use std::borrow::ToOwned; use std::fmt; From dfb5c52131738d15af9987aff02751fa212863f9 Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Fri, 30 Jan 2015 23:18:00 +0100 Subject: [PATCH 5/5] Split overlong line. --- components/style/properties.mako.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/components/style/properties.mako.rs b/components/style/properties.mako.rs index 6dc140c993c..8b2bdb6398c 100644 --- a/components/style/properties.mako.rs +++ b/components/style/properties.mako.rs @@ -1807,7 +1807,9 @@ pub mod longhands { ${single_keyword("mix-blend-mode", - "normal multiply screen overlay darken lighten color-dodge color-burn hard-light soft-light difference exclusion hue saturation color luminosity")} + """normal multiply screen overlay darken lighten color-dodge + color-burn hard-light soft-light difference exclusion hue + saturation color luminosity""")} }