rbib 2.0.1

data/examples/glom_citeulike.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+#
+# Download your CiteULike bibliography and strip
+# unnecessary fields.
+#
+
+##### YOUR SETTINGS HERE #####
+User = 'NickGasson'
+BadFields = [:url]
+##### NO NEED TO EDIT BELOW HERE #####
+
+require 'net/http'
+require 'uri'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "bibtex"
+
+bibtex = Net::HTTP.get URI.parse("http://www.citeulike.org/bibtex/user/#{User}")
+BibTeX::Parser.parse_string(bibtex).map do |entry|
+  entry.reject_fields BadFields
+end.save("#{User}.bib")
+

data/examples/tara_no_url.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+#
+# Strip URL fields from each BibTeX file on the command line.
+# Write the output to filename.stripped.bib
+#
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "bibtex"
+
+ARGV.each do |file|
+  BibTeX::Parser.parse(file).map do |entry|
+    entry.reject_fields [:url]
+  end.save(file.sub(/\.bib$/, '.stripped.bib'))
+end

data/lib/bibtex.rb

@@ -0,0 +1,9 @@
+module Bibtex
+  # NOTHING
+end
+
+require 'bibtex/parser'
+require 'bibtex/bibliography'
+require 'bibtex/entry'
+require 'bibtex/field'
+require 'bibtex/lexer'

data/lib/bibtex/bibliography.rb

@@ -0,0 +1,46 @@
+require 'bibtex/entry'
+
+module Bibtex
+  
+  class Bibliography    
+    attr_reader :entries
+
+    def initialize
+      @entries = {}
+    end
+    
+    def <<(e)
+      if e.kind_of? Entry then
+        $stderr.print "Warning: Bibtex duplicate entry <#{e.key}>\n" if @entries[e.key]
+        @entries[e.key] = e
+      else
+        raise 'Cannot add non-entries to bibliography'
+      end
+    end
+
+    def [](key)
+      @entries[key] or raise "No entry #{key}"
+    end
+
+    # Transform the entries in some way and return a
+    # new bibliography
+    def map
+      r = Bibliography.new
+      @entries.each do |k, e|
+        r << yield(e)
+      end
+      return r
+    end
+
+    def save(filename)
+      f = File.new(filename, 'w')
+      f.puts self.to_s
+      f.close
+    end
+
+    def to_s
+      @entries.keys.sort.collect { |k| @entries[k].to_s }.join
+    end
+  end
+  
+end

data/lib/bibtex/entry.rb

@@ -0,0 +1,89 @@
+module Bibtex
+
+  # A single entry in a bibliography
+  class Entry
+    attr_reader :type, :key
+    
+    def initialize(type, key)
+      @type = type
+      @key = key
+      @fields = {}
+      $stderr.print key,"\n" if $DEBUG
+    end
+
+    def add_field(obj, value = nil)
+      if obj.kind_of? Field then
+        @fields[obj.key] = obj
+      else
+        @fields[obj] = Field.new(obj, value)
+      end
+    end
+
+    def [](key)
+      f = @fields[key]
+      f = @fields[key.to_s.downcase.to_sym] if !f
+      if f then
+        f.value
+      else
+        # raise "No field with key #{key}"
+        ""
+      end
+    end
+
+    def has? key
+      field = self[key]
+      field != nil and field.strip != ''
+    end
+
+    # Make sure the field exists and has meaningful data
+    def required key
+      if !has?(key)
+        $stderr.print self
+        raise "Key #{key} does not exist"
+      end
+      self[key]
+    end
+
+
+    def to_s
+      fs = @fields.collect { |k, f| "  #{f.to_s}" }.sort.join ",\n"
+      "@#{@type}{#{@key},\n#{fs}\n}\n\n"
+    end
+
+    def reject_fields(keys)
+      r = Entry.new(@type, @key)
+      @fields.each do |k, f|
+        r.add_field f unless keys.index k
+      end
+      return r
+    end
+
+    def select_fields(keys)
+      r = Entry.new(@type, @key)
+      @fields.each do |k, f|
+        r.add_field f if keys.index k
+      end
+      return r
+    end 
+
+  end
+
+  # Different types of entries
+  module EntryType
+    Book = 'book'
+    Article = 'article'
+    Booklet = 'booklet'
+    Conference = 'conference'
+    InBook = 'inbook'
+    InCollection = 'incollection'
+    InProceedings = 'inproceedings'
+    Manual = 'manual'
+    MastersThesis = 'mastersthesis'
+    Misc = 'misc'
+    PhDThesis = 'phdthesis'
+    Proceedings = 'proceedings'
+    TechReport = 'techreport'
+    Unpublished = 'unpublished'
+  end
+  
+end

data/lib/bibtex/field.rb

@@ -0,0 +1,17 @@
+module Bibtex
+
+  # A field within an entry E.g. author = {Foo}
+  class Field
+    attr_reader :key, :value
+
+    def initialize(key, value)
+      @key = key
+      @value = value
+    end
+
+    def to_s
+      "#{@key} = {#{@value}}"
+    end
+  end
+  
+end

data/lib/bibtex/lexer.rb

