From e5fb1f09e77e04dc23e5aff684b62c5c7658399f Mon Sep 17 00:00:00 2001 From: Mike Welsh Date: Fri, 12 Feb 2021 05:03:17 -0800 Subject: [PATCH] chore: Appease clippy * #[derive(Collect)] should be before #[collect] * Replace redunant `&buf[..]` with `buf` * Changes most cases of UPPERCase to UpperCase * Allow upper_case_acronym on most SWF types, as they are from SWF spec/more annoying to change. --- core/src/avm1/activation.rs | 6 +- core/src/avm1/globals/load_vars.rs | 4 +- core/src/avm1/globals/movie_clip.rs | 8 +- core/src/avm1/globals/system.rs | 20 +- core/src/avm1/globals/xml.rs | 32 +- core/src/avm1/object.rs | 16 +- core/src/avm1/object/bitmap_data.rs | 6 +- core/src/avm1/object/super_object.rs | 4 +- core/src/avm1/object/xml_attributes_object.rs | 36 +- core/src/avm1/object/xml_idmap_object.rs | 28 +- core/src/avm1/object/xml_object.rs | 36 +- core/src/avm1/string.rs | 4 +- core/src/backend/navigator.rs | 16 +- core/src/backend/render.rs | 2 +- core/src/display_object/edit_text.rs | 12 +- core/src/focus_tracker.rs | 2 +- core/src/html/text_format.rs | 102 ++--- core/src/loader.rs | 20 +- core/src/player.rs | 10 +- core/src/tag_utils.rs | 2 +- core/src/xml.rs | 6 +- core/src/xml/document.rs | 48 +- core/src/xml/iterators.rs | 26 +- core/src/xml/namespace.rs | 12 +- core/src/xml/tests.rs | 52 +-- core/src/xml/tree.rs | 432 +++++++++--------- desktop/src/audio.rs | 2 +- desktop/src/navigator.rs | 4 +- render/canvas/src/lib.rs | 12 +- render/webgl/src/lib.rs | 4 +- render/wgpu/src/lib.rs | 32 +- render/wgpu/src/pipelines.rs | 4 +- swf/src/avm1/opcode.rs | 4 +- swf/src/lib.rs | 7 +- swf/src/read.rs | 12 +- swf/src/test_data.rs | 18 +- swf/src/types.rs | 8 +- swf/src/write.rs | 8 +- web/src/audio.rs | 2 +- web/src/navigator.rs | 8 +- 40 files changed, 535 insertions(+), 532 deletions(-) diff --git a/core/src/avm1/activation.rs b/core/src/avm1/activation.rs index 67de5382f..b6aceae47 100644 --- a/core/src/avm1/activation.rs +++ b/core/src/avm1/activation.rs @@ -2397,15 +2397,15 @@ impl<'a, 'gc, 'gc_context> Activation<'a, 'gc, 'gc_context> { .finish(); match method { - NavigationMethod::GET if url.find('?').is_none() => ( + NavigationMethod::Get if url.find('?').is_none() => ( Cow::Owned(format!("{}?{}", url, qstring)), RequestOptions::get(), ), - NavigationMethod::GET => ( + NavigationMethod::Get => ( Cow::Owned(format!("{}&{}", url, qstring)), RequestOptions::get(), ), - NavigationMethod::POST => ( + NavigationMethod::Post => ( url, RequestOptions::post(Some(( qstring.as_bytes().to_owned(), diff --git a/core/src/avm1/globals/load_vars.rs b/core/src/avm1/globals/load_vars.rs index a8fd33ec3..abb1f516a 100644 --- a/core/src/avm1/globals/load_vars.rs +++ b/core/src/avm1/globals/load_vars.rs @@ -229,7 +229,7 @@ fn send<'gc>( .get(1) .unwrap_or(&Value::Undefined) .coerce_to_string(activation)?; - let method = NavigationMethod::from_method_str(&method_name).unwrap_or(NavigationMethod::POST); + let method = NavigationMethod::from_method_str(&method_name).unwrap_or(NavigationMethod::Post); use indexmap::IndexMap; @@ -276,7 +276,7 @@ fn send_and_load<'gc>( .get(2) .unwrap_or(&Value::Undefined) .coerce_to_string(activation)?; - let method = NavigationMethod::from_method_str(&method_name).unwrap_or(NavigationMethod::POST); + let method = NavigationMethod::from_method_str(&method_name).unwrap_or(NavigationMethod::Post); spawn_load_var_fetch(activation, target, &url, Some((this, method)))?; diff --git a/core/src/avm1/globals/movie_clip.rs b/core/src/avm1/globals/movie_clip.rs index bf6ee4f13..810cfb6d3 100644 --- a/core/src/avm1/globals/movie_clip.rs +++ b/core/src/avm1/globals/movie_clip.rs @@ -431,8 +431,8 @@ fn begin_gradient_fill<'gc>( .and_then(|v| v.coerce_to_string(activation).ok()) .as_deref() { - Some("linearRGB") => GradientInterpolation::LinearRGB, - _ => GradientInterpolation::RGB, + Some("linearRGB") => GradientInterpolation::LinearRgb, + _ => GradientInterpolation::Rgb, }; let gradient = Gradient { @@ -1162,8 +1162,8 @@ pub fn get_url<'gc>( None }; let method = match args.get(2) { - Some(Value::String(s)) if *s == "GET" => Some(NavigationMethod::GET), - Some(Value::String(s)) if *s == "POST" => Some(NavigationMethod::POST), + Some(Value::String(s)) if *s == "GET" => Some(NavigationMethod::Get), + Some(Value::String(s)) if *s == "POST" => Some(NavigationMethod::Post), _ => None, }; let vars_method = method.map(|m| (m, activation.locals_into_form_values())); diff --git a/core/src/avm1/globals/system.rs b/core/src/avm1/globals/system.rs index 94f397b97..e28cc116b 100644 --- a/core/src/avm1/globals/system.rs +++ b/core/src/avm1/globals/system.rs @@ -13,19 +13,19 @@ use std::convert::TryFrom; /// Available cpu architectures pub enum CpuArchitecture { - PowerPC, + PowerPc, X86, - SPARC, - ARM, + Sparc, + Arm, } impl fmt::Display for CpuArchitecture { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(match self { - CpuArchitecture::PowerPC => "PowerPC", + CpuArchitecture::PowerPc => "PowerPC", CpuArchitecture::X86 => "x86", - CpuArchitecture::SPARC => "SPARC", - CpuArchitecture::ARM => "ARM", + CpuArchitecture::Sparc => "SPARC", + CpuArchitecture::Arm => "ARM", }) } } @@ -56,10 +56,10 @@ pub enum OperatingSystem { WindowsNt, Windows98, Windows95, - WindowsCE, + WindowsCe, WindowsUnknown, Linux, - MacOS, + MacOs, } impl fmt::Display for OperatingSystem { @@ -70,10 +70,10 @@ impl fmt::Display for OperatingSystem { OperatingSystem::WindowsNt => "Windows NT", OperatingSystem::Windows98 => "Windows 98/ME", OperatingSystem::Windows95 => "Windows 95", - OperatingSystem::WindowsCE => "Windows CE", + OperatingSystem::WindowsCe => "Windows CE", OperatingSystem::WindowsUnknown => "Windows", OperatingSystem::Linux => "Linux", - OperatingSystem::MacOS => "MacOS", + OperatingSystem::MacOs => "MacOS", }) } } diff --git a/core/src/avm1/globals/xml.rs b/core/src/avm1/globals/xml.rs index 5e6462e4c..8dcf97517 100644 --- a/core/src/avm1/globals/xml.rs +++ b/core/src/avm1/globals/xml.rs @@ -4,13 +4,13 @@ use crate::avm1::activation::Activation; use crate::avm1::error::Error; use crate::avm1::function::{Executable, FunctionObject}; use crate::avm1::object::script_object::ScriptObject; -use crate::avm1::object::xml_object::XMLObject; +use crate::avm1::object::xml_object::XmlObject; use crate::avm1::property::Attribute; use crate::avm1::{AvmString, Object, TObject, Value}; use crate::avm_warn; use crate::backend::navigator::RequestOptions; use crate::xml; -use crate::xml::{XMLDocument, XMLNode}; +use crate::xml::{XmlDocument, XmlNode}; use gc_arena::MutationContext; use quick_xml::Error as ParseError; @@ -35,7 +35,7 @@ pub const XML_MISMATCHED_END: f64 = -10.0; /// not. Those nodes are filtered from all attributes that return XML nodes to /// act as if those nodes did not exist. For example, `prevSibling` skips /// past incompatible nodes, etc. -fn is_as2_compatible(node: XMLNode<'_>) -> bool { +fn is_as2_compatible(node: XmlNode<'_>) -> bool { node.is_document_root() || node.is_element() || node.is_text() } @@ -45,7 +45,7 @@ pub fn xmlnode_constructor<'gc>( this: Object<'gc>, args: &[Value<'gc>], ) -> Result, Error<'gc>> { - let blank_document = XMLDocument::new(activation.context.gc_context); + let blank_document = XmlDocument::new(activation.context.gc_context); match ( args.get(0) @@ -55,13 +55,13 @@ pub fn xmlnode_constructor<'gc>( ) { (Some(Ok(1)), Some(Ok(ref strval)), Some(ref mut this_node)) => { let mut xmlelement = - XMLNode::new_element(activation.context.gc_context, strval, blank_document); + XmlNode::new_element(activation.context.gc_context, strval, blank_document); xmlelement.introduce_script_object(activation.context.gc_context, this); this_node.swap(activation.context.gc_context, xmlelement); } (Some(Ok(3)), Some(Ok(ref strval)), Some(ref mut this_node)) => { let mut xmlelement = - XMLNode::new_text(activation.context.gc_context, strval, blank_document); + XmlNode::new_text(activation.context.gc_context, strval, blank_document); xmlelement.introduce_script_object(activation.context.gc_context, this); this_node.swap(activation.context.gc_context, xmlelement); } @@ -537,7 +537,7 @@ pub fn create_xmlnode_proto<'gc>( proto: Object<'gc>, fn_proto: Object<'gc>, ) -> Object<'gc> { - let xmlnode_proto = XMLObject::empty_node(gc_context, Some(proto)); + let xmlnode_proto = XmlObject::empty_node(gc_context, Some(proto)); xmlnode_proto.add_property( gc_context, @@ -790,7 +790,7 @@ pub fn xml_constructor<'gc>( this.as_xml_node(), ) { (Some(Ok(ref string)), Some(ref mut this_node)) => { - let xmldoc = XMLDocument::new(activation.context.gc_context); + let xmldoc = XmlDocument::new(activation.context.gc_context); let mut xmlnode = xmldoc.as_node(); xmlnode.introduce_script_object(activation.context.gc_context, this); this_node.swap(activation.context.gc_context, xmlnode); @@ -812,7 +812,7 @@ pub fn xml_constructor<'gc>( } } (None, Some(ref mut this_node)) => { - let xmldoc = XMLDocument::new(activation.context.gc_context); + let xmldoc = XmlDocument::new(activation.context.gc_context); let mut xmlnode = xmldoc.as_node(); xmlnode.introduce_script_object(activation.context.gc_context, this); this_node.swap(activation.context.gc_context, xmlnode); @@ -832,15 +832,15 @@ pub fn xml_create_element<'gc>( let document = if let Some(node) = this.as_xml_node() { node.document() } else { - XMLDocument::new(activation.context.gc_context) + XmlDocument::new(activation.context.gc_context) }; let nodename = args .get(0) .map(|v| v.coerce_to_string(activation).unwrap_or_default()) .unwrap_or_default(); - let mut xml_node = XMLNode::new_element(activation.context.gc_context, &nodename, document); - let object = XMLObject::from_xml_node( + let mut xml_node = XmlNode::new_element(activation.context.gc_context, &nodename, document); + let object = XmlObject::from_xml_node( activation.context.gc_context, xml_node, Some(activation.context.avm1.prototypes().xml_node), @@ -859,15 +859,15 @@ pub fn xml_create_text_node<'gc>( let document = if let Some(node) = this.as_xml_node() { node.document() } else { - XMLDocument::new(activation.context.gc_context) + XmlDocument::new(activation.context.gc_context) }; let text_node = args .get(0) .map(|v| v.coerce_to_string(activation).unwrap_or_default()) .unwrap_or_default(); - let mut xml_node = XMLNode::new_text(activation.context.gc_context, &text_node, document); - let object = XMLObject::from_xml_node( + let mut xml_node = XmlNode::new_text(activation.context.gc_context, &text_node, document); + let object = XmlObject::from_xml_node( activation.context.gc_context, xml_node, Some(activation.context.avm1.prototypes().xml_node), @@ -1078,7 +1078,7 @@ pub fn create_xml_proto<'gc>( proto: Object<'gc>, fn_proto: Object<'gc>, ) -> Object<'gc> { - let xml_proto = XMLObject::empty_node(gc_context, Some(proto)); + let xml_proto = XmlObject::empty_node(gc_context, Some(proto)); xml_proto.add_property( gc_context, diff --git a/core/src/avm1/object.rs b/core/src/avm1/object.rs index bf3df12b1..4284d82f3 100644 --- a/core/src/avm1/object.rs +++ b/core/src/avm1/object.rs @@ -21,13 +21,13 @@ use crate::avm1::object::glow_filter::GlowFilterObject; use crate::avm1::object::gradient_bevel_filter::GradientBevelFilterObject; use crate::avm1::object::gradient_glow_filter::GradientGlowFilterObject; use crate::avm1::object::transform_object::TransformObject; -use crate::avm1::object::xml_attributes_object::XMLAttributesObject; -use crate::avm1::object::xml_idmap_object::XMLIDMapObject; -use crate::avm1::object::xml_object::XMLObject; +use crate::avm1::object::xml_attributes_object::XmlAttributesObject; +use crate::avm1::object::xml_idmap_object::XmlIdMapObject; +use crate::avm1::object::xml_object::XmlObject; use crate::avm1::{ScriptObject, SoundObject, StageObject, Value}; use crate::avm_warn; use crate::display_object::DisplayObject; -use crate::xml::XMLNode; +use crate::xml::XmlNode; use gc_arena::{Collect, MutationContext}; use ruffle_macros::enum_trait_object; use std::borrow::Cow; @@ -67,9 +67,9 @@ pub mod xml_object; SoundObject(SoundObject<'gc>), StageObject(StageObject<'gc>), SuperObject(SuperObject<'gc>), - XMLObject(XMLObject<'gc>), - XMLAttributesObject(XMLAttributesObject<'gc>), - XMLIDMapObject(XMLIDMapObject<'gc>), + XmlObject(XmlObject<'gc>), + XmlAttributesObject(XmlAttributesObject<'gc>), + XmlIdMapObject(XmlIdMapObject<'gc>), ValueObject(ValueObject<'gc>), FunctionObject(FunctionObject<'gc>), SharedObject(SharedObject<'gc>), @@ -432,7 +432,7 @@ pub trait TObject<'gc>: 'gc + Collect + Debug + Into> + Clone + Copy } /// Get the underlying XML node for this object, if it exists. - fn as_xml_node(&self) -> Option> { + fn as_xml_node(&self) -> Option> { None } diff --git a/core/src/avm1/object/bitmap_data.rs b/core/src/avm1/object/bitmap_data.rs index 2cab24407..e26d62399 100644 --- a/core/src/avm1/object/bitmap_data.rs +++ b/core/src/avm1/object/bitmap_data.rs @@ -14,11 +14,11 @@ use std::ops::Range; /// An implementation of the Lehmer/Park-Miller random number generator /// Uses the fixed parameters m = 2,147,483,647 and a = 16,807 -pub struct LehmerRNG { +pub struct LehmerRng { x: u32, } -impl LehmerRNG { +impl LehmerRng { pub fn with_seed(seed: u32) -> Self { Self { x: seed } } @@ -333,7 +333,7 @@ impl BitmapData { seed as u32 }; - let mut rng = LehmerRNG::with_seed(true_seed); + let mut rng = LehmerRng::with_seed(true_seed); for y in 0..self.height() { for x in 0..self.width() { diff --git a/core/src/avm1/object/super_object.rs b/core/src/avm1/object/super_object.rs index 2129a3a81..9279b743e 100644 --- a/core/src/avm1/object/super_object.rs +++ b/core/src/avm1/object/super_object.rs @@ -17,12 +17,12 @@ use std::borrow::Cow; /// A `SuperObject` references all data from another object, but with one layer /// of prototyping removed. It's as if the given object had been constructed /// with its parent class. -#[collect(no_drop)] #[derive(Copy, Clone, Collect, Debug)] +#[collect(no_drop)] pub struct SuperObject<'gc>(GcCell<'gc, SuperObjectData<'gc>>); -#[collect(no_drop)] #[derive(Clone, Collect, Debug)] +#[collect(no_drop)] pub struct SuperObjectData<'gc> { /// The object present as `this` throughout the superchain. child: Object<'gc>, diff --git a/core/src/avm1/object/xml_attributes_object.rs b/core/src/avm1/object/xml_attributes_object.rs index 3f4e210d0..7f6161cd8 100644 --- a/core/src/avm1/object/xml_attributes_object.rs +++ b/core/src/avm1/object/xml_attributes_object.rs @@ -5,7 +5,7 @@ use crate::avm1::error::Error; use crate::avm1::object::{ObjectPtr, TObject}; use crate::avm1::property::Attribute; use crate::avm1::{AvmString, Object, ScriptObject, Value}; -use crate::xml::{XMLName, XMLNode}; +use crate::xml::{XmlName, XmlNode}; use gc_arena::{Collect, MutationContext}; use std::borrow::Cow; use std::fmt; @@ -18,36 +18,36 @@ use crate::avm_warn; /// separately. #[derive(Clone, Copy, Collect)] #[collect(no_drop)] -pub struct XMLAttributesObject<'gc>(ScriptObject<'gc>, XMLNode<'gc>); +pub struct XmlAttributesObject<'gc>(ScriptObject<'gc>, XmlNode<'gc>); -impl<'gc> XMLAttributesObject<'gc> { - /// Construct an XMLAttributesObject for an already existing node's +impl<'gc> XmlAttributesObject<'gc> { + /// Construct an XmlAttributesObject for an already existing node's /// attributes. pub fn from_xml_node( gc_context: MutationContext<'gc, '_>, - xml_node: XMLNode<'gc>, + xml_node: XmlNode<'gc>, ) -> Object<'gc> { - XMLAttributesObject(ScriptObject::object(gc_context, None), xml_node).into() + XmlAttributesObject(ScriptObject::object(gc_context, None), xml_node).into() } fn base(&self) -> ScriptObject<'gc> { match self { - XMLAttributesObject(base, ..) => *base, + XmlAttributesObject(base, ..) => *base, } } - fn node(&self) -> XMLNode<'gc> { + fn node(&self) -> XmlNode<'gc> { match self { - XMLAttributesObject(_, node) => *node, + XmlAttributesObject(_, node) => *node, } } } -impl fmt::Debug for XMLAttributesObject<'_> { +impl fmt::Debug for XmlAttributesObject<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - XMLAttributesObject(base, node) => f - .debug_tuple("XMLAttributesObject") + XmlAttributesObject(base, node) => f + .debug_tuple("XmlAttributesObject") .field(base) .field(node) .finish(), @@ -55,7 +55,7 @@ impl fmt::Debug for XMLAttributesObject<'_> { } } -impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { +impl<'gc> TObject<'gc> for XmlAttributesObject<'gc> { fn get_local( &self, name: &str, @@ -64,7 +64,7 @@ impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { ) -> Result, Error<'gc>> { Ok(self .node() - .attribute_value(&XMLName::from_str(name)) + .attribute_value(&XmlName::from_str(name)) .map(|s| AvmString::new(activation.context.gc_context, s).into()) .unwrap_or_else(|| Value::Undefined)) } @@ -77,7 +77,7 @@ impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { ) -> Result<(), Error<'gc>> { self.node().set_attribute_value( activation.context.gc_context, - &XMLName::from_str(name), + &XmlName::from_str(name), &value.coerce_to_string(activation)?, ); self.base().set(name, value, activation) @@ -115,7 +115,7 @@ impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { fn delete(&self, activation: &mut Activation<'_, 'gc, '_>, name: &str) -> bool { self.node() - .delete_attribute(activation.context.gc_context, &XMLName::from_str(name)); + .delete_attribute(activation.context.gc_context, &XmlName::from_str(name)); self.base().delete(activation, name) } @@ -201,7 +201,7 @@ impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { fn has_own_property(&self, _activation: &mut Activation<'_, 'gc, '_>, name: &str) -> bool { self.node() - .attribute_value(&XMLName::from_str(name)) + .attribute_value(&XmlName::from_str(name)) .is_some() } @@ -239,7 +239,7 @@ impl<'gc> TObject<'gc> for XMLAttributesObject<'gc> { Some(self.base()) } - fn as_xml_node(&self) -> Option> { + fn as_xml_node(&self) -> Option> { Some(self.node()) } diff --git a/core/src/avm1/object/xml_idmap_object.rs b/core/src/avm1/object/xml_idmap_object.rs index c29dd819b..7dd039b90 100644 --- a/core/src/avm1/object/xml_idmap_object.rs +++ b/core/src/avm1/object/xml_idmap_object.rs @@ -6,7 +6,7 @@ use crate::avm1::object::{ObjectPtr, TObject}; use crate::avm1::property::Attribute; use crate::avm1::{Object, ScriptObject, Value}; use crate::avm_warn; -use crate::xml::{XMLDocument, XMLNode}; +use crate::xml::{XmlDocument, XmlNode}; use gc_arena::{Collect, MutationContext}; use std::borrow::Cow; use std::fmt; @@ -18,36 +18,36 @@ use std::fmt; /// document. #[derive(Clone, Copy, Collect)] #[collect(no_drop)] -pub struct XMLIDMapObject<'gc>(ScriptObject<'gc>, XMLDocument<'gc>); +pub struct XmlIdMapObject<'gc>(ScriptObject<'gc>, XmlDocument<'gc>); -impl<'gc> XMLIDMapObject<'gc> { - /// Construct an XMLIDMapObject for an already existing node's +impl<'gc> XmlIdMapObject<'gc> { + /// Construct an XmlIdMapObject for an already existing node's /// attributes. pub fn from_xml_document( gc_context: MutationContext<'gc, '_>, - xml_doc: XMLDocument<'gc>, + xml_doc: XmlDocument<'gc>, ) -> Object<'gc> { - XMLIDMapObject(ScriptObject::object(gc_context, None), xml_doc).into() + XmlIdMapObject(ScriptObject::object(gc_context, None), xml_doc).into() } fn base(&self) -> ScriptObject<'gc> { match self { - XMLIDMapObject(base, ..) => *base, + XmlIdMapObject(base, ..) => *base, } } - fn document(&self) -> XMLDocument<'gc> { + fn document(&self) -> XmlDocument<'gc> { match self { - XMLIDMapObject(_, document) => *document, + XmlIdMapObject(_, document) => *document, } } } -impl fmt::Debug for XMLIDMapObject<'_> { +impl fmt::Debug for XmlIdMapObject<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - XMLIDMapObject(base, document) => f - .debug_tuple("XMLIDMapObject") + XmlIdMapObject(base, document) => f + .debug_tuple("XmlIdMapObject") .field(base) .field(document) .finish(), @@ -55,7 +55,7 @@ impl fmt::Debug for XMLIDMapObject<'_> { } } -impl<'gc> TObject<'gc> for XMLIDMapObject<'gc> { +impl<'gc> TObject<'gc> for XmlIdMapObject<'gc> { fn get_local( &self, name: &str, @@ -236,7 +236,7 @@ impl<'gc> TObject<'gc> for XMLIDMapObject<'gc> { Some(self.base()) } - fn as_xml_node(&self) -> Option> { + fn as_xml_node(&self) -> Option> { None } diff --git a/core/src/avm1/object/xml_object.rs b/core/src/avm1/object/xml_object.rs index 56e244d16..7b40d4ad7 100644 --- a/core/src/avm1/object/xml_object.rs +++ b/core/src/avm1/object/xml_object.rs @@ -5,34 +5,34 @@ use crate::avm1::error::Error; use crate::avm1::object::TObject; use crate::avm1::{Object, ScriptObject}; use crate::impl_custom_object; -use crate::xml::{XMLDocument, XMLNode}; +use crate::xml::{XmlDocument, XmlNode}; use gc_arena::{Collect, GcCell, MutationContext}; use std::fmt; /// A ScriptObject that is inherently tied to an XML node. #[derive(Clone, Copy, Collect)] #[collect(no_drop)] -pub struct XMLObject<'gc>(GcCell<'gc, XMLObjectData<'gc>>); +pub struct XmlObject<'gc>(GcCell<'gc, XmlObjectData<'gc>>); #[derive(Clone, Collect)] #[collect(no_drop)] -pub struct XMLObjectData<'gc> { +pub struct XmlObjectData<'gc> { base: ScriptObject<'gc>, - node: XMLNode<'gc>, + node: XmlNode<'gc>, } -impl<'gc> XMLObject<'gc> { +impl<'gc> XmlObject<'gc> { /// Construct a new XML node and object pair. pub fn empty_node( gc_context: MutationContext<'gc, '_>, proto: Option>, ) -> Object<'gc> { - let empty_document = XMLDocument::new(gc_context); - let mut xml_node = XMLNode::new_text(gc_context, "", empty_document); + let empty_document = XmlDocument::new(gc_context); + let mut xml_node = XmlNode::new_text(gc_context, "", empty_document); let base_object = ScriptObject::object(gc_context, proto); - let object = XMLObject(GcCell::allocate( + let object = XmlObject(GcCell::allocate( gc_context, - XMLObjectData { + XmlObjectData { base: base_object, node: xml_node, }, @@ -44,15 +44,15 @@ impl<'gc> XMLObject<'gc> { object } - /// Construct an XMLObject for an already existing node. + /// Construct an XmlObject for an already existing node. pub fn from_xml_node( gc_context: MutationContext<'gc, '_>, - xml_node: XMLNode<'gc>, + xml_node: XmlNode<'gc>, proto: Option>, ) -> Object<'gc> { - XMLObject(GcCell::allocate( + XmlObject(GcCell::allocate( gc_context, - XMLObjectData { + XmlObjectData { base: ScriptObject::object(gc_context, proto), node: xml_node, }, @@ -61,17 +61,17 @@ impl<'gc> XMLObject<'gc> { } } -impl fmt::Debug for XMLObject<'_> { +impl fmt::Debug for XmlObject<'_> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let this = self.0.read(); - f.debug_struct("XMLObject") + f.debug_struct("XmlObject") .field("base", &this.base) .field("node", &this.node) .finish() } } -impl<'gc> TObject<'gc> for XMLObject<'gc> { +impl<'gc> TObject<'gc> for XmlObject<'gc> { impl_custom_object!(base); #[allow(clippy::new_ret_no_self)] @@ -80,13 +80,13 @@ impl<'gc> TObject<'gc> for XMLObject<'gc> { activation: &mut Activation<'_, 'gc, '_>, this: Object<'gc>, ) -> Result, Error<'gc>> { - Ok(XMLObject::empty_node( + Ok(XmlObject::empty_node( activation.context.gc_context, Some(this), )) } - fn as_xml_node(&self) -> Option> { + fn as_xml_node(&self) -> Option> { Some(self.0.read().node) } } diff --git a/core/src/avm1/string.rs b/core/src/avm1/string.rs index b0c2b5861..debb24ca6 100644 --- a/core/src/avm1/string.rs +++ b/core/src/avm1/string.rs @@ -114,7 +114,7 @@ impl<'gc> Hash for AvmString<'gc> { macro_rules! impl_eq { ($lhs:ty, $rhs: ty) => { - #[allow(unused_lifetimes)] + #[allow(unused_lifetimes, clippy::redundant_slicing)] impl<'a, 'b> PartialEq<$rhs> for $lhs { #[inline] fn eq(&self, other: &$rhs) -> bool { @@ -122,7 +122,7 @@ macro_rules! impl_eq { } } - #[allow(unused_lifetimes)] + #[allow(unused_lifetimes, clippy::redundant_slicing)] impl<'a, 'b> PartialEq<$lhs> for $rhs { #[inline] fn eq(&self, other: &$lhs) -> bool { diff --git a/core/src/backend/navigator.rs b/core/src/backend/navigator.rs index 6fa4d07c0..91f210408 100644 --- a/core/src/backend/navigator.rs +++ b/core/src/backend/navigator.rs @@ -72,10 +72,10 @@ pub fn url_from_relative_url(base: &str, relative: &str) -> Result Option { match s { SendVarsMethod::None => None, - SendVarsMethod::Get => Some(Self::GET), - SendVarsMethod::Post => Some(Self::POST), + SendVarsMethod::Get => Some(Self::Get), + SendVarsMethod::Post => Some(Self::Post), } } pub fn from_method_str(method: &str) -> Option { match method { - "GET" => Some(Self::GET), - "POST" => Some(Self::POST), + "GET" => Some(Self::Get), + "POST" => Some(Self::Post), _ => None, } } @@ -113,7 +113,7 @@ impl RequestOptions { /// Construct request options for a GET request. pub fn get() -> Self { Self { - method: NavigationMethod::GET, + method: NavigationMethod::Get, body: None, } } @@ -121,7 +121,7 @@ impl RequestOptions { /// Construct request options for a POST request. pub fn post(body: Option<(Vec, String)>) -> Self { Self { - method: NavigationMethod::POST, + method: NavigationMethod::Post, body, } } diff --git a/core/src/backend/render.rs b/core/src/backend/render.rs index 1e1be49a1..871ee9791 100644 --- a/core/src/backend/render.rs +++ b/core/src/backend/render.rs @@ -395,7 +395,7 @@ pub fn decode_define_bits_lossless( swf_tag: &swf::DefineBitsLossless, ) -> Result> { // Decompress the image data (DEFLATE compression). - let mut decoded_data = decompress_zlib(&swf_tag.data[..])?; + let mut decoded_data = decompress_zlib(swf_tag.data)?; // Swizzle/de-palettize the bitmap. let out_data = match (swf_tag.version, swf_tag.format) { diff --git a/core/src/display_object/edit_text.rs b/core/src/display_object/edit_text.rs index dc7df9c01..8f9a1cffd 100644 --- a/core/src/display_object/edit_text.rs +++ b/core/src/display_object/edit_text.rs @@ -16,7 +16,7 @@ use crate::tag_utils::SwfMovie; use crate::transform::Transform; use crate::types::{Degrees, Percent}; use crate::vminterface::Instantiator; -use crate::xml::XMLDocument; +use crate::xml::XmlDocument; use chrono::Utc; use gc_arena::{Collect, Gc, GcCell, MutationContext}; use std::{cell::Ref, sync::Arc}; @@ -63,7 +63,7 @@ pub struct EditTextData<'gc> { /// appropriate set of format spans, which is used for actual rendering. /// The HTML is only retained if there is also a stylesheet already defined /// on the `EditText`, else it is discarded during the lowering process. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// The underlying text format spans of the `EditText`. /// @@ -157,7 +157,7 @@ impl<'gc> EditText<'gc> { let is_password = swf_tag.is_password; let is_editable = !swf_tag.is_read_only; let is_html = swf_tag.is_html; - let document = XMLDocument::new(context.gc_context); + let document = XmlDocument::new(context.gc_context); let text = swf_tag.initial_text.clone().unwrap_or_default(); let default_format = TextFormat::from_swf_tag(swf_tag.clone(), swf_movie.clone(), context); let encoding = swf_movie.encoding(); @@ -384,7 +384,7 @@ impl<'gc> EditText<'gc> { ) -> Result<(), Error> { if self.is_html() { let html_string = text.replace("", "\n").replace("
", "\n"); - let document = XMLDocument::new(context.gc_context); + let document = XmlDocument::new(context.gc_context); if let Err(err) = document @@ -401,7 +401,7 @@ impl<'gc> EditText<'gc> { Ok(()) } - pub fn html_tree(self, context: &mut UpdateContext<'_, 'gc, '_>) -> XMLDocument<'gc> { + pub fn html_tree(self, context: &mut UpdateContext<'_, 'gc, '_>) -> XmlDocument<'gc> { self.0.read().text_spans.raise_to_html(context.gc_context) } @@ -415,7 +415,7 @@ impl<'gc> EditText<'gc> { /// In stylesheet mode, the opposite is true: text spans are an /// intermediate, user-facing text span APIs don't work, and the document /// is retained. - pub fn set_html_tree(self, doc: XMLDocument<'gc>, context: &mut UpdateContext<'_, 'gc, '_>) { + pub fn set_html_tree(self, doc: XmlDocument<'gc>, context: &mut UpdateContext<'_, 'gc, '_>) { let mut write = self.0.write(context.gc_context); write.document = doc; diff --git a/core/src/focus_tracker.rs b/core/src/focus_tracker.rs index 78adf497e..2145f4e5f 100644 --- a/core/src/focus_tracker.rs +++ b/core/src/focus_tracker.rs @@ -3,8 +3,8 @@ use crate::context::UpdateContext; pub use crate::display_object::{DisplayObject, TDisplayObject}; use gc_arena::{Collect, GcCell, MutationContext}; -#[collect(no_drop)] #[derive(Clone, Copy, Collect, Debug)] +#[collect(no_drop)] pub struct FocusTracker<'gc>(GcCell<'gc, Option>>); impl<'gc> FocusTracker<'gc> { diff --git a/core/src/html/text_format.rs b/core/src/html/text_format.rs index acff8e610..351d23850 100644 --- a/core/src/html/text_format.rs +++ b/core/src/html/text_format.rs @@ -5,7 +5,7 @@ use crate::avm1::{AvmString, Object, ScriptObject, TObject, Value}; use crate::context::UpdateContext; use crate::html::iterators::TextSpanIter; use crate::tag_utils::SwfMovie; -use crate::xml::{Step, XMLDocument, XMLName, XMLNode}; +use crate::xml::{Step, XmlDocument, XmlName, XmlNode}; use gc_arena::{Collect, MutationContext}; use std::borrow::Cow; use std::cmp::{min, Ordering}; @@ -280,11 +280,11 @@ impl TextFormat { /// loaded with all of the *currently existing* styles at this point in the /// lowering process. Any property not implied by markup will be retained /// in this format. - pub fn from_presentational_markup(node: XMLNode<'_>, mut tf: TextFormat) -> Self { + pub fn from_presentational_markup(node: XmlNode<'_>, mut tf: TextFormat) -> Self { match node.tag_name() { - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("p")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("p")) => { match node - .attribute_value_ignore_ascii_case(&XMLName::from_str("align")) + .attribute_value_ignore_ascii_case(&XmlName::from_str("align")) .as_deref() { Some("left") => tf.align = Some(swf::TextAlign::Left), @@ -293,34 +293,34 @@ impl TextFormat { _ => {} } } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("a")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("a")) => { if let Some(href) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("href")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("href")) { tf.url = Some(href); } if let Some(target) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("target")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("target")) { tf.target = Some(target); } } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("font")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("font")) => { if let Some(face) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("face")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("face")) { tf.font = Some(face); } if let Some(size) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("size")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("size")) { tf.size = size.parse().ok(); } if let Some(color) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("color")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("color")) { if color.starts_with('#') { let rval = color.get(1..3).and_then(|v| u8::from_str_radix(v, 16).ok()); @@ -334,13 +334,13 @@ impl TextFormat { } if let Some(letter_spacing) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("letterSpacing")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("letterSpacing")) { tf.letter_spacing = letter_spacing.parse().ok(); } tf.kerning = match node - .attribute_value_ignore_ascii_case(&XMLName::from_str("kerning")) + .attribute_value_ignore_ascii_case(&XmlName::from_str("kerning")) .as_deref() { Some("1") => Some(true), @@ -348,53 +348,53 @@ impl TextFormat { _ => tf.kerning, } } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("b")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("b")) => { tf.bold = Some(true); } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("i")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("i")) => { tf.italic = Some(true); } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("u")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("u")) => { tf.underline = Some(true); } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("li")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("li")) => { tf.bullet = Some(true); } - Some(name) if name.eq_ignore_ascii_case(&XMLName::from_str("textformat")) => { + Some(name) if name.eq_ignore_ascii_case(&XmlName::from_str("textformat")) => { //TODO: Spec says these are all in twips. That doesn't seem to //match Flash 8. if let Some(left_margin) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("leftmargin")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("leftmargin")) { tf.left_margin = left_margin.parse().ok(); } if let Some(right_margin) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("rightmargin")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("rightmargin")) { tf.right_margin = right_margin.parse().ok(); } if let Some(indent) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("indent")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("indent")) { tf.indent = indent.parse().ok(); } if let Some(blockindent) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("blockindent")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("blockindent")) { tf.block_indent = blockindent.parse().ok(); } if let Some(leading) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("leading")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("leading")) { tf.leading = leading.parse().ok(); } if let Some(tabstops) = - node.attribute_value_ignore_ascii_case(&XMLName::from_str("tabstops")) + node.attribute_value_ignore_ascii_case(&XmlName::from_str("tabstops")) { tf.tab_stops = Some( tabstops @@ -1265,7 +1265,7 @@ impl FormatSpans { /// a handful of presentational attributes in the HTML tree to generate /// styling. There's also a `lower_from_css` that respects both /// presentational markup and CSS stylesheets. - pub fn lower_from_html(&mut self, tree: XMLDocument<'_>) { + pub fn lower_from_html(&mut self, tree: XmlDocument<'_>) { let mut format_stack = vec![self.default_format.clone()]; let mut last_successful_format = None; @@ -1349,8 +1349,8 @@ impl FormatSpans { } #[allow(clippy::float_cmp)] - pub fn raise_to_html<'gc>(&self, mc: MutationContext<'gc, '_>) -> XMLDocument<'gc> { - let document = XMLDocument::new(mc); + pub fn raise_to_html<'gc>(&self, mc: MutationContext<'gc, '_>) -> XmlDocument<'gc> { + let document = XmlDocument::new(mc); let mut root = document.as_node(); let mut last_span = self.span(0); @@ -1378,12 +1378,12 @@ impl FormatSpans { || ls.tab_stops != span.tab_stops || last_text_format_element.is_none() { - let new_tf = XMLNode::new_element(mc, "TEXTFORMAT", document); + let new_tf = XmlNode::new_element(mc, "TEXTFORMAT", document); if ls.left_margin != 0.0 { new_tf.set_attribute_value( mc, - &XMLName::from_str("LEFTMARGIN"), + &XmlName::from_str("LEFTMARGIN"), &format!("{}", span.left_margin), ); } @@ -1391,7 +1391,7 @@ impl FormatSpans { if ls.right_margin != 0.0 { new_tf.set_attribute_value( mc, - &XMLName::from_str("RIGHTMARGIN"), + &XmlName::from_str("RIGHTMARGIN"), &format!("{}", span.right_margin), ); } @@ -1399,7 +1399,7 @@ impl FormatSpans { if ls.indent != 0.0 { new_tf.set_attribute_value( mc, - &XMLName::from_str("INDENT"), + &XmlName::from_str("INDENT"), &format!("{}", span.indent), ); } @@ -1407,7 +1407,7 @@ impl FormatSpans { if ls.block_indent != 0.0 { new_tf.set_attribute_value( mc, - &XMLName::from_str("BLOCKINDENT"), + &XmlName::from_str("BLOCKINDENT"), &format!("{}", span.block_indent), ); } @@ -1415,7 +1415,7 @@ impl FormatSpans { if ls.leading != 0.0 { new_tf.set_attribute_value( mc, - &XMLName::from_str("LEADING"), + &XmlName::from_str("LEADING"), &format!("{}", span.leading), ); } @@ -1423,7 +1423,7 @@ impl FormatSpans { if !ls.tab_stops.is_empty() { new_tf.set_attribute_value( mc, - &XMLName::from_str("TABSTOPS"), + &XmlName::from_str("TABSTOPS"), &span .tab_stops .iter() @@ -1450,7 +1450,7 @@ impl FormatSpans { if can_span_create_bullets && span.bullet || !can_span_create_bullets && last_span.map(|ls| ls.bullet).unwrap_or(false) { - let new_li = XMLNode::new_element(mc, "LI", document); + let new_li = XmlNode::new_element(mc, "LI", document); last_bullet = Some(new_li); last_paragraph = None; @@ -1467,11 +1467,11 @@ impl FormatSpans { } if ls.align != span.align || last_paragraph.is_none() { - let new_p = XMLNode::new_element(mc, "P", document); + let new_p = XmlNode::new_element(mc, "P", document); new_p.set_attribute_value( mc, - &XMLName::from_str("ALIGN"), + &XmlName::from_str("ALIGN"), match span.align { swf::TextAlign::Left => "LEFT", swf::TextAlign::Center => "CENTER", @@ -1500,16 +1500,16 @@ impl FormatSpans { || ls.kerning != span.kerning || last_font.is_none() { - let new_font = XMLNode::new_element(mc, "FONT", document); + let new_font = XmlNode::new_element(mc, "FONT", document); if ls.font != span.font || last_font.is_none() { - new_font.set_attribute_value(mc, &XMLName::from_str("FACE"), &span.font); + new_font.set_attribute_value(mc, &XmlName::from_str("FACE"), &span.font); } if ls.size != span.size || last_font.is_none() { new_font.set_attribute_value( mc, - &XMLName::from_str("SIZE"), + &XmlName::from_str("SIZE"), &format!("{}", span.size), ); } @@ -1517,7 +1517,7 @@ impl FormatSpans { if ls.color != span.color || last_font.is_none() { new_font.set_attribute_value( mc, - &XMLName::from_str("COLOR"), + &XmlName::from_str("COLOR"), &format!( "#{:0>2X}{:0>2X}{:0>2X}", span.color.r, span.color.g, span.color.b @@ -1528,7 +1528,7 @@ impl FormatSpans { if ls.letter_spacing != span.letter_spacing || last_font.is_none() { new_font.set_attribute_value( mc, - &XMLName::from_str("LETTERSPACING"), + &XmlName::from_str("LETTERSPACING"), &format!("{}", span.letter_spacing), ); } @@ -1536,7 +1536,7 @@ impl FormatSpans { if ls.kerning != span.kerning || last_font.is_none() { new_font.set_attribute_value( mc, - &XMLName::from_str("KERNING"), + &XmlName::from_str("KERNING"), if span.kerning { "1" } else { "0" }, ); } @@ -1557,12 +1557,12 @@ impl FormatSpans { } if !span.url.is_empty() && (ls.url != span.url || last_a.is_none()) { - let new_a = XMLNode::new_element(mc, "A", document); + let new_a = XmlNode::new_element(mc, "A", document); - new_a.set_attribute_value(mc, &XMLName::from_str("HREF"), &span.url); + new_a.set_attribute_value(mc, &XmlName::from_str("HREF"), &span.url); if !span.target.is_empty() { - new_a.set_attribute_value(mc, &XMLName::from_str("TARGET"), &span.target); + new_a.set_attribute_value(mc, &XmlName::from_str("TARGET"), &span.target); } last_font @@ -1584,7 +1584,7 @@ impl FormatSpans { } if span.bold && last_b.is_none() { - let new_b = XMLNode::new_element(mc, "B", document); + let new_b = XmlNode::new_element(mc, "B", document); last_a .or(last_font) @@ -1605,7 +1605,7 @@ impl FormatSpans { } if span.italic && last_i.is_none() { - let new_i = XMLNode::new_element(mc, "I", document); + let new_i = XmlNode::new_element(mc, "I", document); last_b .or(last_a) @@ -1625,7 +1625,7 @@ impl FormatSpans { } if span.underline && last_u.is_none() { - let new_u = XMLNode::new_element(mc, "U", document); + let new_u = XmlNode::new_element(mc, "U", document); last_i .or(last_b) @@ -1644,7 +1644,7 @@ impl FormatSpans { } let span_text = if last_bullet.is_some() { - XMLNode::new_text(mc, line, document) + XmlNode::new_text(mc, line, document) } else { let line_start = line.as_ptr() as usize - text.as_ptr() as usize; let line_with_newline = if line_start > 0 { @@ -1654,7 +1654,7 @@ impl FormatSpans { line }; - XMLNode::new_text(mc, line_with_newline, document) + XmlNode::new_text(mc, line_with_newline, document) }; last_u diff --git a/core/src/loader.rs b/core/src/loader.rs index b7a0c8c6a..adf502f45 100644 --- a/core/src/loader.rs +++ b/core/src/loader.rs @@ -10,7 +10,7 @@ use crate::player::{Player, NEWEST_PLAYER_VERSION}; use crate::property_map::PropertyMap; use crate::tag_utils::SwfMovie; use crate::vminterface::Instantiator; -use crate::xml::XMLNode; +use crate::xml::XmlNode; use encoding_rs::UTF_8; use gc_arena::{Collect, CollectionContext, MutationContext}; use generational_arena::{Arena, Index}; @@ -234,11 +234,11 @@ impl<'gc> LoadManager<'gc> { pub fn load_xml_into_node( &mut self, player: Weak>, - target_node: XMLNode<'gc>, + target_node: XmlNode<'gc>, active_clip: DisplayObject<'gc>, fetch: OwnedFuture, Error>, ) -> OwnedFuture<(), Error> { - let loader = Loader::XML { + let loader = Loader::Xml { self_handle: None, active_clip, target_node, @@ -319,7 +319,7 @@ pub enum Loader<'gc> { }, /// Loader that is loading XML data into an XML tree. - XML { + Xml { /// The handle to refer to this loader instance. self_handle: Option, @@ -332,7 +332,7 @@ pub enum Loader<'gc> { active_clip: DisplayObject<'gc>, /// The target node whose contents will be replaced with the parsed XML. - target_node: XMLNode<'gc>, + target_node: XmlNode<'gc>, }, } @@ -350,7 +350,7 @@ unsafe impl<'gc> Collect for Loader<'gc> { } Loader::Form { target_object, .. } => target_object.trace(cc), Loader::LoadVars { target_object, .. } => target_object.trace(cc), - Loader::XML { target_node, .. } => target_node.trace(cc), + Loader::Xml { target_node, .. } => target_node.trace(cc), } } } @@ -366,7 +366,7 @@ impl<'gc> Loader<'gc> { Loader::Movie { self_handle, .. } => *self_handle = Some(handle), Loader::Form { self_handle, .. } => *self_handle = Some(handle), Loader::LoadVars { self_handle, .. } => *self_handle = Some(handle), - Loader::XML { self_handle, .. } => *self_handle = Some(handle), + Loader::Xml { self_handle, .. } => *self_handle = Some(handle), } } @@ -758,7 +758,7 @@ impl<'gc> Loader<'gc> { fetch: OwnedFuture, Error>, ) -> OwnedFuture<(), Error> { let handle = match self { - Loader::XML { self_handle, .. } => self_handle.expect("Loader not self-introduced"), + Loader::Xml { self_handle, .. } => self_handle.expect("Loader not self-introduced"), _ => return Box::pin(async { Err(Error::NotXmlLoader) }), }; @@ -774,7 +774,7 @@ impl<'gc> Loader<'gc> { player.lock().expect("Could not lock player!!").update( |uc| -> Result<(), Error> { let (mut node, active_clip) = match uc.load_manager.get_loader(handle) { - Some(Loader::XML { + Some(Loader::Xml { target_node, active_clip, .. @@ -810,7 +810,7 @@ impl<'gc> Loader<'gc> { player.lock().expect("Could not lock player!!").update( |uc| -> Result<(), Error> { let (mut node, active_clip) = match uc.load_manager.get_loader(handle) { - Some(Loader::XML { + Some(Loader::Xml { target_node, active_clip, .. diff --git a/core/src/player.rs b/core/src/player.rs index bfe93d803..875df1f70 100644 --- a/core/src/player.rs +++ b/core/src/player.rs @@ -141,7 +141,7 @@ type Renderer = Box; type Storage = Box; type Locale = Box; type Log = Box; -type UI = Box; +type Ui = Box; pub struct Player { /// The version of the player we're emulating. @@ -169,7 +169,7 @@ pub struct Player { storage: Storage, locale: Locale, log: Log, - ui: UI, + ui: Ui, transform_stack: TransformStack, view_matrix: Matrix, @@ -238,7 +238,7 @@ impl Player { storage: Storage, locale: Locale, log: Log, - ui: UI, + ui: Ui, ) -> Result>, Error> { let fake_movie = Arc::new(SwfMovie::empty(NEWEST_PLAYER_VERSION)); let movie_width = 550; @@ -1025,11 +1025,11 @@ impl Player { self.renderer } - pub fn ui(&self) -> &UI { + pub fn ui(&self) -> &Ui { &self.ui } - pub fn ui_mut(&mut self) -> &mut UI { + pub fn ui_mut(&mut self) -> &mut Ui { &mut self.ui } diff --git a/core/src/tag_utils.rs b/core/src/tag_utils.rs index 18666b1f3..3660694d5 100644 --- a/core/src/tag_utils.rs +++ b/core/src/tag_utils.rs @@ -78,7 +78,7 @@ impl SwfMovie { /// Construct a movie based on the contents of the SWF datastream. pub fn from_data(swf_data: &[u8], url: Option) -> Result { - let swf_buf = swf::read::decompress_swf(&swf_data[..])?; + let swf_buf = swf::read::decompress_swf(swf_data)?; let encoding = swf::SwfStr::encoding_for_version(swf_buf.header.version); Ok(Self { header: swf_buf.header, diff --git a/core/src/xml.rs b/core/src/xml.rs index ad61dd42c..79bc4da70 100644 --- a/core/src/xml.rs +++ b/core/src/xml.rs @@ -9,12 +9,12 @@ mod tree; #[cfg(test)] mod tests; -pub use document::XMLDocument; +pub use document::XmlDocument; pub use error::Error; pub use error::ParseError; pub use iterators::Step; -pub use namespace::XMLName; -pub use tree::XMLNode; +pub use namespace::XmlName; +pub use tree::XmlNode; pub const ELEMENT_NODE: u8 = 1; pub const TEXT_NODE: u8 = 3; diff --git a/core/src/xml/document.rs b/core/src/xml/document.rs index 566043c06..65b2cadf2 100644 --- a/core/src/xml/document.rs +++ b/core/src/xml/document.rs @@ -1,8 +1,8 @@ //! XML Document -use crate::avm1::object::xml_idmap_object::XMLIDMapObject; +use crate::avm1::object::xml_idmap_object::XmlIdMapObject; use crate::avm1::Object; -use crate::xml::{Error, ParseError, XMLName, XMLNode}; +use crate::xml::{Error, ParseError, XmlName, XmlNode}; use gc_arena::{Collect, GcCell, MutationContext}; use quick_xml::events::{BytesDecl, Event}; use quick_xml::{Error as QXError, Writer}; @@ -13,13 +13,13 @@ use std::io::Cursor; /// The entirety of an XML document. #[derive(Copy, Clone, Collect)] #[collect(no_drop)] -pub struct XMLDocument<'gc>(GcCell<'gc, XMLDocumentData<'gc>>); +pub struct XmlDocument<'gc>(GcCell<'gc, XmlDocumentData<'gc>>); #[derive(Clone, Collect)] #[collect(no_drop)] -pub struct XMLDocumentData<'gc> { +pub struct XmlDocumentData<'gc> { /// The root node of the XML document. - root: Option>, + root: Option>, /// Whether or not the document has a document declaration. has_xmldecl: bool, @@ -34,14 +34,14 @@ pub struct XMLDocumentData<'gc> { standalone: Option, /// The XML doctype, if set. - doctype: Option>, + doctype: Option>, /// The document's ID map. /// /// When nodes are parsed into the document by way of `parseXML` or the /// document constructor, they get put into this list here, which is used /// to populate the document's `idMap`. - idmap: BTreeMap>, + idmap: BTreeMap>, /// The script object associated with this XML node, if any. idmap_script_object: Option>, @@ -50,12 +50,12 @@ pub struct XMLDocumentData<'gc> { last_parse_error: Option, } -impl<'gc> XMLDocument<'gc> { +impl<'gc> XmlDocument<'gc> { /// Construct a new, empty XML document. pub fn new(mc: MutationContext<'gc, '_>) -> Self { let document = Self(GcCell::allocate( mc, - XMLDocumentData { + XmlDocumentData { root: None, has_xmldecl: false, version: "1.0".to_string(), @@ -67,7 +67,7 @@ impl<'gc> XMLDocument<'gc> { last_parse_error: None, }, )); - let root = XMLNode::new_document_root(mc, document); + let root = XmlNode::new_document_root(mc, document); document.0.write(mc).root = Some(root); @@ -77,7 +77,7 @@ impl<'gc> XMLDocument<'gc> { /// Yield the document in node form. /// /// If the document does not have a node, then this function will panic. - pub fn as_node(self) -> XMLNode<'gc> { + pub fn as_node(self) -> XmlNode<'gc> { self.0 .read() .root @@ -93,7 +93,7 @@ impl<'gc> XMLDocument<'gc> { let self_read = self.0.read(); Self(GcCell::allocate( gc_context, - XMLDocumentData { + XmlDocumentData { root: None, has_xmldecl: self_read.has_xmldecl, version: self_read.version.clone(), @@ -117,17 +117,17 @@ impl<'gc> XMLDocument<'gc> { pub fn link_root_node( &mut self, gc_context: MutationContext<'gc, '_>, - proposed_root: XMLNode<'gc>, + proposed_root: XmlNode<'gc>, ) { match ( &mut *self.0.write(gc_context), proposed_root.is_document_root(), ) { - (XMLDocumentData { root, .. }, true) if root.is_none() => { + (XmlDocumentData { root, .. }, true) if root.is_none() => { *root = Some(proposed_root); } - (XMLDocumentData { root, .. }, false) if root.is_none() => { - *root = Some(XMLNode::new_document_root(gc_context, *self)); + (XmlDocumentData { root, .. }, false) if root.is_none() => { + *root = Some(XmlNode::new_document_root(gc_context, *self)); } _ => {} } @@ -140,7 +140,7 @@ impl<'gc> XMLDocument<'gc> { pub fn link_doctype( &mut self, gc_context: MutationContext<'gc, '_>, - proposed_doctype: XMLNode<'gc>, + proposed_doctype: XmlNode<'gc>, ) { let mut self_write = self.0.write(gc_context); @@ -150,7 +150,7 @@ impl<'gc> XMLDocument<'gc> { } /// Retrieve the first DocType node in the document. - pub fn doctype(self) -> Option> { + pub fn doctype(self) -> Option> { self.0.read().doctype } @@ -205,7 +205,7 @@ impl<'gc> XMLDocument<'gc> { pub fn idmap_script_object(&mut self, gc_context: MutationContext<'gc, '_>) -> Object<'gc> { let mut object = self.0.read().idmap_script_object; if object.is_none() { - object = Some(XMLIDMapObject::from_xml_document(gc_context, *self)); + object = Some(XmlIdMapObject::from_xml_document(gc_context, *self)); self.0.write(gc_context).idmap_script_object = object; } @@ -213,8 +213,8 @@ impl<'gc> XMLDocument<'gc> { } /// Update the idmap object with a given new node. - pub fn update_idmap(&mut self, mc: MutationContext<'gc, '_>, node: XMLNode<'gc>) { - if let Some(id) = node.attribute_value(&XMLName::from_str("id")) { + pub fn update_idmap(&mut self, mc: MutationContext<'gc, '_>, node: XmlNode<'gc>) { + if let Some(id) = node.attribute_value(&XmlName::from_str("id")) { self.0.write(mc).idmap.insert(id, node); } } @@ -225,7 +225,7 @@ impl<'gc> XMLDocument<'gc> { /// parsing*. Nodes which obtained the `id` after the fact, or nodes with /// the `id` that were added to the document after the fact, will not be /// returned by this function. - pub fn get_node_by_id(self, id: &str) -> Option> { + pub fn get_node_by_id(self, id: &str) -> Option> { self.0.read().idmap.get(id).copied() } @@ -270,9 +270,9 @@ impl<'gc> XMLDocument<'gc> { } } -impl<'gc> fmt::Debug for XMLDocument<'gc> { +impl<'gc> fmt::Debug for XmlDocument<'gc> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("XMLDocument") + f.debug_struct("XmlDocument") .field("root", &self.0.read().root) .finish() } diff --git a/core/src/xml/iterators.rs b/core/src/xml/iterators.rs index ca30fea37..9989ab37b 100644 --- a/core/src/xml/iterators.rs +++ b/core/src/xml/iterators.rs @@ -1,17 +1,17 @@ //! Iterator types for XML trees -use crate::xml::XMLNode; +use crate::xml::XmlNode; /// Iterator that yields direct children of an XML node. pub struct ChildIter<'gc> { - base: XMLNode<'gc>, + base: XmlNode<'gc>, index: usize, back_index: usize, } impl<'gc> ChildIter<'gc> { /// Construct a new `ChildIter` that lists the children of an XML node. - pub fn for_node(base: XMLNode<'gc>) -> Self { + pub fn for_node(base: XmlNode<'gc>) -> Self { Self { base, index: 0, @@ -20,13 +20,13 @@ impl<'gc> ChildIter<'gc> { } /// Yield the base element whose children are being read out of. - pub fn base(&self) -> XMLNode<'gc> { + pub fn base(&self) -> XmlNode<'gc> { self.base } } impl<'gc> Iterator for ChildIter<'gc> { - type Item = XMLNode<'gc>; + type Item = XmlNode<'gc>; fn next(&mut self) -> Option { if self.index < self.back_index { @@ -59,23 +59,23 @@ impl<'gc> DoubleEndedIterator for ChildIter<'gc> { pub enum Step<'gc> { /// `WalkIter` has discovered a new element and will begin to yield its /// children's steps. - In(XMLNode<'gc>), + In(XmlNode<'gc>), /// `WalkIter` has discovered a non-element node that cannot have children. /// /// Note that elements will never be stepped around, even if they are /// empty. They will be stepped in and out. - Around(XMLNode<'gc>), + Around(XmlNode<'gc>), /// `WalkIter` has exhausted the children of an element, stepping out of /// it. - Out(XMLNode<'gc>), + Out(XmlNode<'gc>), } impl<'gc> Step<'gc> { /// Discard the information regarding how we approached a given node, and /// just return the underlying `XMLNode`. - pub fn unwrap(self) -> XMLNode<'gc> { + pub fn unwrap(self) -> XmlNode<'gc> { match self { Self::In(node) | Self::Around(node) | Self::Out(node) => node, } @@ -114,7 +114,7 @@ pub struct WalkIter<'gc> { impl<'gc> WalkIter<'gc> { /// Construct a new `WalkIter` that lists a tree out in `Step`s. - pub fn for_node(base: XMLNode<'gc>) -> Self { + pub fn for_node(base: XmlNode<'gc>) -> Self { Self { stack: vec![ChildIter::for_node(base)], } @@ -144,7 +144,7 @@ impl<'gc> Iterator for WalkIter<'gc> { /// Iterator that yields indirect descendents of an XML node. pub struct AnscIter<'gc> { - next: Option>, + next: Option>, } impl<'gc> AnscIter<'gc> { @@ -152,13 +152,13 @@ impl<'gc> AnscIter<'gc> { /// /// This function should be called with the parent of the node being /// iterated. - pub fn for_node(next: Option>) -> Self { + pub fn for_node(next: Option>) -> Self { Self { next } } } impl<'gc> Iterator for AnscIter<'gc> { - type Item = XMLNode<'gc>; + type Item = XmlNode<'gc>; fn next(&mut self) -> Option { let parent = self.next; diff --git a/core/src/xml/namespace.rs b/core/src/xml/namespace.rs index cf2ced097..7d1a5d5d0 100644 --- a/core/src/xml/namespace.rs +++ b/core/src/xml/namespace.rs @@ -14,7 +14,7 @@ use std::fmt; /// should not be used for user-specified namespaces. #[derive(Clone, Collect, PartialEq, Eq, PartialOrd, Ord)] #[collect(no_drop)] -pub struct XMLName { +pub struct XmlName { /// The name of the XML namespace this name is scoped to. /// /// Names without a namespace use the default namespace. @@ -25,10 +25,10 @@ pub struct XMLName { name: String, } -impl XMLName { +impl XmlName { /// Construct an XML name from its parts (name and namespace). pub fn from_parts(namespace: Option<&str>, name: &str) -> Self { - XMLName { + XmlName { namespace: namespace.map(|s| s.to_string()), name: name.to_string(), } @@ -88,7 +88,7 @@ impl XMLName { /// Compares both names as case-insensitve ASCII (for use in HTML parsing). /// TODO: We shouldn't need this when we have a proper HTML parser. - pub fn eq_ignore_ascii_case(&self, other: &XMLName) -> bool { + pub fn eq_ignore_ascii_case(&self, other: &XmlName) -> bool { if !self.name.eq_ignore_ascii_case(&other.name) { return false; } @@ -101,9 +101,9 @@ impl XMLName { } } -impl fmt::Debug for XMLName { +impl fmt::Debug for XmlName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("XMLName") + f.debug_struct("XmlName") .field("namespace", &self.namespace) .field("name", &self.name) .finish() diff --git a/core/src/xml/tests.rs b/core/src/xml/tests.rs index 7d23e7093..8b7425edf 100644 --- a/core/src/xml/tests.rs +++ b/core/src/xml/tests.rs @@ -1,14 +1,14 @@ //! XML tests use crate::xml; -use crate::xml::{XMLDocument, XMLName}; +use crate::xml::{XmlDocument, XmlName}; use gc_arena::rootless_arena; /// Tests very basic parsing of a single-element document. #[test] fn parse_single_element() { rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str(mc, "", true, false) .expect("Parsed document"); @@ -19,7 +19,7 @@ fn parse_single_element() { let root = roots.next().expect("Parsed document should have a root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test"))); let mut root_children = root.children().unwrap(); assert!(root_children.next().is_none()); @@ -32,7 +32,7 @@ fn parse_single_element() { #[test] fn double_ended_children() { rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str( mc, @@ -49,23 +49,23 @@ fn double_ended_children() { let root = roots.next().expect("Should have first root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test"))); let root = roots.next_back().expect("Should have last root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test5"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test5"))); let root = roots.next().expect("Should have next root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test2"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test2"))); let root = roots.next_back().expect("Should have second-to-last root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test4"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test4"))); let root = roots.next().expect("Should have next root"); assert_eq!(root.node_type(), xml::ELEMENT_NODE); - assert_eq!(root.tag_name(), Some(XMLName::from_str("test3"))); + assert_eq!(root.tag_name(), Some(XmlName::from_str("test3"))); assert!(roots.next().is_none()); assert!(roots.next_back().is_none()); @@ -77,7 +77,7 @@ fn double_ended_children() { #[allow(clippy::cognitive_complexity)] fn walk() { rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str( mc, @@ -95,29 +95,29 @@ fn walk() { let root = roots.next().expect("Should have first root"); assert!(root.stepped_in()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test"))); let root = roots.next().expect("Should have first root's child"); assert!(root.stepped_in()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test2"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test2"))); let root = roots .next() .expect("Should have first root's child step-out"); assert!(root.stepped_out()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test2"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test2"))); let root = roots.next().expect("Should have first root step-out"); assert!(root.stepped_out()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test"))); let root = roots.next().expect("Should have second root"); assert!(root.stepped_in()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test3"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test3"))); let root = roots .next() @@ -129,29 +129,29 @@ fn walk() { let root = roots.next().expect("Should have second root"); assert!(root.stepped_out()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test3"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test3"))); let root = roots.next().expect("Should have last root"); assert!(root.stepped_in()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test4"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test4"))); let root = roots.next().expect("Should have last root's child"); assert!(root.stepped_in()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test5"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test5"))); let root = roots .next() .expect("Should have last root's child step-out"); assert!(root.stepped_out()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test5"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test5"))); let root = roots.next().expect("Should have last root step-out"); assert!(root.stepped_out()); assert_eq!(root.unwrap().node_type(), xml::ELEMENT_NODE); - assert_eq!(root.unwrap().tag_name(), Some(XMLName::from_str("test4"))); + assert_eq!(root.unwrap().tag_name(), Some(XmlName::from_str("test4"))); assert!(roots.next().is_none()); }) @@ -163,7 +163,7 @@ fn round_trip_tostring() { let test_string = "This is a text node"; rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str(mc, test_string, true, false) .expect("Parsed document"); @@ -183,7 +183,7 @@ fn round_trip_filtered_tostring() { let test_string = "This is a text node"; rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str(mc, test_string, true, false) .expect("Parsed document"); @@ -201,7 +201,7 @@ fn round_trip_filtered_tostring() { #[test] fn ignore_white() { rootless_arena(|mc| { - let xml = XMLDocument::new(mc); + let xml = XmlDocument::new(mc); xml.as_node() .replace_with_str( mc, @@ -218,7 +218,7 @@ fn ignore_white() { let mut node = root.next().expect("Should have root"); assert_eq!(node.node_type(), xml::ELEMENT_NODE); - assert_eq!(node.tag_name(), Some(XMLName::from_str("test"))); + assert_eq!(node.tag_name(), Some(XmlName::from_str("test"))); node = node .children() @@ -226,7 +226,7 @@ fn ignore_white() { .next() .expect("Should have children"); assert_eq!(node.node_type(), xml::ELEMENT_NODE); - assert_eq!(node.tag_name(), Some(XMLName::from_str("test2"))); + assert_eq!(node.tag_name(), Some(XmlName::from_str("test2"))); node = node .children() @@ -234,7 +234,7 @@ fn ignore_white() { .next() .expect("Should have children"); assert_eq!(node.node_type(), xml::ELEMENT_NODE); - assert_eq!(node.tag_name(), Some(XMLName::from_str("test3"))); + assert_eq!(node.tag_name(), Some(XmlName::from_str("test3"))); node = node .children() diff --git a/core/src/xml/tree.rs b/core/src/xml/tree.rs index ebe7c0961..b1338ca0d 100644 --- a/core/src/xml/tree.rs +++ b/core/src/xml/tree.rs @@ -1,10 +1,10 @@ //! XML Tree structure -use crate::avm1::object::xml_attributes_object::XMLAttributesObject; -use crate::avm1::object::xml_object::XMLObject; +use crate::avm1::object::xml_attributes_object::XmlAttributesObject; +use crate::avm1::object::xml_object::XmlObject; use crate::avm1::{Object, TObject}; use crate::xml; -use crate::xml::{Error, Step, XMLDocument, XMLName}; +use crate::xml::{Error, Step, XmlDocument, XmlName}; use gc_arena::{Collect, GcCell, MutationContext}; use quick_xml::events::attributes::Attribute; use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; @@ -18,11 +18,11 @@ use std::mem::swap; /// Represents a node in the XML tree. #[derive(Copy, Clone, Collect)] #[collect(no_drop)] -pub struct XMLNode<'gc>(GcCell<'gc, XMLNodeData<'gc>>); +pub struct XmlNode<'gc>(GcCell<'gc, XmlNodeData<'gc>>); #[derive(Clone, Collect)] #[collect(no_drop)] -pub enum XMLNodeData<'gc> { +pub enum XmlNodeData<'gc> { /// The root level of an XML document. Has no parent. DocumentRoot { /// The script object associated with this XML node, if any. @@ -32,10 +32,10 @@ pub enum XMLNodeData<'gc> { attributes_script_object: Option>, /// The document that this is the root of. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// Child nodes of this element. - children: Vec>, + children: Vec>, }, /// An element node in the XML tree. @@ -51,25 +51,25 @@ pub enum XMLNodeData<'gc> { attributes_script_object: Option>, /// The document that this tree node currently belongs to. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// The parent node of this one. - parent: Option>, + parent: Option>, /// The previous sibling node to this one. - prev_sibling: Option>, + prev_sibling: Option>, /// The next sibling node to this one. - next_sibling: Option>, + next_sibling: Option>, /// The tag name of this element. - tag_name: XMLName, + tag_name: XmlName, /// Attributes of the element. - attributes: BTreeMap, + attributes: BTreeMap, /// Child nodes of this element. - children: Vec>, + children: Vec>, }, /// A text node in the XML tree. @@ -81,16 +81,16 @@ pub enum XMLNodeData<'gc> { attributes_script_object: Option>, /// The document that this tree node currently belongs to. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// The parent node of this one. - parent: Option>, + parent: Option>, /// The previous sibling node to this one. - prev_sibling: Option>, + prev_sibling: Option>, /// The next sibling node to this one. - next_sibling: Option>, + next_sibling: Option>, /// The string representation of the text. contents: String, @@ -102,16 +102,16 @@ pub enum XMLNodeData<'gc> { script_object: Option>, /// The document that this tree node currently belongs to. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// The parent node of this one. - parent: Option>, + parent: Option>, /// The previous sibling node to this one. - prev_sibling: Option>, + prev_sibling: Option>, /// The next sibling node to this one. - next_sibling: Option>, + next_sibling: Option>, /// The string representation of the comment. contents: String, @@ -123,32 +123,32 @@ pub enum XMLNodeData<'gc> { script_object: Option>, /// The document that this tree node currently belongs to. - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, /// The parent node of this one. - parent: Option>, + parent: Option>, /// The previous sibling node to this one. - prev_sibling: Option>, + prev_sibling: Option>, /// The next sibling node to this one. - next_sibling: Option>, + next_sibling: Option>, /// The string representation of the DOCTYPE. contents: String, }, } -impl<'gc> XMLNode<'gc> { +impl<'gc> XmlNode<'gc> { /// Construct a new XML text node. pub fn new_text( mc: MutationContext<'gc, '_>, contents: &str, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, ) -> Self { - XMLNode(GcCell::allocate( + XmlNode(GcCell::allocate( mc, - XMLNodeData::Text { + XmlNodeData::Text { script_object: None, attributes_script_object: None, document, @@ -164,17 +164,17 @@ impl<'gc> XMLNode<'gc> { pub fn new_element( mc: MutationContext<'gc, '_>, element_name: &str, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, ) -> Self { - XMLNode(GcCell::allocate( + XmlNode(GcCell::allocate( mc, - XMLNodeData::Element { + XmlNodeData::Element { script_object: None, document, parent: None, prev_sibling: None, next_sibling: None, - tag_name: XMLName::from_str(element_name), + tag_name: XmlName::from_str(element_name), attributes: BTreeMap::new(), attributes_script_object: None, children: Vec::new(), @@ -183,10 +183,10 @@ impl<'gc> XMLNode<'gc> { } /// Construct a new XML root node. - pub fn new_document_root(mc: MutationContext<'gc, '_>, document: XMLDocument<'gc>) -> Self { - XMLNode(GcCell::allocate( + pub fn new_document_root(mc: MutationContext<'gc, '_>, document: XmlDocument<'gc>) -> Self { + XmlNode(GcCell::allocate( mc, - XMLNodeData::DocumentRoot { + XmlNodeData::DocumentRoot { script_object: None, attributes_script_object: None, document, @@ -200,8 +200,8 @@ impl<'gc> XMLNode<'gc> { fn add_child_to_tree( &mut self, mc: MutationContext<'gc, '_>, - open_tags: &mut Vec>, - child: XMLNode<'gc>, + open_tags: &mut Vec>, + child: XmlNode<'gc>, ) -> Result<(), Error> { if let Some(node) = open_tags.last_mut() { node.append_child(mc, child)?; @@ -232,7 +232,7 @@ impl<'gc> XMLNode<'gc> { let mut parser = Reader::from_str(data); let mut buf = Vec::new(); let document = self.document(); - let mut open_tags: Vec> = Vec::new(); + let mut open_tags: Vec> = Vec::new(); document.clear_parse_error(mc); @@ -243,13 +243,13 @@ impl<'gc> XMLNode<'gc> { match event { Event::Start(bs) => { - let child = XMLNode::from_start_event(mc, bs, document)?; + let child = XmlNode::from_start_event(mc, bs, document)?; self.document().update_idmap(mc, child); self.add_child_to_tree(mc, &mut open_tags, child)?; open_tags.push(child); } Event::Empty(bs) => { - let child = XMLNode::from_start_event(mc, bs, document)?; + let child = XmlNode::from_start_event(mc, bs, document)?; self.document().update_idmap(mc, child); self.add_child_to_tree(mc, &mut open_tags, child)?; } @@ -257,7 +257,7 @@ impl<'gc> XMLNode<'gc> { open_tags.pop(); } Event::Text(bt) => { - let child = XMLNode::text_from_text_event(mc, bt, document, process_entity)?; + let child = XmlNode::text_from_text_event(mc, bt, document, process_entity)?; if child.node_value().as_deref() != Some("") && (!ignore_white || !child.is_whitespace_text()) { @@ -265,13 +265,13 @@ impl<'gc> XMLNode<'gc> { } } Event::Comment(bt) => { - let child = XMLNode::comment_from_text_event(mc, bt, document)?; + let child = XmlNode::comment_from_text_event(mc, bt, document)?; if child.node_value().as_deref() != Some("") { self.add_child_to_tree(mc, &mut open_tags, child)?; } } Event::DocType(bt) => { - let child = XMLNode::doctype_from_text_event(mc, bt, document)?; + let child = XmlNode::doctype_from_text_event(mc, bt, document)?; if child.node_value().as_deref() != Some("") { self.add_child_to_tree(mc, &mut open_tags, child)?; } @@ -291,24 +291,24 @@ impl<'gc> XMLNode<'gc> { pub fn from_start_event<'a>( mc: MutationContext<'gc, '_>, bs: BytesStart<'a>, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, ) -> Result { - let tag_name = XMLName::from_bytes(bs.name())?; + let tag_name = XmlName::from_bytes(bs.name())?; let mut attributes = BTreeMap::new(); for a in bs.attributes() { let attribute = a?; attributes.insert( - XMLName::from_bytes(attribute.key)?, + XmlName::from_bytes(attribute.key)?, String::from_utf8(attribute.value.to_owned().to_vec())?, ); } let children = Vec::new(); - Ok(XMLNode(GcCell::allocate( + Ok(XmlNode(GcCell::allocate( mc, - XMLNodeData::Element { + XmlNodeData::Element { script_object: None, document, parent: None, @@ -329,7 +329,7 @@ impl<'gc> XMLNode<'gc> { pub fn text_from_text_event<'a>( mc: MutationContext<'gc, '_>, bt: BytesText<'a>, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, process_entity: bool, ) -> Result { let contents = if process_entity { @@ -338,9 +338,9 @@ impl<'gc> XMLNode<'gc> { String::from_utf8(bt.escaped().to_vec())? }; - Ok(XMLNode(GcCell::allocate( + Ok(XmlNode(GcCell::allocate( mc, - XMLNodeData::Text { + XmlNodeData::Text { script_object: None, attributes_script_object: None, document, @@ -359,11 +359,11 @@ impl<'gc> XMLNode<'gc> { pub fn comment_from_text_event<'a>( mc: MutationContext<'gc, '_>, bt: BytesText<'a>, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, ) -> Result { - Ok(XMLNode(GcCell::allocate( + Ok(XmlNode(GcCell::allocate( mc, - XMLNodeData::Comment { + XmlNodeData::Comment { script_object: None, document, parent: None, @@ -381,11 +381,11 @@ impl<'gc> XMLNode<'gc> { pub fn doctype_from_text_event<'a>( mc: MutationContext<'gc, '_>, bt: BytesText<'a>, - document: XMLDocument<'gc>, + document: XmlDocument<'gc>, ) -> Result { - Ok(XMLNode(GcCell::allocate( + Ok(XmlNode(GcCell::allocate( mc, - XMLNodeData::DocType { + XmlNodeData::DocType { script_object: None, document, parent: None, @@ -398,15 +398,15 @@ impl<'gc> XMLNode<'gc> { /// Return the XML document that this tree node belongs to. /// - /// Every XML node belongs to a document object (see `XMLDocument`) which + /// Every XML node belongs to a document object (see `XmlDocument`) which /// stores global information about the document, such as namespace URIs. - pub fn document(self) -> XMLDocument<'gc> { + pub fn document(self) -> XmlDocument<'gc> { match &*self.0.read() { - XMLNodeData::DocumentRoot { document, .. } => *document, - XMLNodeData::Element { document, .. } => *document, - XMLNodeData::Text { document, .. } => *document, - XMLNodeData::Comment { document, .. } => *document, - XMLNodeData::DocType { document, .. } => *document, + XmlNodeData::DocumentRoot { document, .. } => *document, + XmlNodeData::Element { document, .. } => *document, + XmlNodeData::Text { document, .. } => *document, + XmlNodeData::Comment { document, .. } => *document, + XmlNodeData::DocType { document, .. } => *document, } } @@ -424,7 +424,7 @@ impl<'gc> XMLNode<'gc> { fn adopt_child( &mut self, mc: MutationContext<'gc, '_>, - mut child: XMLNode<'gc>, + mut child: XmlNode<'gc>, new_child_position: usize, ) -> Result<(), Error> { if GcCell::ptr_eq(self.0, child.0) { @@ -432,27 +432,27 @@ impl<'gc> XMLNode<'gc> { } let (mut document, new_prev, new_next) = match &mut *self.0.write(mc) { - XMLNodeData::Element { + XmlNodeData::Element { document, children, .. } - | XMLNodeData::DocumentRoot { + | XmlNodeData::DocumentRoot { document, children, .. } => { let mut write = child.0.write(mc); let (child_document, child_parent) = match &mut *write { - XMLNodeData::Element { + XmlNodeData::Element { document, parent, .. } => Ok((document, parent)), - XMLNodeData::Text { + XmlNodeData::Text { document, parent, .. } => Ok((document, parent)), - XMLNodeData::Comment { + XmlNodeData::Comment { document, parent, .. } => Ok((document, parent)), - XMLNodeData::DocType { + XmlNodeData::DocType { document, parent, .. } => Ok((document, parent)), - XMLNodeData::DocumentRoot { .. } => Err(Error::CannotAdoptRoot), + XmlNodeData::DocumentRoot { .. } => Err(Error::CannotAdoptRoot), }?; if let Some(parent) = child_parent { @@ -490,26 +490,26 @@ impl<'gc> XMLNode<'gc> { /// Get the parent, if this node has one. /// /// If the node cannot have a parent, then this function yields Err. - pub fn parent(self) -> Result>, Error> { + pub fn parent(self) -> Result>, Error> { match *self.0.read() { - XMLNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveParent), - XMLNodeData::Element { parent, .. } => Ok(parent), - XMLNodeData::Text { parent, .. } => Ok(parent), - XMLNodeData::Comment { parent, .. } => Ok(parent), - XMLNodeData::DocType { parent, .. } => Ok(parent), + XmlNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveParent), + XmlNodeData::Element { parent, .. } => Ok(parent), + XmlNodeData::Text { parent, .. } => Ok(parent), + XmlNodeData::Comment { parent, .. } => Ok(parent), + XmlNodeData::DocType { parent, .. } => Ok(parent), } } /// Get the previous sibling, if this node has one. /// /// If the node cannot have siblings, then this function yields Err. - pub fn prev_sibling(self) -> Result>, Error> { + pub fn prev_sibling(self) -> Result>, Error> { match *self.0.read() { - XMLNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveSiblings), - XMLNodeData::Element { prev_sibling, .. } => Ok(prev_sibling), - XMLNodeData::Text { prev_sibling, .. } => Ok(prev_sibling), - XMLNodeData::Comment { prev_sibling, .. } => Ok(prev_sibling), - XMLNodeData::DocType { prev_sibling, .. } => Ok(prev_sibling), + XmlNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveSiblings), + XmlNodeData::Element { prev_sibling, .. } => Ok(prev_sibling), + XmlNodeData::Text { prev_sibling, .. } => Ok(prev_sibling), + XmlNodeData::Comment { prev_sibling, .. } => Ok(prev_sibling), + XmlNodeData::DocType { prev_sibling, .. } => Ok(prev_sibling), } } @@ -517,14 +517,14 @@ impl<'gc> XMLNode<'gc> { fn set_prev_sibling( &mut self, mc: MutationContext<'gc, '_>, - new_prev: Option>, + new_prev: Option>, ) -> Result<(), Error> { match &mut *self.0.write(mc) { - XMLNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveSiblings), - XMLNodeData::Element { prev_sibling, .. } => *prev_sibling = new_prev, - XMLNodeData::Text { prev_sibling, .. } => *prev_sibling = new_prev, - XMLNodeData::Comment { prev_sibling, .. } => *prev_sibling = new_prev, - XMLNodeData::DocType { prev_sibling, .. } => *prev_sibling = new_prev, + XmlNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveSiblings), + XmlNodeData::Element { prev_sibling, .. } => *prev_sibling = new_prev, + XmlNodeData::Text { prev_sibling, .. } => *prev_sibling = new_prev, + XmlNodeData::Comment { prev_sibling, .. } => *prev_sibling = new_prev, + XmlNodeData::DocType { prev_sibling, .. } => *prev_sibling = new_prev, }; Ok(()) @@ -533,13 +533,13 @@ impl<'gc> XMLNode<'gc> { /// Get the next sibling, if this node has one. /// /// If the node cannot have siblings, then this function yields Err. - pub fn next_sibling(self) -> Result>, Error> { + pub fn next_sibling(self) -> Result>, Error> { match *self.0.read() { - XMLNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveSiblings), - XMLNodeData::Element { next_sibling, .. } => Ok(next_sibling), - XMLNodeData::Text { next_sibling, .. } => Ok(next_sibling), - XMLNodeData::Comment { next_sibling, .. } => Ok(next_sibling), - XMLNodeData::DocType { next_sibling, .. } => Ok(next_sibling), + XmlNodeData::DocumentRoot { .. } => Err(Error::RootCantHaveSiblings), + XmlNodeData::Element { next_sibling, .. } => Ok(next_sibling), + XmlNodeData::Text { next_sibling, .. } => Ok(next_sibling), + XmlNodeData::Comment { next_sibling, .. } => Ok(next_sibling), + XmlNodeData::DocType { next_sibling, .. } => Ok(next_sibling), } } @@ -547,14 +547,14 @@ impl<'gc> XMLNode<'gc> { fn set_next_sibling( &mut self, mc: MutationContext<'gc, '_>, - new_next: Option>, + new_next: Option>, ) -> Result<(), Error> { match &mut *self.0.write(mc) { - XMLNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveSiblings), - XMLNodeData::Element { next_sibling, .. } => *next_sibling = new_next, - XMLNodeData::Text { next_sibling, .. } => *next_sibling = new_next, - XMLNodeData::Comment { next_sibling, .. } => *next_sibling = new_next, - XMLNodeData::DocType { next_sibling, .. } => *next_sibling = new_next, + XmlNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveSiblings), + XmlNodeData::Element { next_sibling, .. } => *next_sibling = new_next, + XmlNodeData::Text { next_sibling, .. } => *next_sibling = new_next, + XmlNodeData::Comment { next_sibling, .. } => *next_sibling = new_next, + XmlNodeData::DocType { next_sibling, .. } => *next_sibling = new_next, }; Ok(()) @@ -588,11 +588,11 @@ impl<'gc> XMLNode<'gc> { /// Unset the parent of this node. fn disown_parent(&mut self, mc: MutationContext<'gc, '_>) -> Result<(), Error> { match &mut *self.0.write(mc) { - XMLNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveParent), - XMLNodeData::Element { parent, .. } => *parent = None, - XMLNodeData::Text { parent, .. } => *parent = None, - XMLNodeData::Comment { parent, .. } => *parent = None, - XMLNodeData::DocType { parent, .. } => *parent = None, + XmlNodeData::DocumentRoot { .. } => return Err(Error::RootCantHaveParent), + XmlNodeData::Element { parent, .. } => *parent = None, + XmlNodeData::Text { parent, .. } => *parent = None, + XmlNodeData::Comment { parent, .. } => *parent = None, + XmlNodeData::DocType { parent, .. } => *parent = None, }; Ok(()) @@ -608,8 +608,8 @@ impl<'gc> XMLNode<'gc> { fn adopt_siblings( &mut self, mc: MutationContext<'gc, '_>, - new_prev: Option>, - new_next: Option>, + new_prev: Option>, + new_next: Option>, ) -> Result<(), Error> { if let Some(mut prev) = new_prev { prev.set_next_sibling(mc, Some(*self))?; @@ -631,15 +631,15 @@ impl<'gc> XMLNode<'gc> { fn orphan_child( &mut self, mc: MutationContext<'gc, '_>, - child: XMLNode<'gc>, + child: XmlNode<'gc>, ) -> Result<(), Error> { if let Some(position) = self.child_position(child) { match &mut *self.0.write(mc) { - XMLNodeData::DocumentRoot { children, .. } => children.remove(position), - XMLNodeData::Element { children, .. } => children.remove(position), - XMLNodeData::Text { .. } => return Err(Error::TextNodeCantHaveChildren), - XMLNodeData::Comment { .. } => return Err(Error::CommentNodeCantHaveChildren), - XMLNodeData::DocType { .. } => return Err(Error::DocTypeCantHaveChildren), + XmlNodeData::DocumentRoot { children, .. } => children.remove(position), + XmlNodeData::Element { children, .. } => children.remove(position), + XmlNodeData::Text { .. } => return Err(Error::TextNodeCantHaveChildren), + XmlNodeData::Comment { .. } => return Err(Error::CommentNodeCantHaveChildren), + XmlNodeData::DocType { .. } => return Err(Error::DocTypeCantHaveChildren), }; } @@ -659,17 +659,17 @@ impl<'gc> XMLNode<'gc> { &mut self, mc: MutationContext<'gc, '_>, position: usize, - child: XMLNode<'gc>, + child: XmlNode<'gc>, ) -> Result<(), Error> { if GcCell::ptr_eq(self.0, child.0) { return Err(Error::CannotInsertIntoSelf); } match &mut *self.0.write(mc) { - XMLNodeData::Element { + XmlNodeData::Element { ref mut children, .. } - | XMLNodeData::DocumentRoot { + | XmlNodeData::DocumentRoot { ref mut children, .. } => { children.insert(position, child); @@ -687,7 +687,7 @@ impl<'gc> XMLNode<'gc> { pub fn append_child( &mut self, mc: MutationContext<'gc, '_>, - child: XMLNode<'gc>, + child: XmlNode<'gc>, ) -> Result<(), Error> { self.insert_child(mc, self.children_len(), child) } @@ -699,15 +699,15 @@ impl<'gc> XMLNode<'gc> { pub fn remove_child( &mut self, mc: MutationContext<'gc, '_>, - mut child: XMLNode<'gc>, + mut child: XmlNode<'gc>, ) -> Result<(), Error> { if let Some(position) = self.child_position(child) { match &mut *self.0.write(mc) { - XMLNodeData::Element { children, .. } => children.remove(position), - XMLNodeData::DocumentRoot { children, .. } => children.remove(position), - XMLNodeData::Text { .. } => return Err(Error::TextNodeCantHaveChildren), - XMLNodeData::Comment { .. } => return Err(Error::CommentNodeCantHaveChildren), - XMLNodeData::DocType { .. } => return Err(Error::DocTypeCantHaveChildren), + XmlNodeData::Element { children, .. } => children.remove(position), + XmlNodeData::DocumentRoot { children, .. } => children.remove(position), + XmlNodeData::Text { .. } => return Err(Error::TextNodeCantHaveChildren), + XmlNodeData::Comment { .. } => return Err(Error::CommentNodeCantHaveChildren), + XmlNodeData::DocType { .. } => return Err(Error::DocTypeCantHaveChildren), }; child.disown_siblings(mc)?; @@ -725,18 +725,18 @@ impl<'gc> XMLNode<'gc> { /// should not be used in lieu of a proper `match` statement. pub fn node_type(self) -> u8 { match &*self.0.read() { - XMLNodeData::DocumentRoot { .. } => xml::DOCUMENT_NODE, - XMLNodeData::Element { .. } => xml::ELEMENT_NODE, - XMLNodeData::Text { .. } => xml::TEXT_NODE, - XMLNodeData::Comment { .. } => xml::COMMENT_NODE, - XMLNodeData::DocType { .. } => xml::DOCUMENT_TYPE_NODE, + XmlNodeData::DocumentRoot { .. } => xml::DOCUMENT_NODE, + XmlNodeData::Element { .. } => xml::ELEMENT_NODE, + XmlNodeData::Text { .. } => xml::TEXT_NODE, + XmlNodeData::Comment { .. } => xml::COMMENT_NODE, + XmlNodeData::DocType { .. } => xml::DOCUMENT_TYPE_NODE, } } /// Returns the tagname, if the element has one. - pub fn tag_name(self) -> Option { + pub fn tag_name(self) -> Option { match &*self.0.read() { - XMLNodeData::Element { ref tag_name, .. } => Some(tag_name.clone()), + XmlNodeData::Element { ref tag_name, .. } => Some(tag_name.clone()), _ => None, } } @@ -744,9 +744,9 @@ impl<'gc> XMLNode<'gc> { /// Returns the string contents of the node, if the element has them. pub fn node_value(self) -> Option { match &*self.0.read() { - XMLNodeData::Text { ref contents, .. } => Some(contents.clone()), - XMLNodeData::Comment { ref contents, .. } => Some(contents.clone()), - XMLNodeData::DocType { ref contents, .. } => Some(contents.clone()), + XmlNodeData::Text { ref contents, .. } => Some(contents.clone()), + XmlNodeData::Comment { ref contents, .. } => Some(contents.clone()), + XmlNodeData::DocType { ref contents, .. } => Some(contents.clone()), _ => None, } } @@ -756,7 +756,7 @@ impl<'gc> XMLNode<'gc> { /// Nodes that cannot hold children always yield `0`. pub fn children_len(self) -> usize { match &*self.0.read() { - XMLNodeData::Element { children, .. } | XMLNodeData::DocumentRoot { children, .. } => { + XmlNodeData::Element { children, .. } | XmlNodeData::DocumentRoot { children, .. } => { children.len() } _ => 0, @@ -767,7 +767,7 @@ impl<'gc> XMLNode<'gc> { /// /// This function yields None if the node cannot accept children or if the /// child node is not a child of this node. - pub fn child_position(self, child: XMLNode<'gc>) -> Option { + pub fn child_position(self, child: XmlNode<'gc>) -> Option { if let Some(children) = self.children() { for (i, other_child) in children.enumerate() { if GcCell::ptr_eq(child.0, other_child.0) { @@ -780,9 +780,9 @@ impl<'gc> XMLNode<'gc> { } /// Retrieve a given child by index (e.g. position in the document). - pub fn get_child_by_index(self, index: usize) -> Option> { + pub fn get_child_by_index(self, index: usize) -> Option> { match &*self.0.read() { - XMLNodeData::Element { children, .. } | XMLNodeData::DocumentRoot { children, .. } => { + XmlNodeData::Element { children, .. } | XmlNodeData::DocumentRoot { children, .. } => { Some(children) } _ => None, @@ -798,16 +798,16 @@ impl<'gc> XMLNode<'gc> { pub fn has_children(self) -> bool { matches!( *self.0.read(), - XMLNodeData::Element { .. } | XMLNodeData::DocumentRoot { .. } + XmlNodeData::Element { .. } | XmlNodeData::DocumentRoot { .. } ) } /// Returns an iterator that yields child nodes. /// /// Yields None if this node cannot accept children. - pub fn children(self) -> Option>> { + pub fn children(self) -> Option>> { match &*self.0.read() { - XMLNodeData::Element { .. } | XMLNodeData::DocumentRoot { .. } => { + XmlNodeData::Element { .. } | XmlNodeData::DocumentRoot { .. } => { Some(xml::iterators::ChildIter::for_node(self)) } _ => None, @@ -823,7 +823,7 @@ impl<'gc> XMLNode<'gc> { /// Yields None if this node cannot accept children. pub fn walk(self) -> Option>> { match &*self.0.read() { - XMLNodeData::Element { .. } | XMLNodeData::DocumentRoot { .. } => { + XmlNodeData::Element { .. } | XmlNodeData::DocumentRoot { .. } => { Some(xml::iterators::WalkIter::for_node(self)) } _ => None, @@ -833,13 +833,13 @@ impl<'gc> XMLNode<'gc> { /// Returns an iterator that yields ancestor nodes. /// /// Yields None if this node does not have a parent. - pub fn ancestors(self) -> Option>> { + pub fn ancestors(self) -> Option>> { let parent = match *self.0.read() { - XMLNodeData::DocumentRoot { .. } => return None, - XMLNodeData::Element { parent, .. } => parent, - XMLNodeData::Text { parent, .. } => parent, - XMLNodeData::Comment { parent, .. } => parent, - XMLNodeData::DocType { parent, .. } => parent, + XmlNodeData::DocumentRoot { .. } => return None, + XmlNodeData::Element { parent, .. } => parent, + XmlNodeData::Text { parent, .. } => parent, + XmlNodeData::Comment { parent, .. } => parent, + XmlNodeData::DocType { parent, .. } => parent, }; Some(xml::iterators::AnscIter::for_node(parent)) @@ -848,11 +848,11 @@ impl<'gc> XMLNode<'gc> { /// Get the already-instantiated script object from the current node. fn get_script_object(self) -> Option> { match &*self.0.read() { - XMLNodeData::DocumentRoot { script_object, .. } => *script_object, - XMLNodeData::Element { script_object, .. } => *script_object, - XMLNodeData::Text { script_object, .. } => *script_object, - XMLNodeData::Comment { script_object, .. } => *script_object, - XMLNodeData::DocType { script_object, .. } => *script_object, + XmlNodeData::DocumentRoot { script_object, .. } => *script_object, + XmlNodeData::Element { script_object, .. } => *script_object, + XmlNodeData::Text { script_object, .. } => *script_object, + XmlNodeData::Comment { script_object, .. } => *script_object, + XmlNodeData::DocType { script_object, .. } => *script_object, } } @@ -869,11 +869,11 @@ impl<'gc> XMLNode<'gc> { assert!(self.get_script_object().is_none(), "An attempt was made to change the already-established link between script object and XML node. This has been denied and is likely a bug."); match &mut *self.0.write(gc_context) { - XMLNodeData::DocumentRoot { script_object, .. } => *script_object = Some(new_object), - XMLNodeData::Element { script_object, .. } => *script_object = Some(new_object), - XMLNodeData::Text { script_object, .. } => *script_object = Some(new_object), - XMLNodeData::Comment { script_object, .. } => *script_object = Some(new_object), - XMLNodeData::DocType { script_object, .. } => *script_object = Some(new_object), + XmlNodeData::DocumentRoot { script_object, .. } => *script_object = Some(new_object), + XmlNodeData::Element { script_object, .. } => *script_object = Some(new_object), + XmlNodeData::Text { script_object, .. } => *script_object = Some(new_object), + XmlNodeData::Comment { script_object, .. } => *script_object = Some(new_object), + XmlNodeData::DocType { script_object, .. } => *script_object = Some(new_object), } } @@ -886,7 +886,7 @@ impl<'gc> XMLNode<'gc> { ) -> Object<'gc> { let mut object = self.get_script_object(); if object.is_none() { - object = Some(XMLObject::from_xml_node(gc_context, *self, prototype)); + object = Some(XmlObject::from_xml_node(gc_context, *self, prototype)); self.introduce_script_object(gc_context, object.unwrap()); } @@ -900,21 +900,21 @@ impl<'gc> XMLNode<'gc> { gc_context: MutationContext<'gc, '_>, ) -> Option> { match &mut *self.0.write(gc_context) { - XMLNodeData::Element { + XmlNodeData::Element { attributes_script_object, .. } - | XMLNodeData::DocumentRoot { + | XmlNodeData::DocumentRoot { attributes_script_object, .. } - | XMLNodeData::Text { + | XmlNodeData::Text { attributes_script_object, .. } => { if attributes_script_object.is_none() { *attributes_script_object = - Some(XMLAttributesObject::from_xml_node(gc_context, *self)); + Some(XmlAttributesObject::from_xml_node(gc_context, *self)); } *attributes_script_object @@ -940,56 +940,56 @@ impl<'gc> XMLNode<'gc> { /// Check if this XML node constitutes the root of a whole document. pub fn is_document_root(self) -> bool { - matches!(*self.0.read(), XMLNodeData::DocumentRoot { .. }) + matches!(*self.0.read(), XmlNodeData::DocumentRoot { .. }) } /// Check if this XML node constitutes an element. pub fn is_element(self) -> bool { - matches!(*self.0.read(), XMLNodeData::Element { .. }) + matches!(*self.0.read(), XmlNodeData::Element { .. }) } /// Check if this XML node constitutes text. pub fn is_text(self) -> bool { - matches!(*self.0.read(), XMLNodeData::Text { .. }) + matches!(*self.0.read(), XmlNodeData::Text { .. }) } // Check if this XML node is constitutes text and only contains whitespace. pub fn is_whitespace_text(self) -> bool { const WHITESPACE_CHARS: &[u8] = &[b' ', b'\t', b'\r', b'\n']; - matches!(&*self.0.read(), XMLNodeData::Text { contents, .. } if contents.bytes().all(|c| WHITESPACE_CHARS.contains(&c))) + matches!(&*self.0.read(), XmlNodeData::Text { contents, .. } if contents.bytes().all(|c| WHITESPACE_CHARS.contains(&c))) } /// Check if this XML node constitutes text. #[allow(dead_code)] pub fn is_comment(self) -> bool { - matches!(*self.0.read(), XMLNodeData::Comment { .. }) + matches!(*self.0.read(), XmlNodeData::Comment { .. }) } /// Check if this XML node constitutes a DOCTYPE declaration pub fn is_doctype(self) -> bool { - matches!(*self.0.read(), XMLNodeData::DocType { .. }) + matches!(*self.0.read(), XmlNodeData::DocType { .. }) } /// Create a duplicate copy of this node. /// /// If the `deep` flag is set true, then the entire node tree will be /// cloned. - pub fn duplicate(self, gc_context: MutationContext<'gc, '_>, deep: bool) -> XMLNode<'gc> { + pub fn duplicate(self, gc_context: MutationContext<'gc, '_>, deep: bool) -> XmlNode<'gc> { let mut document = self.document().duplicate(gc_context); - let mut clone = XMLNode(GcCell::allocate( + let mut clone = XmlNode(GcCell::allocate( gc_context, match &*self.0.read() { - XMLNodeData::DocumentRoot { .. } => XMLNodeData::DocumentRoot { + XmlNodeData::DocumentRoot { .. } => XmlNodeData::DocumentRoot { script_object: None, attributes_script_object: None, document, children: Vec::new(), }, - XMLNodeData::Element { + XmlNodeData::Element { tag_name, attributes, .. - } => XMLNodeData::Element { + } => XmlNodeData::Element { script_object: None, document, parent: None, @@ -1000,7 +1000,7 @@ impl<'gc> XMLNode<'gc> { attributes_script_object: None, children: Vec::new(), }, - XMLNodeData::Text { contents, .. } => XMLNodeData::Text { + XmlNodeData::Text { contents, .. } => XmlNodeData::Text { script_object: None, attributes_script_object: None, document, @@ -1009,7 +1009,7 @@ impl<'gc> XMLNode<'gc> { next_sibling: None, contents: contents.to_string(), }, - XMLNodeData::Comment { contents, .. } => XMLNodeData::Comment { + XmlNodeData::Comment { contents, .. } => XmlNodeData::Comment { script_object: None, document, parent: None, @@ -1017,7 +1017,7 @@ impl<'gc> XMLNode<'gc> { next_sibling: None, contents: contents.to_string(), }, - XMLNodeData::DocType { contents, .. } => XMLNodeData::DocType { + XmlNodeData::DocType { contents, .. } => XmlNodeData::DocType { script_object: None, document, parent: None, @@ -1047,9 +1047,9 @@ impl<'gc> XMLNode<'gc> { /// /// If the node does not contain attributes, then this function always /// yields None. - pub fn attribute_value(self, name: &XMLName) -> Option { + pub fn attribute_value(self, name: &XmlName) -> Option { match &*self.0.read() { - XMLNodeData::Element { attributes, .. } => attributes.get(name).cloned(), + XmlNodeData::Element { attributes, .. } => attributes.get(name).cloned(), _ => None, } } @@ -1057,7 +1057,7 @@ impl<'gc> XMLNode<'gc> { /// Retrieve all keys defined on this node. pub fn attribute_keys(self) -> Vec { match &*self.0.read() { - XMLNodeData::Element { attributes, .. } => attributes + XmlNodeData::Element { attributes, .. } => attributes .keys() .map(|v| v.node_name().to_string()) .collect::>(), @@ -1068,9 +1068,9 @@ impl<'gc> XMLNode<'gc> { /// Retrieve the value of a single attribute on this node, case-insensitively. /// /// TODO: Probably won't need this when we have a proper HTML parser. - pub fn attribute_value_ignore_ascii_case(self, name: &XMLName) -> Option { + pub fn attribute_value_ignore_ascii_case(self, name: &XmlName) -> Option { match &*self.0.read() { - XMLNodeData::Element { attributes, .. } => attributes + XmlNodeData::Element { attributes, .. } => attributes .iter() .find(|(k, _)| k.eq_ignore_ascii_case(name)) .map(|(_, v)| v.clone()), @@ -1084,10 +1084,10 @@ impl<'gc> XMLNode<'gc> { pub fn set_attribute_value( self, gc_context: MutationContext<'gc, '_>, - name: &XMLName, + name: &XmlName, value: &str, ) { - if let XMLNodeData::Element { attributes, .. } = &mut *self.0.write(gc_context) { + if let XmlNodeData::Element { attributes, .. } = &mut *self.0.write(gc_context) { attributes.insert(name.clone(), value.to_string()); } } @@ -1095,8 +1095,8 @@ impl<'gc> XMLNode<'gc> { /// Delete the value of a single attribute on this node. /// /// If the node does not contain attributes, then this function silently fails. - pub fn delete_attribute(self, gc_context: MutationContext<'gc, '_>, name: &XMLName) { - if let XMLNodeData::Element { attributes, .. } = &mut *self.0.write(gc_context) { + pub fn delete_attribute(self, gc_context: MutationContext<'gc, '_>, name: &XmlName) { + if let XmlNodeData::Element { attributes, .. } = &mut *self.0.write(gc_context) { attributes.remove(name); } } @@ -1106,8 +1106,8 @@ impl<'gc> XMLNode<'gc> { /// XML namespaces are determined by `xmlns:` namespace attributes on the /// current node, or its parent. pub fn lookup_uri_for_namespace(self, namespace: &str) -> Option { - let xmlns_default = XMLName::from_parts(None, "xmlns"); - let xmlns_ns = XMLName::from_parts(Some("xmlns"), namespace); + let xmlns_default = XmlName::from_parts(None, "xmlns"); + let xmlns_ns = XmlName::from_parts(Some("xmlns"), namespace); if namespace.is_empty() { if let Some(url) = self.attribute_value(&xmlns_default) { @@ -1135,9 +1135,9 @@ impl<'gc> XMLNode<'gc> { /// `within_namespace`. If it is set to `None`, then any namespace's /// attributes may satisfy the search. It is it set to `""`, then /// the default namespace will be searched. - pub fn value_attribute(self, value: &str, within_namespace: Option<&str>) -> Option { + pub fn value_attribute(self, value: &str, within_namespace: Option<&str>) -> Option { match &*self.0.read() { - XMLNodeData::Element { attributes, .. } => { + XmlNodeData::Element { attributes, .. } => { for (attr, attr_value) in attributes.iter() { if let Some(namespace) = within_namespace { if attr.prefix().unwrap_or("") == namespace && value == attr_value { @@ -1179,7 +1179,7 @@ impl<'gc> XMLNode<'gc> { /// that yield `true` shall be printed. pub fn into_string(self, filter: &mut F) -> Result where - F: FnMut(XMLNode<'gc>) -> bool, + F: FnMut(XmlNode<'gc>) -> bool, { let mut buf = Vec::new(); let mut writer = Writer::new(Cursor::new(&mut buf)); @@ -1201,7 +1201,7 @@ impl<'gc> XMLNode<'gc> { ) -> Result<(), Error> where W: Write, - F: FnMut(XMLNode<'gc>) -> bool, + F: FnMut(XmlNode<'gc>) -> bool, { let mut children = Vec::new(); if let Some(my_children) = self.children() { @@ -1215,8 +1215,8 @@ impl<'gc> XMLNode<'gc> { let children_len = children.len(); match &*self.0.read() { - XMLNodeData::DocumentRoot { .. } => Ok(()), - XMLNodeData::Element { + XmlNodeData::DocumentRoot { .. } => Ok(()), + XmlNodeData::Element { tag_name, attributes, .. @@ -1246,13 +1246,13 @@ impl<'gc> XMLNode<'gc> { writer.write_event(&Event::Empty(bs)) } } - XMLNodeData::Text { contents, .. } => { + XmlNodeData::Text { contents, .. } => { writer.write_event(&Event::Text(BytesText::from_plain_str(contents.as_str()))) } - XMLNodeData::Comment { contents, .. } => writer.write_event(&Event::Comment( + XmlNodeData::Comment { contents, .. } => writer.write_event(&Event::Comment( BytesText::from_plain_str(contents.as_str()), )), - XMLNodeData::DocType { contents, .. } => writer.write_event(&Event::DocType( + XmlNodeData::DocType { contents, .. } => writer.write_event(&Event::DocType( BytesText::from_plain_str(contents.as_str()), )), }?; @@ -1262,8 +1262,8 @@ impl<'gc> XMLNode<'gc> { } match &*self.0.read() { - XMLNodeData::DocumentRoot { .. } => Ok(()), - XMLNodeData::Element { tag_name, .. } => { + XmlNodeData::DocumentRoot { .. } => Ok(()), + XmlNodeData::Element { tag_name, .. } => { if children_len > 0 { let bs = match tag_name.node_name() { Cow::Borrowed(name) => BytesEnd::borrowed(name.as_bytes()), @@ -1274,24 +1274,24 @@ impl<'gc> XMLNode<'gc> { Ok(()) } } - XMLNodeData::Text { .. } => Ok(()), - XMLNodeData::Comment { .. } => Ok(()), - XMLNodeData::DocType { .. } => Ok(()), + XmlNodeData::Text { .. } => Ok(()), + XmlNodeData::Comment { .. } => Ok(()), + XmlNodeData::DocType { .. } => Ok(()), }?; Ok(()) } } -impl<'gc> fmt::Debug for XMLNode<'gc> { +impl<'gc> fmt::Debug for XmlNode<'gc> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match &*self.0.read() { - XMLNodeData::DocumentRoot { + XmlNodeData::DocumentRoot { script_object, children, .. } => f - .debug_struct("XMLNodeData::DocumentRoot") + .debug_struct("XmlNodeData::DocumentRoot") .field("0", &self.0.as_ptr()) .field( "script_object", @@ -1302,7 +1302,7 @@ impl<'gc> fmt::Debug for XMLNode<'gc> { .field("document", &"".to_string()) .field("children", children) .finish(), - XMLNodeData::Element { + XmlNodeData::Element { script_object, tag_name, attributes, @@ -1310,7 +1310,7 @@ impl<'gc> fmt::Debug for XMLNode<'gc> { parent, .. } => f - .debug_struct("XMLNodeData::Element") + .debug_struct("XmlNodeData::Element") .field("0", &self.0.as_ptr()) .field( "script_object", @@ -1329,13 +1329,13 @@ impl<'gc> fmt::Debug for XMLNode<'gc> { .field("attributes", attributes) .field("children", children) .finish(), - XMLNodeData::Text { + XmlNodeData::Text { script_object, contents, parent, .. } => f - .debug_struct("XMLNodeData::Text") + .debug_struct("XmlNodeData::Text") .field("0", &self.0.as_ptr()) .field( "script_object", @@ -1352,13 +1352,13 @@ impl<'gc> fmt::Debug for XMLNode<'gc> { ) .field("contents", contents) .finish(), - XMLNodeData::Comment { + XmlNodeData::Comment { script_object, contents, parent, .. } => f - .debug_struct("XMLNodeData::Comment") + .debug_struct("XmlNodeData::Comment") .field("0", &self.0.as_ptr()) .field( "script_object", @@ -1375,13 +1375,13 @@ impl<'gc> fmt::Debug for XMLNode<'gc> { ) .field("contents", contents) .finish(), - XMLNodeData::DocType { + XmlNodeData::DocType { script_object, contents, parent, .. } => f - .debug_struct("XMLNodeData::DocType") + .debug_struct("XmlNodeData::DocType") .field("0", &self.0.as_ptr()) .field( "script_object", diff --git a/desktop/src/audio.rs b/desktop/src/audio.rs index a52d628b1..c717bb129 100644 --- a/desktop/src/audio.rs +++ b/desktop/src/audio.rs @@ -324,7 +324,7 @@ impl AudioBackend for CpalAudioBackend { u16::from(swf_sound.data[0]) | (u16::from(swf_sound.data[1]) << 8); (skip_sample_frames, &swf_sound.data[2..]) } else { - (0, &swf_sound.data[..]) + (0, swf_sound.data) }; let sound = Sound { diff --git a/desktop/src/navigator.rs b/desktop/src/navigator.rs index 3de02eaf5..d5b3acfed 100644 --- a/desktop/src/navigator.rs +++ b/desktop/src/navigator.rs @@ -134,8 +134,8 @@ impl NavigatorBackend for ExternalNavigatorBackend { let client = client.ok_or(Error::NetworkUnavailable)?; let request = match options.method() { - NavigationMethod::GET => Request::get(processed_url.to_string()), - NavigationMethod::POST => Request::post(processed_url.to_string()), + NavigationMethod::Get => Request::get(processed_url.to_string()), + NavigationMethod::Post => Request::post(processed_url.to_string()), }; let (body_data, _) = options.body().clone().unwrap_or_default(); diff --git a/render/canvas/src/lib.rs b/render/canvas/src/lib.rs index 7520c6317..d5ed0c2f4 100644 --- a/render/canvas/src/lib.rs +++ b/render/canvas/src/lib.rs @@ -873,13 +873,13 @@ fn swf_shape_to_svg( GradientSpread::Reflect => svg_gradient.set("spreadMethod", "reflect"), GradientSpread::Repeat => svg_gradient.set("spreadMethod", "repeat"), }; - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { has_linear_rgb_gradient = true; svg_path = svg_path.set("filter", "url('#_linearrgb')"); } for record in &gradient.records { let color = - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { srgb_to_linear(record.color.clone()) } else { record.color.clone() @@ -935,13 +935,13 @@ fn swf_shape_to_svg( GradientSpread::Reflect => svg_gradient.set("spreadMethod", "reflect"), GradientSpread::Repeat => svg_gradient.set("spreadMethod", "repeat"), }; - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { has_linear_rgb_gradient = true; svg_path = svg_path.set("filter", "url('#_linearrgb')"); } for record in &gradient.records { let color = - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { srgb_to_linear(record.color.clone()) } else { record.color.clone() @@ -1001,13 +1001,13 @@ fn swf_shape_to_svg( GradientSpread::Reflect => svg_gradient.set("spreadMethod", "reflect"), GradientSpread::Repeat => svg_gradient.set("spreadMethod", "repeat"), }; - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { has_linear_rgb_gradient = true; svg_path = svg_path.set("filter", "url('#_linearrgb')"); } for record in &gradient.records { let color = - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { srgb_to_linear(record.color.clone()) } else { record.color.clone() diff --git a/render/webgl/src/lib.rs b/render/webgl/src/lib.rs index c91f86f98..ccb0ad803 100644 --- a/render/webgl/src/lib.rs +++ b/render/webgl/src/lib.rs @@ -532,7 +532,7 @@ impl WebGlRenderBackend { ratios[..num_colors].copy_from_slice(&gradient.ratios[..num_colors]); colors[..num_colors].copy_from_slice(&gradient.colors[..num_colors]); // Convert to linear color space if this is a linear-interpolated gradient. - if gradient.interpolation == swf::GradientInterpolation::LinearRGB { + if gradient.interpolation == swf::GradientInterpolation::LinearRgb { for color in &mut colors[..num_colors] { *color = srgb_to_linear(*color); } @@ -1177,7 +1177,7 @@ impl RenderBackend for WebGlRenderBackend { program.uniform1i( &self.gl, ShaderUniform::GradientInterpolation, - (gradient.interpolation == swf::GradientInterpolation::LinearRGB) as i32, + (gradient.interpolation == swf::GradientInterpolation::LinearRgb) as i32, ); } DrawType::Bitmap(bitmap) => { diff --git a/render/wgpu/src/lib.rs b/render/wgpu/src/lib.rs index 57a259f73..e55db3116 100644 --- a/render/wgpu/src/lib.rs +++ b/render/wgpu/src/lib.rs @@ -175,13 +175,13 @@ unsafe impl Zeroable for ColorAdjustments {} #[repr(C)] #[derive(Copy, Clone, Debug)] -struct GPUVertex { +struct GpuVertex { position: [f32; 2], color: [f32; 4], } -unsafe impl Pod for GPUVertex {} -unsafe impl Zeroable for GPUVertex {} +unsafe impl Pod for GpuVertex {} +unsafe impl Zeroable for GpuVertex {} impl WgpuRenderBackend { pub fn for_window( @@ -349,7 +349,7 @@ impl WgpuRenderBackend { shape_id: CharacterId, draw: IncompleteDrawType, draws: &mut Vec, - lyon_mesh: &mut VertexBuffers, + lyon_mesh: &mut VertexBuffers, device: &wgpu::Device, pipelines: &Pipelines, ) { @@ -1328,19 +1328,19 @@ impl RenderBackend for WgpuRenderBackend { fn create_quad_buffers(device: &wgpu::Device) -> (wgpu::Buffer, wgpu::Buffer, wgpu::Buffer) { let vertices = [ - GPUVertex { + GpuVertex { position: [0.0, 0.0], color: [1.0, 1.0, 1.0, 1.0], }, - GPUVertex { + GpuVertex { position: [1.0, 0.0], color: [1.0, 1.0, 1.0, 1.0], }, - GPUVertex { + GpuVertex { position: [1.0, 1.0], color: [1.0, 1.0, 1.0, 1.0], }, - GPUVertex { + GpuVertex { position: [0.0, 1.0], color: [1.0, 1.0, 1.0, 1.0], }, @@ -1401,7 +1401,7 @@ fn swf_gradient_to_uniforms( } // Convert colors from sRGB to linear space if necessary. - if gradient.interpolation == GradientInterpolation::LinearRGB { + if gradient.interpolation == GradientInterpolation::LinearRgb { for color in &mut colors[0..gradient.records.len()] { *color = srgb_to_linear(*color); } @@ -1411,7 +1411,7 @@ fn swf_gradient_to_uniforms( gradient_type, ratios, colors, - interpolation: (gradient.interpolation == GradientInterpolation::LinearRGB) as i32, + interpolation: (gradient.interpolation == GradientInterpolation::LinearRgb) as i32, num_colors: gradient.records.len() as u32, repeat_mode: gradient_spread_mode_index(gradient.spread), focal_point, @@ -1430,18 +1430,18 @@ struct RuffleVertexCtor { color: [f32; 4], } -impl FillVertexConstructor for RuffleVertexCtor { - fn new_vertex(&mut self, vertex: FillVertex) -> GPUVertex { - GPUVertex { +impl FillVertexConstructor for RuffleVertexCtor { + fn new_vertex(&mut self, vertex: FillVertex) -> GpuVertex { + GpuVertex { position: [vertex.position().x, vertex.position().y], color: self.color, } } } -impl StrokeVertexConstructor for RuffleVertexCtor { - fn new_vertex(&mut self, vertex: StrokeVertex) -> GPUVertex { - GPUVertex { +impl StrokeVertexConstructor for RuffleVertexCtor { + fn new_vertex(&mut self, vertex: StrokeVertex) -> GpuVertex { + GpuVertex { position: [vertex.position().x, vertex.position().y], color: self.color, } diff --git a/render/wgpu/src/pipelines.rs b/render/wgpu/src/pipelines.rs index d07386bf1..377b3ef5c 100644 --- a/render/wgpu/src/pipelines.rs +++ b/render/wgpu/src/pipelines.rs @@ -1,4 +1,4 @@ -use crate::{Error, GPUVertex, MaskState}; +use crate::{Error, GpuVertex, MaskState}; use enum_map::{enum_map, EnumMap}; use wgpu::vertex_attr_array; @@ -43,7 +43,7 @@ impl Pipelines { device.create_shader_module(&wgpu::include_spirv!("../shaders/bitmap.frag.spv")); let vertex_buffers_description = [wgpu::VertexBufferDescriptor { - stride: std::mem::size_of::() as u64, + stride: std::mem::size_of::() as u64, step_mode: wgpu::InputStepMode::Vertex, attributes: &vertex_attr_array![ 0 => Float2, diff --git a/swf/src/avm1/opcode.rs b/swf/src/avm1/opcode.rs index adbc7ca8e..1cfc84838 100644 --- a/swf/src/avm1/opcode.rs +++ b/swf/src/avm1/opcode.rs @@ -1,6 +1,4 @@ -#![allow(clippy::useless_attribute)] - -#[allow(dead_code)] +#[allow(dead_code, clippy::useless_attribute)] #[derive(Debug, PartialEq, Clone, Copy, FromPrimitive)] pub enum OpCode { End = 0x00, diff --git a/swf/src/lib.rs b/swf/src/lib.rs index 0fe0ec17e..802916e75 100644 --- a/swf/src/lib.rs +++ b/swf/src/lib.rs @@ -6,7 +6,12 @@ //! //! This library consists of a `read` module for decoding SWF data, and a `write` library for //! writing SWF data. -#![allow(clippy::unusual_byte_groupings)] +#![allow( + renamed_and_removed_lints, + clippy::unknown_clippy_lints, + clippy::unusual_byte_groupings, + clippy::upper_case_acronyms +)] extern crate byteorder; #[cfg(feature = "flate2")] diff --git a/swf/src/read.rs b/swf/src/read.rs index f5f0401f6..49c8902ad 100644 --- a/swf/src/read.rs +++ b/swf/src/read.rs @@ -1817,8 +1817,8 @@ impl<'a> Reader<'a> { _ => return Err(Error::invalid_data("Invalid gradient spread mode")), }; let interpolation = match flags & 0b11_0000 { - 0b00_0000 => GradientInterpolation::RGB, - 0b01_0000 => GradientInterpolation::LinearRGB, + 0b00_0000 => GradientInterpolation::Rgb, + 0b01_0000 => GradientInterpolation::LinearRgb, _ => return Err(Error::invalid_data("Invalid gradient interpolation mode")), }; let num_records = usize::from(flags & 0b1111); @@ -2625,8 +2625,8 @@ impl<'a> Reader<'a> { let codec = match self.read_u8()? { 2 => VideoCodec::H263, 3 => VideoCodec::ScreenVideo, - 4 => VideoCodec::VP6, - 5 => VideoCodec::VP6WithAlpha, + 4 => VideoCodec::Vp6, + 5 => VideoCodec::Vp6WithAlpha, 6 => VideoCodec::ScreenVideoV2, _ => return Err(Error::invalid_data("Invalid video codec.")), }; @@ -3063,8 +3063,8 @@ pub mod tests { assert_eq!(reader.read_string().unwrap(), ""); } { - let buf = "12🤖12\0".as_bytes(); - let mut reader = Reader::new(&buf[..], 1); + let buf = "12🤖12\0"; + let mut reader = Reader::new(buf.as_bytes(), 1); assert_eq!(reader.read_string().unwrap(), "12🤖12"); } } diff --git a/swf/src/test_data.rs b/swf/src/test_data.rs index f4f8a5158..038da9954 100644 --- a/swf/src/test_data.rs +++ b/swf/src/test_data.rs @@ -737,7 +737,7 @@ pub fn tag_tests() -> Vec { c: -0.024429321, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 0, @@ -840,7 +840,7 @@ pub fn tag_tests() -> Vec { c: 0.0, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 56, @@ -958,7 +958,7 @@ pub fn tag_tests() -> Vec { c: 0.0, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 0, @@ -1081,7 +1081,7 @@ pub fn tag_tests() -> Vec { c: -0.15675354, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 0, @@ -1217,7 +1217,7 @@ pub fn tag_tests() -> Vec { c: 0.0, }, spread: GradientSpread::Reflect, - interpolation: GradientInterpolation::LinearRGB, + interpolation: GradientInterpolation::LinearRgb, records: vec![ GradientRecord { ratio: 0, @@ -1305,7 +1305,7 @@ pub fn tag_tests() -> Vec { c: -0.084503174, }, spread: GradientSpread::Reflect, - interpolation: GradientInterpolation::LinearRGB, + interpolation: GradientInterpolation::LinearRgb, records: vec![ GradientRecord { ratio: 0, @@ -1514,7 +1514,7 @@ pub fn tag_tests() -> Vec { c: 0f32, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 0, @@ -1637,7 +1637,7 @@ pub fn tag_tests() -> Vec { c: 0f32, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::LinearRGB, + interpolation: GradientInterpolation::LinearRgb, records: vec![ GradientRecord { ratio: 0, @@ -1701,7 +1701,7 @@ pub fn tag_tests() -> Vec { c: 0f32, }, spread: GradientSpread::Pad, - interpolation: GradientInterpolation::RGB, + interpolation: GradientInterpolation::Rgb, records: vec![ GradientRecord { ratio: 0, diff --git a/swf/src/types.rs b/swf/src/types.rs index 5e290b52e..e6a7ba416 100644 --- a/swf/src/types.rs +++ b/swf/src/types.rs @@ -849,8 +849,8 @@ pub enum GradientSpread { #[derive(Debug, PartialEq, Clone, Copy)] pub enum GradientInterpolation { - RGB, - LinearRGB, + Rgb, + LinearRgb, } #[derive(Debug, PartialEq, Clone)] @@ -1227,8 +1227,8 @@ pub enum VideoDeblocking { pub enum VideoCodec { H263, ScreenVideo, - VP6, - VP6WithAlpha, + Vp6, + Vp6WithAlpha, ScreenVideoV2, } diff --git a/swf/src/write.rs b/swf/src/write.rs index 3078ec82d..037dc2145 100644 --- a/swf/src/write.rs +++ b/swf/src/write.rs @@ -1781,8 +1781,8 @@ impl Writer { }; flags |= match &gradient.interpolation { - GradientInterpolation::RGB => 0b00_0000, - GradientInterpolation::LinearRGB => 0b_01_0000, + GradientInterpolation::Rgb => 0b00_0000, + GradientInterpolation::LinearRgb => 0b_01_0000, }; flags |= (gradient.records.len() as u8) & 0b1111; @@ -2565,8 +2565,8 @@ impl Writer { self.write_u8(match video.codec { VideoCodec::H263 => 2, VideoCodec::ScreenVideo => 3, - VideoCodec::VP6 => 4, - VideoCodec::VP6WithAlpha => 5, + VideoCodec::Vp6 => 4, + VideoCodec::Vp6WithAlpha => 5, VideoCodec::ScreenVideoV2 => 6, })?; Ok(()) diff --git a/web/src/audio.rs b/web/src/audio.rs index 308eaf31a..72e8efb77 100644 --- a/web/src/audio.rs +++ b/web/src/audio.rs @@ -803,7 +803,7 @@ impl AudioBackend for WebAudioBackend { let skip_sample_frames = u16::from(sound.data[0]) | (u16::from(sound.data[1]) << 8); (skip_sample_frames, &sound.data[2..]) } else { - (0, &sound.data[..]) + (0, sound.data) }; let sound = Sound { diff --git a/web/src/navigator.rs b/web/src/navigator.rs index f896bad53..2ae703205 100644 --- a/web/src/navigator.rs +++ b/web/src/navigator.rs @@ -111,8 +111,8 @@ impl NavigatorBackend for WebNavigatorBackend { let _ = form.set_attribute( "method", match navmethod { - NavigationMethod::GET => "get", - NavigationMethod::POST => "post", + NavigationMethod::Get => "get", + NavigationMethod::Post => "post", }, ); @@ -165,8 +165,8 @@ impl NavigatorBackend for WebNavigatorBackend { let mut init = RequestInit::new(); init.method(match options.method() { - NavigationMethod::GET => "GET", - NavigationMethod::POST => "POST", + NavigationMethod::Get => "GET", + NavigationMethod::Post => "POST", }); if let Some((data, mime)) = options.body() {