bibsync 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+*.gem
+Gemfile.lock
+.bundle
+.yardoc
+

data/bibsync.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/bibsync/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name              = 'bibsync'
+  s.version           = BibSync::VERSION
+  s.date              = Date.today.to_s
+  s.authors           = ['Daniel Mendler']
+  s.email             = ['mail@daniel-mendler.de']
+  s.summary           = 'BibSync is a tool to synchronize scientific papers and bibtex bibliography files'
+  s.description       = 'BibSync is a tool to synchronize scientific papers and bibtex bibliography files'
+  s.homepage          = 'https://github.com/minad/bibsync'
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_runtime_dependency('nokogiri')
+end

data/bin/bibsync

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'bibsync/command'
+
+BibSync::Command.new(ARGV).run

data/lib/bibsync/actions/check_versions.rb

@@ -0,0 +1,35 @@
+module BibSync
+  module Actions
+    class CheckVersions
+      include Log
+      include Utils
+
+      SliceSize = 20
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+        raise 'Directory must be set' unless @dir = options[:dir]
+        @update = options[:update]
+      end
+
+      def run
+        notice 'Check for newer version on arXiv'
+        @bib.select {|e| e[:arxiv] }.each_slice(SliceSize) do |entry|
+          begin
+            xml = fetch_xml("http://export.arxiv.org/api/query?id_list=#{entry.map{|e| arxiv_id(e, :version => false, :prefix => true) }.join(',')}&max_results=#{SliceSize}")
+            xml.xpath('//entry/id').map(&:content).each_with_index do |id, i|
+              id.gsub!('http://arxiv.org/abs/', '')
+              if id != entry[i][:arxiv]
+                info("#{entry[i][:arxiv]} replaced by http://arxiv.org/pdf/#{id}", :key => entry[i])
+                arxiv_download(@dir, id) if @update
+              end
+            end
+          rescue => ex
+            error('arXiv query failed', :ex => ex)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/bibsync/actions/fetch_from_arxiv.rb

@@ -0,0 +1,52 @@
+module BibSync
+  module Actions
+    class FetchFromArXiv
+      SliceSize = 20
+
+      include Log
+      include Utils
+
+      def initialize(options)
+        raise 'Fetch must be set' unless @fetch = options[:fetch]
+        raise 'Directory must be set' unless @dir = options[:dir]
+      end
+
+      def run
+        ids = []
+        urls = []
+
+        @fetch.each do |url|
+          if url =~ %r{^http://arxiv.org/abs/(\d+\.\d+)$}
+            ids << $1
+          else
+            urls << url
+          end
+        end
+
+        unless urls.empty?
+          notice 'Starting browser for non-arXiv urls'
+          urls.each do |url|
+            info "Opening #{url}"
+            `xdg-open #{Shellwords.escape url}`
+          end
+        end
+
+        unless ids.empty?
+          notice 'Downloading from arXiv'
+          ids.each_slice(SliceSize) do |ids|
+            begin
+              xml = fetch_xml("http://export.arxiv.org/api/query?id_list=#{ids.join(',')}&max_results=#{SliceSize}")
+              xml.xpath('//entry/id').map(&:content).each_with_index do |id, i|
+                id.gsub!('http://arxiv.org/abs/', '')
+                info 'arXiv download', :key => id
+                arxiv_download(@dir, id)
+              end
+            rescue => ex
+              error('arXiv query failed', :ex => ex)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bibsync/actions/find_my_citations.rb

@@ -0,0 +1,46 @@
+module BibSync
+  module Actions
+    class FindMyCitations
+      include Log
+      include Utils
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+        raise 'Tex directory must be set' unless @dir = options[:citedbyme]
+        raise "#{@dir} is not a directory" unless File.directory?(@dir)
+      end
+
+      def run
+        notice 'Find citations in my TeX files'
+
+        cites = {}
+        Dir[File.join(@dir, '**/*.tex')].each do |file|
+          File.read(file).scan(/cite\{([^\}]+)\}/) do
+            $1.split(/\s*,\s*/).each do |key|
+              key.strip!
+              file = @bib.relative_path(file)
+              debug("Cited in #{file}", :key => key)
+              (cites[key] ||= []) << file
+            end
+          end
+        end
+
+        @bib.each do |entry|
+          next if entry.comment?
+          entry.delete(:cites) unless cites.include?(entry.key)
+        end
+
+        cites.each do |key, files|
+          files = files.sort.uniq.join(';')
+          if @bib[key]
+            @bib[key][:citedbyme] = files
+          else
+            warning("Cited in #{files} but not found in #{@bib.file}", :key => key)
+          end
+        end
+
+        @bib.save
+      end
+    end
+  end
+end