@@ -0,0 +1,123 @@
+require 'strscan'
+
+module Bibtex
+  class SourcePos
+    attr_reader :line, :column, :file
+    
+    def initialize(line, column, file)
+      @line = line
+      @column = column
+      @file = file
+    end
+
+    def to_s
+      "#{file}:#{line}"
+    end
+  end
+
+  class RuleSet
+    def initialize
+      @rules = []
+    end
+
+    def match(regexp, result)
+      @rules << [regexp, result]
+    end
+
+    def literals(words)
+      words.each do |w|
+        match(/#{w}/, w)
+      end
+    end
+
+    def each
+      @rules.each do |pair|
+        yield pair[0], pair[1]
+      end
+    end
+  end
+
+  class LexerError < RuntimeError
+    attr_reader :src_pos
+    
+    def initialize(mess, src_pos)
+      super(mess)
+      @src_pos = src_pos
+    end
+  end
+
+  class Lexer
+    attr_reader :lval, :ignore_whitespace
+    attr_accessor :ignore_newlines, :file_name
+    
+    def initialize(ignore_whitespace = false)
+      @scanner = StringScanner.new('')
+      @rules = RuleSet.new
+      @ignore_whitespace = ignore_whitespace
+      @ignore_newlines = ignore_whitespace
+      @lineno = 1
+      @file_name = '<unknown>'
+      yield @rules
+    end
+
+    # ignore_whitespace turns on ignore_newlines too
+    def ignore_whitespace=(b)
+      @ignore_whitespace = b
+      @ignore_newlines = b
+    end
+    
+    def feed(str)
+      @scanner = StringScanner.new(str)
+      @cols_prev = 0
+    end
+
+    def src_pos
+      SourcePos.new(@lineno, @scanner.pos - @cols_prev, @file_name)
+    end
+    
+    def next_token!
+      if @scanner.check(/^\s*\n/) then
+        @lineno += 1
+        @cols_prev = @scanner.pos + 1
+      end
+      skip_whitespace
+      @rules.each do |regexp, result|
+        return result if @lval = @scanner.scan(regexp)
+      end
+      unexpect = if @scanner.rest.length < 10 then
+                   @scanner.rest
+                 else
+                   "#{@scanner.rest.first 10}..."
+                 end
+      raise LexerError.new("Unexpected input #{unexpect}", src_pos)
+    end
+
+    def peek_token
+      tok = self.next_token!
+      @scanner.unscan
+      return tok
+    end
+
+    def peek_lval
+      peek_token
+      @lval
+    end
+
+    def more_tokens?
+      skip_whitespace
+      not @scanner.eos?
+    end
+
+    private
+
+    def skip_whitespace
+      if @ignore_newlines and @ignore_whitespace then
+        @scanner.skip(/\s+/)
+      elsif @ignore_whitespace then
+        @scanner.skip(/[ \t\r]+/)
+      elsif @ignore_newlines  then
+        @scanner.skip(/[\r\n]+/)
+      end
+    end
+  end
+end

data/lib/bibtex/parser.rb

@@ -0,0 +1,116 @@
+require 'bibtex/bibliography'
+require 'bibtex/entry'
+require 'bibtex/field'
+require 'bibtex/lexer'
+
+module Bibtex
+
+  class Parser
+    def self.parse(filename)
+      parse_string File.read(filename)
+    end
+
+    def self.parse_string(data)
+      @lexer.feed data
+
+      b = Bibliography.new
+      while @lexer.more_tokens?
+        b << parse_entry
+      end
+      return b
+    end
+
+    private
+
+    def self.parse_entry
+      expect :at, '@'
+      type = expect :id
+      expect :lbrace, '{'
+      key = expect :id
+
+      e = Entry.new(type, key)
+      while @lexer.peek_token != :rbrace
+        expect :comma, ','
+        e.add_field parse_field
+      end
+
+      expect :rbrace, '}'
+      return e
+    end
+
+    def self.parse_field
+      key = expect :id
+      expect :equals, '='
+      value = parse_value
+      Field.new(key.intern, value)
+    end
+
+    def self.parse_value
+      close = :rbrace
+      brace_count = 1
+      if @lexer.peek_token == :dquote then
+        expect :dquote
+        close = :dquote
+      elsif @lexer.peek_token == :lbrace then
+        expect :lbrace, '{'
+      else
+        # Not surrounded by quotes or braces
+        brace_count = 0
+      end
+
+      str = ''
+      @lexer.ignore_whitespace = false
+      @lexer.ignore_newlines = true
+      loop do
+        unless @lexer.more_tokens?
+          raise 'Unexpected end of input'
+        end
+
+        if (@lexer.peek_token == :comma \
+            or @lexer.peek_token == :rbrace) and brace_count == 0 then
+          # A field not delimited by "" or {}
+          @lexer.ignore_whitespace = true
+          return str
+        end
+        
+        case @lexer.next_token!
+        when :rbrace, close
+          brace_count -= 1
+          if brace_count == 0 then
+            @lexer.ignore_whitespace = true
+            return str
+          else
+            str += '}'
+          end
+        when :lbrace
+          str += '{'
+          brace_count += 1
+        else
+          str += @lexer.lval
+        end
+      end
+    end
+
+    def self.expect(token, pretty = nil)
+      pretty ||= token.to_s
+      got = @lexer.next_token!
+      unless got == token then
+        raise "#{@lexer.src_pos}: Expected '#{pretty}' but found token '#{got}' (text='#{@lexer.lval}')"
+      else
+        @lexer.lval
+      end
+    end
+
+    @lexer = Lexer.new(true) do |rules|
+      rules.match(/@/,:at)
+      rules.match(/\{/,:lbrace)
+      rules.match(/\}/,:rbrace)
+      rules.match(/\"/,:dquote)
+      rules.match(/\=/,:equals)
+      rules.match(/\,/,:comma)
+      rules.match(/[\w\-:&]+/,:id)
+      rules.match(/.+?/,:cdata)
+    end
+  end
+  
+end