pax_global_header 0000666 0000000 0000000 00000000064 12705153350 0014513 g ustar 00root root 0000000 0000000 52 comment=93e54d41ef7b2d1441f81b01822cbabac11fb84c
buildtools-master/ 0000775 0000000 0000000 00000000000 12705153350 0014530 5 ustar 00root root 0000000 0000000 buildtools-master/.gitignore 0000664 0000000 0000000 00000000013 12705153350 0016512 0 ustar 00root root 0000000 0000000 *.pyc
*.pyo buildtools-master/.hgignore 0000664 0000000 0000000 00000000032 12705153350 0016326 0 ustar 00root root 0000000 0000000 syntax: glob
*.pyc
*.pyo
buildtools-master/.hgtags 0000664 0000000 0000000 00000015370 12705153350 0016014 0 ustar 00root root 0000000 0000000 05e77b813c46dedfe5445d7f8ea94bb632f05a37 ADBLOCK_PLUS_1_1_1_RELEASE
05e77b813c46dedfe5445d7f8ea94bb632f05a37 ADBLOCK_PLUS_1_1_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ABP_WATCHER_1_0_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_2_4_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_5_1_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_5_2_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_5_3_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_5_4_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ADBLOCK_PLUS_0_7_5_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_1_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_2_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_3_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_4_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_5_RELEASE
1d21bae42fef29c2e7c37a49dafef42b69940ec5 ELEMENT_HIDING_HELPER_1_0_RELEASE
444b33dcb6109e01027aa1210d6de8bc2c014adb ABP_WATCHER_1_1_RELEASE
444b33dcb6109e01027aa1210d6de8bc2c014adb ADBLOCK_PLUS_1_0_RELEASE
691e89575c4980ecc2a3846f98f199edfef3be93 ELEMENT_HIDING_HELPER_1_0_6_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 ABP_WATCHER_1_1_1_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 ABP_WATCHER_1_1_2_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 ADBLOCK_PLUS_1_0_1_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 ADBLOCK_PLUS_1_0_2_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_0_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_5_1_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_5_2_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_5_3_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_5_4_RELEASE
a0a32c0d2b78aedd03d96dee00dcae8f3f4e9193 JAVASCRIPT_DEOBFUSCATOR_1_5_RELEASE
ac857138170b83ed248f4fc13d78dd94d5e9b2a0 ADBLOCK_PLUS_1_1_2_RELEASE
7c2f01c8c700cd7aa4a571a5399de57b2f317155 ADBLOCK_PLUS_1_1_3_RELEASE
b125b50e173bf62dfb4c72d035492f7b2ef04e63 JAVASCRIPT_DEOBFUSCATOR_1_5_5_RELEASE
d7cbf93407f0807a1061cfa858be738cf470df0e ADBLOCK_PLUS_1_2_RELEASE
d7cbf93407f0807a1061cfa858be738cf470df0e ADBLOCK_PLUS_1_2_1_RELEASE
aa418d95c8c0ea6faa7a1386c439c051f810a5e7 ADBLOCK_PLUS_1_3_RELEASE
538ae6dd1e643c75f20e18905aebacde8b4ebb35 ELEMENT_HIDING_HELPER_1_1_RELEASE
ac268e1f37085134fe51f73c9562755374097a37 ABP_WATCHER_1_1_3_RELEASE
a0cd6bdefd90e5eb398b13f993159a5f257d2dee ADBLOCK_PLUS_1_3_1_RELEASE
391c1232dee0a30749a975d7c59c3729ac19edd5 ADBLOCK_PLUS_1_3_2_RELEASE
b2a8bd2dc96361c7d1885cc2c4fedeb80050feab ADBLOCK_PLUS_1_3_3_RELEASE
07d055535689b2ab46e0518ce0e58b081f8415aa JAVASCRIPT_DEOBFUSCATOR_1_5_6_RELEASE
644052ef2f2411891c8868f5c982db825e6184f6 ABP_WATCHER_1_1_4_RELEASE
434ee0e009d445adbab170c398b23a518d379c7d ELEMENT_HIDING_HELPER_1_1_1_RELEASE
0edf30418dc2cfbd0cb71b1aadf8e7aa00b92eba ADBLOCK_PLUS_1_3_5_RELEASE
c0a0d743040c26c1b37f2fbfc3e19d10dab1789d ADBLOCK_PLUS_KMELEON_1_3_5_RELEASE
59b0e20dc59dd2c0f28cb3ca5fd9c572e0bec11d ADBLOCK_PLUS_1_3_6_RELEASE
1422054e2011dcbb94421458408af673794be67d ADBLOCK_PLUS_KMELEON_1_3_6_RELEASE
8970fc469a4410b257e298f5bddfc69187f8fc24 ADBLOCK_PLUS_1_3_7_RELEASE
7cc148eef51f2b35165f84c567ca047f043940df ADBLOCK_PLUS_KMELEON_1_3_7_RELEASE
e2c5bf9a8dc8f03e9f49dda791185bed0addecc3 JAVASCRIPT_DEOBFUSCATOR_1_5_7_RELEASE
76c46b4ee2fd47eafdedd5634df06817ee626b2b ADBLOCK_PLUS_1_3_8_RELEASE
a8e03cd6aef95a4b3db34eca2e4f42fe2f015b00 ADBLOCK_PLUS_KMELEON_1_3_8_RELEASE
ead047a6b186518121ee456814d2b3f6af9d6740 ABP_WATCHER_1_1_5_RELEASE
a0ba2a9a53af62f151e0cbafa9126e02bb94c7cf ADBLOCK_PLUS_1_3_9_RELEASE
ce37cb990a89e147b1ad9e0a39bd8f9e8e619684 ADBLOCK_PLUS_KMELEON_1_3_9_RELEASE
b4b4323c3501250bf4e4375e7473ba2a42ba9906 ELEMENT_HIDING_HELPER_1_1_2_RELEASE
37fe814b65b584b88d3c02d374b92e9da1668701 ABP_WATCHER_1_1_6_RELEASE
9c29efb989ece0347a500a3f480876fec69ad357 ADBLOCK_PLUS_1_3_10_RELEASE
630eb6bf75e81ba4d77f2fdd0d478b5c9d48b3bb ADBLOCK_PLUS_KMELEON_1_3_10_RELEASE
a5a4f30fdf3e395d735c154203018f007086d38e JAVASCRIPT_DEOBFUSCATOR_1_5_8_RELEASE
d7cd0262d92a2d3f6fe68f1de47f0aab58853a25 ABP_WATCHER_1_1_7_RELEASE
ecb9569793eed88b408f46db4ccdf5bae89642d8 ELEMENT_HIDING_HELPER_1_1_3_RELEASE
38b8085634bf2185c7549c65d9d64ab0041ea6cd ELEMENT_HIDING_HELPER_1_1_4_RELEASE
88b62e5ba449980c83013aae2d6221ceb7e2837d ADBLOCK_PLUS_2_0_RELEASE
62cea42809d0354d8df066a7bfd45a91ef7fe4a5 ADBLOCK_PLUS_2_0_1_RELEASE
b630b6747a2d00431014a791b486ae3dfbcf3ef5 ADBLOCK_PLUS_2_0_2_RELEASE
05edfbc5c813afd70de99a9bf815d43fea311402 CUSTOMIZATION_1_0_RELEASE
1eccc3112297fb94d848f00b5bb2c209dabf1c1f ADBLOCK_PLUS_2_0_3_RELEASE
14532d60afb8210a98e9f9a3f47cfba266ad8ed3 JAVASCRIPT_DEOBFUSCATOR_1_6_RELEASE
08a46fb193f0aa68c1bb1bd927b2c6e6657ef2fc ABP_WATCHER_1_2_RELEASE
56dd755a721e2890c08dad63ba81ebf5df513e3a JAVASCRIPT_DEOBFUSCATOR_1_6_1_RELEASE
c5958a6c1cb08efeacad9d14f65827809e1a375a AUTOINSTALLER_1_0_RELEASE
1b532e3599fff6a145f757f674739b2214997d4d AUTOINSTALLER_1_1_RELEASE
14c6fdcdc149e1f25b817eee00442c263d0fde6a GOOGLE_SEARCH_LINK_FIX_1_3_RELEASE
bb77812431d21ea803fe35143021f59e903c3052 ELEMENT_HIDING_HELPER_1_2_RELEASE
03505f53d52de381abca885d705c5212a6d54d4c GOOGLE_SEARCH_LINK_FIX_1_3_1_RELEASE
10cb63148b5ce503adf91a13a567b5c384fb36a7 GOOGLE_SEARCH_LINK_FIX_1_3_2_RELEASE
cf5b9b6fd27ddd41599b7bee81a54fc5a4ce0bb2 ELEMENT_HIDING_HELPER_1_2_1_RELEASE
b3c05e8115c9ff5a7a17febf0cc0fc617fb84624 ABP_WATCHER_1_2_1_RELEASE
466eb41ee62393b736174aad8e27cf956fec7dce JAVASCRIPT_DEOBFUSCATOR_1_6_2_RELEASE
15962ef33d5e526aa9c8ad26a57607705d9988c2 JAVASCRIPT_DEOBFUSCATOR_1_6_3_RELEASE
20f1f1e841a8b1f63d960f91c3f3c901d7e84c3f REMOVE_TEMPORARILY_1_0_RELEASE
20f1f1e841a8b1f63d960f91c3f3c901d7e84c3f GOOGLE_SEARCH_LINK_FIX_1_4_RELEASE
29c8204a0fa4207c0d5cf3fdb0b761c20d7f64f9 ELEMENT_HIDING_HELPER_1_2_2_RELEASE
21212f67d6a3817aeee3f445c610d0da4da6fb66 SUSPENDBACKGROUNDTABS_1_0_RELEASE
fd96a114740e24caf8bb9e0f785bf987d2f46e58 SUSPENDBACKGROUNDTABS_1_0_1_RELEASE
56c7be4a579cc478e88025579d377601dd099e26 AUTOINSTALLER_1_2_RELEASE
af6348c2d9adeb12d71d2014379274da1809d347 REMOVE_TEMPORARILY_1_0_1_RELEASE
0b0cdb9acb6ebe8cdc644462be11edd00fc8f68b ABP_WATCHER_1_2_2_RELEASE
8c5debfdd7c6c9cdf8aaea0bca23dc6d0ed153c0 ELEMENT_HIDING_HELPER_1_2_3_RELEASE
05c2d3577c29c80e37791111be0b2c99683e1eba ADBLOCK_PLUS_2_1_RELEASE
6a3359885ac46a5226ae503e41619433c4a9078e CUSTOMIZATION_1_0_1_RELEASE
26e006a867080de4dbb7466af112cf58b3e674a9 ADBLOCK_PLUS_2_1_1_RELEASE
18328ad4a8be688d8797cc15356bdb957b428355 ADBLOCK_PLUS_2_1_2_RELEASE
1b984d62d804131f6f19f0c597b3c92041ed88ea CUSTOMIZATION_1_0_2_RELEASE
ca55b056ec5b4adc90d080ee110b0bd3c9fe2162 CUSTOMIZATION_1_0_3_RELEASE
9a398ff2ec6e1e562f1773acfb4b7cb588c8f697 ABP_WATCHER_1_2_3_RELEASE
buildtools-master/Info.plist.tmpl 0000664 0000000 0000000 00000010350 12705153350 0017452 0 ustar 00root root 0000000 0000000 {%- macro str_or_real(value) -%}
{%- if value is number -%}
{{ value }}
{%- else -%}
{{ value }}
{%- endif -%}
{%- endmacro -%}
CFBundleDisplayName{{ name }}CFBundleIdentifierorg.adblockplus.{{ basename }}CFBundleInfoDictionaryVersion6.0CFBundleShortVersionString{{ version }}CFBundleVersion{{ version }}
{%- if developerIdentifier %}
DeveloperIdentifier{{ developerIdentifier }}
{%- endif %}
ChromeDatabase Quota104857600Global Pagebackground.html
{%- if menus %}
Menus
{%- for identifier, items in menus.iteritems() %}
Identifier{{ identifier }}Menu Items
{%- for identifier, props in items.iteritems() %}
Identifier{{ identifier }}
{%- for key, value in props.iteritems() %}
{{ key }}
{{ str_or_real(value) }}
{%- endfor %}
{%- endfor %}
{%- endfor %}
{%- endif %}
{%- if popovers %}
Popovers
{%- for identifier, props in popovers.iteritems() %}
Identifier{{ identifier }}
{%- for key, value in props.iteritems() %}
{{ key }}
{{ str_or_real(value) }}
{%- endfor %}
{%- endfor %}
{%- endif %}
{%- if toolbarItems %}
Toolbar Items
{%- for identifier, props in toolbarItems.iteritems() %}
Identifier{{ identifier }}Label{{ name }}
{%- for key, value in props.iteritems() %}
{{ key }}
{{ str_or_real(value) }}
{%- endfor %}
{%- endfor %}
{%- endif %}
{%- if startScripts or endScripts %}
ContentScripts
{%- if startScripts %}
Start
{%- for script in startScripts %}
{{ script }}
{%- endfor %}
{%- endif %}
{%- if endScripts %}
End
{%- for script in endScripts %}
{{ script }}
{%- endfor %}
{%- endif %}
{%- endif %}
ExtensionInfoDictionaryVersion1.0PermissionsWebsite Access
{%- if allowedDomains and not allowAllDomains %}
Allowed Domains
{%- for domain in allowedDomains %}
{{ domain }}
{%- endfor %}
{%- endif %}
Include Secure Pages
{%- if allowSecurePages %}
{%- else %}
{%- endif %}
Level
{%- if allowAllDomains %}
All
{%- elif allowedDomains %}
Some
{%- else %}
None
{%- endif %}
Description{{ description }}
{%- if author %}
Author{{ author }}
{%- endif %}
{%- if homepage %}
Website{{ homepage }}
{%- endif %}
{%- if not releaseBuild or updateURL %}
Update Manifest URL
{%- if not releaseBuild -%}
https://adblockplus.org/devbuilds/{{ basename }}/updates.plist
{%- else -%}
{{ updateURL }}
{%- endif -%}
{%- endif %}
buildtools-master/LocaleTester.pm 0000664 0000000 0000000 00000020531 12705153350 0017455 0 ustar 00root root 0000000 0000000 # This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
package LocaleTester;
use strict;
use warnings;
my %keepAccessKeys = map {$_ => $_} (
'ja-JP',
'ja',
'ko-KR',
'ko',
'zh-CN',
'zh-TW',
);
my @placeholders = (
'?1?',
'?2?',
'?3?',
'?4?',
'?5?',
'?6?',
'?7?',
'?8?',
'?9?',
'--',
'%S',
'[link]',
'[/link]',
);
sub testLocales
{
my %params = @_;
die "Need at least one locale path to work on" unless exists($params{paths}) && %{$params{paths}};
$params{mustDiffer} = [] unless exists($params{mustDiffer});
$params{mustEqual} = [] unless exists($params{mustEqual});
$params{ignoreUntranslated} = [] unless exists($params{ignoreUntranslated});
$params{lengthRestrictions} = {} unless exists($params{lengthRestrictions});
my @locales = sort {$a cmp $b} (exists($params{locales}) && @{$params{locales}} ? @{$params{locales}} : makeLocaleList($params{paths}));
my $referenceLocale = readLocaleFiles($params{paths}, "en-US");
foreach my $locale (@locales)
{
my $currentLocale = $locale eq "en-US" ? $referenceLocale : readLocaleFiles($params{paths}, $locale);
compareLocales($locale, $currentLocale, $referenceLocale) unless $currentLocale == $referenceLocale;
foreach my $entry (@{$params{mustDiffer}})
{
my %values = ();
foreach my $key (@$entry)
{
my ($dir, $file, $name) = split(/:/, $key);
next unless exists($currentLocale->{"$dir:$file"}) && exists($currentLocale->{"$dir:$file"}{$name}) && $currentLocale->{"$dir:$file"}{$name} =~ /\S/;
my $value = lc($currentLocale->{"$dir:$file"}{$name});
print "$locale: Values for '$values{$value}' and '$key' are identical, must differ\n" if exists $values{$value};
$values{$value} = $key;
}
}
foreach my $entry (@{$params{mustEqual}})
{
my $stdValue;
my $stdName;
foreach my $key (@$entry)
{
my ($dir, $file, $name) = split(/:/, $key);
next unless exists($currentLocale->{"$dir:$file"}) && exists($currentLocale->{"$dir:$file"}{$name});
my $value = lc($currentLocale->{"$dir:$file"}{$name});
$stdValue = $value unless defined $stdValue;
$stdName = $key unless defined $stdName;
print "$locale: Values for '$stdName' and '$key' differ, must be equal\n" if $value ne $stdValue;
}
}
foreach my $key (keys %{$params{lengthRestrictions}})
{
my $maxLength = $params{lengthRestrictions}{$key};
my ($dir, $file, $name) = split(/:/, $key);
print "$locale: Value of '$key' is too long, must not be longer than $maxLength characters\n" if exists($currentLocale->{"$dir:$file"}) && exists($currentLocale->{"$dir:$file"}{$name}) && length($currentLocale->{"$dir:$file"}{$name}) > $maxLength;
}
foreach my $file (keys %$currentLocale)
{
my $fileData = $currentLocale->{$file};
foreach my $key (keys %$fileData)
{
if (($key =~ /\.accesskey$/ || $key =~ /\.key$/) && length($fileData->{$key}) != 1)
{
print "$locale: Length of accesskey '$file:$key' isn't 1 character\n";
}
if ($key =~ /\.accesskey$/)
{
if (exists($keepAccessKeys{$locale}))
{
if (exists($referenceLocale->{$file}{$key}) && lc($fileData->{$key}) ne lc($referenceLocale->{$file}{$key}))
{
print "$locale: Accesskey '$file:$key' should be the same as in the reference locale\n";
}
}
else
{
my $labelKey = $key;
$labelKey =~ s/\.accesskey$/.label/;
if (exists($fileData->{$labelKey}) && $fileData->{$labelKey} !~ /\Q$fileData->{$key}/i)
{
print "$locale: Accesskey '$file:$key' not found in the corresponding label '$file:$labelKey'\n";
}
}
}
if ($currentLocale != $referenceLocale && $locale ne "en-GB" && exists($referenceLocale->{$file}{$key}) && length($fileData->{$key}) > 1 && $fileData->{$key} eq $referenceLocale->{$file}{$key})
{
my $ignore = 0;
foreach my $re (@{$params{ignoreUntranslated}})
{
$ignore = 1 if "$file:$key" =~ $re;
}
print "$locale: Value of '$file:$key' is the same as in the reference locale, probably an untranslated string\n" unless $ignore;
}
if ($currentLocale != $referenceLocale && exists($referenceLocale->{$file}{$key}))
{
foreach my $placeholder (@placeholders)
{
print "$locale: Placeholder '$placeholder' missing in '$file:$key'\n" if index($referenceLocale->{$file}{$key}, $placeholder) >= 0 && index($currentLocale->{$file}{$key}, $placeholder) < 0;
}
}
}
}
}
}
sub makeLocaleList
{
my $paths = shift;
my %locales = ();
foreach my $dir (keys %$paths)
{
opendir(local* DIR, $paths->{$dir}) or next;
my @locales = grep {!/[^\w\-]/ && !-e("$paths->{$dir}/$_/.incomplete")} readdir(DIR);
$locales{$_} = 1 foreach @locales;
closedir(DIR);
}
return keys %locales;
}
sub readFile
{
my $file = shift;
open(local *FILE, "<", $file) || die "Could not read file '$file'";
binmode(FILE);
local $/;
my $result = ;
close(FILE);
print "Byte Order Mark found in file '$file'\n" if $result =~ /\xEF\xBB\xBF/;
print "File '$file' is not valid UTF-8\n" unless (utf8::decode($result));
return $result;
}
sub parseDTDFile
{
my $file = shift;
my %result = ();
my $data = readFile($file);
my $S = qr/[\x20\x09\x0D\x0A]/;
my $Name = qr/[A-Za-z_:][\w.\-:]*/;
my $Reference = qr/&$Name;|&#\d+;|&#x[\da-fA-F]+;/;
my $PEReference = qr/%$Name;/;
my $EntityValue = qr/\"((?:[^%&\"]|$PEReference|$Reference)*)\"|'((?:[^%&']|$PEReference|$Reference)*)'/;
sub processEntityValue
{
my $text = shift;
$text =~ s/&#(\d+);/chr($1)/ge;
$text =~ s/&#x([\da-fA-F]+);/chr(hex($1))/ge;
$text =~ s/'/'/g;
return $text;
}
# Remove comments
$data =~ s///gs;
# Process entities
while ($data =~ //gs)
{
my ($name, $value) = ($1, $2 || $3);
$result{$name} = processEntityValue($value);
}
# Remove entities
$data =~ s///gs;
# Remove spaces
$data =~ s/^\s+//gs;
$data =~ s/\s+$//gs;
$data =~ s/\s+/ /gs;
print "Unrecognized data in file '$file': $data\n" if $data ne '';
return \%result;
}
sub parsePropertiesFile
{
my $file = shift;
my %result = ();
my $data = readFile($file);
while ($data =~ /^(.*)$/mg)
{
my $line = $1;
# ignore comments
next if $line =~ /^\s*[#!]/;
if ($line =~ /=/)
{
my ($key, $value) = split(/=/, $line, 2);
$result{$key} = $value;
}
elsif ($line =~ /\S/)
{
print "Unrecognized data in file '$file': $line\n";
}
}
close(FILE);
return \%result;
}
sub readLocaleFiles
{
my $paths = shift;
my $locale = shift;
my %result = ();
foreach my $dir (keys %$paths)
{
opendir(local *DIR, "$paths->{$dir}/$locale") or next;
foreach my $file (readdir(DIR))
{
if ($file =~ /(.*)\.dtd$/)
{
$result{"$dir:$1"} = parseDTDFile("$paths->{$dir}/$locale/$file");
}
elsif ($file =~ /(.*)\.properties$/)
{
$result{"$dir:$1"} = parsePropertiesFile("$paths->{$dir}/$locale/$file");
}
}
closedir(DIR);
}
return \%result;
}
sub compareLocales
{
my ($locale, $current, $reference) = @_;
my %hasFile = ();
foreach my $file (keys %$current)
{
unless (exists($reference->{$file}))
{
print "$locale: Extra file '$file'\n";
next;
}
$hasFile{$file} = 1;
my %hasValue = ();
foreach my $key (keys %{$current->{$file}})
{
unless (exists($reference->{$file}{$key}))
{
print "$locale: Extra value '$file:$key'\n";
next;
}
$hasValue{$key} = 1;
}
foreach my $key (keys %{$reference->{$file}})
{
unless (exists($current->{$file}{$key}))
{
print "$locale: Missing value '$file:$key'\n";
next;
}
}
}
foreach my $file (keys %$reference)
{
unless (exists($current->{$file}))
{
print "$locale: Missing file '$file'\n";
next;
}
}
}
1;
buildtools-master/__init__.py 0000664 0000000 0000000 00000000000 12705153350 0016627 0 ustar 00root root 0000000 0000000 buildtools-master/background.html.tmpl 0000664 0000000 0000000 00000000233 12705153350 0020506 0 ustar 00root root 0000000 0000000
{%- for script in scripts %}
{%- endfor %}
buildtools-master/bootstrap.js.tmpl 0000664 0000000 0000000 00000012146 12705153350 0020062 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
const Cc = Components.classes;
const Ci = Components.interfaces;
const Cr = Components.results;
const Cu = Components.utils;
let {Services} = Cu.import("resource://gre/modules/Services.jsm", {});
Cu.importGlobalProperties(["atob", "btoa", "File", "URL",
"TextDecoder", "TextEncoder"]);
{%- if hasXMLHttpRequest %}
Cu.importGlobalProperties(["XMLHttpRequest"]);
{%- endif %}
let addonData = null;
function startup(params, reason)
{
addonData = params;
{%- if hasChromeRequires %}
Services.obs.addObserver(RequireObserver, "{{metadata.get('general', 'basename')}}-require", true);
onShutdown.add(function()
{
Services.obs.removeObserver(RequireObserver, "{{metadata.get('general', 'basename')}}-require");
});
{%- set hasShutdownHandlers = True %}
{%- endif %}
require("main");
}
function shutdown(params, reason)
{
{%- if chromeWindows %}
let windowNames = {{chromeWindows|json}};
for (let i = 0; i < windowNames.length; i++)
{
let enumerator = Services.wm.getEnumerator(windowNames[i]);
while (enumerator.hasMoreElements())
{
let window = enumerator.getNext().QueryInterface(Ci.nsIDOMWindow);
window.setTimeout("window.close()", 0); // Closing immediately might not work due to modal windows
try
{
window.close();
} catch(e) {}
}
}
{%- endif %}
{%- if hasShutdownHandlers %}
onShutdown.done = true;
for (let i = shutdownHandlers.length - 1; i >= 0; i --)
{
try
{
shutdownHandlers[i]();
}
catch (e)
{
Cu.reportError(e);
}
}
shutdownHandlers = null;
{%- endif %}
// Make sure to release our ties to the modules even if the sandbox cannot be
// released for some reason.
for (let key in require.scopes)
{
let scope = require.scopes[key];
let list = Object.keys(scope);
for (let i = 0; i < list.length; i++)
scope[list[i]] = null;
}
require.scopes = null;
addonData = null;
}
function install(params, reason) {}
function uninstall(params, reason)
{
{%- if 'currentVersion' in jsonRequires.get('prefs.json', {}).get('defaults', {}) %}
const ADDON_UNINSTALL = 6; // https://developer.mozilla.org/en/Extensions/Bootstrapped_extensions#Reason_constants
if (reason == ADDON_UNINSTALL)
{
// Users often uninstall/reinstall extension to "fix" issues. Clear current
// version number on uninstall to rerun first-run actions in this scenario.
Services.prefs.clearUserPref("extensions.{{metadata.get('general', 'basename')}}.currentVersion");
}
{%- endif %}
}
{%- if hasShutdownHandlers %}
let shutdownHandlers = [];
let onShutdown =
{
done: false,
add: function(handler)
{
if (shutdownHandlers.indexOf(handler) < 0)
shutdownHandlers.push(handler);
},
remove: function(handler)
{
let index = shutdownHandlers.indexOf(handler);
if (index >= 0)
shutdownHandlers.splice(index, 1);
}
};
{%- endif %}
function require(module)
{
let scopes = require.scopes;
if (!(module in scopes))
{
{%- if 'info' in requires %}
if (module == "info")
{
let applications = {{applications|json}};
let appInfo = Services.appinfo;
scopes[module] = {};
scopes[module].exports =
{
addonID: addonData.id,
addonVersion: addonData.version,
addonRoot: addonData.resourceURI.spec,
addonName: "{{metadata.get('general', 'basename')}}",
application: (appInfo.ID in applications ? applications[appInfo.ID] : "other"),
applicationVersion: appInfo.version,
platform: "gecko",
platformVersion: appInfo.platformVersion
};
}
else
{
{%- endif %}
let url = addonData.resourceURI.spec + "lib/" + module + ".js";
scopes[module] = {
Cc, Ci, Cr, Cu, atob, btoa, File, URL, require,
{% if hasShutdownHandlers %}
onShutdown,
{% endif %}
{%- if hasXMLHttpRequest %}
XMLHttpRequest,
{% endif %}
exports: {}};
{%- if multicompartment %}
let principal = Cc["@mozilla.org/systemprincipal;1"].getService(Ci.nsIPrincipal);
scopes[module] = new Cu.Sandbox(principal, {
sandboxName: url,
sandboxPrototype: scopes[module],
wantXrays: false
});
{%- endif %}
Services.scriptloader.loadSubScript(url, scopes[module]);
{%- if 'info' in requires %}
}
{%- endif %}
}
return scopes[module].exports;
}
require.scopes = Object.create(null);
{%- for name, data in jsonRequires.iteritems() %}
require.scopes[{{name|json}}] = {exports: {{data|json}}};
{%- endfor %}
{%- if hasChromeRequires %}
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
let RequireObserver =
{
observe: function(subject, topic, data)
{
if (topic == "{{metadata.get('general', 'basename')}}-require")
{
subject.wrappedJSObject.exports = require(data);
}
},
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupportsWeakReference, Ci.nsIObserver])
};
{%- endif %}
buildtools-master/build.py 0000664 0000000 0000000 00000056121 12705153350 0016206 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import os
import sys
import re
import subprocess
import shutil
import buildtools
from getopt import getopt, GetoptError
from StringIO import StringIO
from zipfile import ZipFile
knownTypes = ('gecko', 'chrome', 'safari', 'generic')
class Command(object):
name = property(lambda self: self._name)
shortDescription = property(
lambda self: self._shortDescription,
lambda self, value: self.__dict__.update({'_shortDescription': value})
)
description = property(
lambda self: self._description,
lambda self, value: self.__dict__.update({'_description': value})
)
params = property(
lambda self: self._params,
lambda self, value: self.__dict__.update({'_params': value})
)
supportedTypes = property(
lambda self: self._supportedTypes,
lambda self, value: self.__dict__.update({'_supportedTypes': value})
)
options = property(lambda self: self._options)
def __init__(self, handler, name):
self._handler = handler
self._name = name
self._shortDescription = ''
self._description = ''
self._params = ''
self._supportedTypes = None
self._options = []
self.addOption('Show this message and exit', short='h', long='help')
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
def __call__(self, baseDir, scriptName, opts, args, type):
return self._handler(baseDir, scriptName, opts, args, type)
def isSupported(self, type):
return self._supportedTypes == None or type in self._supportedTypes
def addOption(self, description, short=None, long=None, value=None, types=None):
self._options.append((description, short, long, value, types))
def parseArgs(self, type, args):
shortOptions = map(
lambda o: o[1] + ':' if o[3] != None else o[1],
filter(
lambda o: o[1] != None and (o[4] == None or type in o[4]),
self._options
)
)
longOptions = map(
lambda o: o[2] + '=' if o[3] != None else o[2],
filter(
lambda o: o[2] != None and (o[4] == None or type in o[4]),
self._options
)
)
return getopt(args, ''.join(shortOptions), longOptions)
commandsList = []
commands = {}
def addCommand(handler, name):
if isinstance(name, basestring):
aliases = ()
else:
name, aliases = (name[0], name[1:])
global commandsList, commands
command = Command(handler, name)
commandsList.append(command)
commands[name] = command
for alias in aliases:
commands[alias] = command
return command
def splitByLength(string, maxLen):
parts = []
currentPart = ''
for match in re.finditer(r'\s*(\S+)', string):
if len(match.group(0)) + len(currentPart) < maxLen:
currentPart += match.group(0)
else:
parts.append(currentPart)
currentPart = match.group(1)
if len(currentPart):
parts.append(currentPart)
return parts
def usage(scriptName, type, commandName=None):
if commandName == None:
global commandsList
descriptions = []
for command in commandsList:
if not command.isSupported(type):
continue
commandText = ('%s %s' % (command.name, command.params)).ljust(39)
descriptionParts = splitByLength(command.shortDescription, 29)
descriptions.append(' %s [-t %s] %s %s' % (scriptName, type, commandText, descriptionParts[0]))
for part in descriptionParts[1:]:
descriptions.append(' %s %s %s %s' % (' ' * len(scriptName), ' ' * len(type), ' ' * len(commandText), part))
print '''Usage:
%(descriptions)s
For details on a command run:
%(scriptName)s [-t %(type)s] --help
''' % {
'scriptName': scriptName,
'type': type,
'descriptions': '\n'.join(descriptions)
}
else:
global commands
command = commands[commandName]
description = '\n'.join(map(lambda s: '\n'.join(splitByLength(s, 80)), command.description.split('\n')))
options = []
for descr, short, long, value, types in command.options:
if types != None and type not in types:
continue
if short == None:
shortText = ''
elif value == None:
shortText = '-%s' % short
else:
shortText = '-%s %s' % (short, value)
if long == None:
longText = ''
elif value == None:
longText = '--%s' % long
else:
longText = '--%s=%s' % (long, value)
descrParts = splitByLength(descr, 46)
options.append(' %s %s %s' % (shortText.ljust(11), longText.ljust(19), descrParts[0]))
for part in descrParts[1:]:
options.append(' %s %s %s' % (' ' * 11, ' ' * 19, part))
print '''%(scriptName)s [-t %(type)s] %(name)s %(params)s
%(description)s
Options:
%(options)s
''' % {
'scriptName': scriptName,
'type': type,
'name': command.name,
'params': command.params,
'description': description,
'options': '\n'.join(options)
}
def runBuild(baseDir, scriptName, opts, args, type):
locales = None
buildNum = None
multicompartment = False
releaseBuild = False
keyFile = None
for option, value in opts:
if option in ('-l', '--locales'):
locales = value.split(',')
elif option in ('-b', '--build'):
buildNum = int(value)
elif option in ('-k', '--key'):
keyFile = value
elif option in ('-m', '--multi-compartment'):
multicompartment = True
elif option in ('-r', '--release'):
releaseBuild = True
outFile = args[0] if len(args) > 0 else None
if type == 'gecko':
import buildtools.packagerGecko as packager
packager.createBuild(baseDir, type=type, outFile=outFile, locales=locales, buildNum=buildNum,
releaseBuild=releaseBuild, keyFile=keyFile,
multicompartment=multicompartment)
elif type == 'chrome':
import buildtools.packagerChrome as packager
packager.createBuild(baseDir, type=type, outFile=outFile, buildNum=buildNum,
releaseBuild=releaseBuild, keyFile=keyFile)
elif type == 'safari':
import buildtools.packagerSafari as packager
packager.createBuild(baseDir, type=type, outFile=outFile, buildNum=buildNum,
releaseBuild=releaseBuild, keyFile=keyFile)
def runAutoInstall(baseDir, scriptName, opts, args, type):
if len(args) == 0:
print 'Port of the Extension Auto-Installer needs to be specified'
usage(scriptName, type, 'autoinstall')
return
multicompartment = False
for option, value in opts:
if option in ('-m', '--multi-compartment'):
multicompartment = True
if ':' in args[0]:
host, port = args[0].rsplit(':', 1)
else:
host, port = ('localhost', args[0])
import buildtools.packagerGecko as packager
packager.autoInstall(baseDir, type, host, port, multicompartment=multicompartment)
def createDevEnv(baseDir, scriptName, opts, args, type):
if type == 'safari':
import buildtools.packagerSafari as packager
else:
import buildtools.packagerChrome as packager
file = StringIO()
packager.createBuild(baseDir, type=type, outFile=file, devenv=True, releaseBuild=True)
from buildtools.packager import getDevEnvPath
devenv_dir = getDevEnvPath(baseDir, type)
shutil.rmtree(devenv_dir, ignore_errors=True)
file.seek(0)
with ZipFile(file, 'r') as zip_file:
zip_file.extractall(devenv_dir)
def readLocaleConfig(baseDir, type, metadata):
if type == 'gecko':
import buildtools.packagerGecko as packager
localeDir = packager.getLocalesDir(baseDir)
localeConfig = {
'name_format': 'BCP-47',
'file_format': 'gecko-dtd',
'target_platforms': {'gecko'},
'default_locale': packager.defaultLocale
}
elif type == 'chrome':
import buildtools.packagerChrome as packager
localeDir = os.path.join(baseDir, '_locales')
localeConfig = {
'name_format': 'ISO-15897',
'file_format': 'chrome-json',
'target_platforms': {'chrome'},
'default_locale': packager.defaultLocale,
}
else:
localeDir = os.path.join(
baseDir, *metadata.get('locales', 'base_path').split('/')
)
localeConfig = {
'name_format': metadata.get('locales', 'name_format'),
'file_format': metadata.get('locales', 'file_format'),
'target_platforms': set(metadata.get('locales',
'target_platforms').split()),
'default_locale': metadata.get('locales', 'default_locale')
}
localeConfig['base_path'] = localeDir
locales = [(locale, os.path.join(localeDir, locale))
for locale in os.listdir(localeDir)]
if localeConfig['name_format'] == 'ISO-15897':
locales = [(locale.replace('_', '-'), localePath)
for locale, localePath in locales]
localeConfig['locales'] = dict(locales)
return localeConfig
def setupTranslations(baseDir, scriptName, opts, args, type):
if len(args) < 1:
print 'Project key is required to update translation master files.'
usage(scriptName, type, 'setuptrans')
return
key = args[0]
from buildtools.packager import readMetadata
metadata = readMetadata(baseDir, type)
basename = metadata.get('general', 'basename')
localeConfig = readLocaleConfig(baseDir, type, metadata)
import buildtools.localeTools as localeTools
localeTools.setupTranslations(localeConfig, basename, key)
def updateTranslationMaster(baseDir, scriptName, opts, args, type):
if len(args) < 1:
print 'Project key is required to update translation master files.'
usage(scriptName, type, 'translate')
return
key = args[0]
from buildtools.packager import readMetadata
metadata = readMetadata(baseDir, type)
basename = metadata.get('general', 'basename')
localeConfig = readLocaleConfig(baseDir, type, metadata)
defaultLocaleDir = os.path.join(localeConfig['base_path'],
localeConfig['default_locale'])
import buildtools.localeTools as localeTools
localeTools.updateTranslationMaster(localeConfig, metadata, defaultLocaleDir,
basename, key)
def uploadTranslations(baseDir, scriptName, opts, args, type):
if len(args) < 1:
print 'Project key is required to upload existing translations.'
usage(scriptName, type, 'uploadtrans')
return
key = args[0]
from buildtools.packager import readMetadata
metadata = readMetadata(baseDir, type)
basename = metadata.get('general', 'basename')
localeConfig = readLocaleConfig(baseDir, type, metadata)
import buildtools.localeTools as localeTools
for locale, localeDir in localeConfig['locales'].iteritems():
if locale != localeConfig['default_locale']:
localeTools.uploadTranslations(localeConfig, metadata, localeDir, locale,
basename, key)
def getTranslations(baseDir, scriptName, opts, args, type):
if len(args) < 1:
print 'Project key is required to update translation master files.'
usage(scriptName, type, 'translate')
return
key = args[0]
from buildtools.packager import readMetadata
metadata = readMetadata(baseDir, type)
basename = metadata.get('general', 'basename')
localeConfig = readLocaleConfig(baseDir, type, metadata)
import buildtools.localeTools as localeTools
localeTools.getTranslations(localeConfig, basename, key)
def showDescriptions(baseDir, scriptName, opts, args, type):
locales = None
for option, value in opts:
if option in ('-l', '--locales'):
locales = value.split(',')
import buildtools.packagerGecko as packager
if locales == None:
locales = packager.getLocales(baseDir)
elif locales == 'all':
locales = packager.getLocales(baseDir, True)
data = packager.readLocaleMetadata(baseDir, locales)
localeCodes = data.keys()
localeCodes.sort()
for localeCode in localeCodes:
locale = data[localeCode]
print ('''%s
%s
%s
%s
%s
''' % (localeCode,
locale['name'] if 'name' in locale else 'None',
locale['description'] if 'description' in locale else 'None',
locale['description.short'] if 'description.short' in locale else 'None',
locale['description.long'] if 'description.long' in locale else 'None',
)).encode('utf-8')
def generateDocs(baseDir, scriptName, opts, args, type):
if len(args) == 0:
print 'No target directory specified for the documentation'
usage(scriptName, type, 'docs')
return
targetDir = args[0]
source_dir = os.path.join(baseDir, 'lib')
sources = [source_dir]
# JSDoc struggles wih huge objects: https://github.com/jsdoc3/jsdoc/issues/976
if type == 'chrome':
sources = [os.path.join(source_dir, filename) for filename in os.listdir(source_dir) if filename != 'publicSuffixList.js']
config = os.path.join(os.path.dirname(__file__), 'jsdoc.conf')
command = ['jsdoc', '--destination', targetDir, '--configure', config] + sources
if any(opt in ('-q', '--quiet') for opt, _ in opts):
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stderr = process.communicate()[1]
retcode = process.poll()
if retcode:
sys.stderr.write(stderr)
raise subprocess.CalledProcessError(command, retcode)
else:
subprocess.check_call(command)
def runReleaseAutomation(baseDir, scriptName, opts, args, type):
keyFiles = []
downloadsRepo = os.path.join(baseDir, '..', 'downloads')
for option, value in opts:
if option in ('-k', '--key'):
keyFiles.append(value)
elif option in ('-d', '--downloads'):
downloadsRepo = value
if len(args) == 0:
print 'No version number specified for the release'
usage(scriptName, type, 'release')
return
version = args[0]
if re.search(r'[^\d\.]', version):
print 'Wrong version number format'
usage(scriptName, type, 'release')
return
if type == "gecko" and len(keyFiles) == 0:
print >>sys.stderr, "Warning: no key file specified, creating an unsigned release build\n"
elif type == "gecko" and len(keyFiles) > 1:
print >>sys.stderr, "Error: too many key files, only one required"
usage(scriptName, type, 'release')
return
elif type == "chrome" and len(keyFiles) != 2:
print >>sys.stderr, "Error: wrong number of key files specified, two keys (Chrome and Safari) required for the release"
usage(scriptName, type, 'release')
return
import buildtools.releaseAutomation as releaseAutomation
releaseAutomation.run(baseDir, type, version, keyFiles, downloadsRepo)
def updatePSL(baseDir, scriptName, opts, args, type):
import buildtools.publicSuffixListUpdater as publicSuffixListUpdater
publicSuffixListUpdater.updatePSL(baseDir)
with addCommand(lambda baseDir, scriptName, opts, args, type: usage(scriptName, type), ('help', '-h', '--help')) as command:
command.shortDescription = 'Show this message'
with addCommand(runBuild, 'build') as command:
command.shortDescription = 'Create a build'
command.description = 'Creates an extension build with given file name. If output_file is missing a default name will be chosen.'
command.params = '[options] [output_file]'
command.addOption('Only include the given locales (if omitted: all locales not marked as incomplete)', short='l', long='locales', value='l1,l2,l3', types=('gecko'))
command.addOption('Use given build number (if omitted the build number will be retrieved from Mercurial)', short='b', long='build', value='num')
command.addOption('File containing private key and certificates required to sign the package', short='k', long='key', value='file', types=('gecko', 'chrome', 'safari'))
command.addOption('Create a build for leak testing', short='m', long='multi-compartment', types=('gecko'))
command.addOption('Create a release build', short='r', long='release')
command.supportedTypes = ('gecko', 'chrome', 'safari')
with addCommand(runAutoInstall, 'autoinstall') as command:
command.shortDescription = 'Install extension automatically'
command.description = 'Will automatically install the extension in a browser running Extension Auto-Installer. If host parameter is omitted assumes that the browser runs on localhost.'
command.params = '[:]'
command.addOption('Create a build for leak testing', short='m', long='multi-compartment')
command.supportedTypes = ('gecko')
with addCommand(createDevEnv, 'devenv') as command:
command.shortDescription = 'Set up a development environment'
command.description = 'Will set up or update the devenv folder as an unpacked extension folder for development.'
command.supportedTypes = ('chrome', 'safari')
with addCommand(setupTranslations, 'setuptrans') as command:
command.shortDescription = 'Sets up translation languages'
command.description = 'Sets up translation languages for the project on crowdin.net.'
command.params = '[options] project-key'
command.supportedTypes = ('gecko', 'chrome', 'generic')
with addCommand(updateTranslationMaster, 'translate') as command:
command.shortDescription = 'Updates translation master files'
command.description = 'Updates the translation master files in the project on crowdin.net.'
command.params = '[options] project-key'
command.supportedTypes = ('gecko', 'chrome', 'generic')
with addCommand(uploadTranslations, 'uploadtrans') as command:
command.shortDescription = 'Uploads existing translations'
command.description = 'Uploads already existing translations to the project on crowdin.net.'
command.params = '[options] project-key'
command.supportedTypes = ('gecko', 'chrome', 'generic')
with addCommand(getTranslations, 'gettranslations') as command:
command.shortDescription = 'Downloads translation updates'
command.description = 'Downloads updated translations from crowdin.net.'
command.params = '[options] project-key'
command.supportedTypes = ('gecko', 'chrome', 'generic')
with addCommand(showDescriptions, 'showdesc') as command:
command.shortDescription = 'Print description strings for all locales'
command.description = 'Display description strings for all locales as specified in the corresponding meta.properties files.'
command.addOption('Only include the given locales', short='l', long='locales', value='l1,l2,l3')
command.params = '[options]'
command.supportedTypes = ('gecko')
with addCommand(generateDocs, 'docs') as command:
command.shortDescription = 'Generate documentation (requires node.js)'
command.description = 'Generate documentation files and write them into the specified directory. This operation requires JsDoc 3 to be installed.'
command.addOption('Suppress JsDoc output', short='q', long='quiet')
command.params = '[options] '
command.supportedTypes = ('gecko', 'chrome')
with addCommand(runReleaseAutomation, 'release') as command:
command.shortDescription = 'Run release automation'
command.description = 'Note: If you are not the project owner then you '\
'probably don\'t want to run this!\n\n'\
'Runs release automation: creates downloads for the new version, tags '\
'source code repository as well as downloads and buildtools repository.'
command.addOption('File containing private key and certificates required to sign the release. Note that for Chrome releases this option needs to be specified twice: first a key to sign Chrome builds, then another to sign the Safari build.', short='k', long='key', value='file', types=('gecko', 'chrome'))
command.addOption('Directory containing downloads repository (if omitted ../downloads is assumed)', short='d', long='downloads', value='dir')
command.params = '[options] '
command.supportedTypes = ('gecko', 'chrome')
with addCommand(updatePSL, 'updatepsl') as command:
command.shortDescription = 'Updates Public Suffix List'
command.description = 'Downloads Public Suffix List (see http://publicsuffix.org/) and generates lib/publicSuffixList.js from it.'
command.supportedTypes = ('chrome',)
def getType(baseDir, scriptName, args):
# Look for an explicit type parameter (has to be the first parameter)
if len(args) >= 2 and args[0] == '-t':
type = args[1]
del args[1]
del args[0]
if type not in knownTypes:
print '''
Unknown type %s specified, supported types are: %s
''' % (type, ', '.join(knownTypes))
return None
return type
# Try to guess repository type
types = []
for t in knownTypes:
if os.path.exists(os.path.join(baseDir, 'metadata.%s' % t)):
types.append(t)
if len(types) == 1:
return types[0]
elif len(types) > 1:
print '''
Ambiguous repository type, please specify -t parameter explicitly, e.g.
%s -t %s build
''' % (scriptName, types[0])
return None
else:
print '''
No metadata file found in this repository, a metadata file like
metadata.%s is required.
''' % knownTypes[0]
return None
def processArgs(baseDir, args):
global commands
scriptName = os.path.basename(args[0])
args = args[1:]
type = getType(baseDir, scriptName, args)
if type == None:
return
if len(args) == 0:
args = ['build']
print '''
No command given, assuming "build". For a list of commands run:
%s help
''' % scriptName
command = args[0]
if command in commands:
if commands[command].isSupported(type):
try:
opts, args = commands[command].parseArgs(type, args[1:])
except GetoptError, e:
print str(e)
usage(scriptName, type, command)
sys.exit(2)
for option, value in opts:
if option in ('-h', '--help'):
usage(scriptName, type, command)
sys.exit()
commands[command](baseDir, scriptName, opts, args, type)
else:
print 'Command %s is not supported for this application type' % command
usage(scriptName, type)
else:
print 'Command %s is unrecognized' % command
usage(scriptName, type)
buildtools-master/chainedconfigparser.py 0000664 0000000 0000000 00000014224 12705153350 0021103 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import os
import io
import ConfigParser
from StringIO import StringIO
class Item(tuple):
def __new__(cls, name, value, source):
result = super(Item, cls).__new__(cls, (name, value))
result.source = source
return result
class DiffForUnknownOptionError(ConfigParser.Error):
def __init__(self, option, section):
ConfigParser.Error.__init__(self, 'Failed to apply diff for unknown option '
'%r in section %r' % (option, section))
self.option = option
self.section = section
self.args = (option, section)
class ChainedConfigParser(ConfigParser.SafeConfigParser):
'''
This class provides essentially the same interfaces as SafeConfigParser but
allows chaining configuration files so that one config file provides the
default values for the other. To specify the config file to inherit from
a config file needs to contain the following option:
[default]
inherit = foo/bar.config
It is also possible to add values to or remove values from
whitespace-separated lists given by an inherited option:
[section]
opt1 += foo
opt2 -= bar
The value of the inherit option has to be a relative path with forward
slashes as delimiters. Up to 5 configuration files can be chained this way,
longer chains are disallowed to deal with circular references.
As opposed to SafeConfigParser, files are decoded as UTF-8 while
reading. Also, ChainedConfigParser data is read-only. An additional
option_source(section, option) method is provided to get the path
of the configuration file defining this option (for relative paths).
Items returned by the items() function also have a source attribute
serving the same purpose.
'''
def __init__(self):
ConfigParser.SafeConfigParser.__init__(self)
self._origin = {}
def _make_parser(self, filename):
parser = ConfigParser.SafeConfigParser()
parser.optionxform = lambda option: option
with io.open(filename, encoding='utf-8') as file:
parser.readfp(file, filename)
return parser
def _get_parser_chain(self, parser, filename):
parsers = [(parser, filename)]
try:
inherit = parser.get('default', 'inherit')
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
return parsers
dirname = os.path.dirname(filename)
for parent in inherit.split():
parent_filename = os.path.join(dirname, *parent.split('/'))
parent_parser = self._make_parser(parent_filename)
parsers[:0] = self._get_parser_chain(parent_parser, parent_filename)
return parsers
def _apply_diff(self, section, option, value):
is_addition = option.endswith('+')
is_diff = is_addition or option.endswith('-')
if is_diff:
option = option[:-1].rstrip()
try:
orig_value = self.get(section, option)
except ConfigParser.NoOptionError:
raise DiffForUnknownOptionError(option, section)
orig_values = orig_value.split()
diff_values = value.split()
if is_addition:
new_values = orig_values + [v for v in diff_values if v not in orig_values]
else:
new_values = [v for v in orig_values if v not in diff_values]
value = ' '.join(new_values)
return is_diff, option, value
def _process_parsers(self, parsers):
for parser, filename in parsers:
for section in parser.sections():
if not self.has_section(section):
try:
ConfigParser.SafeConfigParser.add_section(self, section)
except ValueError:
# add_section() hardcodes 'default' and raises a ValueError if
# you try to add a section called like that (case insensitive).
# This bug has been fixed in Python 3.
ConfigParser.SafeConfigParser.readfp(self, StringIO('[%s]' % section))
for option, value in parser.items(section):
is_diff, option, value = self._apply_diff(section, option, value)
ConfigParser.SafeConfigParser.set(self, section, option, value)
if not is_diff:
self._origin[(section, self.optionxform(option))] = filename
def read(self, filenames):
if isinstance(filenames, basestring):
filenames = [filenames]
read_ok = []
for filename in filenames:
try:
parser = self._make_parser(filename)
except IOError:
continue
self._process_parsers(self._get_parser_chain(parser, filename))
read_ok.append(filename)
return read_ok
def items(self, section, *args, **kwargs):
items = []
for option, value in ConfigParser.SafeConfigParser.items(self, section, *args, **kwargs):
items.append(Item(
option, value,
self._origin[(section, self.optionxform(option))]
))
return items
def option_source(self, section, option):
option = self.optionxform(option)
try:
return self._origin[(section, option)]
except KeyError:
if not self.has_section(section):
raise ConfigParser.NoSectionError(section)
raise ConfigParser.NoOptionError(option, section)
def readfp(self, fp, filename=None):
raise NotImplementedError
def set(self, section, option, value=None):
raise NotImplementedError
def add_section(self, section):
raise NotImplementedError
def remove_option(self, section, option):
raise NotImplementedError
def remove_section(self, section):
raise NotImplementedError
buildtools-master/chromeDevenvPoller__.js 0000664 0000000 0000000 00000001320 12705153350 0021163 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
(function()
{
var version = null;
function doPoll()
{
fetch(chrome.extension.getURL("devenvVersion__"))
.then(function(response)
{
return response.text();
})
.then(function(text)
{
if (version == null)
version = text;
if (text != version)
chrome.runtime.reload();
else
window.setTimeout(doPoll, 5000);
});
}
// Delay first poll to prevent reloading again immediately after a reload
doPoll();
})();
buildtools-master/chromeInfo.js.tmpl 0000664 0000000 0000000 00000003254 12705153350 0020136 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
(function() {
var platform = "chromium";
var platformVersion = null;
var application = null;
var applicationVersion;
var regexp = /(\S+)\/(\S+)(?:\s*\(.*?\))?/g;
var match;
while (match = regexp.exec(navigator.userAgent))
{
var app = match[1];
var ver = match[2];
if (app == "Chrome")
{
platformVersion = ver;
}
else if (app == "Edge")
{
platform = "edgehtml";
platformVersion = ver;
application = "edge";
applicationVersion = "0";
}
else if (app != "Mozilla" && app != "AppleWebKit" && app != "Safari")
{
// For compatibility with legacy websites, Chrome's UA
// also includes a Mozilla, AppleWebKit and Safari token.
// Any further name/version pair indicates a fork.
application = app == "OPR" ? "opera" : app.toLowerCase();
applicationVersion = ver;
}
}
// not a Chromium-based UA, probably modifed by the user
if (!platformVersion)
{
application = "unknown";
applicationVersion = platformVersion = "0";
}
// no additional name/version, so this is upstream Chrome
if (!application)
{
application = "chrome";
applicationVersion = platformVersion;
}
require.scopes.info = {
addonName: {{ metadata.get('general', 'basename')|json }},
addonVersion: {{ version|json }},
application: application,
applicationVersion: applicationVersion,
platform: platform,
platformVersion: platformVersion
};
})();
buildtools-master/dependencies 0000664 0000000 0000000 00000000171 12705153350 0017100 0 ustar 00root root 0000000 0000000 _root = hg:https://hg.adblockplus.org/ git:https://github.com/adblockplus/
jshydra = jshydra hg:2f88c16af976 git:104e620
buildtools-master/ensure_dependencies.py 0000775 0000000 0000000 00000033317 12705153350 0021123 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import sys
import os
import posixpath
import re
import io
import errno
import logging
import subprocess
import urlparse
import argparse
from collections import OrderedDict
from ConfigParser import RawConfigParser
USAGE = """
A dependencies file should look like this:
# VCS-specific root URLs for the repositories
_root = hg:https://hg.adblockplus.org/ git:https://github.com/adblockplus/
# File to update this script from (optional)
_self = buildtools/ensure_dependencies.py
# Clone elemhidehelper repository into extensions/elemhidehelper directory at
# tag "1.2".
extensions/elemhidehelper = elemhidehelper 1.2
# Clone buildtools repository into buildtools directory at VCS-specific
# revision IDs.
buildtools = buildtools hg:016d16f7137b git:f3f8692f82e5
# Clone the adblockplus repository into adblockplus directory, overwriting the
# usual source URL for Git repository and specifying VCS specific revision IDs.
adblockplus = adblockplus hg:893426c6a6ab git:git@github.com:user/adblockplus.git@b2ffd52b
# Clone the adblockpluschrome repository into the adblockpluschrome directory,
# from a specific Git repository, specifying the revision ID.
adblockpluschrome = git:git@github.com:user/adblockpluschrome.git@1fad3a7
"""
SKIP_DEPENDENCY_UPDATES = os.environ.get(
"SKIP_DEPENDENCY_UPDATES", ""
).lower() not in ("", "0", "false")
class Mercurial():
def istype(self, repodir):
return os.path.exists(os.path.join(repodir, ".hg"))
def clone(self, source, target):
if not source.endswith("/"):
source += "/"
subprocess.check_call(["hg", "clone", "--quiet", "--noupdate", source, target])
def get_revision_id(self, repo, rev=None):
command = ["hg", "id", "--repository", repo, "--id"]
if rev:
command.extend(["--rev", rev])
# Ignore stderr output and return code here: if revision lookup failed we
# should simply return an empty string.
result = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
return result.strip()
def pull(self, repo):
subprocess.check_call(["hg", "pull", "--repository", repo, "--quiet"])
def update(self, repo, rev, revname):
subprocess.check_call(["hg", "update", "--repository", repo, "--quiet", "--check", "--rev", rev])
def ignore(self, target, repo):
if not self.istype(target):
config_path = os.path.join(repo, ".hg", "hgrc")
ignore_path = os.path.abspath(os.path.join(repo, ".hg", "dependencies"))
config = RawConfigParser()
config.read(config_path)
if not config.has_section("ui"):
config.add_section("ui")
config.set("ui", "ignore.dependencies", ignore_path)
with open(config_path, "w") as stream:
config.write(stream)
module = os.path.relpath(target, repo)
_ensure_line_exists(ignore_path, module)
def postprocess_url(self, url):
return url
class Git():
def istype(self, repodir):
return os.path.exists(os.path.join(repodir, ".git"))
def clone(self, source, target):
source = source.rstrip("/")
if not source.endswith(".git"):
source += ".git"
subprocess.check_call(["git", "clone", "--quiet", source, target])
def get_revision_id(self, repo, rev="HEAD"):
command = ["git", "rev-parse", "--revs-only", rev + '^{commit}']
return subprocess.check_output(command, cwd=repo).strip()
def pull(self, repo):
# Fetch tracked branches, new tags and the list of available remote branches
subprocess.check_call(["git", "fetch", "--quiet", "--all", "--tags"], cwd=repo)
# Next we need to ensure all remote branches are tracked
newly_tracked = False
remotes = subprocess.check_output(["git", "branch", "--remotes"], cwd=repo)
for match in re.finditer(r"^\s*(origin/(\S+))$", remotes, re.M):
remote, local = match.groups()
with open(os.devnull, "wb") as devnull:
if subprocess.call(["git", "branch", "--track", local, remote],
cwd=repo, stdout=devnull, stderr=devnull) == 0:
newly_tracked = True
# Finally fetch any newly tracked remote branches
if newly_tracked:
subprocess.check_call(["git", "fetch", "--quiet", "origin"], cwd=repo)
def update(self, repo, rev, revname):
subprocess.check_call(["git", "checkout", "--quiet", revname], cwd=repo)
def ignore(self, target, repo):
module = os.path.sep + os.path.relpath(target, repo)
exclude_file = os.path.join(repo, ".git", "info", "exclude")
_ensure_line_exists(exclude_file, module)
def postprocess_url(self, url):
# Handle alternative syntax of SSH URLS
if "@" in url and ":" in url and not urlparse.urlsplit(url).scheme:
return "ssh://" + url.replace(":", "/", 1)
return url
repo_types = OrderedDict((
("hg", Mercurial()),
("git", Git()),
))
# [vcs:]value
item_regexp = re.compile(
"^(?:(" + "|".join(map(re.escape, repo_types.keys())) + "):)?"
"(.+)$"
)
# [url@]rev
source_regexp = re.compile(
"^(?:(.*)@)?"
"(.+)$"
)
def merge_seqs(seq1, seq2):
"""Return a list of any truthy values from the suplied sequences
(None, 2), (1,) => [1, 2]
None, (1, 2) => [1, 2]
(1, 2), (3, 4) => [3, 4]
"""
return map(lambda item1, item2: item2 or item1, seq1 or (), seq2 or ())
def parse_spec(path, line):
if "=" not in line:
logging.warning("Invalid line in file %s: %s" % (path, line))
return None, None
key, value = line.split("=", 1)
key = key.strip()
items = value.split()
if not len(items):
logging.warning("No value specified for key %s in file %s" % (key, path))
return key, None
result = OrderedDict()
is_dependency_field = not key.startswith("_")
for i, item in enumerate(items):
try:
vcs, value = re.search(item_regexp, item).groups()
vcs = vcs or "*"
if is_dependency_field:
if i == 0 and vcs == "*":
# In order to be backwards compatible we have to assume that the first
# source contains only a URL/path for the repo if it does not contain
# the VCS part
url_rev = (value, None)
else:
url_rev = re.search(source_regexp, value).groups()
result[vcs] = merge_seqs(result.get(vcs), url_rev)
else:
if vcs in result:
logging.warning("Ignoring duplicate value for type %r "
"(key %r in file %r)" % (vcs, key, path))
result[vcs] = value
except AttributeError:
logging.warning("Ignoring invalid item %r for type %r "
"(key %r in file %r)" % (item, vcs, key, path))
continue
return key, result
def read_deps(repodir):
result = {}
deps_path = os.path.join(repodir, "dependencies")
try:
with io.open(deps_path, "rt", encoding="utf-8") as handle:
for line in handle:
# Remove comments and whitespace
line = re.sub(r"#.*", "", line).strip()
if not line:
continue
key, spec = parse_spec(deps_path, line)
if spec:
result[key] = spec
return result
except IOError, e:
if e.errno != errno.ENOENT:
raise
return None
def safe_join(path, subpath):
# This has been inspired by Flask's safe_join() function
forbidden = {os.sep, os.altsep} - {posixpath.sep, None}
if any(sep in subpath for sep in forbidden):
raise Exception("Illegal directory separator in dependency path %s" % subpath)
normpath = posixpath.normpath(subpath)
if posixpath.isabs(normpath):
raise Exception("Dependency path %s cannot be absolute" % subpath)
if normpath == posixpath.pardir or normpath.startswith(posixpath.pardir + posixpath.sep):
raise Exception("Dependency path %s has to be inside the repository" % subpath)
return os.path.join(path, *normpath.split(posixpath.sep))
def get_repo_type(repo):
for name, repotype in repo_types.iteritems():
if repotype.istype(repo):
return name
return "hg"
def ensure_repo(parentrepo, parenttype, target, type, root, sourcename):
if os.path.exists(target):
return
if SKIP_DEPENDENCY_UPDATES:
logging.warning("SKIP_DEPENDENCY_UPDATES environment variable set, "
"%s not cloned", target)
return
postprocess_url = repo_types[type].postprocess_url
root = postprocess_url(root)
sourcename = postprocess_url(sourcename)
if os.path.exists(root):
url = os.path.join(root, sourcename)
else:
url = urlparse.urljoin(root, sourcename)
logging.info("Cloning repository %s into %s" % (url, target))
repo_types[type].clone(url, target)
repo_types[parenttype].ignore(target, parentrepo)
def update_repo(target, type, revision):
resolved_revision = repo_types[type].get_revision_id(target, revision)
current_revision = repo_types[type].get_revision_id(target)
if resolved_revision != current_revision:
if SKIP_DEPENDENCY_UPDATES:
logging.warning("SKIP_DEPENDENCY_UPDATES environment variable set, "
"%s not checked out to %s", target, revision)
return
if not resolved_revision:
logging.info("Revision %s is unknown, downloading remote changes" % revision)
repo_types[type].pull(target)
resolved_revision = repo_types[type].get_revision_id(target, revision)
if not resolved_revision:
raise Exception("Failed to resolve revision %s" % revision)
logging.info("Updating repository %s to revision %s" % (target, resolved_revision))
repo_types[type].update(target, resolved_revision, revision)
def resolve_deps(repodir, level=0, self_update=True, overrideroots=None, skipdependencies=set()):
config = read_deps(repodir)
if config is None:
if level == 0:
logging.warning("No dependencies file in directory %s, nothing to do...\n%s" % (repodir, USAGE))
return
if level >= 10:
logging.warning("Too much subrepository nesting, ignoring %s" % repo)
return
if overrideroots is not None:
config["_root"] = overrideroots
for dir, sources in config.iteritems():
if (dir.startswith("_") or
skipdependencies.intersection([s[0] for s in sources if s[0]])):
continue
target = safe_join(repodir, dir)
parenttype = get_repo_type(repodir)
_root = config.get("_root", {})
for key in sources.keys() + _root.keys():
if key == parenttype or key is None and vcs != "*":
vcs = key
source, rev = merge_seqs(sources.get("*"), sources.get(vcs))
if not (vcs and source and rev):
logging.warning("No valid source / revision found to create %s" % target)
continue
ensure_repo(repodir, parenttype, target, vcs, _root.get(vcs, ""), source)
update_repo(target, vcs, rev)
resolve_deps(target, level + 1, self_update=False,
overrideroots=overrideroots, skipdependencies=skipdependencies)
if self_update and "_self" in config and "*" in config["_self"]:
source = safe_join(repodir, config["_self"]["*"])
try:
with io.open(source, "rb") as handle:
sourcedata = handle.read()
except IOError, e:
if e.errno != errno.ENOENT:
raise
logging.warning("File %s doesn't exist, skipping self-update" % source)
return
target = __file__
with io.open(target, "rb") as handle:
targetdata = handle.read()
if sourcedata != targetdata:
logging.info("Updating %s from %s, don't forget to commit" % (target, source))
with io.open(target, "wb") as handle:
handle.write(sourcedata)
if __name__ == "__main__":
logging.info("Restarting %s" % target)
os.execv(sys.executable, [sys.executable, target] + sys.argv[1:])
else:
logging.warning("Cannot restart %s automatically, please rerun" % target)
def _ensure_line_exists(path, pattern):
with open(path, 'a+') as f:
file_content = [l.strip() for l in f.readlines()]
if not pattern in file_content:
file_content.append(pattern)
f.seek(0, os.SEEK_SET)
f.truncate()
for l in file_content:
print >>f, l
if __name__ == "__main__":
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
parser = argparse.ArgumentParser(description="Verify dependencies for a set of repositories, by default the repository of this script.")
parser.add_argument("repos", metavar="repository", type=str, nargs="*", help="Repository path")
parser.add_argument("-q", "--quiet", action="store_true", help="Suppress informational output")
args = parser.parse_args()
if args.quiet:
logging.disable(logging.INFO)
repos = args.repos
if not len(repos):
repos = [os.path.dirname(__file__)]
for repo in repos:
resolve_deps(repo)
buildtools-master/install.rdf.tmpl 0000664 0000000 0000000 00000010030 12705153350 0017640 0 ustar 00root root 0000000 0000000
{%- macro meta() -%}
{{metadata.get('general', 'author')}}
{%- for contributor in contributors -%}
{{contributor}}
{%- endfor -%}
{%- endmacro %}
{{metadata.get('general', 'id')}}{{version}}{{localeMetadata[defaultLocale].name}}{{localeMetadata[defaultLocale].description}}
{{ meta() }}
{%- if metadata.has_option('homepage', 'default') %}
{{metadata.get('homepage', 'default')}}
{%- endif %}
2true
{%- if not metadata.has_option('general', 'needMultiprocessShims') %}
true
{%- endif %}
{%- if metadata.has_option('general', 'updateURL') %}
{{- metadata.get('general', 'updateURL') -}}
{{- '?reqVersion=%REQ_VERSION%&id=%ITEM_ID%&version=%ITEM_VERSION%&maxAppVersion=%ITEM_MAXAPPVERSION%&status=%ITEM_STATUS%&appID=%APP_ID%&appVersion=%APP_VERSION%&appOS=%APP_OS%&appABI=%APP_ABI%&locale=%APP_LOCALE%¤tAppVersion=%CURRENT_APP_VERSION%&updateType=%UPDATE_TYPE%' -}}
{%- endif %}
{%- if metadata.has_option('general', 'icon') %}
{{metadata.get('general', 'icon')}}
{%- endif %}
{%- if metadata.has_option('general', 'about') %}
{{metadata.get('general', 'about')}}
{%- endif %}
{%- if metadata.has_option('general', 'options') %}
{{metadata.get('general', 'options')}}
{%- endif %}
{%- if metadata.has_option('general', 'optionsType') %}
{{metadata.get('general', 'optionsType')}}
{%- endif %}
{%- for localeCode in localeMetadata.keys()|sort %}
{%- set locale = localeMetadata[localeCode] %}
{{localeCode}}
{{ meta() }}
{%- if 'name' in locale -%}
{{locale.name}}
{%- else -%}
{{localeMetadata[defaultLocale].name}}
{%- endif -%}
{%- if 'description' in locale -%}
{{locale.description}}
{%- else -%}
{{localeMetadata[defaultLocale].description}}
{%- endif -%}
{%- if metadata.has_option('homepage', 'default') %}
{%- if metadata.has_option('homepage', localeCode) -%}
{{- metadata.get('homepage', localeCode) -}}
{%- elif metadata.has_option('homepage', localeCode.split('-')[0]) -%}
{{- metadata.get('homepage', localeCode.split('-')[0]) -}}
{%- else -%}
{{- metadata.get('homepage', 'default') -}}
{%- endif -%}
{%- endif %}
{%- for translator in locale.translators %}
{{translator}}
{%- endfor %}
{%- endfor %}
{%- for appName in metadata.options('compat')|sort %}
{%- if appName in KNOWN_APPS %}
{{KNOWN_APPS[appName]}}{{metadata.get('compat', appName).split('/')[0]}}{{metadata.get('compat', appName).split('/')[1]}}
{%- endif %}
{%- endfor %}
buildtools-master/jsdoc.conf 0000664 0000000 0000000 00000000164 12705153350 0016502 0 ustar 00root root 0000000 0000000 {
"opts": {
"access": "all"
},
"templates": {
"default": {
"useLongnameInNav": true
}
}
}
buildtools-master/lib/ 0000775 0000000 0000000 00000000000 12705153350 0015276 5 ustar 00root root 0000000 0000000 buildtools-master/lib/hooks.js 0000664 0000000 0000000 00000002616 12705153350 0016764 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
function hook(obj, name, func, cleanup)
{
let orig = obj[name];
let origDesc = Object.getOwnPropertyDescriptor(obj, name);
let dumbOverrideAttempt = false;
let newFunc = function()
{
let params = arguments;
try
{
let result = func.apply(this, params);
if (typeof result == "object")
params = result;
}
catch(e)
{
Cu.reportError(e);
}
try
{
return orig.apply(this, params);
}
finally
{
if (typeof cleanup == "function")
cleanup();
}
};
newFunc.toString = function()
{
dumbOverrideAttempt = true;
return orig.toString();
};
newFunc.toSource = function()
{
dumbOverrideAttempt = true;
return orig.toSource();
};
Object.defineProperty(obj, name, {
get: function()
{
dumbOverrideAttempt = false;
return newFunc;
},
set: function(value)
{
if (dumbOverrideAttempt)
{
orig = value;
}
else
{
delete obj[name];
obj[name] = value;
}
},
enumerable: true,
configurable: true
});
return function()
{
Object.defineProperty(obj, name, origDesc);
};
}
exports.hook = hook;
buildtools-master/lib/keySelector.js 0000664 0000000 0000000 00000013173 12705153350 0020132 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
Cu.import("resource://gre/modules/Services.jsm");
let validModifiers = Object.create(null);
validModifiers.ACCEL = null;
validModifiers.CTRL = "control";
validModifiers.CONTROL = "control";
validModifiers.SHIFT = "shift";
validModifiers.ALT = "alt";
validModifiers.META = "meta";
/**
* Sets the correct value of validModifiers.ACCEL.
*/
function initAccelKey()
{
validModifiers.ACCEL = "control";
try
{
let accelKey = Services.prefs.getIntPref("ui.key.accelKey");
if (accelKey == Ci.nsIDOMKeyEvent.DOM_VK_CONTROL)
validModifiers.ACCEL = "control";
else if (accelKey == Ci.nsIDOMKeyEvent.DOM_VK_ALT)
validModifiers.ACCEL = "alt";
else if (accelKey == Ci.nsIDOMKeyEvent.DOM_VK_META)
validModifiers.ACCEL = "meta";
}
catch(e)
{
Cu.reportError(e);
}
}
exports.KeySelector = KeySelector;
/**
* This class provides capabilities to find and use available keyboard shortcut
* keys.
* @param {ChromeWindow} window the window where to look up existing shortcut
* keys
* @constructor
*/
function KeySelector(window)
{
this._initExistingShortcuts(window);
}
KeySelector.prototype =
{
/**
* Map listing existing shortcut keys as its keys.
* @type Object
*/
_existingShortcuts: null,
/**
* Sets up _existingShortcuts property for a window.
*/
_initExistingShortcuts: function(/**ChromeWindow*/ window)
{
if (!validModifiers.ACCEL)
initAccelKey();
this._existingShortcuts = Object.create(null);
let keys = window.document.getElementsByTagName("key");
for (let i = 0; i < keys.length; i++)
{
let key = keys[i];
let keyData =
{
shift: false,
meta: false,
alt: false,
control: false,
char: null,
code: null
};
let keyChar = key.getAttribute("key");
if (keyChar && keyChar.length == 1)
keyData.char = keyChar.toUpperCase();
let keyCode = key.getAttribute("keycode");
if (keyCode && "DOM_" + keyCode.toUpperCase() in Ci.nsIDOMKeyEvent)
keyData.code = Ci.nsIDOMKeyEvent["DOM_" + keyCode.toUpperCase()];
if (!keyData.char && !keyData.code)
continue;
let keyModifiers = key.getAttribute("modifiers");
if (keyModifiers)
for (let modifier of keyModifiers.toUpperCase().match(/\w+/g))
if (modifier in validModifiers)
keyData[validModifiers[modifier]] = true;
let canonical = [keyData.shift, keyData.meta, keyData.alt, keyData.control, keyData.char || keyData.code].join(" ");
this._existingShortcuts[canonical] = true;
}
},
/**
* Selects a keyboard shortcut variant that isn't already taken,
* parses it into an object.
*/
selectKey: function(/**String*/ variants) /**Object*/
{
for (let variant of variants.split(/\s*,\s*/))
{
if (!variant)
continue;
let keyData =
{
shift: false,
meta: false,
alt: false,
control: false,
char: null,
code: null,
codeName: null
};
for (let part of variant.toUpperCase().split(/\s+/))
{
if (part in validModifiers)
keyData[validModifiers[part]] = true;
else if (part.length == 1)
keyData.char = part;
else if ("DOM_VK_" + part in Ci.nsIDOMKeyEvent)
{
keyData.code = Ci.nsIDOMKeyEvent["DOM_VK_" + part];
keyData.codeName = "VK_" + part;
}
}
if (!keyData.char && !keyData.code)
continue;
let canonical = [keyData.shift, keyData.meta, keyData.alt, keyData.control, keyData.char || keyData.code].join(" ");
if (canonical in this._existingShortcuts)
continue;
return keyData;
}
return null;
}
};
/**
* Creates the text representation for a key.
* @static
*/
KeySelector.getTextForKey = function (/**Object*/ key) /**String*/
{
if (!key)
return null;
if (!("text" in key))
{
key.text = null;
try
{
let stringBundle = Services.strings.createBundle("chrome://global-platform/locale/platformKeys.properties");
let parts = [];
if (key.control)
parts.push(stringBundle.GetStringFromName("VK_CONTROL"));
if (key.alt)
parts.push(stringBundle.GetStringFromName("VK_ALT"));
if (key.meta)
parts.push(stringBundle.GetStringFromName("VK_META"));
if (key.shift)
parts.push(stringBundle.GetStringFromName("VK_SHIFT"));
if (key.char)
parts.push(key.char.toUpperCase());
else
{
let stringBundle2 = Services.strings.createBundle("chrome://global/locale/keys.properties");
parts.push(stringBundle2.GetStringFromName(key.codeName));
}
key.text = parts.join(stringBundle.GetStringFromName("MODIFIER_SEPARATOR"));
}
catch (e)
{
Cu.reportError(e);
return null;
}
}
return key.text;
};
/**
* Tests whether a keypress event matches the given key.
* @static
*/
KeySelector.matchesKey = function(/**Event*/ event, /**Object*/ key) /**Boolean*/
{
if (event.defaultPrevented || !key)
return false;
if (key.shift != event.shiftKey || key.alt != event.altKey)
return false;
if (key.meta != event.metaKey || key.control != event.ctrlKey)
return false;
if (key.char && event.charCode && String.fromCharCode(event.charCode).toUpperCase() == key.char)
return true;
if (key.code && event.keyCode && event.keyCode == key.code)
return true;
return false;
};
buildtools-master/lib/prefs.js 0000664 0000000 0000000 00000011743 12705153350 0016761 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
let {Services} = Cu.import("resource://gre/modules/Services.jsm", {});
let {XPCOMUtils} = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {});
let {addonRoot, addonName} = require("info");
let branchName = "extensions." + addonName + ".";
let branch = Services.prefs.getBranch(branchName);
let preconfiguredBranch =
Services.prefs.getBranch(branchName + "preconfigured.");
let ignorePrefChanges = false;
function init()
{
// Load default preferences and set up properties for them
let defaultBranch = Services.prefs.getDefaultBranch(branchName);
let prefsData = require("prefs.json");
let defaults = prefsData.defaults;
let preconfigurable = new Set(prefsData.preconfigurable);
for (let pref in defaults)
{
let value = defaults[pref];
let [getter, setter] = typeMap[typeof value];
if (preconfigurable.has(pref))
{
try
{
value = getter(preconfiguredBranch, pref);
}
catch (e) {}
}
setter(defaultBranch, pref, value);
defineProperty(pref, false, getter, setter);
}
// Add preference change observer
try
{
branch.QueryInterface(Ci.nsIPrefBranch2).addObserver("", Prefs, true);
onShutdown.add(() => branch.removeObserver("", Prefs));
}
catch (e)
{
Cu.reportError(e);
}
}
/**
* Sets up getter/setter on Prefs object for preference.
*/
function defineProperty(/**String*/ name, defaultValue, /**Function*/ readFunc, /**Function*/ writeFunc)
{
let value = defaultValue;
Prefs["_update_" + name] = () =>
{
try
{
value = readFunc(branch, name);
triggerListeners(name);
}
catch(e)
{
Cu.reportError(e);
}
};
Object.defineProperty(Prefs, name, {
enumerable: true,
get: () => value,
set: (newValue) =>
{
if (value == newValue)
return value;
try
{
ignorePrefChanges = true;
writeFunc(branch, name, newValue);
value = newValue;
Services.prefs.savePrefFile(null);
triggerListeners(name);
}
catch(e)
{
Cu.reportError(e);
}
finally
{
ignorePrefChanges = false;
}
return value;
}
});
Prefs["_update_" + name]();
}
let listeners = [];
function triggerListeners(/**String*/ name)
{
for (let i = 0; i < listeners.length; i++)
{
try
{
listeners[i](name);
}
catch(e)
{
Cu.reportError(e);
}
}
}
/**
* Manages the preferences for an extension, object properties corresponding
* to extension's preferences are added automatically. Setting the property
* will automatically change the preference, external preference changes are
* also recognized automatically.
*/
let Prefs = exports.Prefs =
{
/**
* Migrates an old preference to a new name.
*/
migrate: function(/**String*/ oldName, /**String*/ newName)
{
if (newName in this && Services.prefs.prefHasUserValue(oldName))
{
let [getter, setter] = typeMap[typeof this[newName]];
try
{
this[newName] = getter(Services.prefs, oldName);
} catch(e) {}
Services.prefs.clearUserPref(oldName);
}
},
/**
* Adds a preferences listener that will be fired whenever a preference
* changes.
*/
addListener: function(/**Function*/ listener)
{
if (listeners.indexOf(listener) < 0)
listeners.push(listener);
},
/**
* Removes a preferences listener.
*/
removeListener: function(/**Function*/ listener)
{
let index = listeners.indexOf(listener);
if (index >= 0)
listeners.splice(index, 1);
},
observe: function(subject, topic, data)
{
if (ignorePrefChanges || topic != "nsPref:changed")
return;
if ("_update_" + data in this)
this["_update_" + data]();
},
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupportsWeakReference, Ci.nsIObserver])
};
let getIntPref = (branch, pref) => branch.getIntPref(pref);
let setIntPref = (branch, pref, newValue) => branch.setIntPref(pref, newValue);
let getBoolPref = (branch, pref) => branch.getBoolPref(pref);
let setBoolPref = (branch, pref, newValue) => branch.setBoolPref(pref, newValue);
let getCharPref = (branch, pref) => branch.getComplexValue(pref, Ci.nsISupportsString).data;
let setCharPref = (branch, pref, newValue) =>
{
let str = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
str.data = newValue;
branch.setComplexValue(pref, Ci.nsISupportsString, str);
};
let getJSONPref = (branch, pref) => JSON.parse(getCharPref(branch, pref));
let setJSONPref = (branch, pref, newValue) => setCharPref(branch, pref, JSON.stringify(newValue));
// Getter/setter functions for difference preference types
let typeMap =
{
boolean: [getBoolPref, setBoolPref],
number: [getIntPref, setIntPref],
string: [getCharPref, setCharPref],
object: [getJSONPref, setJSONPref]
};
init();
buildtools-master/lib/windowObserver.js 0000664 0000000 0000000 00000005777 12705153350 0020673 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
exports.WindowObserver = WindowObserver;
/**
* This class will call listener's method applyToWindow() for all new chrome
* windows being opened. It will also call listener's method removeFromWindow()
* for all windows still open when the extension is shut down.
* @param {Object} listener
* @param {String} [when] when to execute applyToWindow(). "start" means immediately
* when the window opens, "ready" when its contents are available
* and "end" (default) means to wait until the "load" event.
* @constructor
*/
function WindowObserver(listener, when)
{
this._listener = listener;
this._when = when;
let windows = [];
let e = Services.wm.getZOrderDOMWindowEnumerator(null, true);
while (e.hasMoreElements())
windows.push(e.getNext());
// Check if there are any windows that we missed
let eAll = Services.ww.getWindowEnumerator();
while (eAll.hasMoreElements())
{
let element = eAll.getNext();
if (windows.indexOf(element) < 0)
windows.push(element);
}
for (let i = 0; i < windows.length; i++)
{
let window = windows[i].QueryInterface(Ci.nsIDOMWindow);
if (when == "start" || window.document.readyState == "complete")
this._listener.applyToWindow(window);
else
this.observe(window, "chrome-document-global-created", null);
}
Services.obs.addObserver(this, "chrome-document-global-created", true);
this._shutdownHandler = function()
{
let e = Services.ww.getWindowEnumerator();
while (e.hasMoreElements())
this._listener.removeFromWindow(e.getNext().QueryInterface(Ci.nsIDOMWindow));
Services.obs.removeObserver(this, "chrome-document-global-created");
}.bind(this);
onShutdown.add(this._shutdownHandler);
}
WindowObserver.prototype =
{
_listener: null,
_when: null,
_shutdownHandler: null,
shutdown: function()
{
if (!this._shutdownHandler)
return;
onShutdown.remove(this._shutdownHandler);
this._shutdownHandler();
this._shutdownHandler = null;
},
observe: function(subject, topic, data)
{
if (topic == "chrome-document-global-created")
{
let window = subject.QueryInterface(Ci.nsIDOMWindow);
if (this._when == "start")
{
this._listener.applyToWindow(window);
return;
}
let event = (this._when == "ready" ? "DOMContentLoaded" : "load");
let listener = function()
{
window.removeEventListener(event, listener, false);
if (this._shutdownHandler)
this._listener.applyToWindow(window);
}.bind(this);
window.addEventListener(event, listener, false);
}
},
QueryInterface: XPCOMUtils.generateQI([Ci.nsISupportsWeakReference, Ci.nsIObserver])
};
buildtools-master/localeTools.py 0000664 0000000 0000000 00000037435 12705153350 0017376 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import re
import os
import sys
import codecs
import json
import urllib
import urllib2
from StringIO import StringIO
from ConfigParser import SafeConfigParser
from zipfile import ZipFile
from xml.parsers.expat import ParserCreate, XML_PARAM_ENTITY_PARSING_ALWAYS
langMappingGecko = {
'bn-BD': 'bn',
'br': 'br-FR',
'dsb': 'dsb-DE',
'fj-FJ': 'fj',
'hsb': 'hsb-DE',
'hi-IN': 'hi',
'ml': 'ml-IN',
'nb-NO': 'nb',
'rm': 'rm-CH',
'ta-LK': 'ta',
'wo-SN': 'wo',
}
langMappingChrome = {
'es-419': 'es-MX',
'es': 'es-ES',
'sv': 'sv-SE',
'ml': 'ml-IN',
'gu': 'gu-IN',
}
chromeLocales = [
"am",
"ar",
"bg",
"bn",
"ca",
"cs",
"da",
"de",
"el",
"en-GB",
"en-US",
"es-419",
"es",
"et",
"fa",
"fi",
"fil",
"fr",
"gu",
"he",
"hi",
"hr",
"hu",
"id",
"it",
"ja",
"kn",
"ko",
"lt",
"lv",
"ml",
"mr",
"ms",
"nb",
"nl",
"pl",
"pt-BR",
"pt-PT",
"ro",
"ru",
"sk",
"sl",
"sr",
"sv",
"sw",
"ta",
"te",
"th",
"tr",
"uk",
"vi",
"zh-CN",
"zh-TW",
]
class OrderedDict(dict):
def __init__(self):
self.__order = []
def __setitem__(self, key, value):
self.__order.append(key)
dict.__setitem__(self, key, value)
def iteritems(self):
done = set()
for key in self.__order:
if not key in done and key in self:
yield (key, self[key])
done.add(key)
def escapeEntity(value):
return value.replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"')
def unescapeEntity(value):
return value.replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"')
def mapLocale(type, locale):
mapping = langMappingChrome if type == 'ISO-15897' else langMappingGecko
return mapping.get(locale, locale)
def parseDTDString(data, path):
result = []
currentComment = [None]
parser = ParserCreate()
parser.UseForeignDTD(True)
parser.SetParamEntityParsing(XML_PARAM_ENTITY_PARSING_ALWAYS)
def ExternalEntityRefHandler(context, base, systemId, publicId):
subparser = parser.ExternalEntityParserCreate(context, 'utf-8')
subparser.Parse(data.encode('utf-8'), True)
return 1
def CommentHandler(data):
currentComment[0] = data.strip()
def EntityDeclHandler(entityName, is_parameter_entity, value, base, systemId, publicId, notationName):
result.append((unescapeEntity(entityName), currentComment[0], unescapeEntity(value.strip())))
currentComment[0] = None
parser.ExternalEntityRefHandler = ExternalEntityRefHandler
parser.CommentHandler = CommentHandler
parser.EntityDeclHandler = EntityDeclHandler
parser.Parse('', True)
for entry in result:
yield entry
def escapeProperty(value):
return value.replace('\n', '\\n')
def unescapeProperty(value):
return value.replace('\\n', '\n')
def parsePropertiesString(data, path):
currentComment = None
for line in data.splitlines():
match = re.search(r'^\s*[#!]\s*(.*)', line)
if match:
currentComment = match.group(1)
elif '=' in line:
key, value = line.split('=', 1)
yield (unescapeProperty(key), currentComment, unescapeProperty(value))
currentComment = None
elif re.search(r'\S', line):
print >>sys.stderr, 'Unrecognized data in file %s: %s' % (path, line)
def parseString(data, path):
result = {'_origData': data}
if path.endswith('.dtd'):
it = parseDTDString(data, path)
elif path.endswith('.properties'):
it = parsePropertiesString(data, path)
else:
return None
for name, comment, value in it:
result[name] = value
return result
def readFile(path):
fileHandle = codecs.open(path, 'rb', encoding='utf-8')
data = fileHandle.read()
fileHandle.close()
return parseString(data, path)
def generateStringEntry(key, value, path):
if path.endswith('.dtd'):
return '\n' % (escapeEntity(key), escapeEntity(value))
else:
return '%s=%s\n' % (escapeProperty(key), escapeProperty(value))
def appendToFile(path, key, value):
fileHandle = codecs.open(path, 'ab', encoding='utf-8')
fileHandle.write(generateStringEntry(key, value, path))
fileHandle.close()
def removeFromFile(path, key):
fileHandle = codecs.open(path, 'rb', encoding='utf-8')
data = fileHandle.read()
fileHandle.close()
if path.endswith('.dtd'):
data = re.sub(r'\s*' % key, '', data, re.S)
else:
data = re.sub(r'(^|\n)%s=[^\n]*\n' % key, r'\1', data, re.S)
fileHandle = codecs.open(path, 'wb', encoding='utf-8')
fileHandle.write(data)
fileHandle.close()
def toJSON(path):
fileHandle = codecs.open(path, 'rb', encoding='utf-8')
data = fileHandle.read()
fileHandle.close()
if path.endswith('.dtd'):
it = parseDTDString(data, path)
elif path.endswith('.properties'):
it = parsePropertiesString(data, path)
else:
return None
result = OrderedDict()
for name, comment, value in it:
obj = {'message': value}
if comment == None:
obj['description'] = name
else:
obj['description'] = '%s: %s' % (name, comment)
result[name] = obj
return json.dumps(result, ensure_ascii=False, indent=2)
def fromJSON(path, data):
data = json.loads(data)
if not data:
if os.path.exists(path):
os.remove(path)
return
dir = os.path.dirname(path)
if not os.path.exists(dir):
os.makedirs(dir)
file = codecs.open(path, 'wb', encoding='utf-8')
for key, value in data.iteritems():
file.write(generateStringEntry(key, value['message'], path))
file.close()
def preprocessChromeLocale(path, metadata, isMaster):
fileHandle = codecs.open(path, 'rb', encoding='utf-8')
data = json.load(fileHandle)
fileHandle.close()
for key, value in data.iteritems():
if isMaster:
# Make sure the key name is listed in the description
if "description" in value:
value["description"] = "%s: %s" % (key, value["description"])
else:
value["description"] = key
else:
# Delete description from translations
if "description" in value:
del value["description"]
return json.dumps(data, ensure_ascii=False, sort_keys=True, indent=2)
def postprocessChromeLocale(path, data):
parsed = json.loads(data)
if isinstance(parsed, list):
return
# Delete description from translations
for key, value in parsed.iteritems():
if "description" in value:
del value["description"]
file = codecs.open(path, 'wb', encoding='utf-8')
json.dump(parsed, file, ensure_ascii=False, sort_keys=True, indent=2, separators=(',', ': '))
file.close()
def setupTranslations(localeConfig, projectName, key):
# Make a new set from the locales list, mapping to Crowdin friendly format
locales = {mapLocale(localeConfig['name_format'], locale)
for locale in localeConfig['locales']}
# Fill up with locales that we don't have but the browser supports
if 'chrome' in localeConfig['target_platforms']:
for locale in chromeLocales:
locales.add(mapLocale('ISO-15897', locale))
if 'gecko' in localeConfig['target_platforms']:
firefoxLocales = urllib2.urlopen('http://www.mozilla.org/en-US/firefox/all.html').read()
for match in re.finditer(r'&lang=([\w\-]+)"', firefoxLocales):
locales.add(mapLocale('BCP-47', match.group(1)))
langPacks = urllib2.urlopen('https://addons.mozilla.org/en-US/firefox/language-tools/').read()
for match in re.finditer(r'
.*?
', langPacks, re.S):
if match.group(0).find('Install Language Pack') >= 0:
match2 = re.search(r'lang="([\w\-]+)"', match.group(0))
if match2:
locales.add(mapLocale('BCP-47', match2.group(1)))
allowed = set()
allowedLocales = urllib2.urlopen('http://crowdin.net/page/language-codes').read()
for match in re.finditer(r'
\s*]*>([\w\-]+)', allowedLocales, re.S):
allowed.add(match.group(1))
if not allowed.issuperset(locales):
print 'Warning, following locales aren\'t allowed by server: ' + ', '.join(locales - allowed)
locales = list(locales & allowed)
locales.sort()
params = urllib.urlencode([('languages[]', locale) for locale in locales])
result = urllib2.urlopen('http://api.crowdin.net/api/project/%s/edit-project?key=%s' % (projectName, key), params).read()
if result.find(' 0:
if re.search(r'(^|\.)\d+$', version):
# Numerical version number - need to fill up with zeros to have three
# version components.
while version.count('.') < 2:
version += '.0'
version += '.' + buildNum
return version
def getTemplate(template, autoEscape=False):
import jinja2
templatePath = buildtools.__path__[0]
if autoEscape:
env = jinja2.Environment(loader=jinja2.FileSystemLoader(templatePath), autoescape=True)
else:
env = jinja2.Environment(loader=jinja2.FileSystemLoader(templatePath))
env.filters.update({'json': json.dumps})
return env.get_template(template)
class Files(dict):
def __init__(self, includedFiles, ignoredFiles, process=None):
self.includedFiles = includedFiles
self.ignoredFiles = ignoredFiles
self.process = process
def __setitem__(self, key, value):
if self.process:
value = self.process(key, value)
dict.__setitem__(self, key, value)
def isIncluded(self, relpath):
parts = relpath.split('/')
if not parts[0] in self.includedFiles:
return False
for part in parts:
if part in self.ignoredFiles:
return False
return True
def read(self, path, relpath='', skip=()):
if os.path.isdir(path):
for file in os.listdir(path):
name = relpath + ('/' if relpath != '' else '') + file
if name not in skip and self.isIncluded(name):
self.read(os.path.join(path, file), name, skip)
else:
with open(path, 'rb') as file:
if relpath in self:
print >>sys.stderr, 'Warning: File %s defined multiple times' % relpath
self[relpath] = file.read()
def readMappedFiles(self, mappings):
for item in mappings:
target, source = item
# Make sure the file is inside an included directory
if '/' in target and not self.isIncluded(target):
continue
parts = source.split('/')
path = os.path.join(os.path.dirname(item.source), *parts)
if os.path.exists(path):
self.read(path, target)
else:
print >>sys.stderr, 'Warning: Mapped file %s doesn\'t exist' % source
def preprocess(self, filenames, params={}):
import jinja2
env = jinja2.Environment()
for filename in filenames:
env.autoescape = os.path.splitext(filename)[1].lower() in ('.html', '.xml')
template = env.from_string(self[filename].decode('utf-8'))
self[filename] = template.render(params).encode('utf-8')
def zip(self, outFile, sortKey=None):
zip = zipfile.ZipFile(outFile, 'w', zipfile.ZIP_DEFLATED)
names = self.keys()
names.sort(key=sortKey)
for name in names:
zip.writestr(name, self[name])
zip.close()
def zipToString(self, sortKey=None):
buffer = StringIO()
self.zip(buffer, sortKey=sortKey)
return buffer.getvalue()
buildtools-master/packagerChrome.py 0000664 0000000 0000000 00000033044 12705153350 0020021 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import sys
import os
import re
import json
import struct
import io
from StringIO import StringIO
import packager
from packager import readMetadata, getMetadataPath, getDefaultFileName, getBuildVersion, getTemplate, Files
defaultLocale = 'en_US'
def getIgnoredFiles(params):
return {'store.description'}
def getPackageFiles(params):
result = set(('_locales', 'icons', 'jquery-ui', 'lib', 'skin', 'ui', 'ext'))
if params['devenv']:
result.add('qunit')
baseDir = params['baseDir']
for file in os.listdir(baseDir):
if file.endswith('.js') or file.endswith('.html') or file.endswith('.xml'):
result.add(file)
return result
def processFile(path, data, params):
# We don't change anything yet, this function currently only exists here so
# that it can be overridden if necessary.
return data
def makeIcons(files, filenames):
try:
from PIL import Image
except ImportError:
import Image
icons = {}
for filename in filenames:
width, height = Image.open(StringIO(files[filename])).size
if(width != height):
print >>sys.stderr, 'Warning: %s size is %ix%i, icon should be square' % (filename, width, height)
icons[width] = filename
return icons
def createScriptPage(params, template_name, script_option):
template = getTemplate(template_name, autoEscape=True)
return template.render(
basename=params['metadata'].get('general', 'basename'),
scripts=params['metadata'].get(*script_option).split()
).encode('utf-8')
def createManifest(params, files):
template = getTemplate('manifest.json.tmpl')
templateData = dict(params)
baseDir = templateData['baseDir']
metadata = templateData['metadata']
for opt in ('browserAction', 'pageAction'):
if not metadata.has_option('general', opt):
continue
icons = metadata.get('general', opt).split()
if not icons:
continue
if len(icons) == 1:
# ... = icon.png
icon, popup = icons[0], None
elif len(icons) == 2:
# ... = icon.png popup.html
icon, popup = icons
else:
# ... = icon-19.png icon-38.png popup.html
popup = icons.pop()
icon = makeIcons(files, icons)
templateData[opt] = {'icon': icon, 'popup': popup}
if metadata.has_option('general', 'icons'):
templateData['icons'] = makeIcons(files,
metadata.get('general', 'icons').split())
if metadata.has_option('general', 'permissions'):
templateData['permissions'] = metadata.get('general', 'permissions').split()
if metadata.has_option('general', 'optionalPermissions'):
templateData['optionalPermissions'] = metadata.get(
'general', 'optionalPermissions').split()
if metadata.has_option('general', 'backgroundScripts'):
templateData['backgroundScripts'] = metadata.get(
'general', 'backgroundScripts').split()
if params['devenv']:
templateData['backgroundScripts'].append('devenvPoller__.js')
if metadata.has_option('general', 'webAccessible') and metadata.get('general', 'webAccessible') != '':
templateData['webAccessible'] = metadata.get('general',
'webAccessible').split()
if metadata.has_section('contentScripts'):
contentScripts = []
for run_at, scripts in metadata.items('contentScripts'):
if scripts == '':
continue
contentScripts.append({
'matches': ['http://*/*', 'https://*/*'],
'js': scripts.split(),
'run_at': run_at,
'all_frames': True,
'match_about_blank': True,
})
templateData['contentScripts'] = contentScripts
manifest = template.render(templateData)
# Normalize JSON structure
licenseComment = re.compile(r'/\*.*?\*/', re.S)
data = json.loads(re.sub(licenseComment, '', manifest, 1))
if '_dummy' in data:
del data['_dummy']
manifest = json.dumps(data, sort_keys=True, indent=2)
return manifest.encode('utf-8')
def createInfoModule(params):
template = getTemplate('chromeInfo.js.tmpl')
return template.render(params).encode('utf-8')
def convertJS(params, files):
from jshydra.abp_rewrite import doRewrite
for item in params['metadata'].items('convert_js'):
file, sources = item
baseDir = os.path.dirname(item.source)
# Make sure the file is inside an included directory
if '/' in file and not files.isIncluded(file):
continue
sourceFiles = sources.split()
args = []
try:
argsStart = sourceFiles.index('--arg')
args = sourceFiles[argsStart + 1:]
sourceFiles = sourceFiles[0:argsStart]
except ValueError:
pass
# Source files of the conversion shouldn't be part of the build
for sourceFile in sourceFiles:
if sourceFile in files:
del files[sourceFile]
sourceFiles = map(lambda f: os.path.abspath(os.path.join(baseDir, f)), sourceFiles)
files[file] = doRewrite(sourceFiles, args)
def toJson(data):
return json.dumps(
data, ensure_ascii=False, sort_keys=True,
indent=2, separators=(',', ': ')
).encode('utf-8') + '\n'
def importGeckoLocales(params, files):
import localeTools
# FIXME: localeTools doesn't use real Chrome locales, it uses dash as
# separator instead.
convert_locale_code = lambda code: code.replace('-', '_')
# We need to map Chrome locales to Gecko locales. Start by mapping Chrome
# locales to themselves, merely with the dash as separator.
locale_mapping = {convert_locale_code(l): l for l in localeTools.chromeLocales}
# Convert values to Crowdin locales first (use Chrome => Crowdin mapping).
for chrome_locale, crowdin_locale in localeTools.langMappingChrome.iteritems():
locale_mapping[convert_locale_code(chrome_locale)] = crowdin_locale
# Now convert values to Gecko locales (use Gecko => Crowdin mapping).
reverse_mapping = {v: k for k, v in locale_mapping.iteritems()}
for gecko_locale, crowdin_locale in localeTools.langMappingGecko.iteritems():
if crowdin_locale in reverse_mapping:
locale_mapping[reverse_mapping[crowdin_locale]] = gecko_locale
for target, source in locale_mapping.iteritems():
targetFile = '_locales/%s/messages.json' % target
if not targetFile in files:
continue
for item in params['metadata'].items('import_locales'):
fileName, keys = item
parts = map(lambda n: source if n == '*' else n, fileName.split('/'))
sourceFile = os.path.join(os.path.dirname(item.source), *parts)
incompleteMarker = os.path.join(os.path.dirname(sourceFile), '.incomplete')
if not os.path.exists(sourceFile) or os.path.exists(incompleteMarker):
continue
data = json.loads(files[targetFile].decode('utf-8'))
try:
if sourceFile.endswith('.json'):
with io.open(sourceFile, 'r', encoding='utf-8') as handle:
sourceData = {k: v['message'] for k, v in json.load(handle).iteritems()}
else:
sourceData = localeTools.readFile(sourceFile)
# Resolve wildcard imports
if keys == '*' or keys == '=*':
importList = sourceData.keys()
importList = filter(lambda k: not k.startswith('_'), importList)
if keys == '=*':
importList = map(lambda k: '=' + k, importList)
keys = ' '.join(importList)
for stringID in keys.split():
noMangling = False
if stringID.startswith('='):
stringID = stringID[1:]
noMangling = True
if stringID in sourceData:
if noMangling:
key = re.sub(r'\W', '_', stringID)
else:
key = re.sub(r'\..*', '', parts[-1]) + '_' + re.sub(r'\W', '_', stringID)
if key in data:
print 'Warning: locale string %s defined multiple times' % key
# Remove access keys
value = sourceData[stringID]
match = re.search(r'^(.*?)\s*\(&.\)$', value)
if match:
value = match.group(1)
else:
index = value.find("&")
if index >= 0:
value = value[0:index] + value[index + 1:]
data[key] = {'message': value}
except Exception, e:
print 'Warning: error importing locale data from %s: %s' % (sourceFile, e)
files[targetFile] = toJson(data)
def truncate(text, length_limit):
if len(text) <= length_limit:
return text
return text[:length_limit - 1].rstrip() + u"\u2026"
def fixTranslationsForCWS(files):
# Chrome Web Store requires messages used in manifest.json to be present in
# all languages. It also enforces length limits for extension names and
# descriptions.
defaults = {}
data = json.loads(files['_locales/%s/messages.json' % defaultLocale])
for match in re.finditer(r'__MSG_(\S+)__', files['manifest.json']):
name = match.group(1)
defaults[name] = data[name]
limits = {}
manifest = json.loads(files['manifest.json'])
for key, limit in (('name', 45), ('description', 132), ('short_name', 12)):
match = re.search(r'__MSG_(\S+)__', manifest.get(key, ""))
if match:
limits[match.group(1)] = limit
for filename in files:
if not filename.startswith('_locales/') or not filename.endswith('/messages.json'):
continue
data = json.loads(files[filename])
for name, info in defaults.iteritems():
data.setdefault(name, info)
for name, limit in limits.iteritems():
if name in data:
data[name]['message'] = truncate(data[name]['message'], limit)
files[filename] = toJson(data)
def signBinary(zipdata, keyFile):
import M2Crypto
if not os.path.exists(keyFile):
M2Crypto.RSA.gen_key(1024, 65537, callback=lambda x: None).save_key(keyFile, cipher=None)
key = M2Crypto.EVP.load_key(keyFile)
key.sign_init()
key.sign_update(zipdata)
return key.final()
def getPublicKey(keyFile):
import M2Crypto
return M2Crypto.EVP.load_key(keyFile).as_der()
def writePackage(outputFile, pubkey, signature, zipdata):
if isinstance(outputFile, basestring):
file = open(outputFile, 'wb')
else:
file = outputFile
if pubkey != None and signature != None:
file.write(struct.pack('<4sIII', 'Cr24', 2, len(pubkey), len(signature)))
file.write(pubkey)
file.write(signature)
file.write(zipdata)
def createBuild(baseDir, type='chrome', outFile=None, buildNum=None, releaseBuild=False, keyFile=None, devenv=False):
metadata = readMetadata(baseDir, type)
version = getBuildVersion(baseDir, metadata, releaseBuild, buildNum)
if outFile == None:
outFile = getDefaultFileName(metadata, version, 'crx' if keyFile else 'zip')
params = {
'type': type,
'baseDir': baseDir,
'releaseBuild': releaseBuild,
'version': version,
'devenv': devenv,
'metadata': metadata,
}
mapped = metadata.items('mapping') if metadata.has_section('mapping') else []
files = Files(getPackageFiles(params), getIgnoredFiles(params),
process=lambda path, data: processFile(path, data, params))
files.readMappedFiles(mapped)
files.read(baseDir, skip=[opt for opt, _ in mapped])
if metadata.has_section('convert_js'):
convertJS(params, files)
if metadata.has_section('preprocess'):
files.preprocess(
[f for f, _ in metadata.items('preprocess')],
{'needsExt': True}
)
if metadata.has_section('import_locales'):
importGeckoLocales(params, files)
files['manifest.json'] = createManifest(params, files)
if type == 'chrome':
fixTranslationsForCWS(files)
if devenv:
import buildtools
import random
files.read(os.path.join(buildtools.__path__[0], 'chromeDevenvPoller__.js'), relpath='devenvPoller__.js')
files['devenvVersion__'] = str(random.random())
if (metadata.has_option('general', 'backgroundScripts') and
'lib/info.js' in metadata.get('general', 'backgroundScripts').split() and
'lib/info.js' not in files):
files['lib/info.js'] = createInfoModule(params)
if metadata.has_option('general', 'testScripts'):
files['qunit/index.html'] = createScriptPage(params, 'testIndex.html.tmpl',
('general', 'testScripts'))
zipdata = files.zipToString()
signature = None
pubkey = None
if keyFile != None:
signature = signBinary(zipdata, keyFile)
pubkey = getPublicKey(keyFile)
writePackage(outFile, pubkey, signature, zipdata)
buildtools-master/packagerGecko.py 0000664 0000000 0000000 00000034373 12705153350 0017642 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import os
import sys
import re
import hashlib
import base64
import urllib
import json
import io
from ConfigParser import SafeConfigParser
from StringIO import StringIO
import xml.dom.minidom as minidom
import buildtools.localeTools as localeTools
import packager
from packager import readMetadata, getMetadataPath, getDefaultFileName, getBuildVersion, getTemplate, Files
KNOWN_APPS = {
'conkeror': '{a79fe89b-6662-4ff4-8e88-09950ad4dfde}',
'emusic': 'dlm@emusic.com',
'fennec': '{a23983c0-fd0e-11dc-95ff-0800200c9a66}',
'fennec2': '{aa3c5121-dab2-40e2-81ca-7ea25febc110}',
'firefox': '{ec8030f7-c20a-464f-9b0e-13a3a9e97384}',
'midbrowser': '{aa5ca914-c309-495d-91cf-3141bbb04115}',
'prism': 'prism@developer.mozilla.org',
'seamonkey': '{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}',
'songbird': 'songbird@songbirdnest.com',
'thunderbird': '{3550f703-e582-4d05-9a08-453d09bdfdc6}',
'toolkit': 'toolkit@mozilla.org',
'adblockbrowser': '{55aba3ac-94d3-41a8-9e25-5c21fe874539}',
}
defaultLocale = 'en-US'
def getChromeDir(baseDir):
return os.path.join(baseDir, 'chrome')
def getLocalesDir(baseDir):
return os.path.join(getChromeDir(baseDir), 'locale')
def getChromeSubdirs(baseDir, locales):
result = {}
chromeDir = getChromeDir(baseDir)
for subdir in ('content', 'skin'):
result[subdir] = os.path.join(chromeDir, subdir)
for locale in locales:
result['locale/%s' % locale] = os.path.join(chromeDir, 'locale', locale)
return result
def getPackageFiles(params):
result = set(('chrome', 'components', 'modules', 'lib', 'resources', 'chrome.manifest', 'icon.png', 'icon64.png',))
baseDir = params['baseDir']
for file in os.listdir(baseDir):
if file.endswith('.js') or file.endswith('.xml'):
result.add(file)
return result
def getIgnoredFiles(params):
return {'.incomplete', 'meta.properties'}
def archive_path(path, baseDir):
return '/'.join(os.path.split(os.path.relpath(path, baseDir)))
def isValidLocale(localesDir, dir, includeIncomplete=False):
if re.search(r'[^\w\-]', dir):
return False
curLocaleDir = os.path.join(localesDir, dir)
if not os.path.isdir(curLocaleDir):
return False
if len(os.listdir(curLocaleDir)) == 0:
return False
if not includeIncomplete and os.path.exists(os.path.join(localesDir, dir, '.incomplete')):
return False
return True
def getLocales(baseDir, includeIncomplete=False):
global defaultLocale
localesDir = getLocalesDir(baseDir)
locales = filter(lambda dir: isValidLocale(localesDir, dir, includeIncomplete), os.listdir(localesDir))
locales.sort(key=lambda x: '!' if x == defaultLocale else x)
return locales
def processFile(path, data, params):
if path.endswith('.manifest') and data.find('{{LOCALE}}') >= 0:
localesRegExp = re.compile(r'^(.*?){{LOCALE}}(.*?){{LOCALE}}(.*)$', re.M)
replacement = '\n'.join(map(lambda locale: r'\1%s\2%s\3' % (locale, locale), params['locales']))
data = re.sub(localesRegExp, replacement, data)
return data
def readLocaleMetadata(baseDir, locales):
result = {}
# Make sure we always have fallback data even if the default locale isn't part
# of the build
locales = list(locales)
if not defaultLocale in locales:
locales.append(defaultLocale)
for locale in locales:
data = SafeConfigParser()
data.optionxform = str
try:
result[locale] = localeTools.readFile(os.path.join(getLocalesDir(baseDir), locale, 'meta.properties'))
except:
result[locale] = {}
return result
def getContributors(metadata):
main = []
additional = set()
if metadata.has_section('contributors'):
options = metadata.options('contributors')
options.sort()
for option in options:
value = metadata.get('contributors', option)
if re.search(r'\D', option):
match = re.search(r'^\s*(\S+)\s+//([^/\s]+)/@(\S+)\s*$', value)
if not match:
print >>sys.stderr, 'Warning: unrecognized contributor location "%s"\n' % value
continue
baseDir = os.path.dirname(metadata.option_source('contributors', option))
parts = match.group(1).split('/')
dom = minidom.parse(os.path.join(baseDir, *parts))
tags = dom.getElementsByTagName(match.group(2))
for tag in tags:
if tag.hasAttribute(match.group(3)):
for name in re.split(r'\s*,\s*', tag.getAttribute(match.group(3))):
additional.add(name)
else:
main.append(value)
return main + sorted(additional, key=unicode.lower)
def initTranslators(localeMetadata):
for locale in localeMetadata.itervalues():
if 'translator' in locale:
locale['translators'] = sorted(map(lambda t: t.strip(), locale['translator'].split(',')), key=unicode.lower)
else:
locale['translators'] = []
def createManifest(params):
global KNOWN_APPS, defaultLocale
template = getTemplate('install.rdf.tmpl', autoEscape=True)
templateData = dict(params)
templateData['localeMetadata'] = readLocaleMetadata(params['baseDir'], params['locales'])
initTranslators(templateData['localeMetadata'])
templateData['KNOWN_APPS'] = KNOWN_APPS
templateData['defaultLocale'] = defaultLocale
return template.render(templateData).encode('utf-8')
def importLocales(params, files):
SECTION = 'import_locales'
if not params['metadata'].has_section(SECTION):
return
import localeTools
for locale in params['locales']:
for item in params['metadata'].items(SECTION):
path, keys = item
parts = [locale if p == '*' else p for p in path.split('/')]
source = os.path.join(os.path.dirname(item.source), *parts)
if not os.path.exists(source):
continue
with io.open(source, 'r', encoding='utf-8') as handle:
data = json.load(handle)
target_name = os.path.splitext(os.path.basename(source))[0] + '.properties'
target = archive_path(os.path.join(getLocalesDir(params['baseDir']), locale, target_name), params['baseDir'])
files[target] = ''
for key, value in sorted(data.items()):
message = value['message']
files[target] += localeTools.generateStringEntry(key, message, target).encode('utf-8')
def fixupLocales(params, files):
global defaultLocale
# Read in default locale data, it might not be included in package files
defaultLocaleDir = os.path.join(getLocalesDir(params['baseDir']), defaultLocale)
reference_files = Files(getPackageFiles(params), getIgnoredFiles(params))
reference_files.read(defaultLocaleDir, archive_path(defaultLocaleDir, params['baseDir']))
reference_params = dict(params)
reference_params['locales'] = [defaultLocale]
importLocales(reference_params, reference_files)
reference = {}
for path, data in reference_files.iteritems():
filename = path.split('/')[-1]
data = localeTools.parseString(data.decode('utf-8'), filename)
if data:
reference[filename] = data
for locale in params['locales']:
for file in reference.iterkeys():
path = 'chrome/locale/%s/%s' % (locale, file)
if path in files:
data = localeTools.parseString(files[path].decode('utf-8'), path)
for key, value in reference[file].iteritems():
if not key in data:
files[path] += localeTools.generateStringEntry(key, value, path).encode('utf-8')
else:
files[path] = reference[file]['_origData'].encode('utf-8')
def processJSONFiles(params, files):
prefix = 'lib/'
for name, content in files.iteritems():
if name.startswith(prefix) and name.endswith('.json'):
params['jsonRequires'][name[len(prefix):]] = json.loads(content)
for name in params['jsonRequires'].iterkeys():
del files[prefix + name]
def addMissingFiles(params, files):
templateData = {
'hasChrome': False,
'hasChromeRequires': False,
'hasShutdownHandlers': False,
'hasXMLHttpRequest': False,
'chromeWindows': [],
'requires': set(),
'jsonRequires': params['jsonRequires'],
'metadata': params['metadata'],
'multicompartment': params['multicompartment'],
'applications': dict((v, k) for k, v in KNOWN_APPS.iteritems()),
}
def checkScript(name):
content = files[name]
for match in re.finditer(r'(?:^|\s)require\(\s*"([\w\-]+)"\s*\)', content):
templateData['requires'].add(match.group(1))
if name.startswith('chrome/content/'):
templateData['hasChromeRequires'] = True
if name.startswith('lib/') and re.search(r'\bXMLHttpRequest\b', content):
templateData['hasXMLHttpRequest'] = True
if not '/' in name or name.startswith('lib/'):
if re.search(r'(?:^|\s)onShutdown\.', content):
templateData['hasShutdownHandlers'] = True
for name, content in files.iteritems():
if name == 'chrome.manifest':
templateData['hasChrome'] = True
elif name.endswith('.js'):
checkScript(name)
elif name.endswith('.xul'):
match = re.search(r'<(?:window|dialog)\s[^>]*\bwindowtype="([^">]+)"', content)
if match:
templateData['chromeWindows'].append(match.group(1))
while True:
missing = []
for module in templateData['requires']:
moduleFile = 'lib/' + module + '.js'
if not moduleFile in files:
import buildtools
path = os.path.join(buildtools.__path__[0], moduleFile)
if os.path.exists(path):
missing.append((path, moduleFile))
if not len(missing):
break
for path, moduleFile in missing:
files.read(path, moduleFile)
checkScript(moduleFile)
template = getTemplate('bootstrap.js.tmpl')
files['bootstrap.js'] = template.render(templateData).encode('utf-8')
def signFiles(files, keyFile):
import M2Crypto
manifest = []
signature = []
def getDigest(data):
md5 = hashlib.md5()
md5.update(data)
sha1 = hashlib.sha1()
sha1.update(data)
return 'Digest-Algorithms: MD5 SHA1\nMD5-Digest: %s\nSHA1-Digest: %s\n' % (base64.b64encode(md5.digest()), base64.b64encode(sha1.digest()))
def addSection(manifestData, signaturePrefix):
manifest.append(manifestData)
signatureData = ''
if signaturePrefix:
signatureData += signaturePrefix
signatureData += getDigest(manifestData)
signature.append(signatureData)
addSection('Manifest-Version: 1.0\n', 'Signature-Version: 1.0\n')
fileNames = files.keys()
fileNames.sort()
for fileName in fileNames:
addSection('Name: %s\n%s' % (fileName, getDigest(files[fileName])), 'Name: %s\n' % fileName)
files['META-INF/manifest.mf'] = '\n'.join(manifest)
files['META-INF/zigbert.sf'] = '\n'.join(signature)
keyHandle = open(keyFile, 'rb')
keyData = keyHandle.read()
keyHandle.close()
stack = M2Crypto.X509.X509_Stack()
first = True
for match in re.finditer(r'-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----', keyData, re.S):
if first:
# Skip first certificate
first = False
else:
stack.push(M2Crypto.X509.load_cert_string(match.group(0)))
mime = M2Crypto.SMIME.SMIME()
mime.load_key(keyFile)
mime.set_x509_stack(stack)
signature = mime.sign(M2Crypto.BIO.MemoryBuffer(files['META-INF/zigbert.sf'].encode('utf-8')), M2Crypto.SMIME.PKCS7_DETACHED | M2Crypto.SMIME.PKCS7_BINARY)
buffer = M2Crypto.BIO.MemoryBuffer()
signature.write_der(buffer)
files['META-INF/zigbert.rsa'] = buffer.read()
def createBuild(baseDir, type="gecko", outFile=None, locales=None, buildNum=None, releaseBuild=False, keyFile=None, multicompartment=False):
if locales == None:
locales = getLocales(baseDir)
elif locales == 'all':
locales = getLocales(baseDir, True)
metadata = readMetadata(baseDir, type)
version = getBuildVersion(baseDir, metadata, releaseBuild, buildNum)
if outFile == None:
outFile = getDefaultFileName(metadata, version, 'xpi')
contributors = getContributors(metadata)
params = {
'baseDir': baseDir,
'locales': locales,
'releaseBuild': releaseBuild,
'version': version.encode('utf-8'),
'metadata': metadata,
'contributors': contributors,
'multicompartment': multicompartment,
'jsonRequires': {},
}
mapped = metadata.items('mapping') if metadata.has_section('mapping') else []
skip = [opt for opt, _ in mapped] + ['chrome']
files = Files(getPackageFiles(params), getIgnoredFiles(params),
process=lambda path, data: processFile(path, data, params))
files['install.rdf'] = createManifest(params)
files.readMappedFiles(mapped)
files.read(baseDir, skip=skip)
for name, path in getChromeSubdirs(baseDir, params['locales']).iteritems():
if os.path.isdir(path):
files.read(path, 'chrome/%s' % name, skip=skip)
importLocales(params, files)
fixupLocales(params, files)
processJSONFiles(params, files)
if not 'bootstrap.js' in files:
addMissingFiles(params, files)
if metadata.has_section('preprocess'):
files.preprocess([f for f, _ in metadata.items('preprocess')])
if keyFile:
signFiles(files, keyFile)
files.zip(outFile, sortKey=lambda x: '!' if x == 'META-INF/zigbert.rsa' else x)
def autoInstall(baseDir, type, host, port, multicompartment=False):
fileBuffer = StringIO()
createBuild(baseDir, type=type, outFile=fileBuffer, multicompartment=multicompartment)
urllib.urlopen('http://%s:%s/' % (host, port), data=fileBuffer.getvalue())
buildtools-master/packagerSafari.py 0000664 0000000 0000000 00000021342 12705153350 0020007 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import os
import re
import json
import ConfigParser
from urlparse import urlparse
from packager import readMetadata, getDefaultFileName, getBuildVersion, getTemplate, Files
from packagerChrome import convertJS, importGeckoLocales, getIgnoredFiles, getPackageFiles, defaultLocale, createScriptPage
def processFile(path, data, params):
return data
def createManifest(params, files):
template = getTemplate('Info.plist.tmpl', autoEscape=True)
metadata = params['metadata']
catalog = json.loads(files['_locales/%s/messages.json' % defaultLocale])
def parse_section(section, depth=1):
result = {}
if not metadata.has_section(section):
return result
for opt in metadata.options(section):
bits = opt.split('_', depth)
key = bits.pop().replace('_', ' ').title()
val = metadata.get(section, opt)
try:
val = int(val)
except ValueError:
try:
val = float(val)
except ValueError:
pass
reduce(lambda d, x: d.setdefault(x, {}), bits, result)[key] = val
return result
def get_optional(*args):
try:
return metadata.get(*args)
except ConfigParser.Error:
return None
allowedDomains = set()
allowAllDomains = False
allowSecurePages = False
for perm in metadata.get('general', 'permissions').split():
if perm == '':
allowAllDomains = True
allowSecurePages = True
continue
url = urlparse(perm)
if url.scheme == 'https':
allowSecurePages = True
elif url.scheme != 'http':
continue
if '*' in url.hostname:
allowAllDomains = True
continue
allowedDomains.add(url.hostname)
return template.render(
basename=metadata.get('general', 'basename'),
version=params['version'],
releaseBuild=params['releaseBuild'],
name=catalog['name']['message'],
description=catalog['description']['message'],
author=get_optional('general', 'author'),
homepage=get_optional('general', 'homepage'),
updateURL=get_optional('general', 'updateURL'),
allowedDomains=allowedDomains,
allowAllDomains=allowAllDomains,
allowSecurePages=allowSecurePages,
startScripts=(get_optional('contentScripts', 'document_start') or '').split(),
endScripts=(get_optional('contentScripts', 'document_end') or '').split(),
menus=parse_section('menus', 2),
toolbarItems=parse_section('toolbar_items'),
popovers=parse_section('popovers'),
developerIdentifier=params.get('developerIdentifier')
).encode('utf-8')
def createInfoModule(params):
template = getTemplate('safariInfo.js.tmpl')
return template.render(params).encode('utf-8')
def fixAbsoluteUrls(files):
for filename, content in files.iteritems():
if os.path.splitext(filename)[1].lower() == '.html':
files[filename] = re.sub(
r'(<[^<>]*?\b(?:href|src)\s*=\s*["\']?)\/+',
r'\1' + '/'.join(['..'] * filename.count('/') + ['']),
content, re.S | re.I
)
def get_certificates_and_key(keyfile):
import M2Crypto
certs = []
bio = M2Crypto.BIO.openfile(keyfile)
try:
key = M2Crypto.RSA.load_key_bio(bio)
bio.reset()
while True:
try:
certs.append(M2Crypto.X509.load_cert_bio(bio))
except M2Crypto.X509.X509Error:
break
finally:
bio.close()
return certs, key
def get_developer_identifier(certs):
for cert in certs:
subject = cert.get_subject()
for entry in subject.get_entries_by_nid(subject.nid['CN']):
m = re.match(r'Safari Developer: \((.*?)\)', entry.get_data().as_text())
if m:
return m.group(1)
raise Exception('No Safari developer certificate found in chain')
def createSignedXarArchive(outFile, files, certs, key):
import subprocess
import tempfile
import shutil
import M2Crypto
# write files to temporary directory and create a xar archive
dirname = tempfile.mkdtemp()
try:
for filename, contents in files.iteritems():
path = os.path.join(dirname, filename)
try:
os.makedirs(os.path.dirname(path))
except OSError:
pass
with open(path, 'wb') as file:
file.write(contents)
subprocess.check_output(
['xar', '-czf', os.path.abspath(outFile), '--distribution'] + os.listdir(dirname),
cwd=dirname
)
finally:
shutil.rmtree(dirname)
certificate_filenames = []
try:
# write each certificate in DER format to a separate
# temporary file, that they can be passed to xar
for cert in certs:
fd, filename = tempfile.mkstemp()
try:
certificate_filenames.append(filename)
os.write(fd, cert.as_der())
finally:
os.close(fd)
# add certificates and placeholder signature
# to the xar archive, and get data to sign
fd, digestinfo_filename = tempfile.mkstemp()
os.close(fd)
try:
subprocess.check_call(
[
'xar', '--sign', '-f', outFile,
'--digestinfo-to-sign', digestinfo_filename,
'--sig-size', str(len(key.private_encrypt('', M2Crypto.RSA.pkcs1_padding)))
] + [
arg for cert in certificate_filenames for arg in ('--cert-loc', cert)
]
)
with open(digestinfo_filename, 'rb') as file:
digestinfo = file.read()
finally:
os.unlink(digestinfo_filename)
finally:
for filename in certificate_filenames:
os.unlink(filename)
# sign data and inject signature into xar archive
fd, signature_filename = tempfile.mkstemp()
try:
try:
os.write(fd, key.private_encrypt(
digestinfo,
M2Crypto.RSA.pkcs1_padding
))
finally:
os.close(fd)
subprocess.check_call(['xar', '--inject-sig', signature_filename, '-f', outFile])
finally:
os.unlink(signature_filename)
def createBuild(baseDir, type, outFile=None, buildNum=None, releaseBuild=False, keyFile=None, devenv=False):
metadata = readMetadata(baseDir, type)
version = getBuildVersion(baseDir, metadata, releaseBuild, buildNum)
if not outFile:
outFile = getDefaultFileName(metadata, version, 'safariextz' if keyFile else 'zip')
params = {
'type': type,
'baseDir': baseDir,
'releaseBuild': releaseBuild,
'version': version,
'devenv': devenv,
'metadata': metadata,
}
mapped = metadata.items('mapping') if metadata.has_section('mapping') else []
files = Files(getPackageFiles(params), getIgnoredFiles(params),
process=lambda path, data: processFile(path, data, params))
files.readMappedFiles(mapped)
files.read(baseDir, skip=[opt for opt, _ in mapped])
if metadata.has_section('convert_js'):
convertJS(params, files)
if metadata.has_section('preprocess'):
files.preprocess(
[f for f, _ in metadata.items('preprocess')],
{'needsExt': True}
)
if metadata.has_section('import_locales'):
importGeckoLocales(params, files)
if metadata.has_option('general', 'testScripts'):
files['qunit/index.html'] = createScriptPage(params, 'testIndex.html.tmpl',
('general', 'testScripts'))
if keyFile:
certs, key = get_certificates_and_key(keyFile)
params['developerIdentifier'] = get_developer_identifier(certs)
files['lib/info.js'] = createInfoModule(params)
files['background.html'] = createScriptPage(params, 'background.html.tmpl',
('general', 'backgroundScripts'))
files['Info.plist'] = createManifest(params, files)
fixAbsoluteUrls(files)
dirname = metadata.get('general', 'basename') + '.safariextension'
for filename in files.keys():
files[os.path.join(dirname, filename)] = files.pop(filename)
if not devenv and keyFile:
createSignedXarArchive(outFile, files, certs, key)
else:
files.zip(outFile)
buildtools-master/publicSuffixListUpdater.py 0000664 0000000 0000000 00000003135 12705153350 0021730 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""
Update the public suffix list
==============================
This script generates a js array of public suffixes (http://publicsuffix.org/)
"""
import os
import urllib
import json
def urlopen(url, attempts=3):
"""
Tries to open a particular URL, retries on failure.
"""
for i in range(attempts):
try:
return urllib.urlopen(url)
except IOError, e:
error = e
time.sleep(5)
raise error
def getPublicSuffixList():
"""
gets download link for a Gecko add-on from the Mozilla Addons site
"""
suffixes = {}
url = 'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1'
resource = urlopen(url)
for line in resource:
line = line.rstrip()
if line.startswith("//") or "." not in line:
continue
if line.startswith('*.'):
suffixes[line[2:]] = 2
elif line.startswith('!'):
suffixes[line[1:]] = 0
else:
suffixes[line] = 1
return suffixes
def updatePSL(baseDir):
"""
writes the current public suffix list to js file in json format
"""
psl = getPublicSuffixList()
file = open(os.path.join(baseDir, 'lib', 'publicSuffixList.js'), 'w')
print >>file, 'var publicSuffixes = ' + json.dumps(psl, sort_keys=True, indent=4, separators=(',', ': ')) + ';'
file.close()
buildtools-master/releaseAutomation.py 0000664 0000000 0000000 00000012044 12705153350 0020564 0 ustar 00root root 0000000 0000000 # coding: utf-8
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import os
import re
import codecs
import subprocess
import tarfile
import json
def get_dependencies(prefix, repos):
from ensure_dependencies import read_deps, safe_join
repo = repos[prefix]
deps = read_deps(repo)
if deps:
for subpath in deps:
if subpath.startswith('_'):
continue
depprefix = prefix + subpath + '/'
deppath = safe_join(repo, subpath)
repos[depprefix] = deppath
get_dependencies(depprefix, repos)
def create_sourcearchive(repo, output):
with tarfile.open(output, mode='w:gz') as archive:
repos = {'': repo}
get_dependencies('', repos)
for prefix, path in repos.iteritems():
process = subprocess.Popen(['hg', 'archive', '-R', path, '-t', 'tar', '-S', '-'], stdout=subprocess.PIPE)
try:
with tarfile.open(fileobj=process.stdout, mode='r|') as repoarchive:
for fileinfo in repoarchive:
if os.path.basename(fileinfo.name) in ('.hgtags', '.hgignore'):
continue
filedata = repoarchive.extractfile(fileinfo)
fileinfo.name = re.sub(r'^[^/]+/', prefix, fileinfo.name)
archive.addfile(fileinfo, filedata)
finally:
process.stdout.close()
process.wait()
def run(baseDir, type, version, keyFiles, downloadsRepo):
if type == "gecko":
import buildtools.packagerGecko as packager
elif type == "chrome":
import buildtools.packagerChrome as packager
# Replace version number in metadata file "manually", ConfigParser will mess
# up the order of lines.
metadata = packager.readMetadata(baseDir, type)
with open(metadata.option_source("general", "version"), 'r+b') as file:
rawMetadata = file.read()
rawMetadata = re.sub(
r'^(\s*version\s*=\s*).*', r'\g<1>%s' % version,
rawMetadata, flags=re.I | re.M
)
file.seek(0)
file.write(rawMetadata)
file.truncate()
# Read extension name from locale data
import buildtools.packagerGecko as packagerGecko
if type == "gecko":
locales_base = baseDir
else:
# This is somewhat of a hack but reading out locale import config here would be too much
locales_base = os.path.join(baseDir, "adblockplus")
locales = packagerGecko.readLocaleMetadata(locales_base, [packagerGecko.defaultLocale])
extensionName = locales[packagerGecko.defaultLocale]['name']
# Now commit the change and tag it
subprocess.check_call(['hg', 'commit', '-R', baseDir, '-m', 'Releasing %s %s' % (extensionName, version)])
subprocess.check_call(['hg', 'tag', '-R', baseDir, '-f', version])
# Create a release build
downloads = []
if type == "gecko":
keyFile = keyFiles[0] if keyFiles else None
metadata = packager.readMetadata(baseDir, type)
buildPath = os.path.join(downloadsRepo, packager.getDefaultFileName(metadata, version, 'xpi'))
packager.createBuild(baseDir, type=type, outFile=buildPath, releaseBuild=True, keyFile=keyFile)
downloads.append(buildPath)
elif type == "chrome":
# We actually have to create three different builds: signed and unsigned
# Chrome builds (the latter for Chrome Web Store), and a signed Safari build.
metadata = packager.readMetadata(baseDir, type)
buildPath = os.path.join(downloadsRepo, packager.getDefaultFileName(metadata, version, 'crx'))
packager.createBuild(baseDir, type=type, outFile=buildPath, releaseBuild=True, keyFile=keyFiles[0])
downloads.append(buildPath)
buildPathUnsigned = os.path.join(baseDir, packager.getDefaultFileName(metadata, version, 'zip'))
packager.createBuild(baseDir, type=type, outFile=buildPathUnsigned, releaseBuild=True, keyFile=None)
import buildtools.packagerSafari as packagerSafari
metadataSafari = packagerSafari.readMetadata(baseDir, "safari")
buildPathSafari = os.path.join(downloadsRepo, packagerSafari.getDefaultFileName(metadataSafari, version, 'safariextz'))
packagerSafari.createBuild(baseDir, type="safari", outFile=buildPathSafari, releaseBuild=True, keyFile=keyFiles[1])
downloads.append(buildPathSafari)
# Create source archive
archivePath = os.path.splitext(buildPath)[0] + '-source.tgz'
create_sourcearchive(baseDir, archivePath)
downloads.append(archivePath)
# Now add the downloads and commit
subprocess.check_call(['hg', 'add', '-R', downloadsRepo] + downloads)
subprocess.check_call(['hg', 'commit', '-R', downloadsRepo, '-m', 'Releasing %s %s' % (extensionName, version)])
# Push all changes
subprocess.check_call(['hg', 'push', '-R', baseDir])
subprocess.check_call(['hg', 'push', '-R', downloadsRepo])
buildtools-master/safariInfo.js.tmpl 0000664 0000000 0000000 00000001035 12705153350 0020121 0 ustar 00root root 0000000 0000000 /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
require.scopes.info = {
addonName: {{ metadata.get('general', 'basename')|json }},
addonVersion: {{ version|json }},
application: 'safari',
get applicationVersion() {
return navigator.userAgent.match(/Version\/([\d.]+)/)[1];
},
platform: 'safari',
get platformVersion() {
return this.applicationVersion;
}
};
buildtools-master/testIndex.html.tmpl 0000664 0000000 0000000 00000001265 12705153350 0020344 0 ustar 00root root 0000000 0000000
{%- for script in scripts %}
{%- endfor %}