data/lib/bibsync/actions/jabref_format.rb

@@ -0,0 +1,22 @@
+module BibSync
+  module Actions
+    class JabrefFormat
+      include Utils
+      include Log
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+      end
+
+      def run
+        @bib.save
+        if File.read(@bib.file, 80) !~ /JabRef/
+          notice 'Transforming file with JabRef'
+          tmp_file = "#{@bib.file}.tmp.bib"
+          `jabref --nogui --import #{Shellwords.escape @bib.file} --output #{Shellwords.escape tmp_file} 2>&1 >/dev/null`
+          File.rename(tmp_file, @bib.file) if File.exists?(tmp_file)
+        end
+      end
+    end
+  end
+end

data/lib/bibsync/actions/synchronize_files.rb

@@ -0,0 +1,41 @@
+module BibSync
+  module Actions
+    class SynchronizeFiles
+      include Utils
+      include Log
+
+      FileTypes = %w(djvu pdf ps)
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+        raise 'Directory must be set' unless @dir = options[:dir]
+      end
+
+      def run
+        notice 'Synchronize with files'
+
+        files = {}
+        Dir[File.join(@dir, "**/*.{#{FileTypes.join(',')}}")].sort.each do |file|
+          name = File.basename(file)
+          key, type = split_filename(name)
+          raise "Duplicate file #{name}" if files[key]
+          files[key] = file
+        end
+
+        files.each do |key, file|
+          unless entry = @bib[key]
+            info('New file', :key => key)
+            entry = Bibliography::Entry.new
+            entry.key = key
+            @bib << entry
+          end
+
+          entry.type ||= :ARTICLE
+          entry.file = file
+        end
+
+        @bib.save
+      end
+    end
+  end
+end

data/lib/bibsync/actions/synchronize_metadata.rb

