Sync up w3c import script with changes in Blink
[WebKit-https.git] / Tools / Scripts / webkitpy / w3c / test_converter.py
1 #!/usr/bin/env python
2
3 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
4 #
5 # Redistribution and use in source and binary forms, with or without
6 # modification, are permitted provided that the following conditions
7 # are met:
8 #
9 # 1. Redistributions of source code must retain the above
10 #    copyright notice, this list of conditions and the following
11 #    disclaimer.
12 # 2. Redistributions in binary form must reproduce the above
13 #    copyright notice, this list of conditions and the following
14 #    disclaimer in the documentation and/or other materials
15 #    provided with the distribution.
16 #
17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
18 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
21 # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
22 # OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
27 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 # SUCH DAMAGE.
29
30 import logging
31 import re
32
33 from webkitpy.common.host import Host
34 from webkitpy.common.webkit_finder import WebKitFinder
35 from webkitpy.thirdparty.BeautifulSoup import BeautifulSoup, Tag
36
37
38 _log = logging.getLogger(__name__)
39
40
41 class W3CTestConverter(object):
42
43     def __init__(self):
44         self._host = Host()
45         self._filesystem = self._host.filesystem
46         self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
47
48         # These settings might vary between WebKit and Blink
49         self._css_property_file = self.path_from_webkit_root('Source', 'WebCore', 'css', 'CSSPropertyNames.in')
50         self._css_property_split_string = '='
51
52         self.prefixed_properties = self.read_webkit_prefixed_css_property_list()
53
54     def path_from_webkit_root(self, *comps):
55         return self._filesystem.abspath(self._filesystem.join(self._webkit_root, *comps))
56
57     def read_webkit_prefixed_css_property_list(self):
58         prefixed_properties = []
59
60         contents = self._filesystem.read_text_file(self._css_property_file)
61         for line in contents.splitlines():
62             # Find lines starting with the -webkit- prefix.
63             match = re.match('-webkit-[\w|-]*', line)
64             if match:
65                 # Ignore lines where both the prefixed and non-prefixed property
66                 # are supported - denoted by -webkit-some-property = some-property.
67                 fields = line.split(self._css_property_split_string)
68                 if len(fields) == 2 and fields[1].strip() in fields[0].strip():
69                     continue
70                 prefixed_properties.append(match.group(0))
71
72         return prefixed_properties
73
74     def convert_for_webkit(self, new_path, filename):
75         """ Converts a file's |contents| so it will function correctly in its |new_path| in Webkit.
76
77         Returns the list of modified properties and the modified text if the file was modifed, None otherwise."""
78         contents = self._filesystem.read_binary_file(filename)
79         if filename.endswith('.css'):
80             return self.convert_css(contents, filename)
81         return self.convert_html(new_path, contents, filename)
82
83     def convert_css(self, contents, filename):
84         return self.add_webkit_prefix_to_unprefixed_properties(contents, filename)
85
86     def convert_html(self, new_path, contents, filename):
87         doc = BeautifulSoup(contents)
88         did_modify_paths = self.convert_testharness_paths(doc, new_path, filename)
89         converted_properties_and_content = self.convert_prefixed_properties(doc, filename)
90         return converted_properties_and_content if (did_modify_paths or converted_properties_and_content[0]) else None
91
92     def convert_testharness_paths(self, doc, new_path, filename):
93         """ Update links to testharness.js in the BeautifulSoup |doc| to point to the copy in |new_path|.
94
95         Returns whether the document was modified."""
96
97         # Look for the W3C-style path to any testharness files - scripts (.js) or links (.css)
98         pattern = re.compile('/resources/testharness')
99         script_tags = doc.findAll(src=pattern)
100         link_tags = doc.findAll(href=pattern)
101         testharness_tags = script_tags + link_tags
102
103         if not testharness_tags:
104             return False
105
106         resources_path = self.path_from_webkit_root('LayoutTests', 'resources')
107         resources_relpath = self._filesystem.relpath(resources_path, new_path)
108
109         for tag in testharness_tags:
110             # FIXME: We need to handle img, audio, video tags also.
111             attr = 'src'
112             if tag.name != 'script':
113                 attr = 'href'
114
115             if not attr in tag.attrMap:
116                 # FIXME: Figure out what to do w/ invalid tags. For now, we return False
117                 # and leave the document unmodified, which means that it'll probably fail to run.
118                 _log.error("Missing an attr in %s" % filename)
119                 return False
120
121             old_path = tag[attr]
122             new_tag = Tag(doc, tag.name, tag.attrs)
123             new_tag[attr] = re.sub(pattern, resources_relpath + '/testharness', old_path)
124
125             self.replace_tag(tag, new_tag)
126
127         return True
128
129     def convert_prefixed_properties(self, doc, filename):
130         """ Searches a BeautifulSoup |doc| for any CSS properties requiring the -webkit- prefix and converts them.
131
132         Returns the list of converted properties and the modified document as a string """
133
134         converted_properties = []
135
136         # Look for inline and document styles.
137         inline_styles = doc.findAll(style=re.compile('.*'))
138         style_tags = doc.findAll('style')
139         all_styles = inline_styles + style_tags
140
141         for tag in all_styles:
142
143             # Get the text whether in a style tag or style attribute.
144             style_text = ''
145             if tag.name == 'style':
146                 if not tag.contents:
147                     continue
148                 style_text = tag.contents[0]
149             else:
150                 style_text = tag['style']
151
152             updated_style_text = self.add_webkit_prefix_to_unprefixed_properties(style_text, filename)
153
154             # Rewrite tag only if changes were made.
155             if updated_style_text[0]:
156                 converted_properties.extend(updated_style_text[0])
157
158                 new_tag = Tag(doc, tag.name, tag.attrs)
159                 new_tag.insert(0, updated_style_text[1])
160
161                 self.replace_tag(tag, new_tag)
162
163         return (converted_properties, doc.prettify())
164
165     def add_webkit_prefix_to_unprefixed_properties(self, text, filename):
166         """ Searches |text| for instances of properties requiring the -webkit- prefix and adds the prefix to them.
167
168         Returns the list of converted properties and the modified text."""
169
170         converted_properties = []
171
172         for prefixed_property in self.prefixed_properties:
173             # FIXME: add in both the prefixed and unprefixed versions, rather than just replacing them?
174             # That might allow the imported test to work in other browsers more easily.
175
176             unprefixed_property = prefixed_property.replace('-webkit-', '')
177
178             # Look for the various ways it might be in the CSS
179             # Match the the property preceded by either whitespace or left curly brace
180             # or at the beginning of the string (for inline style attribute)
181             pattern = '([\s{]|^)' + unprefixed_property + '(\s+:|:)'
182             if re.search(pattern, text):
183                 _log.info('converting %s -> %s' % (unprefixed_property, prefixed_property))
184                 converted_properties.append(prefixed_property)
185                 text = re.sub(pattern, prefixed_property + ':', text)
186
187         # FIXME: Handle the JS versions of these properties and GetComputedStyle, too.
188         return (converted_properties, text)
189
190     def replace_tag(self, old_tag, new_tag):
191         index = old_tag.parent.contents.index(old_tag)
192         old_tag.parent.insert(index, new_tag)
193         old_tag.extract()