private void RefreshJavaScriptEditor()
{
List <BibTexItem> bibtex_items_list = BibTexParser.Parse(ObjBibTexEditor.Text).Items;
Dictionary <string, CSLProcessorBibTeXFinder.MatchingBibTeXRecord> bitex_items = new Dictionary <string, CSLProcessorBibTeXFinder.MatchingBibTeXRecord>();
bibtex_items_list.ForEach(o => bitex_items[o.Key] = new CSLProcessorBibTeXFinder.MatchingBibTeXRecord {
bibtex_item = o
});
// Sample citation clusters
List <CitationCluster> citation_clusters = new List <CitationCluster>();
bibtex_items_list.ForEach(o => citation_clusters.Add(new CitationCluster(new CitationItem(o.Key, ""))));
CitationCluster mega_citation_cluster = new CitationCluster();
bibtex_items_list.ForEach(o => mega_citation_cluster.citation_items.Add(new CitationItem(o.Key, "")));
citation_clusters.Add(mega_citation_cluster);
Dictionary <string, string> abbreviations = new Dictionary <string, string>();
string citation_uses = CSLProcessorTranslator_CitationClustersToJavaScript.Translate(citation_clusters);
string citation_init = CSLProcessorTranslator_BibTeXToJavaScript.Translate_INIT(bitex_items);
string citation_database = CSLProcessorTranslator_BibTeXToJavaScript.Translate_DATABASE(bitex_items, abbreviations);
string final_text = ""
+ citation_uses
+ "\n"
+ citation_init
+ "\n"
+ citation_database
;
ObjJavaScriptEditor.Text = final_text;
}
public void LoadSpecialCharactersDatabase()
{
var data = File.ReadAllText(@"Sample Files\b4w.bib", Encoding.GetEncoding(1252));
var parser = new BibTexParser(new BibTexLexer(data));
specialCharactersDatabase = parser.Parse();
}
[Test] // From http://theoval.cmp.uea.ac.uk/~nlct/latex/novices/symbols.html
public void SymbolTests()
{
var text = @"@MISC{LatexSymbols,title = {\textbackslash \_ - -- \textendash --- \textemdash \P \textasciicircum \$ \S \textasciitilde \{ \ldots \pounds \} ?` \textquestiondown \textregistered \# !` \textexclamdown \texttrademark \% ' \textquoteright '' \textquotedblright \copyright \& ` \textquoteleft `` \textquotedblleft \yen \i \j \textbar \textperiodcentered \textless \textgreater \slash}";
var title = new BibTexParser(new BibTexLexer(text)).Parse()["LatexSymbols"]["title"];
Assert.AreEqual("\\ _ - – – — — ¶ ^ $ § ~ { … £ } ¿ ¿ ® # ¡ ¡ \x2122 % ’ ’ ” ” © & ‘ ‘ “ “ ¥ \uD835\uDEA4 \uD835\uDEA5 | · < > /", title.Display);
}
public static BibTexDatabase LoadBibTexDatabase(string filename)
{
LastTemplateParseException = null;
try
{
var text = LoadFile(filename);
var parser = new BibTexParser(new BibTexLexer(text));
var result = parser.Parse();
var fileInfo = new FileInfo(filename);
result.Filename = fileInfo.FullName;
result.Timestamp = fileInfo.LastWriteTime;
return(result);
}
catch (Exception ex)
{
LastTemplateParseException = ex as TemplateParseException;
Helper.LogUnexpectedException("Failed loading Bibtex database from '" + filename + "'", ex);
return(null);
}
}
internal static string Process(string source)
{
// If it is empty
if (String.IsNullOrEmpty(source))
{
return(source);
}
// See if it is valid BibTeX - if so, use it...
try
{
List <BibTexItem> bibtexes = BibTexParser.Parse(source).Items;
if (0 == bibtexes[0].Exceptions.Count)
{
return(source);
}
}
catch (Exception ex)
{
ExceptionLog(ex, "BibTeX");
}
// See if it is valid PubMed XML
try
{
string bibtex;
List <string> messages;
if (PubMedXMLToBibTex.TryConvert(source, out bibtex, out messages))
{
return(bibtex);
}
}
catch (Exception ex)
{
ExceptionLog(ex, "PubMed");
}
// See if it is valid EndNote
try
{
List <EndNoteToBibTex.EndNoteRecord> endnotes = EndNoteToBibTex.Parse(source);
if (endnotes.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var endnote in endnotes)
{
sb.Append(endnote.ToBibTeX().ToBibTex());
sb.Append("\n\n");
}
return(sb.ToString());
}
}
catch (Exception ex)
{
ExceptionLog(ex, "EndNote");
}
// If we get here, we don't have a clue what is going on...
return(source);
}
public void TempParser()
{
var data = File.ReadAllText(@"Sample Files\Temp.bib");
var parser = new BibTexParser(new BibTexLexer(data));
var db = parser.Parse();
Console.WriteLine("{0} abbreviations; {1} entries", db.AbbreviationCount, db.EntryCount);
}
protected BibTeXImporter(Library library, string filename)
: base(library, filename)
{
string bibTex = File.ReadAllText(ExportFileName, System.Text.Encoding.UTF8);
BibTexParseResult = BibTexParser.Parse(bibTex);
BibTexParseResult.Items.ForEach(x => Entries.Add(new BibTeXEntry {
Item = x, BibTeX = x.ToBibTex()
}));
}
public static string GetField(string bibtex, string field)
{
try
{
BibTexItem bibtex_item = BibTexParser.ParseOne(bibtex, false);
return(GetField(bibtex_item, field));
}
catch (Exception ex)
{
Logging.Warn(ex, "There was a problem extracting from the BibTeX");
return("");
}
}
public static bool DoesBibTeXMatchDocument(string bibtex, PDFDocument pdf_document, out PDFSearchResultSet search_result_set)
{
try
{
if (!String.IsNullOrEmpty(bibtex))
{
BibTexItem bibtex_item = BibTexParser.ParseOne(bibtex, true);
return(DoesBibTeXMatchDocument(bibtex_item, pdf_document, out search_result_set));
}
}
catch (Exception) { }
search_result_set = new PDFSearchResultSet();
return(false);
}
public void Mendeley2Parser()
{
var data = File.ReadAllText(@"Sample Files\Mendeley 2.bib");
var parser = new BibTexParser(new BibTexLexer(data));
var db = parser.Parse();
Console.WriteLine("{0} abbreviations; {1} entries", db.AbbreviationCount, db.EntryCount);
Assert.AreEqual(0, db.AbbreviationCount);
Assert.AreEqual(1231, db.EntryCount);
Assert.AreEqual(14673, parser.Current.Line);
Assert.AreEqual(1, parser.Current.Column);
Assert.AreEqual(713525, parser.Current.Position);
}
public void DocearParser()
{
var data = File.ReadAllText(@"Sample Files\Docear.bib");
var parser = new BibTexParser(new BibTexLexer(data));
var db = parser.Parse();
Console.WriteLine("{0} abbreviations; {1} entries", db.AbbreviationCount, db.EntryCount);
Assert.AreEqual(8, db.AbbreviationCount);
Assert.AreEqual(1064, db.EntryCount);
Assert.AreEqual(17638, parser.Current.Line);
Assert.AreEqual(1, parser.Current.Column);
Assert.AreEqual(682497, parser.Current.Position);
}
public void BigFileParser()
{
var data = File.ReadAllText(@"Sample Files\BigFile.bib");
var parser = new BibTexParser(new BibTexLexer(data));
var db = parser.Parse();
Console.WriteLine("{0} abbreviations; {1} entries", db.AbbreviationCount, db.EntryCount);
Assert.AreEqual(232, db.AbbreviationCount);
Assert.AreEqual(1457, db.EntryCount);
Assert.AreEqual(11264, parser.Current.Line);
Assert.AreEqual(1, parser.Current.Column);
Assert.AreEqual(359616, parser.Current.Position);
}
private void ButtonApplyBibTeX_Click(object sender, RoutedEventArgs e)
{
List <PDFDocument> selected_pdf_documents = SelectedPDFDocuments;
if (null == selected_pdf_documents)
{
return;
}
if (!MessageBoxes.AskQuestion("Are you sure you want to mass-edit {0} documents?", selected_pdf_documents.Count))
{
return;
}
BibTexItem bibtex_item_global = BibTexParser.ParseOne(bibtex_stub.BibTex, true);
int non_updateable_documents = 0;
foreach (var pdf_document in selected_pdf_documents)
{
BibTexItem bibtex_item = pdf_document.BibTexItem;
if (null != bibtex_item)
{
if (!String.IsNullOrEmpty(bibtex_item_global.Type))
{
bibtex_item.Type = bibtex_item_global.Type;
}
foreach (var field_pair in bibtex_item_global.Fields)
{
bibtex_item[field_pair.Key] = field_pair.Value;
}
pdf_document.BibTex = bibtex_item.ToBibTex();
pdf_document.Bindable.NotifyPropertyChanged(() => pdf_document.BibTex);
}
else
{
++non_updateable_documents;
}
}
if (0 < non_updateable_documents)
{
MessageBoxes.Warn("There was a problem updating {0} documents as they do not have an existing BibTeX record associated with them.", non_updateable_documents);
}
}
public void BibTex_Parse_Successful()
{
// Set up BibTexParser.
var customFieldCheckers = new Dictionary <Item.FieldType, IFieldChecker>
{
[Item.FieldType.ISSN] = new IssnFieldChecker(),
[Item.FieldType.ISBN] = new IsbnFieldChecker(),
[Item.FieldType.Author] = new AuthorFieldChecker(),
[Item.FieldType.Year] = new YearFieldChecker(),
[Item.FieldType.URL] = new UrlFieldChecker()
};
var itemChecker = new DefaultItemChecker(new FieldValidator(new DefaultFieldChecker(), customFieldCheckers));
var parser = new BibTexParser(new ItemValidator(itemChecker));
var bib = parser.Parse(Encoding.Default.GetString(Properties.Resources.bibtex));
Assert.AreEqual(100, bib.Count);
}
public void SimpleParser()
{
const string Data = @"
@article{mrx05,
auTHor = ""Mr. X"",
Title = {Something Great},
publisher = ""nob"" # ""ody"",
YEAR = 2005,
} ";
var lexer = new BibTexLexer(Data);
var parser = new BibTexParser(lexer);
var db = parser.Parse();
Console.WriteLine("{0} abbreviations; {1} entries", db.AbbreviationCount, db.EntryCount);
}
protected BibTeXImporter(Library library, string filename)
: base(library, filename)
{
string bibTex = null;
using (Stream fs = new FileStream(ExportFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (StreamReader sr = new StreamReader(fs))
{
bibTex = sr.ReadToEnd();
}
}
BibTexParseResult = BibTexParser.Parse(bibTex);
BibTexParseResult.Items.ForEach(x => Entries.Add(new BibTeXEntry {
Item = x, BibTeX = x.ToBibTex()
}));
}
// ----------------------------------------------------------------------------------------
public static void Test()
{
string sample_bibtext = @"@conference{kamp1984theory,title = {{A theory of truth and semantic representation}},author = {Kamp, H.},booktitle={Truth, Interpretation and Information: Selected Papers from the Third Amsterdam Colloquium},pages={1--41},year={1984}";
Logging.Info("BibTex is:\n" + sample_bibtext);
BibTexItem bibtex_item = BibTexParser.ParseOne(sample_bibtext, false);
Logging.Info("Title is: " + GetTitle(bibtex_item));
Logging.Info("Author is: " + GetAuthor(bibtex_item));
Logging.Info("Year is: " + GetYear(bibtex_item));
string replaced_bibtex = sample_bibtext;
replaced_bibtex = SetTitle(replaced_bibtex, "New title");
replaced_bibtex = SetAuthor(replaced_bibtex, "New author");
replaced_bibtex = SetYear(replaced_bibtex, "New year");
Logging.Info("Replaced BibTex is:\n" + replaced_bibtex);
}
void RebuidTextAndGrid()
{
string bibtex = BibTeX;
if (String.IsNullOrEmpty(bibtex) && !ForceHideNoBibTeXInstructions)
{
ObjNoBibTeXInstructions.Visibility = Visibility.Visible;
}
else
{
ObjNoBibTeXInstructions.Visibility = Visibility.Collapsed;
}
BibTexItem bibtex_item = BibTexParser.ParseOne(bibtex, true);
if (null == bibtex_item)
{
bibtex_item = new BibTexItem();
}
// If there were any exceptions, go pink and jump to the text editor
if (bibtex_item.Exceptions.Count > 0 || bibtex_item.Warnings.Count > 0)
{
TextBlock tb = new TextBlock();
tb.FontFamily = new FontFamily("Courier New");
tb.Text = bibtex_item.GetExceptionsAndMessagesString();
tb.TextWrapping = TextWrapping.Wrap;
tb.MaxWidth = 400;
ImageBibTeXParseError.ToolTip = tb;
ImageBibTeXParseError.Visibility = ObjErrorPanel.Visibility = Visibility.Visible;
}
else
{
ObjErrorPanel.ToolTip = null;
ImageBibTeXParseError.Visibility = ObjErrorPanel.Visibility = Visibility.Collapsed;
}
BuildGridFromBibTeX(bibtex, bibtex_item);
BuildTextFromBibTeX(bibtex, bibtex_item);
}
/// <summary>
/// After setting the field, returns the WHOLE bibtex again
/// </summary>
/// <param name="bibtex"></param>
/// <param name="field"></param>
/// <param name="field_value"></param>
/// <returns></returns>
public static string SetField(string bibtex, string field, string field_value)
{
try
{
BibTexItem item = BibTexParser.ParseOne(bibtex, false);
if (null != item)
{
item[field] = field_value;
return(item.ToBibTex());
}
else
{
return(bibtex);
}
}
catch (Exception ex)
{
Logging.Warn(ex, "There was a problem setting the BibTeX");
return(null);
}
}
internal static void Export(WebLibraryDetail web_library_detail, List <PDFDocument> pdf_documents, string base_path, Dictionary <string, PDFDocumentExportItem> pdf_document_export_items)
{
Logging.Info("Exporting entries to BibTeXTAB separated");
// First work out what fields are available
List <string> field_names = null;
{
HashSet <string> field_names_set = new HashSet <string>();
for (int i = 0; i < pdf_documents.Count; ++i)
{
PDFDocument pdf_document = pdf_documents[i];
if (!String.IsNullOrEmpty(pdf_document.BibTex))
{
BibTexItem item = BibTexParser.ParseOne(pdf_document.BibTex, true);
if (null != item)
{
foreach (var field in item.Fields)
{
field_names_set.Add(field.Key.ToLower());
}
}
}
}
field_names = new List <string>(field_names_set);
field_names.Sort();
}
// Write out the header
DateTime now = DateTime.Now;
StringBuilder sb = new StringBuilder();
sb.AppendLine("% -------------------------------------------------------------------------");
sb.AppendLine(String.Format("% This tab separated file was generated by Qiqqa ({0}?ref=EXPTAB)", Common.Configuration.WebsiteAccess.Url_Documentation4Qiqqa));
sb.AppendLine(String.Format("% {0} {1}", now.ToLongDateString(), now.ToLongTimeString()));
sb.AppendLine("% Version 1");
sb.AppendLine("% -------------------------------------------------------------------------");
sb.AppendLine();
// Headers
sb.AppendFormat("{0}\t", "Fingerprint");
sb.AppendFormat("{0}\t", "Filename");
sb.AppendFormat("{0}\t", "BibTexKey");
sb.AppendFormat("{0}\t", "BibTexType");
foreach (string field_name in field_names)
{
sb.AppendFormat("{0}\t", FormatFreeText(field_name));
}
sb.AppendLine();
// Write out the entries
for (int i = 0; i < pdf_documents.Count; ++i)
{
StatusManager.Instance.UpdateStatus("TabExport", String.Format("Exporting entry {0} of {1}", i, pdf_documents.Count), i, pdf_documents.Count);
PDFDocument pdf_document = pdf_documents[i];
sb.AppendFormat("{0}\t", pdf_document.Fingerprint);
sb.AppendFormat("{0}\t", pdf_document_export_items.ContainsKey(pdf_document.Fingerprint) ? pdf_document_export_items[pdf_document.Fingerprint].filename : "");
try
{
if (!String.IsNullOrEmpty(pdf_document.BibTex))
{
BibTexItem item = BibTexParser.ParseOne(pdf_document.BibTex, true);
if (null != item)
{
sb.AppendFormat("{0}\t", item.Key);
sb.AppendFormat("{0}\t", item.Type);
foreach (string field_name in field_names)
{
sb.AppendFormat("{0}\t", item.ContainsField(field_name) ? FormatFreeText(item[field_name]) : "");
}
}
}
}
catch (Exception ex)
{
Logging.Error(ex, "There was a problem exporting the tab representation for document {0}", pdf_document.Fingerprint);
}
sb.AppendLine();
}
// Write to disk
string filename = Path.GetFullPath(Path.Combine(base_path, @"Qiqqa.BibTeX.tab"));
File.WriteAllText(filename, sb.ToString());
StatusManager.Instance.UpdateStatus("TabExport", String.Format("Exported your BibTeX tab entries to {0}", filename));
}
public static BibTexDatabase CreateBibTexDatabase(string text)
{
var parser = new BibTexParser(new BibTexLexer(text));
return(parser.Parse());
}
public static void Main()
{
// Set up BibTexParser.
var customFieldCheckers = new Dictionary <Item.FieldType, IFieldChecker>
{
[Item.FieldType.ISSN] = new IssnFieldChecker(),
[Item.FieldType.ISBN] = new IsbnFieldChecker(),
[Item.FieldType.Author] = new AuthorFieldChecker(),
[Item.FieldType.Year] = new YearFieldChecker(),
[Item.FieldType.URL] = new UrlFieldChecker()
};
var itemChecker = new DefaultItemChecker(new FieldValidator(new DefaultFieldChecker(), customFieldCheckers));
var parser = new BibTexParser(new ItemValidator(itemChecker));
// Populate repository with parsed BibTex data.
var repo = new InMemoryItemRepo();
try
{
repo.AddRange(parser.Parse(Encoding.Default.GetString(Properties.Resources.bibtex)));
}
catch (InvalidDataException)
{
Console.WriteLine("Not all loaded BibTeX data is valid. Ensure the field checkers are implemented properly.");
Console.ReadLine();
return;
}
// Show interface to search.
Console.WriteLine($"Hi, and welcome to the BibTeX search engine!");
Console.WriteLine($"Enter a word or sentence to search in the repo (searches on all fields):\n");
while (true)
{
// Search for specified search string.
Console.Write($">");
var s = Console.ReadLine();
var result = repo.Search(s);
List <Item> items = result.ToList();
// Print results.
Console.Write($"\nThere are {items.Count} items containing \"{s}\".\n");
int curItem = 0;
const int pageSize = 10;
bool continuePrinting = true;
while (continuePrinting && curItem < items.Count)
{
Item item = items[curItem];
Console.WriteLine($"\t{item.Fields[Item.FieldType.Title]}");
if ((curItem + 1) % pageSize == 0)
{
Console.Write($"\nEnter enter to get more. Write end to escape > ");
if (Console.ReadLine()?.ToLower() == "end")
{
continuePrinting = false;
break;
}
}
curItem++;
}
if (items.Count > 0 && continuePrinting)
{
Console.WriteLine($"No more items.");
}
}
}
internal static bool InferBibTeX(PDFDocument pdf_document, bool manual_override)
{
if (MustBackoff() && !manual_override)
{
return(false);
}
if (!pdf_document.DocumentExists)
{
return(false);
}
if (!String.IsNullOrEmpty(pdf_document.BibTex) && !manual_override)
{
return(false);
}
if (pdf_document.AutoSuggested_BibTeXSearch && !manual_override)
{
return(false);
}
if (!ConfigurationManager.Instance.ConfigurationRecord.Metadata_AutomaticallyAssociateBibTeX && !manual_override)
{
return(false);
}
// Flag on this document that we have tried to do the bibtex
pdf_document.AutoSuggested_BibTeXSearch = true;
pdf_document.Bindable.NotifyPropertyChanged(() => pdf_document.AutoSuggested_BibTeXSearch);
string title = pdf_document.TitleCombined;
title = title.Trim();
if (String.IsNullOrEmpty(title))
{
return(false);
}
if (title.Length < 10)
{
return(false);
}
// If there is only a single word in the title, it is not useful to us...
if (-1 == title.IndexOf(' '))
{
return(false);
}
// Unwanted automatic titles
if (Constants.TITLE_UNKNOWN == title || pdf_document.DownloadLocation == title)
{
return(false);
}
// Get the search results!
string json = DoSearch(title);
if (null != json)
{
object o = JsonConvert.DeserializeObject(json);
JArray ja = (JArray)o;
// Get the bibtexes that suit this document
List <string> bibtex_choices = new List <string>();
foreach (var jo in ja)
{
var bibtex = jo["_source"]["bibtex"].ToString();
if (String.IsNullOrEmpty(bibtex))
{
continue;
}
BibTexItem bibtex_item = BibTexParser.ParseOne(bibtex, true);
// Does the bibtex match sufficiently? Empty bibtex will be handled accordingly: no fit/match
PDFSearchResultSet search_result_set;
if (!BibTeXGoodnessOfFitEstimator.DoesBibTeXMatchDocument(bibtex_item, pdf_document, out search_result_set))
{
continue;
}
// Does the title match sufficiently to the bibtex
{
string title_string = BibTexTools.GetTitle(bibtex_item);
string title_string_tolower = title_string.Trim().ToLower();
string title_tolower = title.Trim().ToLower();
double similarity = StringTools.LewensteinSimilarity(title_tolower, title_string_tolower);
if (0.75 > similarity)
{
continue;
}
}
if (!bibtex.Contains(BibTeXActionComments.AUTO_BIBTEXSEARCH))
{
bibtex =
BibTeXActionComments.AUTO_BIBTEXSEARCH
+ "\r\n"
+ bibtex;
}
// If we get this far, we are happy with the bibtex
bibtex_choices.Add(bibtex);
}
// Pick the longest matching bibtex
if (0 < bibtex_choices.Count)
{
bibtex_choices.Sort(delegate(string a, string b)
{
if (a.Length > b.Length)
{
return(-1);
}
if (a.Length < b.Length)
{
return(+1);
}
return(0);
}
);
pdf_document.BibTex = bibtex_choices[0];
pdf_document.Bindable.NotifyPropertyChanged(() => pdf_document.BibTex);
FeatureTrackingManager.Instance.UseFeature(Features.BibTeX_BibTeXSearchMatch);
return(true);
}
}
return(false);
}