@@ -0,0 +1,172 @@
+module BibSync
+  module Actions
+    class SynchronizeMetadata
+      include Utils
+      include Log
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+        @force = options[:resync]
+      end
+
+      def run
+        notice 'Synchronize with arXiv and DOI'
+
+        @bib.each do |entry|
+          next if entry.comment?
+
+          if @force || !(entry[:title] && entry[:author] && entry[:year])
+            determine_arxiv_and_doi(entry)
+
+            if entry[:arxiv]
+              if entry.key == arxiv_id(entry, :prefix => false, :version => true)
+                entry = rename_arxiv_file(entry)
+                next unless entry
+              end
+              update_arxiv(entry)
+            end
+
+            update_doi(entry) if entry[:doi]
+          end
+
+          if @force || (!entry[:abstract] && entry[:doi] =~ /\A10\.1103\//)
+            update_aps_abstract(entry)
+          end
+
+          @bib.save
+        end
+      end
+
+      private
+
+      def update_aps_abstract(entry)
+        info("Downloading APS abstract", :key => entry)
+        html = fetch_html("http://link.aps.org/doi/#{entry[:doi]}")
+        entry[:abstract] = html.css('.aps-abstractbox').map(&:content).first
+      rescue => ex
+        error('Abstract download failed', :key => entry, :ex => ex)
+      end
+
+      def update_doi(entry)
+        info('Downloading doi.org metadata', :key => entry)
+        text = fetch("http://dx.doi.org/#{entry[:doi]}", 'Accept' => 'text/bibliography; style=bibtex')
+        raise text if text == 'Unknown DOI'
+        Bibliography::Entry.parse(text).each {|k, v| entry[k] = v }
+      rescue => ex
+        entry.delete(:doi)
+        error('doi download failed', :key => entry, :ex => ex)
+      end
+
+      # Rename arxiv file if key contains version
+      def rename_arxiv_file(entry)
+        file = entry.file
+
+        key = arxiv_id(entry, :prefix => false, :version => false)
+
+        if old_entry = @bib[key]
+          # Existing entry found
+          @bib.delete(entry)
+          old_entry[:arxiv] =~ /v(\d+)$/
+          old_version = $1
+          entry[:arxiv] =~ /v(\d+)$/
+          new_version = $1
+          if old_version && new_version && old_version >= new_version
+            info('Not updating existing entry with older version', :key => old_entry)
+            File.delete(file[:path]) if file
+            return nil
+          end
+
+          old_entry[:arxiv] = entry[:arxiv]
+          old_entry[:doi] = entry[:doi]
+          entry = old_entry
+          info('Updating existing entry', :key => entry)
+        else
+          # This is a new entry
+          entry.key = key
+        end
+
+        if file
+          new_path = file[:path].sub(arxiv_id(entry, :prefix => false, :version => true), key)
+          File.rename(file[:path], new_path)
+          entry.file = new_path
+        end
+
+        @bib.save
+
+        entry
+      end
+
+      def update_arxiv(entry)
+        info('Downloading arXiv metadata', :key => entry)
+        xml = fetch_xml("http://export.arxiv.org/oai2?verb=GetRecord&identifier=oai:arXiv.org:#{arxiv_id(entry, :prefix => true, :version => false)}&metadataPrefix=arXiv")
+        error = xml.xpath('//error').map(&:content).first
+        raise error if error
+
+        entry[:title] = xml.xpath('//arXiv/title').map(&:content).first
+        entry[:abstract] = xml.xpath('//arXiv/abstract').map(&:content).first
+        entry[:primaryclass] = xml.xpath('//arXiv/categories').map(&:content).first.split(/\s+/).first
+        entry[:author] = xml.xpath('//arXiv/authors/author').map do |author|
+          "{#{author.xpath('keyname').map(&:content).first}}, {#{author.xpath('forenames').map(&:content).first}}"
+        end.join(' and ')
+        entry[:journal] = ArXivJournal
+        entry[:eprint] = entry[:arxiv]
+        entry[:archiveprefix] = 'arXiv'
+        date = xml.xpath('//arXiv/updated').map(&:content).first || xml.xpath('//arXiv/created').map(&:content).first
+        date = Date.parse(date)
+        entry[:year] = date.year
+        entry[:month] = Bibliography::RawValue.new(%w(jan feb mar apr may jun jul aug sep oct nov dec)[date.month - 1])
+        doi = xml.xpath('//arXiv/doi').map(&:content).first
+        entry[:doi] = doi if doi
+        journal = xml.xpath('//arXiv/journal-ref').map(&:content).first
+        entry[:journal] = journal if journal
+        comments = xml.xpath('//arXiv/comments').map(&:content).first
+        entry[:comments] = comments if comments
+        entry[:url] = "http://arxiv.org/abs/#{entry[:arxiv]}"
+      rescue => ex
+        entry.delete(:arxiv)
+        error('arXiv download failed', :key => entry, :ex => ex)
+      end
+
+      def determine_arxiv_and_doi(entry)
+        if file = entry.file
+          if file[:type] == :PDF && !entry[:arxiv] && !entry[:doi]
+            debug('Searching for arXiv or doi identifier in pdf file', :key => entry)
+            text = `pdftotext -f 1 -l 2 #{Shellwords.escape file[:path]} - 2>/dev/null`
+            entry[:arxiv] = $1 if text =~ /arXiv:\s*([\w\.\/\-]+)/
+            entry[:doi] = $1 if text =~ /doi:\s*([\w\.\/\-]+)/i
+          end
+
+          if !entry[:arxiv] && file[:name] =~ /^(\d+.\d+v\d+)\.\w+$/
+            debug('Interpreting file name as arXiv identifier', :key => entry)
+            entry[:arxiv] = $1
+          end
+
+          if !entry[:doi] && file[:name] =~ /^(PhysRev.*?|RevModPhys.*?)\.\w+$/
+            debug('Interpreting file name as doi identifier', :key => entry)
+            entry[:doi] = "10.1103/#{$1}"
+          end
+        end
+
+        if !entry[:arxiv] && entry[:doi]
+          begin
+            info('Fetch missing arXiv identifier', :key => entry)
+            xml = fetch_xml("http://export.arxiv.org/api/query?search_query=doi:#{entry[:doi]}&max_results=1")
+            if xml.xpath('//entry/doi').map(&:content).first == entry[:doi]
+              id = xml.xpath('//entry/id').map(&:content).first
+              if id =~ %r{\Ahttp://arxiv.org/abs/(.+)\Z}
+                entry[:arxiv] = $1
+              end
+            end
+          rescue => ex
+            error('arXiv doi query failed', :ex => ex, :key => entry)
+          end
+        end
+
+        unless entry[:arxiv] || entry[:doi]
+          warning('No arXiv or doi identifier found', :key => entry)
+        end
+      end
+
+    end
+  end
+end

data/lib/bibsync/actions/validate.rb

@@ -0,0 +1,49 @@
+module BibSync
+  module Actions
+    class Validate
+      include Utils
+      include Log
+
+      def initialize(options)
+        raise 'Bibliography must be set' unless @bib = options[:bib]
+      end
+
+      def run
+        notice 'Check validity'
+        titles, arxivs = {}, {}
+
+        @bib.each do |entry|
+          next if entry.comment?
+
+          w = []
+
+          file = entry.file
+          w << 'Missing file' unless file && File.file?(file[:path])
+
+          w += [:title, :author, :year, :abstract].reject {|k| entry[k] }.map {|k| "Missing #{k}" }
+
+          w << 'Invalid file' if split_filename(file[:name]).first != entry.key if file
+
+          if entry[:arxiv]
+            id = arxiv_id(entry, :version => false, :prefix => true)
+            if arxivs.include?(id)
+              w << "ArXiv duplicate of '#{arxivs[id]}'"
+            else
+              arxivs[id] = entry.key
+            end
+          end
+
+          if entry[:title]
+            if titles.include?(entry[:title])
+              w << "Title duplicate of '#{titles[entry[:title]]}'"
+            else
+              titles[entry[:title]] = entry.key
+            end
+          end
+
+          warning(w.join(', '), :key => entry) unless w.empty?
+        end
+      end
+    end
+  end
+end

data/lib/bibsync/actions.rb

@@ -0,0 +1,7 @@
+require 'bibsync/actions/check_versions'
+require 'bibsync/actions/synchronize_files'
+require 'bibsync/actions/synchronize_metadata'
+require 'bibsync/actions/validate'
+require 'bibsync/actions/jabref_format'
+require 'bibsync/actions/fetch_from_arxiv'
+require 'bibsync/actions/find_my_citations'

data/lib/bibsync/bibliography.rb

@@ -0,0 +1,244 @@
+module BibSync
+  class Bibliography
+    include Enumerable
+
+    attr_reader :file
+
+    def initialize(file = nil)
+      @entries, @file = {}, file
+      parse(File.read(@file)) if @file && File.exists?(@file)
+      @dirty = false
+      @save_hooks = []
+    end
+
+    def save_hook(hook)
+      @save_hooks << hook
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    def dirty!
+      @dirty = true
+    end
+
+    def [](key)
+      @entries[key]
+    end
+
+    def delete(entry)
+      if @entries.include?(entry.key)
+        @entries.delete(entry.key)
+        entry.bibliography = nil
+        dirty!
+      end
+    end
+
+    def relative_path(file)
+      raise 'No filename given' unless @file
+      bibpath = Pathname.new(@file).realpath.parent
+      Pathname.new(file).realpath.relative_path_from(bibpath).to_s
+    end
+
+    def each(&block)
+      @entries.each_value(&block)
+    end
+
+    def save(file = nil)
+      if file
+        @file = file
+        @parent_path = nil
+        @dirty = true
+      end
+
+      raise 'No filename given' unless @file
+      if @dirty
+        @save_hooks.each {|hook| hook.call(self) }
+        File.open("#{@file}.tmp", 'w') {|f| f.write(self) }
+        File.rename("#{@file}.tmp", @file)
+        @dirty = false
+        true
+      else
+        false
+      end
+    end
+
+    def <<(entry)
+      entry.bibliography = self
+      @entries[entry.key] = entry
+      dirty!
+    end
+
+    def parse(text)
+      until text.empty?
+        case text
+        when /\A(\s+|%[^\n]+\n)/
+          text = $'
+        else
+          entry = Entry.new
+          text = entry.parse(text)
+          entry.key ||= @entries.size
+          self << entry
+        end
+      end
+    end
+
+    def to_s
+      "% #{DateTime.now}\n% Encoding: UTF8\n\n" <<
+        @entries.values.join("\n") << "\n"
+    end
+
+    class RawValue < String; end
+
+    class Entry
+      include Enumerable
+
+      attr_accessor :key, :type, :bibliography
+
+      def self.parse(text)
+        entry = Entry.new
+        entry.parse(text)
+        entry
+      end
+
+      def initialize
+        @fields = {}
+      end
+
+      def file=(file)
+        raise 'No bibliography set' unless bibliography
+        file =~ /\.(\w+)$/
+        self[:file] = ":#{bibliography.relative_path(file)}:#{$1.upcase}" # JabRef file format "description:path:type"
+        file
+      end
+
+      def file
+        if self[:file]
+          raise 'No bibliography set' unless bibliography
+          description, file, type = self[:file].split(':', 3)
+          path = (Pathname.new(bibliography.file).realpath.parent + file).to_s
+          { :name => File.basename(path), :type => type.upcase.to_sym, :path => path }
+        end
+      end
+
+      def [](key)
+        @fields[convert_key(key)]
+      end
+
+      def []=(key, value)
+        if value then
+          key = convert_key(key)
+          value = RawValue === value ? RawValue.new(value.to_s.strip) : value.to_s.strip
+          if @fields[key] != value || @fields[key].class != value.class
+            @fields[key] = value
+            dirty!
+          end
+        else
+          delete(key)
+        end
+      end
+
+      def delete(key)
+        key = convert_key(key)
+        if @fields.include?(key)
+          @fields.delete(key)
+          dirty!
+        end
+      end
+
+      def each(&block)
+        @fields.each(&block)
+      end
+
+      def comment?
+        type.to_s.downcase == 'comment'
+      end
+
+      def dirty!
+        bibliography.dirty! if bibliography
+      end
+
+      def to_s
+        s = "@#{type}{"
+        if comment?
+          s << self[:comment]
+        else
+          s << "#{key},\n" << to_a.map {|k,v| RawValue === v ? "  #{k} = #{v}" : "  #{k} = {#{v}}" }.join(",\n") << "\n"
+        end
+        s << "}\n"
+      end
+
+      def parse(text)
+        raise 'Unexpected token' if text !~ /\A\s*@(\w+)\s*\{/
+        self.type = $1
+        text = $'
+
+        if comment?
+          text, self[:comment] = parse_field(text)
+        else
+          raise 'Expected entry key' if text !~ /([^,]+),\s*/
+          self.key = $1.strip
+          text = $'
+
+          until text.empty?
+            case text
+            when /\A(\s+|%[^\n]+\n)/
+              text = $'
+            when /\A\s*(\w+)\s*=\s*/
+              text, key = $', $1
+              if text =~ /\A\{/
+                text, self[key] = parse_field(text)
+              else
+                text, value = parse_field(text)
+                self[key] = RawValue.new(value)
+              end
+            else
+              break
+            end
+          end
+        end
+
+        raise 'Expected closing }' unless text =~ /\A\s*\}/
+        $'
+      end
+
+      private
+
+      def parse_field(text)
+        value = ''
+        count = 0
+        until text.empty?
+          case text
+          when /\A\{/
+            text = $'
+            value << $& if count > 0
+            count += 1
+          when /\A\}/
+            break if count == 0
+            count -= 1
+            text = $'
+            value << $& if count > 0
+          when /\A,/
+            text = $'
+            break if count == 0
+            value << $&
+          when /\A[^\}\{,]+/
+            text = $'
+            value << $&
+          else
+            break
+          end
+        end
+
+        raise 'Expected closing }' if count != 0
+
+        return text, value
+      end
+
+      def convert_key(key)
+        key.to_s.downcase.to_sym
+      end
+    end
+  end
+end

data/lib/bibsync/command.rb

@@ -0,0 +1,107 @@
+require 'bibsync'
+require 'optparse'
+
+module BibSync
+  class Command
+    def initialize(args)
+      @args = args
+      @options = {}
+    end
+
+    def run
+      @opts = OptionParser.new(&method(:set_opts))
+      @opts.parse!(@args)
+      process
+      exit 0
+    rescue Exception => ex
+      raise ex if Log.trace? || SystemExit === ex
+      $stderr.print "#{ex.class}: " if ex.class != RuntimeError
+      $stderr.puts ex.message
+      $stderr.puts '  Use --trace for backtrace.'
+      exit 1
+    end
+
+    private
+
+    def set_opts(opts)
+      opts.banner = "Usage: #{$0} [options]"
+
+      opts.on('-b', '--bib bibfile.bib', 'Set bibliography') do |bib|
+        @options[:bib] = bib
+      end
+
+      opts.on('-d', '--directory directory', 'Set directory') do |dir|
+        @options[:dir] = dir
+      end
+
+      opts.on('-v', '--check-versions', 'Check for updated arXiv papers') do
+        @options[:check_versions] = true
+      end
+
+      opts.on('-u', '--update', 'Update arXiv papers') do
+        @options[:update] = true
+      end
+
+      opts.on('-s', '--sync', 'Synchronize missing metadata') do
+        @options[:sync] = true
+      end
+
+      opts.on('-r', '--resync', 'Force synchronization with arXiv and DOI') do
+        @options[:resync] = true
+      end
+
+      opts.on('-m', '--citedbyme directory', 'Find my citations in my TeX files') do |dir|
+        @options[:citedbyme] = dir
+      end
+
+      opts.on('-j', '--jabref', 'Format bibliography file with JabRef') do
+        @options[:jabref] = true
+      end
+
+      opts.on('-f', '--fetch url', 'Fetch arXiv paper as PDF file') do |url|
+        (@options[:fetch] ||= []) << url
+      end
+
+      opts.on('-V', '--verbose', 'Verbose output') do
+        Log.verbose!
+      end
+
+      opts.on('--trace', 'Show a full traceback on error') do
+        Log.trace!
+      end
+
+      opts.on('-h', '--help', 'Display this help') do
+        puts opts
+        exit
+      end
+
+      opts.on('--version', 'Display version information') do
+        puts "BibSync Version #{BibSync::VERSION}"
+        exit
+      end
+    end
+
+    def process
+      if @args.size != 0
+        error 'Too many arguments'
+        puts @opts
+        exit
+      end
+
+      if @options[:bib]
+        @options[:bib] = Bibliography.new(@options[:bib])
+        @options[:bib].save_hook(Transformer.new)
+      end
+
+      actions = []
+      actions << :FetchFromArXiv if @options[:fetch]
+      actions << :CheckVersions if @options[:check_versions] || @options[:update]
+      actions << :SynchronizeFiles << :SynchronizeMetadata if @options[:sync] || @options[:resync]
+      actions << :FindMyCitations if @options[:citedbyme]
+      actions << :Validate
+      actions << :JabrefFormat if @options[:jabref]
+
+      actions.map {|a| Actions.const_get(a).new(@options) }.each {|a| a.run }
+    end
+  end
+end

data/lib/bibsync/log.rb

@@ -0,0 +1,59 @@
+module BibSync
+  module Log
+    Reset = "\e[0m"
+    Red = "\e[31m"
+    Yellow = "\e[33m"
+    Blue = "\e[36m"
+
+    def self.verbose?
+      @verbose
+    end
+
+    def self.verbose!
+      @verbose = true
+    end
+
+    def self.trace?
+      @trace
+    end
+
+    def self.trace!
+      @trace = true
+    end
+
+    def debug(message, opts = {})
+      info(message, opts) if Log.verbose?
+    end
+
+    def info(message, opts = {})
+      log(message, opts)
+    end
+
+    def notice(message, opts = {})
+      log(message, opts.merge(:color => Blue))
+    end
+
+    def warning(message, opts = {})
+      log(message, opts.merge(:color => Yellow))
+    end
+
+    def error(message, opts = {})
+      log(message, opts.merge(:color => Red))
+    end
+
+    def log(message, opts = {})
+      if ex = opts[:ex]
+        message = "#{message} - #{ex.message}"
+      end
+      message = "#{opts[:color]}#{message}#{Reset}" if opts[:color]
+      if key = opts[:key]
+        key = key.key if key.respond_to? :key
+        message = "#{key} : #{message}"
+      end
+      puts(message)
+      if Log.trace? && ex = opts[:ex]
+        puts(ex.backtrace.join("\n"))
+      end
+    end
+  end
+end

data/lib/bibsync/transformer.rb

@@ -0,0 +1,69 @@
+module BibSync
+  class Transformer
+    include Utils
+
+    def call(bib)
+      bib.each do |entry|
+        next if entry.comment?
+
+        if entry[:author]
+          entry[:author] = entry[:author].gsub(/\{(\w+)\}/, '\\1').gsub(/#/, ' and ')
+        end
+
+        if entry[:doi] && entry[:doi] =~ /(PhysRev|RevModPhys).*?\.(\d+)$/
+          entry[:publisher] ||= 'American Physical Society'
+          entry[:pages] ||= $2
+        end
+
+        if entry[:publisher] && entry[:publisher] =~ /American Physical Society/i
+          entry[:publisher] = 'American Physical Society'
+        end
+
+        if entry[:month]
+          entry[:month] = Bibliography::RawValue.new(entry[:month].downcase)
+        end
+
+        if entry[:journal]
+          if entry[:journal] =~ /EPL/
+            entry[:year] = $1 if entry[:journal] =~ /\((\d{4})\)/
+            entry[:pages] = $1 if entry[:journal] =~ / (\d{5,10})( |\Z)/
+            entry[:volume] = $1 if entry[:journal] =~ / (\d{2,4})( |\Z)/
+            entry[:journal] = 'Europhysics Letters'
+          end
+
+          if entry[:journal] =~ /(Phys\.|Physical) (Rev\.|Review) Lett[^ ]+ /
+            entry[:year] = $1 if entry[:journal] =~ /\((\d{4})\)/
+            entry[:pages] = $1 if entry[:journal] =~ / (\d{5,10})( |,|\Z)/
+            entry[:volume] = $1 if entry[:journal] =~ / (\d{2,4})( |,|\Z)/
+            entry[:journal] = 'Physical Review Letters'
+          end
+
+          if entry[:journal] =~ /(Phys\.|Physical) (Rev\.|Review) (\w) /
+            letter = $3
+            entry[:year] = $1 if entry[:journal] =~ /\((\d{4})\)/
+            entry[:pages] = $1 if entry[:journal] =~ / (\d{5,10})( |,|\Z)/
+            entry[:volume] = $1 if entry[:journal] =~ / (\d{2,4})( |,|\Z)/
+            entry[:journal] = "Physical Review #{letter}"
+          end
+
+          case entry[:journal]
+          when /\APhysical Review (\w)\Z/i
+            entry[:shortjournal] = "PR#{$1.upcase}"
+          when /\APhysical Review Letters\Z/i
+            entry[:shortjournal] = 'PRL'
+          when /\AReviews of Modern Physics\Z/i
+            entry[:shortjournal] = 'RMP'
+          when /\ANew Journal of Physics\Z/i
+            entry[:shortjournal] = 'NJP'
+          when /\A#{ArXivJournal}\Z/i
+            entry[:shortjournal] = 'arXiv'
+          when /\AEurophysics Letters\Z/i
+            entry[:shortjournal] = 'EPL'
+          else
+            entry[:shortjournal] = entry[:journal]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bibsync/utils.rb

@@ -0,0 +1,45 @@
+module BibSync
+  module Utils
+    ArXivJournal = 'ArXiv e-prints'
+
+    def split_filename(file)
+      file =~ /^(.*?)\.(\w+)$/
+      return $1, $2.upcase
+    end
+
+    def fetch(url, headers = {})
+      # open(url, headers) {|f| f.read }
+      headers = headers.map {|k,v| '-H ' + Shellwords.escape("#{k}: #{v}") }.join(' ')
+      result = `curl --stderr - -S -s -L #{headers} #{Shellwords.escape url}`
+      raise result.chomp if $? != 0
+      result
+    end
+
+    def arxiv_download(dir, id)
+      url = "http://arxiv.org/pdf/#{id}"
+      file = File.join(dir, "#{arxiv_id(id, :version => true, :prefix => false)}.pdf")
+      result = `curl --stderr - -S -s -L -o #{Shellwords.escape file} #{Shellwords.escape url}`
+      raise result.chomp if $? != 0
+    end
+
+    def fetch_xml(url, headers = {})
+      xml = Nokogiri::XML(fetch(url, headers))
+      xml.remove_namespaces!
+      xml
+    end
+
+    def fetch_html(url, headers = {})
+      Nokogiri::HTML(fetch(url, headers))
+    end
+
+    def arxiv_id(arxiv, opts = {})
+      raise unless opts.include?(:prefix) && opts.include?(:version)
+      arxiv = arxiv[:arxiv] if Bibliography::Entry === arxiv
+      if arxiv
+        arxiv = arxiv.sub(/^.*\//, '') unless opts[:prefix]
+        arxiv = arxiv.sub(/v\d+$/, '') unless opts[:version]
+        arxiv
+      end
+    end
+  end
+end

data/lib/bibsync/version.rb

@@ -0,0 +1,3 @@
+module BibSync
+  VERSION = '0.0.1'
+end

data/lib/bibsync.rb

@@ -0,0 +1,10 @@
+require 'nokogiri'
+require 'shellwords'
+require 'date'
+require 'pathname'
+require 'bibsync/version'
+require 'bibsync/utils'
+require 'bibsync/transformer'
+require 'bibsync/bibliography'
+require 'bibsync/log'
+require 'bibsync/actions'

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: bibsync
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Mendler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: BibSync is a tool to synchronize scientific papers and bibtex bibliography
+  files
+email:
+- mail@daniel-mendler.de
+executables:
+- bibsync
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- bibsync.gemspec
+- bin/bibsync
+- lib/bibsync.rb
+- lib/bibsync/actions.rb
+- lib/bibsync/actions/check_versions.rb
+- lib/bibsync/actions/fetch_from_arxiv.rb
+- lib/bibsync/actions/find_my_citations.rb
+- lib/bibsync/actions/jabref_format.rb
+- lib/bibsync/actions/synchronize_files.rb
+- lib/bibsync/actions/synchronize_metadata.rb
+- lib/bibsync/actions/validate.rb
+- lib/bibsync/bibliography.rb
+- lib/bibsync/command.rb
+- lib/bibsync/log.rb
+- lib/bibsync/transformer.rb
+- lib/bibsync/utils.rb
+- lib/bibsync/version.rb
+homepage: https://github.com/minad/bibsync
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: bibsync
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: BibSync is a tool to synchronize scientific papers and bibtex bibliography
+  files
+test_files: []