Vai al contenuto

Wikivoyage:AutoWikiBrowser

Da Wikivoyage.

AutoWikiBrowser (spesso abbreviato AWB) è un editor MediaWiki semi-automatico per Windows XP e versioni successive, progettato per effettuare le operazioni ripetitive e noiose in modo più semplice e veloce. Per l'installazione su sistemi Linux vedi la guida in inglese su questa pagina Ogni modifica fatta con AWB deve essere riesaminata manualmente prima di essere salvata, e (se necessario) bisogna applicare manualmente le correzioni necessarie. Per una guida più estesa vedi la relativa pagina su Wikipedia

Le seguenti operazioni consentono l'uso di AWB su una macchina Windows con impostazioni per Wikivoyage.

Installare AWB

[modifica]
  1. scarica l'ultima versione da qui
  2. Estrai il contenuto
  3. Doppio click su AutoWikiBrowser.exe per avviare AWB

Configurare AWB

[modifica]

Configurare di AWB richiede l'impostazione di alcuni parametri e il caricamento di un set di impostazioni standard di AWB che sono stati adattati per Wikivoyage. Per la documentazione tecnica dettagliata vedi questa pagina

  1. Configura AWB per Wikivoyage. Seleziona Options → Preferences → Site → Project → Wikivoyage. e poi scegli la lingua. Nel nostro caso 'it'
  2. Imposta il login: Seleziona File → Log in/Profiles → Add → Login. Scrivi il tuo username e password in modo che le modifiche di AWB appaiano fatte dal tuo account.
  3. Importa la configurazione specifica per Wikivoyage. Copia il testo XML qui sotto e salvalo in un file con estensione .xml. Poi da AWB seleziona File → Log in/Profiles → Add → Login e premi Edit sul login da te salvato. Metti la spunta a "Select default settings" e inserisci il percorso del file xml. Una volta fatto il login potrai iniziare ad usare AWB per Wikivoyage.


file di configurazione AWB per Wikivoyage italiano
<?xml version="1.0" encoding="utf-8"?>
<AutoWikiBrowserPreferences xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xml:space="preserve" Version="5.5.6.0">
  <Project>wikivoyage</Project>
  <LanguageCode>it</LanguageCode>
  <CustomProject />
  <Protocol>http://</Protocol>
  <LoginDomain />
  <List>
    <ListSource />
    <SelectedProvider>CategoryListProvider</SelectedProvider>
    <ArticleList />
  </List>
  <FindAndReplace>
    <Enabled>true</Enabled>
    <IgnoreSomeText>false</IgnoreSomeText>
    <IgnoreMoreText>false</IgnoreMoreText>
    <AppendSummary>true</AppendSummary>
    <Replacements>
      <Replacement>
        <Find>\|thumbnail\|</Find>
        <Replace>|thumb|</Replace>
        <Comment />
        <IsRegex>false</IsRegex>
        <Enabled>true</Enabled>
        <Minor>true</Minor>
        <BeforeOrAfter>false</BeforeOrAfter>
        <RegularExpressionOptions>IgnoreCase</RegularExpressionOptions>
      </Replacement>
    </Replacements>
    <AdvancedReps />
    <SubstTemplates />
    <IncludeComments>false</IncludeComments>
    <ExpandRecursively>true</ExpandRecursively>
    <IgnoreUnformatted>false</IgnoreUnformatted>
  </FindAndReplace>
  <Editprefs>
    <GeneralFixes>true</GeneralFixes>
    <Tagger>false</Tagger>
    <Unicodify>true</Unicodify>
    <Recategorisation>0</Recategorisation>
    <NewCategory />
    <NewCategory2 />
    <ReImage>0</ReImage>
    <ImageFind />
    <Replace />
    <SkipIfNoCatChange>false</SkipIfNoCatChange>
    <RemoveSortKey>false</RemoveSortKey>
    <SkipIfNoImgChange>false</SkipIfNoImgChange>
    <AppendText>false</AppendText>
    <AppendTextMetaDataSort>false</AppendTextMetaDataSort>
    <Append>true</Append>
    <Text />
    <Newlines>2</Newlines>
    <AutoDelay>10</AutoDelay>
    <BotMaxEdits>0</BotMaxEdits>
    <SupressTag>false</SupressTag>
    <RegexTypoFix>true</RegexTypoFix>
  </Editprefs>
  <General>
    <AutoSaveEdit>
      <Enabled>false</Enabled>
      <SavePeriod>30</SavePeriod>
      <SaveFile />
    </AutoSaveEdit>
    <SelectedSummary>correzioni</SelectedSummary>
    <Summaries>
      <string>correzioni</string>
      <string>typo</string>
      <string>fix vari</string>
      <string>sistemo</string>
    </Summaries>
    <PasteMore>
      <string />
      <string />
      <string />
      <string />
      <string />
      <string />
      <string />
      <string />
      <string />
      <string />
    </PasteMore>
    <FindText />
    <FindRegex>false</FindRegex>
    <FindCaseSensitive>false</FindCaseSensitive>
    <WordWrap>true</WordWrap>
    <ToolBarEnabled>true</ToolBarEnabled>
    <BypassRedirect>true</BypassRedirect>
    <AutoSaveSettings>true</AutoSaveSettings>
    <noSectionEditSummary>false</noSectionEditSummary>
    <restrictDefaultsortAddition>true</restrictDefaultsortAddition>
    <restrictOrphanTagging>true</restrictOrphanTagging>
    <noMOSComplianceFixes>true</noMOSComplianceFixes>
    <syntaxHighlightEditBox>false</syntaxHighlightEditBox>
    <highlightAllFind>false</highlightAllFind>
    <PreParseMode>false</PreParseMode>
    <NoAutoChanges>false</NoAutoChanges>
    <OnLoadAction>0</OnLoadAction>
    <DiffInBotMode>false</DiffInBotMode>
    <Minor>true</Minor>
    <AddToWatchlist>2</AddToWatchlist>
    <TimerEnabled>false</TimerEnabled>
    <SortListAlphabetically>true</SortListAlphabetically>
    <AddIgnoredToLog>false</AddIgnoredToLog>
    <EditToolbarEnabled>true</EditToolbarEnabled>
    <filterNonMainSpace>false</filterNonMainSpace>
    <AutoFilterDuplicates>true</AutoFilterDuplicates>
    <FocusAtEndOfEditBox>false</FocusAtEndOfEditBox>
    <scrollToUnbalancedBrackets>false</scrollToUnbalancedBrackets>
    <TextBoxSize>9</TextBoxSize>
    <TextBoxFont>Courier New</TextBoxFont>
    <LowThreadPriority>false</LowThreadPriority>
    <Beep>false</Beep>
    <Flash>false</Flash>
    <Minimize>false</Minimize>
    <LockSummary>false</LockSummary>
    <SaveArticleList>true</SaveArticleList>
    <SuppressUsingAWB>false</SuppressUsingAWB>
    <AddUsingAWBToActionSummaries>false</AddUsingAWBToActionSummaries>
    <IgnoreNoBots>false</IgnoreNoBots>
    <ClearPageListOnProjectChange>false</ClearPageListOnProjectChange>
    <SortInterWikiOrder>true</SortInterWikiOrder>
    <ReplaceReferenceTags>true</ReplaceReferenceTags>
    <LoggingEnabled>true</LoggingEnabled>
    <AlertPreferences>
      <int>1</int>
      <int>2</int>
      <int>3</int>
      <int>4</int>
      <int>5</int>
      <int>6</int>
      <int>7</int>
      <int>8</int>
      <int>9</int>
      <int>10</int>
      <int>11</int>
      <int>12</int>
      <int>13</int>
      <int>14</int>
      <int>15</int>
      <int>16</int>
      <int>17</int>
      <int>18</int>
      <int>19</int>
      <int>20</int>
      <int>21</int>
    </AlertPreferences>
  </General>
  <SkipOptions>
    <SkipNonexistent>true</SkipNonexistent>
    <Skipexistent>false</Skipexistent>
    <SkipWhenNoChanges>true</SkipWhenNoChanges>
    <SkipSpamFilterBlocked>false</SkipSpamFilterBlocked>
    <SkipInuse>false</SkipInuse>
    <SkipWhenOnlyWhitespaceChanged>true</SkipWhenOnlyWhitespaceChanged>
    <SkipOnlyGeneralFixChanges>true</SkipOnlyGeneralFixChanges>
    <SkipOnlyMinorGeneralFixChanges>false</SkipOnlyMinorGeneralFixChanges>
    <SkipOnlyCosmetic>false</SkipOnlyCosmetic>
    <SkipOnlyCasingChanged>false</SkipOnlyCasingChanged>
    <SkipIfRedirect>false</SkipIfRedirect>
    <SkipIfNoAlerts>false</SkipIfNoAlerts>
    <SkipDoes>false</SkipDoes>
    <SkipDoesNot>false</SkipDoesNot>
    <SkipDoesText />
    <SkipDoesNotText />
    <Regex>false</Regex>
    <CaseSensitive>false</CaseSensitive>
    <AfterProcessing>false</AfterProcessing>
    <SkipNoFindAndReplace>false</SkipNoFindAndReplace>
    <SkipMinorFindAndReplace>false</SkipMinorFindAndReplace>
    <SkipNoRegexTypoFix>false</SkipNoRegexTypoFix>
    <SkipNoDisambiguation>false</SkipNoDisambiguation>
    <SkipNoLinksOnPage>false</SkipNoLinksOnPage>
    <GeneralSkipList />
  </SkipOptions>
  <Module>
    <Enabled>true</Enabled>
    <Language>C# 3.5</Language>
    <Code>// implementing the "aggressive" rules is more likely to produce false positives
private static readonly bool AGGRESSIVE = true;
private static readonly Regex ListingTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("listing,see,do,buy,eat,drink,sleep".Split(',')));
private static readonly string[] ListingTemplateParamNames = {"type","nome","alt","sito","email","indirizzo","lat","long","indicazioni","tel","numero verde","fax","orari","checkin","checkout","prezzo","descrizione"};
private static readonly string[] ListingPhoneParamNames = {"tel","fax","numero verde"};
private static readonly Regex PhoneNumberRegex = new Regex(@"'*[\d\+\(][\s\d\(\)\-\.'\+]+[\d\)]'*");
private static readonly Regex MailtoRegex = new Regex(@"mailto:[/]*", RegexOptions.IgnoreCase);
private static readonly Regex ExcessWhitespaceRegex = new Regex(@"\s\s+", RegexOptions.Singleline);
// "http://www.example.com"
private static readonly string ValidUrlPattern = @"((http(s)?:)//)?(([a-z]+\.)+)([a-z]+)";
private static readonly Regex ValidUrlRegex = new Regex(ValidUrlPattern, RegexOptions.Singleline | RegexOptions.IgnoreCase);
// "[http://www.example.com]"
private static readonly Regex FootnoteUrlRegex = new Regex(@"\[(" + ValidUrlPattern + @"([^\]\s]+))\]", RegexOptions.Singleline);
// "Foo (disambiguation)"
private static readonly Regex CityNameWithDisambiguationRegex = new Regex(@"([^\(]+) \([^\)]+\)", RegexOptions.Singleline);
// "blah, CA 99999", "blah CA", etc
private static readonly Regex AddressWithStateOrZipRegex = new Regex(@"(.+)[\.,\-]+\s*(AL|alabama|AK|alaska|AZ|arizona|AR|arkansas|CA|california|CO|colorado|CT|connecticut|DC|DE|delaware|FL|florida|GA|georgia|HI|hawaii|ID|idaho|IL|illinois|IN|indiana|IA|iowa|KS|kansas|KY|kentucky|LA|louisiana|ME|maine|MD|maryland|MA|massachusetts|MI|michigan|MN|minnesota|MS|mississippi|MO|missouri|MT|montana|NE|nebraska|NV|nevada|NH|new hampshire|NJ|new jersey|NM|new mexico|NY|new york|NC|north carolina|ND|north dakota|OH|ohio|OK|oklahoma|OR|oregon|PA|pennsylvania|RI|rhode island|SC|south carolina|SD|south dakota|TN|tennessee|TX|texas|UT|utah|VT|vermont|VA|virginia|WA|washington|WV|west virginia|WI|wisconsin|WY|wyoming)([\s,\-]*[0-9]{5})?$", RegexOptions.Singleline | RegexOptions.IgnoreCase);
// "* ", "** ", etc
private static readonly Regex EmptyListItemRegex = new Regex(@"^\*+\s*\n", RegexOptions.Multiline);
private static readonly Regex FootnoteToFrontLinkRegex = new Regex(@"('*)((?!The )\p{Lu}[\w\-'/]*[\w]( (e|del|di|da|&amp;|il|lo|la|le|per|\p{Lu}[\w\-'/]*[\w]))*)('*)[, ]*\[(http[^ ]+)( )*\]");
private static readonly Regex TimeValuesShouldUseColonAsSeperator = new Regex(@"\b([1-9]|10|11|12)\.([0-5][0-9])([ ]*)((a|p)\.?\s*m\.|(a|p)\.?\s*m\b)", RegexOptions.IgnoreCase);
private static readonly Regex TimeValuesSuffixAM = new Regex(@"\b([1-9]|10|11|12)(:[0-5][0-9])*[ ]*(a\.\s*m\.|a\s*m\b)", RegexOptions.IgnoreCase);
private static readonly Regex TimeValuesSuffixPM = new Regex(@"\b([1-9]|10|11|12)(:[0-5][0-9])*[ ]*(p\.\s*m\.|p\s*m\b)", RegexOptions.IgnoreCase);
private static readonly Regex ExternalToInternalLinkWikipedia = new Regex(@"\[http[s]?://it.wikipedia.org/wiki/([^\] ]+)[ ]+([^\]]+)]", RegexOptions.IgnoreCase);
private static readonly Regex ExternalToInternalLinkWikipediaNoText = new Regex(@"\[http[s]?://it.wikipedia.org/wiki/([^\] ]+)[ ]*]", RegexOptions.IgnoreCase);
private static readonly Regex ExternalToInternalLinkWikivoyage = new Regex(@"\[http[s]?://it.wikivoyage.org/wiki/([^\] ]+)[ ]+([^\]]+)]", RegexOptions.IgnoreCase);
private static readonly Regex ExternalToInternalLinkWikivoyageNoText = new Regex(@"\[http[s]?://it.wikivoyage.org/wiki/([^\] ]+)[ ]*]", RegexOptions.IgnoreCase);
// "* blah blah blah", "** blah blah blah", etc
private static readonly Regex CandidateListingItemRegex = new Regex(@"^\*+\s*([^\{]{2}.+)$", RegexOptions.Multiline);
private static readonly Regex ListingNameRegex = new Regex(@"(il\s+)*'''(.{3,}?)'''", RegexOptions.IgnoreCase);
// "[http://www.example.com/ Example Text]"
private static readonly Regex ExternalLinkWithTextRegex = new Regex(@"\[(http[^\]\s]+)\s+([^\]]+)\]", RegexOptions.IgnoreCase);
// "123-456-7890"
private static readonly string ListingPhoneNumber = @"((''|\+|\()*\d+(''|\)*)[\s\-]+)+(''|\+|\()*\d+(''|\)*)( ext\.? \d+)?";
private static readonly Regex ListingPhoneNumberRegex = new Regex(ListingPhoneNumber, RegexOptions.IgnoreCase);
// "fax: 123-456-7890"
private static readonly string ListingFaxNumber = @"(\(''|''\(|\()?fax(:)?(\s)*(" + ListingPhoneNumber + @")(''\)|\)''|\))?";
private static readonly Regex ListingFaxNumberRegex = new Regex(ListingFaxNumber, RegexOptions.IgnoreCase);
// "tele: 123-456-7890" and similar
private static readonly string ListingPhoneNumberWithLabel = @"(\(''|''\(|\()?(\u260e|chiama|call:telefono:|telephone|tel:|tel\.:|tel\.|tel|tel:|tel|ph:|ph\.:|ph\.|ph|\u260E)(\s)*(" + ListingPhoneNumber + @")(''\)|\)''|\))?";
private static readonly Regex ListingPhoneNumberWithLabelRegex = new Regex(ListingPhoneNumberWithLabel, RegexOptions.IgnoreCase);
// "toll-free: 123-456-7890" and similar
private static readonly string ListingTollfreeNumber = @"(\(''|''\(|\()?(toll[ \-]?free)(:)?(\s)*(" + ListingPhoneNumber + @")(''\)|\)''|\))?";
private static readonly Regex ListingTollfreeNumberRegex = new Regex(ListingTollfreeNumber, RegexOptions.IgnoreCase);
private static readonly string InvalidLeadingOrTrailingPunctuation = @",|\-|\*|\:|\–";
private static readonly string InvalidLeadingPunctuation = @"\.|!|\?|\)|\]|\}|&amp;mdash;";
private static readonly string InvalidTrailingPunctuation = @"\(|\[|\{";
private static readonly string InvalidDuplicatePunctuation = @"\.|!|\?|" + InvalidLeadingOrTrailingPunctuation;
private static readonly Regex InvalidLeadingPunctuationRegex = new Regex(@"^(\s|" + InvalidLeadingPunctuation + "|" + InvalidLeadingOrTrailingPunctuation + @")+", RegexOptions.Multiline);
private static readonly Regex InvalidTrailingPunctuationRegex = new Regex(@"(\s|" + InvalidTrailingPunctuation + "|" + InvalidLeadingOrTrailingPunctuation + @")+$", RegexOptions.Multiline);
private static readonly Regex InvalidDuplicatePunctuationRegex = new Regex(@"(" + InvalidDuplicatePunctuation + @"|\s)+(" + InvalidDuplicatePunctuation + @")");
// "email: foo@bar.com" OR "mailto:foo@bar.com" OR "foo@bar.com"
private static readonly string ListingEmail = @"(mailto:|e-mail:)?\s*(\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b)";
private static readonly Regex ListingEmailRegex = new Regex(ListingEmail, RegexOptions.IgnoreCase);
// "1234 First St"
private static readonly string ListingAddress = @"([\d]+([/\-][\d]+)? ([nesw]\.? )?([\p{L}\d]+[ \.\-]*){1,3} (avenue|ave|av|boulevard|blvd|court|ct|drive|dr|expressway|expwy|freeway|fwy|highway( \d{1,3})?|hwy( \d{1,3})?|lane|ln|loop|parkway|pkwy|place|pl|road|rd|row|street|st|way|via|viale|piazza|gåta|väg|Straße|Strasse|parcheggio|statale|ulica|ulitsa|uliza|vicolo)\b(\.? (#(\s)*[\d]+|nord|nordest|Nord|Est|NO|N|Est|E|Sud|SE|SO|S|Ovest|O)\b)?)[\. , ]*";
private static readonly Regex ListingAddressRegex = new Regex(ListingAddress, RegexOptions.IgnoreCase);
// the above pattern will match things like "25 km by road", so add a pattern to catch those
private static readonly string ListingAddressFalsePositives = @"\b(km|kilometer|kilometers|mi|mile|miles)\b";
private static readonly Regex ListingAddressFalsePositivesRegex = new Regex(ListingAddressFalsePositives, RegexOptions.IgnoreCase);
// "Calle Ricardo Montalban, 452"
private static readonly string ListingAddressInternational = @"(avenida|ave|av|calle|estrada|est|rua)(\.)? ([\p{L}\d]+[ \.\-]*){1,3}, [\d]+([/\-][\d]+)?";
private static readonly Regex ListingAddressInternationalRegex = new Regex(ListingAddressInternational, RegexOptions.IgnoreCase);
private static readonly Regex ListingAddressIsDirectionsRegex = new Regex(@"^(between|corner|end|next|on|)\s", RegexOptions.Multiline);
//private static readonly Regex CityStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinecity,usablecity,guidecity,starcity".Split(',')));
//private static readonly Regex CountryStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinecountry,usablecountry,guidecountry,starcountry".Split(',')));
//private static readonly Regex DiveguideStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinediveguide,usablediveguide,guidediveguide,stardiveguide".Split(',')));
//private static readonly Regex DistrictStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;/("outlinedistrict,usabledistrict,guidedistrict,stardistrict".Split(',')));
//private static readonly Regex ItineraryStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlineitinerary,usableitinerary,guideitinerary,staritinerary".Split(',')));
//private static readonly Regex ParkStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinepark,usablepark,guidepark,starpark".Split(',')));
//private static readonly Regex PhrasebookStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinephrasebook,usablephrasebook,guidephrasebook,starphrasebook".Split(',')));
//private static readonly Regex RegionStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlineregion,usableregion,guideregion,starregion".Split(',')));
//private static readonly Regex TopicStatusTemplateNamesRegex = Tools.NestedTemplateRegex(new List&lt;string&gt;("outlinetopic,usabletopic,guidetopic,startopic".Split(',')));
//private static readonly Regex ListingAltParamRegex = new Regex(@"\|\s*alt\s*=", RegexOptions.Singleline);
// "()", "[]", "{}"
private static readonly Regex EmptyPunctuationRegex = new Regex(@"(\(\s*\)|\[\s*\]|\{\s*\})");
private static readonly Regex OnlyPunctuationRegex = new Regex(@"^['\-\(\)\[\]\{\}\*\.\?!\s]+$", RegexOptions.Singleline);
// match a single digit
private static readonly Regex DigitRegex = new Regex(@"\d");
private static readonly Regex DoubleSpaceRegex = new Regex(@"\s{2,}");
private static readonly Regex InvalidGetInHeadingRegex = new Regex(@"^(get in|Arrivare|come arrivare|getting in|getting there)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidGetAroundHeadingRegex = new Regex(@"^(get around|getting around)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidSeeHeadingRegex = new Regex(@"^(Monumenti|monumenti|Vedere|Attrazioni|attrazioni)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidDoHeadingRegex = new Regex(@"^(Attività|Tempo libero)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidBuyHeadingRegex = new Regex(@"^(shopping|negozi)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidEatHeadingRegex = new Regex(@"^(ristoranti|a pranzo|Mangiare)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidDrinkHeadingRegex = new Regex(@"^(bars|nightlife)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidSleepHeadingRegex = new Regex(@"^(accommodation|hotels)", RegexOptions.IgnoreCase);
private static readonly Regex InvalidGoNextHeadingRegex = new Regex(@"^(nei dintorni|Uscire)", RegexOptions.IgnoreCase);
private static readonly Regex MidrangeHeadingRegex = new Regex(@"^prezzi[ \-]*modici", RegexOptions.IgnoreCase);
private static readonly Regex ByOnHeadingRegex = new Regex(@"^(presso|su) (.+)", RegexOptions.IgnoreCase);
public string ProcessArticle(string articleText, string articleTitle, int wikiNamespace, out string summary, out bool skip) {
	string originalText = articleText;
	summary = "";
	skip = false;
	articleText = UpdateHeadings(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	articleText = ExternalToInternalLink(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	articleText = FootnoteToFrontlink(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	articleText = FormatTimeValues(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	if (AGGRESSIVE) {
		articleText = ConvertTextToListings(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	}
	articleText = FormatListings(articleText, articleTitle, wikiNamespace, ref summary, ref skip);
	if (articleText.Equals(originalText)) {
		skip = true;
	}
	return articleText;
}
// ensure that headings match the article templates
public string UpdateHeadings(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) { 
	foreach(Match m in WikiRegexes.Headings.Matches(articleText)) {
		string originalHeading = m.Value;
		string originalTitle = m.Groups[1].Value;
		string newTitle = originalTitle;
		string lowerTitle = originalTitle.ToLower().Trim();
		int headingLevel = 1;
		while (originalHeading[headingLevel] == '=') {
			headingLevel++;
		}
		Match match = null;
		if (headingLevel == 2) {
			if (MatchText(lowerTitle, InvalidGetInHeadingRegex, ref match)) {
				newTitle = "Come arrivare";
			} else if (MatchText(lowerTitle, InvalidGetAroundHeadingRegex, ref match)) {
				newTitle = "Come spostarsi";
			} else if (MatchText(lowerTitle, InvalidSeeHeadingRegex, ref match)) {
				newTitle = "Cosa vedere";
			} else if (MatchText(lowerTitle, InvalidDoHeadingRegex, ref match)) {
				newTitle = "Cosa fare";
			} else if (MatchText(lowerTitle, InvalidBuyHeadingRegex, ref match)) {
				newTitle = "Acquisti";
			} else if (MatchText(lowerTitle, InvalidEatHeadingRegex, ref match)) {
				newTitle = "Dove mangiare";
			} else if (MatchText(lowerTitle, InvalidDrinkHeadingRegex, ref match)) {
				newTitle = "Come divertirsi";
			} else if (MatchText(lowerTitle, InvalidSleepHeadingRegex, ref match)) {
				newTitle = "Dove alloggiare";
			} else if (MatchText(lowerTitle, InvalidGoNextHeadingRegex, ref match)) {
				newTitle = "Nei dintorni";
			}
		} else {
			if (MatchText(lowerTitle, MidrangeHeadingRegex, ref match)) {
				newTitle = "Prezzi modici";
			} else if (MatchText(lowerTitle, ByOnHeadingRegex, ref match)) {
				newTitle = Capitalize(match.Groups[1].Value) + " " + match.Groups[2].Value.ToLower();
			}
		}
		if (!newTitle.Equals(originalTitle)) {
			string headingBars = originalHeading.Substring(0, headingLevel);
			articleText = articleText.Replace(originalHeading, headingBars + newTitle + headingBars);
			summary = UpdateEditSummary(summary, "sistemo sezioni");
		}
	}
	return articleText;
}

// convert footnote links to frontlinks
public string FootnoteToFrontlink(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) {
	string originalText = articleText;
	articleText = FootnoteToFrontLinkRegex.Replace(articleText, "$1[$6 $2]$5");
	if (!articleText.Equals(originalText)) {
		summary = UpdateEditSummary(summary, "sistemo note");
	}
	return articleText;
}
// convert external links to interwiki/internal links
public string ExternalToInternalLink(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) {
	string originalText = articleText;
	articleText = ExternalToInternalLinkWikipedia.Replace(articleText, "[[w:$1|$2]]");
	articleText = ExternalToInternalLinkWikipediaNoText.Replace(articleText, "[[w:$1]]");
	articleText = ExternalToInternalLinkWikivoyage.Replace(articleText, "[[$1|$2]]");
	articleText = ExternalToInternalLinkWikivoyageNoText.Replace(articleText, "[[$1]]");
	if (!articleText.Equals(originalText)) {
		summary = UpdateEditSummary(summary, "fix link");
	}
	return articleText;
}
public string FormatTimeValues(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) {
	string originalText = articleText;
	articleText = TimeValuesShouldUseColonAsSeperator.Replace(articleText, "$1:$2$3$4");
	articleText = TimeValuesSuffixAM.Replace(articleText, "$1$2AM");
	articleText = TimeValuesSuffixPM.Replace(articleText, "$1$2PM");
	if (!articleText.Equals(originalText)) {
		summary = UpdateEditSummary(summary, "sistemo date");
	}
	return articleText;
}
public string ConvertTextToListings(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) {
	//if (!IsCityArticle(articleText) &amp;&amp; !IsDistrictArticle(articleText) &amp;&amp; !IsParkArticle(articleText)) {
		// do not try to convert text to listings for non-city or park articles
		//return articleText;
	//}
	string originalText = articleText;
	// loop through all sections
	foreach(KeyValuePair&lt;string, string&gt; sectionData in SplitToSecondLevelSections(articleText)) {
		string sectionName = sectionData.Key;
		if (!sectionName.ToLower().Equals("see") &amp;&amp; !sectionName.ToLower().Equals("do") &amp;&amp; !sectionName.ToLower().Equals("buy") &amp;&amp; !sectionName.ToLower().Equals("eat") &amp;&amp; !sectionName.ToLower().Equals("drink") &amp;&amp; !sectionName.ToLower().Equals("sleep")) {
			// only convert text that's in a section that supports non-generic listings
			continue;
		}
		string listingType = GetValidListingTypeForSection(sectionName);
		string sectionText = sectionData.Value;
		// get all list items within the section

		foreach(Match m in CandidateListingItemRegex.Matches(sectionText)) {
			string listItemText = m.Groups[1].Value;
			string templateCall = ConvertListingItemtoTemplatedListing(listItemText, listingType, ref summary);
			if (templateCall != "") {
				articleText = articleText.Replace(listItemText, templateCall);
				summary = UpdateEditSummary(summary, "converto in listing");
			}
		}
	}
	return articleText;
}
public string ConvertListingItemtoTemplatedListing(string listItemText, string listingType, ref string summary) {
	string templateCall = "{{" + listingType + "}}";
	if (!ProcessListingNameInListItem(ref listItemText, ref templateCall)) {
		// if we don't have a listing name don't bother trying to convert anything else
		return "";
	}
	ProcessListingPhoneInListItem(ref listItemText, ref templateCall);
	ProcessListingEmailInListItem(ref listItemText, ref templateCall);
	ProcessListingUrlInListItem(ref listItemText, ref templateCall);
	ProcessListingAddressInListItem(ref listItemText, ref templateCall);
	ProcessListingContentInListItem(ref listItemText, ref templateCall);
	return templateCall;
}
private bool ProcessListingNameInListItem(ref string listItemText, ref string templateCall) {
	Match m = ListingNameRegex.Match(listItemText);
	if (!m.Success || m.Index != 0) {
		// if there isn't a name at the beginning of the listing, don't convert
		return false;
	}
	string nome = m.Groups[2].Value;
	templateCall = Tools.SetTemplateParameterValue(templateCall, "nome", nome);
	// see if the nome is front-linked
	Match sitoMatch = ExternalLinkWithTextRegex.Match(nome);
	if (sitoMatch.Success &amp;&amp; sitoMatch.Index == 0) {
		// split the nome &amp; sito fields
		string sito = sitoMatch.Groups[1].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "sito", sito);
		nome = sitoMatch.Groups[2].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "nome", nome);
	}
	// remove nome from list item text
	listItemText = RemoveValueFromListItemText(listItemText, m.Value);
	return true;
}
private void ProcessListingPhoneInListItem(ref string listItemText, ref string templateCall) {
	Match telMatch = ListingPhoneNumberWithLabelRegex.Match(listItemText);
	if (telMatch.Success) {
		string tel = telMatch.Groups[4].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "tel", tel);
		listItemText = RemoveValueFromListItemText(listItemText, telMatch.Value);
	}
	Match faxMatch = ListingFaxNumberRegex.Match(listItemText);
	if (faxMatch.Success) {
		string fax = faxMatch.Groups[4].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "fax", fax);
		listItemText = RemoveValueFromListItemText(listItemText, faxMatch.Value);
	}
	Match tollfreeMatch = ListingTollfreeNumberRegex.Match(listItemText);
	if (tollfreeMatch.Success) {
		string tollfree = tollfreeMatch.Groups[5].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "tollfree", "numero verde");
		listItemText = RemoveValueFromListItemText(listItemText, tollfreeMatch.Value);
	}
	if (!telMatch.Success) {
		// try to find a tel number without a label
		telMatch = ListingPhoneNumberRegex.Match(listItemText);
		if (telMatch.Success) {
			string tel = telMatch.Value;
			if (DigitRegex.Matches(tel).Count &gt; 6) {
				// only consider a tel number valid if it contains more than six digits
				templateCall = Tools.SetTemplateParameterValue(templateCall, "tel", tel);
				listItemText = RemoveValueFromListItemText(listItemText, telMatch.Value);
			}
		}
	}
}
private void ProcessListingEmailInListItem(ref string listItemText, ref string templateCall) {
	Match emailMatch = ListingEmailRegex.Match(listItemText);
	if (emailMatch.Success) {
		string email = emailMatch.Groups[2].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "email", email);
		listItemText = RemoveValueFromListItemText(listItemText, emailMatch.Value);
	}
}
private void ProcessListingUrlInListItem(ref string listItemText, ref string templateCall) {
	if (Tools.GetTemplateParameterValue(templateCall, "sito") != "") {
		// sito was already set when processing listing nome
		return;
	}
	Match sitoMatch = FootnoteUrlRegex.Match(listItemText);
	if (sitoMatch.Success) {
		string sito = sitoMatch.Groups[1].Value;
		templateCall = Tools.SetTemplateParameterValue(templateCall, "sito", sito);
		listItemText = RemoveValueFromListItemText(listItemText, sitoMatch.Value);
	}
}
private void ProcessListingAddressInListItem(ref string listItemText, ref string templateCall) {
	Match indirizzoMatch = ListingAddressRegex.Match(listItemText);
	if (indirizzoMatch.Success) {
		string indirizzo = indirizzoMatch.Groups[1].Value;
		Match falsePositiveMatch = ListingAddressFalsePositivesRegex.Match(indirizzo);
		if (!falsePositiveMatch.Success) {
			templateCall = Tools.SetTemplateParameterValue(templateCall, "indirizzo", indirizzo);
			listItemText = RemoveValueFromListItemText(listItemText, indirizzoMatch.Value);
		}
	} else {
		indirizzoMatch = ListingAddressInternationalRegex.Match(listItemText);
		if (indirizzoMatch.Success) {
			string indirizzo = indirizzoMatch.Groups[1].Value;
			templateCall = Tools.SetTemplateParameterValue(templateCall, "indirizzo", indirizzo);
			listItemText = RemoveValueFromListItemText(listItemText, indirizzoMatch.Value);
		}
	}
}
private void ProcessListingContentInListItem(ref string listItemText, ref string templateCall) {
	if (String.IsNullOrEmpty(listItemText)) {
		return;
	}
	// strip empty punctuation
	listItemText = EmptyPunctuationRegex.Replace(listItemText, "");
	// strip sentence fragments left over from removing the listing nome
	if (listItemText.ToLower().StartsWith("is ")) {
		listItemText = listItemText.Substring("is ".Length);
	}
	// make sure first character is capitalized
	listItemText = Capitalize(listItemText);
	// if only punctuation is left, remove everything
	if (OnlyPunctuationRegex.IsMatch(listItemText)) {
		listItemText = "";
	}
	templateCall = Tools.SetTemplateParameterValue(templateCall, "descrizione", listItemText);
}
private string RemoveValueFromListItemText(string listItemText, string value) {
	listItemText = listItemText.Replace(value, "").Trim();
	listItemText = InvalidDuplicatePunctuationRegex.Replace(listItemText, "$1");
	listItemText = StripLeadingPunctuation(listItemText).Trim();
	return listItemText;
}
// Perform various tasks on listings to ensure params and other values
// are formatted correctly.
public string FormatListings(string articleText, string articleTitle, int wikiNamespace, ref string summary, ref bool skip) {
	string originalText = articleText;
	// loop through all sections
	foreach(KeyValuePair&lt;string, string&gt; sectionData in SplitToSecondLevelSections(articleText)) {
		string sectionName = sectionData.Key;
		string sectionText = sectionData.Value;
		// get all listing tags within the section
		foreach(Match m in ListingTemplateNamesRegex.Matches(sectionText)) {
			string templateCall = m.Value;
			string originalTemplateCall = m.Value;
			templateCall = ConvertGenericListingToSpecificType(templateCall, ref summary);
			templateCall = MatchListingTypeToSection(templateCall, sectionName, ref summary);
			templateCall = FormatListingParams(templateCall, ref summary);
			templateCall = SanitizeListingPhoneNumbers(templateCall, ref summary);
			templateCall = SanitizeListingEmail(templateCall, ref summary);
			templateCall = SanitizeListingUrl(templateCall, ref summary);
			if (AGGRESSIVE) {
				templateCall = SanitizeListingAddress(templateCall, articleTitle, ref summary);
			}
			if (!templateCall.Equals(originalTemplateCall)) {
				articleText = articleText.Replace(originalTemplateCall, templateCall);
			}
		}
	}
	return articleText;
}
// change "{{listing|type=xyz|...}}" to "{{xyz|...}}"
public string ConvertGenericListingToSpecificType(string templateCall, ref string summary) {
	string originalTemplateCall = templateCall;
	string listingType = Tools.GetTemplateName(templateCall);
	if (listingType.Equals("listing")) {
		string templateType = Tools.GetTemplateParameterValue(templateCall, "type");
		if (templateType.Equals("see") || templateType.Equals("do") || templateType.Equals("buy") || templateType.Equals("eat") || templateType.Equals("drink") || templateType.Equals("sleep")) {
			templateCall = Tools.RenameTemplate(templateCall, templateType);
			templateCall = Tools.RemoveTemplateParameter(templateCall, "type");
		}
	}
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "listing appropriato");
	}
	return templateCall;
}
// make sure listings are formatted according to the style guidelines in
// Wikivoyage:Listings
public string FormatListingParams(string templateCall, ref string summary) {
	string originalTemplateCall = templateCall;
	string listingType = Tools.GetTemplateName(templateCall);
	string formattedValue = "{{" + listingType + "\n";
	// loop through expected template arguments and format appropriately
	foreach(string param in ListingTemplateParamNames) {
		if (param.Equals("descrizione")) {
			continue;
		}
		string paramValue = Tools.GetTemplateParameterValue(templateCall, param);
		if (param.Equals("type") &amp;&amp; (paramValue == "" || !listingType.Equals("listing"))) {
			// only listing uses the "type" attribute
			if (paramValue == "") {
				templateCall = Tools.RemoveTemplateParameter(templateCall, param);
			}
			continue;
		}
		if ((param.Equals("image") || param.Equals("lastedit")) &amp;&amp; paramValue == "") {
			// empty image &amp; lastedit attributes are unnecessary
			continue;
		}
		if (listingType.Equals("sleep") &amp;&amp; param.Equals("orari") &amp;&amp; paramValue == "") {
			// sleep listings don't use the "orari" attribute
			if (paramValue == "") {
				templateCall = Tools.RemoveTemplateParameter(templateCall, param);
			}
			continue;
		}
		if (!listingType.Equals("sleep") &amp;&amp; (param.Equals("checkin") || param.Equals("checkout"))) {
			// only sleep listings use the "checkin" and "checkout" attributes
			if (paramValue == "") {
				templateCall = Tools.RemoveTemplateParameter(templateCall, param);
			}
			continue;
		}
		//if (param.Equals("alt") &amp;&amp; paramValue == "" &amp;&amp; !ListingAltParamRegex.IsMatch(templateCall)) {
			// do not add an alt tag if it isn't already present
			//continue;
		//}
		// replace excess whitespace with single spaces
		paramValue = DoubleSpaceRegex.Replace(paramValue, " ");
		formattedValue += "| " + param + "=" + paramValue;
		// add either a newline or a space after the param value, depending on param and template type
		if (param.Equals("email") || param.Equals("indicazioni") || param.Equals("fax") || param.Equals("prezzo") || param.Equals("image") || param.Equals("lastedit")) {
			formattedValue += "\n";
		} else {
			formattedValue += " ";
		}
		templateCall = Tools.RemoveTemplateParameter(templateCall, param);
	}
	// loop through any unexpected template args and format on their own lines
	int remainingTemplateArgs = Tools.GetTemplateArgumentCount(templateCall);
	foreach(KeyValuePair&lt;string, string&gt; templateParameter in Tools.GetTemplateParameterValues(templateCall)) {
		string param = templateParameter.Key;
		if (param.Equals("descrizione")) {
			continue;
		}
		string paramValue = templateParameter.Value;
		if (paramValue == "") {
			// any empty, unrecognized listing params can be removed
			continue;
		}
		formattedValue += "| " + param + "=" + paramValue + "\n";
	}
	// now add template descrizione on its own line
	formattedValue += "| descrizione=" + Tools.GetTemplateParameterValue(templateCall, "descrizione") + "\n";
	formattedValue += "}}";
	if (!originalTemplateCall.Equals(formattedValue)) {
		// suppress edit summary for now - it is being applied to any article with listings
		// whether they are updated or not
		// summary = UpdateEditSummary(summary, "formato listing");
	}
	return formattedValue;
}
// update the listing tel number fields as much as possible to match
// Wikivoyage:Phone numbers
public string SanitizeListingPhoneNumbers(string templateCall, ref string summary) {
	string originalTemplateCall = templateCall;
	// loop through expected template arguments and format appropriately
	foreach(string param in ListingPhoneParamNames) {
		string paramValue = Tools.GetTemplateParameterValue(templateCall, param);
		paramValue = SanitizePhoneNumber(paramValue);
		templateCall = Tools.UpdateTemplateParameterValue(templateCall, param, paramValue);
	}
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "formato phone");
	}
	return templateCall;
}
// update the listing email field to ensure it is valid
public string SanitizeListingEmail(string templateCall, ref string summary) {
	string originalTemplateCall = templateCall;
	string email = Tools.GetTemplateParameterValue(templateCall, "email");
	email = MailtoRegex.Replace(email, "").Trim();
	templateCall = Tools.UpdateTemplateParameterValue(templateCall, "email", email);
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "fix e-mail");
	}
	return templateCall;
}
// update the listing URL field to ensure it is valid
public string SanitizeListingUrl(string templateCall, ref string summary) {
	string originalTemplateCall = templateCall;
	string sito = Tools.GetTemplateParameterValue(templateCall, "sito");
	Match match = FootnoteUrlRegex.Match(sito);
	if (match.Success) {
		sito = match.Groups[1].Value;
	}
	match = ValidUrlRegex.Match(sito);
	if (match.Success &amp;&amp; !sito.ToLower().StartsWith("http://") &amp;&amp; !sito.ToLower().StartsWith("https://") &amp;&amp; !sito.ToLower().StartsWith("//")) {
		sito = "http://" + sito;
	}
	templateCall = Tools.UpdateTemplateParameterValue(templateCall, "sito", sito);
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "sistemo indirizzo web");
	}
	return templateCall;
}
// update the listing indirizzo field to ensure it is valid
public string SanitizeListingAddress(string templateCall, string articleName, ref string summary) {
	string originalTemplateCall = templateCall;
	string indirizzo = Tools.GetTemplateParameterValue(templateCall, "indirizzo");
	if (String.IsNullOrEmpty(indirizzo)) {
		return templateCall;
	}
	Match m = ListingAddressIsDirectionsRegex.Match(indirizzo);
	if (m.Success) {
		// the indirizzo field belongs in the indicazioni field
		string indicazioni = Tools.GetTemplateParameterValue(templateCall, "indicazioni");
		if (String.IsNullOrEmpty(indicazioni)) {
			templateCall = Tools.UpdateTemplateParameterValue(templateCall, "indicazioni", indirizzo);
			templateCall = Tools.UpdateTemplateParameterValue(templateCall, "indirizzo", "");
			summary = UpdateEditSummary(summary, "indicazioni");
			return templateCall;
		}
	}
	// strip out state and zip code if present
	m = AddressWithStateOrZipRegex.Match(indirizzo);
	if (m.Success) {
		indirizzo = m.Groups[1].Value.Trim();
	}
	indirizzo = StripStrayPunctuation(indirizzo);
	// strip out the city if it is present
	string city = GetCityFromArticleName(articleName);
	if (indirizzo.ToLower().EndsWith(city.ToLower())) {
		int pos = indirizzo.ToLower().LastIndexOf(city.ToLower());
		indirizzo = indirizzo.Substring(0, pos).Trim();
	}
	indirizzo = StripStrayPunctuation(indirizzo);
	// properly abbreviate street name
	indirizzo = AbbreviateStreeType(indirizzo, "via", "Via");
	indirizzo = AbbreviateStreeType(indirizzo, "Piazza", "Pz");
	indirizzo = AbbreviateStreeType(indirizzo, "Viale", "V.le");
	indirizzo = AbbreviateStreeType(indirizzo, "Ulica", "Ul");
	indirizzo = AbbreviateStreeType(indirizzo, "Ulitsa", "Ul");
	indirizzo = AbbreviateStreeType(indirizzo, "Uliza", "Ul.");
	indirizzo = AbbreviateStreeType(indirizzo, "Prospekt", "Pr");
	indirizzo = AbbreviateStreeType(indirizzo, "Strasse", "Str");
	indirizzo = AbbreviateStreeType(indirizzo, "Straße", "Str");
	templateCall = Tools.UpdateTemplateParameterValue(templateCall, "indirizzo", indirizzo);
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "indirizzi");
	}
	return templateCall;
}
// make sure that the listing type matches the section in which the listing
// is found (example: "see" listings in the "See" section)
public string MatchListingTypeToSection(string templateCall, string sectionName, ref string summary) {
	string originalTemplateCall = templateCall;
	if (sectionName.ToLower() == "eat and drink" || sectionName.ToLower() == "see and do") {
		// skip these "combined" sections
		return templateCall;
	}
	string expectedListingType = GetValidListingTypeForSection(sectionName);
	string listingType = Tools.GetTemplateName(templateCall);
	if (!listingType.Equals(expectedListingType)) {
		templateCall = Tools.RenameTemplate(templateCall, expectedListingType);
	}
	if (!templateCall.Equals(originalTemplateCall)) {
		summary = UpdateEditSummary(summary, "aggiorno listing");
	}
	return templateCall;
}
// return a map of section name-section descrizione for all second level headings.
// the opening text of the article is returned without a section name
private static List&lt;KeyValuePair&lt;string, string&gt;&gt; SplitToSecondLevelSections(string articleText) {
	List&lt;KeyValuePair&lt;string, string&gt;&gt; sections = new List&lt;KeyValuePair&lt;string, string&gt;&gt;();
	int lastmatchpos = 0;
	Match lastMatch = null;
	foreach(Match m in WikiRegexes.HeadingLevelTwo.Matches(articleText)) {
		if (m.Index &gt; 0) {
			// Don't add empty first section if page starts with heading
			string sectionContent = articleText.Substring(lastmatchpos, m.Index-lastmatchpos);
			string sectionName = (lastMatch != null) ? lastMatch.Groups[1].Value.Trim() : "";
			sections.Add(new KeyValuePair&lt;string, string&gt;(sectionName, sectionContent));
		}
		lastmatchpos = m.Index;
		lastMatch = m;
	}
	// Add text of final section
	string sectionContentLast = articleText.Substring(lastmatchpos);
	string sectionNameLast = (lastMatch != null) ? lastMatch.Groups[1].Value : "";
	sections.Add(new KeyValuePair&lt;string, string&gt;(sectionNameLast, sectionContentLast));
	return sections;
}
// return the expected listing type for the given section name ("See" returns "see").
private static string GetValidListingTypeForSection(string sectionName) {
	if (sectionName == "Cosa vedere") {
		return "see";
	} if (sectionName == "Cosa fare") {
		return "do";
	} if (sectionName == "Acquisti") {
		return "buy";
	} if (sectionName == "Dove mangiare" || sectionName.ToLower() == "Mangiare") {
		return "eat";
	} if (sectionName == "Come divertirsi") {
		return "drink";
	} if (sectionName == "Dove alloggiare") {
		return "sleep";
	} else {
		return "listing";
	}
}
private static string SanitizePhoneNumber(string telNumberText) {
	// strip out the tel number, in case it is contained within other text
	// such as "888-888-8888 (front office)"
	Match match = PhoneNumberRegex.Match(telNumberText);
	if (match.Success) {
		string telNumber = match.Value;
		string originalPhoneNumber = match.Value;
		// remove invalid characters
		telNumber = telNumber.Replace("'", "");
		telNumber = telNumber.Replace("(", " ").Trim();
		telNumber = telNumber.Replace(")", " ").Trim();
		// convert periods to dashes
		telNumber = telNumber.Replace(".", "-");
		telNumber = ExcessWhitespaceRegex.Replace(telNumber, " ");
		// if there is a pattern like " -", "- ", "+ " left, replace the space
		telNumber = telNumber.Replace(" -", "-");
		telNumber = telNumber.Replace("- ", "-");
		telNumber = telNumber.Replace("+ ", "+");
		// if the tel number starts with a 1, change it to +1
		if (telNumber.StartsWith("1 ") || telNumber.StartsWith("1-")) {
			telNumber = "+" + telNumber;
		}
		telNumberText = telNumberText.Replace(originalPhoneNumber, telNumber);
	}
	return telNumberText;
}
// return the city from the article name.  if the article name is "Foo (Disambiguation)"
// then this method returns "Foo".
private static string GetCityFromArticleName(string articleName) {
	string basePageName = Tools.BasePageName(articleName);
	Match match = CityNameWithDisambiguationRegex.Match(basePageName);
	return (match.Success) ? match.Groups[1].Value : basePageName;
}
// if the indirizzo ends in a full street type value, convert to the abbreviated value
private static string AbbreviateStreeType(string indirizzo, string invalidStreetType, string validStreetType) {
	if (indirizzo.ToLower().EndsWith(" " + invalidStreetType.ToLower())) {
		int pos = indirizzo.ToLower().LastIndexOf(invalidStreetType.ToLower());
		if (pos &gt; 0) {
			indirizzo = indirizzo.Substring(0, pos) + validStreetType;
		}
	}
	return indirizzo;
}
// remove any leading or trailing punctuation
private static string StripStrayPunctuation(string text) {
	return StripPunctuation(text, true, true);
}
// remove any leading punctuation
private static string StripLeadingPunctuation(string text) {
	return StripPunctuation(text, true, false);
}
// remove any trailing punctuation
private static string StripTrailingPunctuation(string text) {
	return StripPunctuation(text, false, true);
}
// remove any leading punctuation
private static string StripPunctuation(string text, bool stripLeading, bool stripTrailing) {
	if (stripTrailing) {
		text = InvalidTrailingPunctuationRegex.Replace(text, "");
	}
	if (stripLeading) {
		text = InvalidLeadingPunctuationRegex.Replace(text, "");
	}
	return text;
}
// return true if the text matches the pattern, otherwise return null,  the "match"
// param will be populated with the match object
private static bool MatchText(string matchText, Regex regex, ref Match match) {
	match = regex.Match(matchText);
	return (match.Success);
}
private static string Capitalize(string text) {
	if (String.IsNullOrEmpty(text)) {
		return text;
	}
	// make sure first character is capitalized
	return (text.Length == 1) ? Char.ToUpper(text[0]) + "" : Char.ToUpper(text[0]) + text.Substring(1);
}
// add the value to the edit summary if it is not already present
private static string UpdateEditSummary(string summary, string textToAdd) {
	if (summary == "") {
		return textToAdd;
	}
	foreach(string summaryField in summary.Split(',')) {
		if (summaryField.Trim().Equals(textToAdd)) {
			// text already present in edit summary
			return summary;
		}
	}
	return summary += ", " + textToAdd;
}
// return true if the article contains a city status template
//public static bool IsCityArticle(string articleText) {
//	return CityStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a country status template
//public static bool IsCountryArticle(string articleText) {
//	return CountryStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a dive guide status template
//public static bool IsDiveguideArticle(string articleText) {
//	return DiveguideStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a district status template
//public static bool IsDistrictArticle(string articleText) {
//	return DistrictStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains an itinerary status template
//public static bool IsItineraryArticle(string articleText) {
//	return ItineraryStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a park status template
//public static bool IsParkArticle(string articleText) {
//	return ParkStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a phrasebook status template
//public static bool IsPhrasebookArticle(string articleText) {
//	return PhrasebookStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a region status template
//public static bool IsRegionArticle(string articleText) {
//	return RegionStatusTemplateNamesRegex.IsMatch(articleText);
//}
// return true if the article contains a topic status template
//public static bool IsTopicArticle(string articleText) {
//	return TopicStatusTemplateNamesRegex.IsMatch(articleText);
//}
// TODO:
// - clean up frontlink conversion logic
// - move tollfree numbers to tollfree in listings
// - don't allow "otheruses" to be moved above the page banner</Code>
  </Module>
  <ExternalProgram>
    <Enabled>false</Enabled>
    <Skip>false</Skip>
    <Program />
    <Parameters />
    <PassAsFile>true</PassAsFile>
    <OutputFile />
  </ExternalProgram>
  <Disambiguation>
    <Enabled>false</Enabled>
    <Link />
    <Variants />
    <ContextChars>20</ContextChars>
  </Disambiguation>
  <Special>
    <namespaceValues>
      <int>0</int>
      <int>1</int>
      <int>2</int>
      <int>3</int>
      <int>4</int>
      <int>5</int>
      <int>6</int>
      <int>7</int>
      <int>10</int>
      <int>11</int>
      <int>14</int>
      <int>15</int>
    </namespaceValues>
    <remDupes>true</remDupes>
    <sortAZ>true</sortAZ>
    <filterTitlesThatContain>false</filterTitlesThatContain>
    <filterTitlesThatContainText />
    <filterTitlesThatDontContain>false</filterTitlesThatDontContain>
    <filterTitlesThatDontContainText />
    <areRegex>false</areRegex>
    <opType>-1</opType>
    <remove />
  </Special>
  <Tool>
    <ListComparerUseCurrentArticleList>0</ListComparerUseCurrentArticleList>
    <ListSplitterUseCurrentArticleList>0</ListSplitterUseCurrentArticleList>
    <DatabaseScannerUseCurrentArticleList>0</DatabaseScannerUseCurrentArticleList>
  </Tool>
  <Plugin />
</AutoWikiBrowserPreferences>


Eseguire modifiche con AWB

[modifica]

Per operare modifiche con AWB è necessario innanzitutto individuare un elenco di articoli da editare. Una volta fatto, AWB creerà una lista in un riquadro al lato sinistro della sua interfaccia e di volta in volta mostrerà il Diff di ogni modifica. Per iniziare ad operare con AWB clicca su Start (ultima linguetta del riquadro centrale) e poi ancora sul pulsante Start. AWB visualizzerà il testo con le modifiche che intende apportare e un riquadro con diverse opzioni, comprese quelle di modifica manuale. Per non effettuare alcuna modifica premi Skip, per salvarla fai clic su Save.

  • Attenzione: AWB potrebbe apportare modifiche diverse da quelle attese, in quanto si basa su espressioni regolari, e spetta a voi per rivedere le modifiche proposte e correggere eventuali errori prima di salvare. La responsabilità di ogni modifica è solo vostra.

Modifiche manuali possono essere effettuate modificando il contenuto della scheda "Edit". Una volta salvata una modifica questa apparirà nella cronologia della relativa pagina. In ogni caso, appena salvato o saltato un diff, AWB procederà con le successive pagine nella lista.

Creare la lista

[modifica]

Vai nel riquadro "Source" e digitare il nome dell'articolo da modificare o una modalità di creazione della lista, quindi utilizza "Make list" per le diverse opzioni o per generare la lista pronta all'utilizzo.

Mi sembra di aver capito, ma...

Se non riesci ad afferrare qualche concetto o non capisci il perché di tale procedura, ci metti cinque secondi a chiederlo e avere risposta. Se pensi invece di avere una proposta, piccola o grande che sia, siamo tutti pronti ad ascoltarti.

L'elenco di tutte le pagine riguardanti Wikivoyage si trova nella pagina Aiuto:Aiuto.