bibtex-ruby 1.0.0

data/lib/bibtex/bibtex.y

@@ -0,0 +1,129 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010  Sylvester Keil <http://sylvester.keil.or.at>
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+# A BibTeX grammar for the parser generator +racc+
+#
+
+# -*- racc -*-
+
+class BibTeX::Parser
+
+token AT COMMA COMMENT CONTENT ERROR EQ LBRACE META_COMMENT
+      NAME NUMBER PREAMBLE RBRACE SHARP STRING STRING_LITERAL
+
+expect 0
+
+rule
+
+  bibliography : /* empty */                       { result = Bibliography.new }
+               | objects                           { result = val[0] }
+
+  objects : object                                 { result = Bibliography.new << val[0] }
+          | objects object                         { result << val[1] }
+
+  object : AT at_object                            { result = val[1] }
+         | META_COMMENT                            { result = BibTeX::MetaComment.new(val[0]) }
+         | ERROR                                   { result = BibTeX::Error.new(val[0]) }
+
+  at_object : comment                              { result = val[0] }
+            | string                               { result = val[0] }
+            | preamble                             { result = val[0] }
+            | entry                                { result = val[0] }
+
+  comment : COMMENT LBRACE content RBRACE          { result = BibTeX::Comment.new(val[2]) }
+  
+  content : /* empty */                            { result = '' }
+          | CONTENT                                { result = val[0] }
+  
+  preamble : PREAMBLE LBRACE string_value RBRACE   { result = BibTeX::Preamble.new(val[2]) }
+
+  string : STRING LBRACE string_assignment RBRACE  { result = BibTeX::String.new(val[2][0],val[2][1]); }
+
+  string_assignment : NAME EQ string_value         { result = [val[0].downcase.to_sym, val[2]] }
+
+  string_value : string_literal                    { result = [val[0]] }
+               | string_value SHARP string_literal { result << val[2] }
+
+  string_literal : NAME                            { result = val[0].downcase.to_sym }
+                 | STRING_LITERAL                  { result = val[0] }
+
+  entry : entry_head assignments RBRACE            { result = val[0] << val[1] }
+        | entry_head assignments COMMA RBRACE      { result = val[0] << val[1] }
+        | entry_head RBRACE                        { result = val[0] }
+
+  entry_head : NAME LBRACE key COMMA               { result = BibTeX::Entry.new(val[0].downcase.to_sym,val[2]) }
+
+  key : NAME                                       { result = val[0] }
+      | NUMBER                                     { result = val[0] }
+
+  assignments : assignment                         { result = val[0] }
+              | assignments COMMA assignment       { result.merge!(val[2]) }
+
+  assignment : NAME EQ value                       { result = { val[0].downcase.to_sym => val[2] } }
+
+  value : string_value                             { result = val[0] }
+        | NUMBER                                   { result = val[0] }
+        | LBRACE content RBRACE                    { result = val[1] }
+
+end
+
+---- header
+require 'bibtex/lexer'
+
+---- inner
+
+  attr_reader :lexer
+  
+  def initialize(options={})
+    @options = options
+    @options[:include] ||= [:errors]
+    @lexer = Lexer.new(options)
+  end
+
+  def parse(input)
+    @yydebug = self.debug?
+    
+    self.lexer.src = input
+    self.lexer.analyse
+    
+    do_parse
+  end
+  
+  def next_token
+    token = self.lexer.next_token
+    if token[0] == :ERROR
+      self.include_errors? ? token : next_token
+    else
+      [token[0],token[1][0]]
+    end
+  end
+  
+  def debug?
+    @options[:debug] == true || ENV['DEBUG'] == true
+  end
+  
+  def include_errors?
+    @options[:include].include?(:errors)
+  end
+  
+  def on_error(tid, val, vstack)
+    #raise(ParseError, "Failed to parse BibTeX on value %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect])
+    Log.error("Failed to parse BibTeX on value %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect])
+  end
+
+# -*- racc -*-

data/lib/bibtex/elements.rb

@@ -0,0 +1,262 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010	Sylvester Keil <sylvester.keil.or.at>
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.	If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'json'
+require 'rexml/document'
+require 'yaml'
+
+module BibTeX
+
+	#
+	# The base class for BibTeX objects.
+	#
+	class Element
+
+		attr_reader :bibliography
+		
+		def initialize
+			@bibliography = nil
+		end
+		
+		# Returns a string containing the object's content.
+		def content
+			""
+		end
+
+		# Returns a string representation of the object.
+		def to_s
+			self.content
+		end
+		
+		def to_hash
+		  { self.class.name.downcase => content }
+	  end
+	  
+	  def to_yaml
+	    self.to_hash.to_yaml
+	  end
+	  
+	  def to_json
+	    self.to_hash.to_json
+	  end
+	  
+	  def to_xml
+	    xml = REXML::Element.new(self.class.name.downcase)
+	    xml.text = self.content
+	    xml
+	  end
+
+		# Called when the element was added to a bibliography.
+		def added_to_bibliography(bibliography)
+			@bibliography = bibliography
+			self
+		end
+		
+		# Called when the element was removed from a bibliography.
+		def removed_from_bibliography(bibliography)
+			@bibliography = nil
+			self
+		end
+	end
+
+ 
+	#
+	# Represents a @string object.
+	#
+	# In BibTeX @string objects contain a single string constant
+	# assignment. For example, @string{ foo = "bar" } defines the
+	# constant `foo'; this constant can be used (using BibTeX's
+	# string concatenation syntax) in susbsequent
+	# @string and @preamble objects, as well as in field values
+	# of regular entries.
+	#
+	class String < Element
+		attr_reader :key, :value
+
+		# Creates a new instance.
+		def initialize(key=nil,value=nil)
+			self.key = key.to_sym unless key.nil?
+			self.value = value unless value.nil?
+		end
+
+		# Sets the string's key (i.e., the name of the constant)
+		def key=(key)
+			raise(ArgumentError, "BibTeX::String key must be of type Symbol; was: #{key.class.name}.") unless key.kind_of?(Symbol)
+			@key = key
+		end
+
+		# Sets the string's value (i.e., the string literal defined by the constant)
+		def value=(value)
+			raise(ArgumentError, "BibTeX::String value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.kind_of?(k) }.inject { |sum,n| sum || n }
+			@value = value.kind_of?(Array) ? value : [value]
+		end
+
+		# Replaces all constants in this string's value which are defined in +hsh+.
+		# Returns the new value (the @string object itself remains unchanged).
+		#
+		# call-seq:
+		# s.to_s
+		# => "@string{ foobar = foo # "bar"}"
+		# s.replace({:foo => 'foo'})
+		# => ["foo","bar"]
+		# s.to_s
+		# => "@string{ foobar = foo # "bar"}"
+		def replace(hsh)
+			StringReplacement.replace(@value,hsh)
+		end
+
+		# Replaces all constants in this string's value which are defined in +hsh+.
+		# Returns the new value (the @string object itself is changed as well).
+		#
+		# call-seq:
+		# s.to_s
+		# => "@string{ foobar = foo # "bar"}"
+		# s.replace({:foo => 'foo'})
+		# => ["foo","bar"]
+		# s.to_s
+		# => "@string{ foobar = "foo" # "bar"}"
+		def replace!(hsh)
+			@value = replace(hsh)
+			@bibliography.strings[@key] = value unless @bibliography.nil?
+		end
+
+		# Adds either a string constant or literal to the current value. The
+		# values will be concatenated using the `#' symbol.
+		def <<(value)
+			raise(ArgumentError, "BibTeX::String value can contain only instances of Symbol or String; was: #{value.class.name}.") unless [::String,Symbol].map { |k| value.kind_of?(k) }.inject { |sum,n| sum || n }
+			@value << value
+		end
+
+		# Called when the element was added to a bibliography.
+		def added_to_bibliography(bibliography)
+			super(bibliography)
+			bibliography.strings[@key] = @value
+			self
+		end
+		
+		# Called when the element was removed from a bibliography.
+		def removed_from_bibliography(bibliography)
+			super(bibliography)
+			bibliography.strings[@key] = nil
+			self
+		end
+
+		# Returns a string representation of the @string's content.
+		def content
+			[@key.to_s,' = ',StringReplacement.to_s(@value)].join
+		end
+
+		# Returns a string representation of the @string object.
+		def to_s
+			['@string{ ',content,'}'].join
+		end
+		
+		def to_hash
+		  { 'string' => { @key.to_s => StringReplacement.to_s(@value) } }
+		end
+		
+		def to_xml
+		  xml = REXML::Element.new('string')
+		  key = REXML::Element.new('key')
+		  val = REXML::Element.new('value')
+		  key.text = @key.to_s
+		  val.text = @value.to_s
+		  xml
+		end
+	end
+
+	#
+	# Represents a @preamble object.
+	#
+	# In BibTeX an @preamble object contains a single string literal,
+	# a single constant, or a concatenation of string literals and
+	# constants.
+	class Preamble < Element
+		attr_reader :value
+
+		# Creates a new instance.
+		def initialize(value=[])
+			self.value = value
+		end
+
+		def value=(value)
+			raise(ArgumentError, "BibTeX::Preamble value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.kind_of?(k) }.inject { |sum,n| sum || n }
+			@value = value.kind_of?(Array) ? value : [value]
+		end
+
+		def replace(hsh)
+			StringReplacement.replace(@value,hsh)
+		end
+
+		def replace!(hsh)
+			@value = replace(hsh)
+			@bibliography.strings[@key] = @value unless @bibliography.nil?
+		end
+
+		# Returns a string representation of the @preamble's content.
+		def content
+			StringReplacement.to_s(@value)
+		end
+
+		# Returns a string representation of the @preamble object
+		def to_s
+			['@preamble{ ',content,'}'].join
+		end
+		
+		def to_hash
+		  { 'preamble' => StringReplacement.to_s(@value) }
+		end
+	end
+
+	# Represents a @comment object.
+	class Comment < Element
+
+		def initialize(content='')
+			self.content = content
+		end
+
+		def content=(content)
+			raise(ArgumentError, "BibTeX::#{self.class.name} content must be of type String; was: #{content.class.name}.") unless content.kind_of?(::String)
+			@content = content
+		end
+
+		def content
+			@content
+		end
+
+		def to_s
+			['@comment{ ',content,'}'].join
+		end
+		
+	end
+
+	# Represents text in a `.bib' file, but outside of an
+	# actual BibTeX object; typically, such text is treated
+	# as a comment and is ignored by the parser. 
+	# BibTeX-Ruby offers this class to allows for
+	# post-processing of this type of `meta' comment. If you
+	# want the parser to include +MetaComment+ objects, you
+	# need to add +:meta_comments+ to the parser's +:include+
+	# option.
+	class MetaComment < Comment
+		def to_s
+			@content
+		end
+	end
+
+end

data/lib/bibtex/entry.rb

@@ -0,0 +1,154 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010	Sylvester Keil <sylvester.keil.or.at>
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.	If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module BibTeX
+	#
+	# Represents a regular BibTeX entry.
+	#
+	class Entry < Element
+		attr_reader :key, :type, :fields
+	 
+		# Hash containing the required fields of the standard entry types
+		@@RequiredFields = Hash.new([])
+		@@RequiredFields.merge!({
+			:article => [:author,:title,:journal,:year],
+			:book => [[:author,:editor],:title,:publisher,:year],
+			:booklet => [:title],
+			:conference => [:author,:title,:booktitle,:year],
+			:inbook => [[:author,:editor],:title,[:chapter,:pages],:publisher,:year],
+			:incollection => [:author,:title,:booktitle,:publisher,:year],
+			:inproceedings => [:author,:title,:booktitle,:year],
+			:manual => [:title],
+			:mastersthesis => [:author,:title,:school,:year],
+			:misc => [],
+			:phdthesis => [:author,:title,:school,:year],
+			:proceedings => [:title,:year],
+			:techreport => [:author,:title,:institution,:year],
+			:unpublished => [:author,:title,:note]
+		})
+
+		# Creates a new instance of a given +type+ (e.g., :article, :book, etc.)
+		# identified by a +key+.
+		def initialize(type=nil, key=nil)
+			self.key = key.to_s unless key.nil?
+			self.type = type.to_sym unless type.nil?
+			@fields = {}
+		end
+
+		# Sets the key of the entry
+		def key=(key)
+			raise(ArgumentError, "BibTeX::Entry key must be of type String; was: #{key.class.name}.") unless key.kind_of?(::String)
+			@key = key
+		end
+
+		# Sets the type of the entry.
+		def type=(type)
+			raise(ArgumentError, "BibTeX::Entry type must be of type Symbol; was: #{type.class.name}.") unless type.kind_of?(Symbol)
+			@type = type
+		end
+		
+		# Returns the value of the field with the given name.
+		def [](name)
+			@fields[name.to_sym]
+		end
+
+		# Adds a new field (name-value pair) to the entry.
+		# Returns the new value.
+		def []=(name,value)
+			add(name,value)
+		end
+
+		# Adds a new field (name-value pair) to the entry.
+		# Returns the new value.
+		def add(name,value)
+			raise(ArgumentError, "BibTeX::Entry field name must be of type Symbol; was: #{name.class.name}.") unless name.kind_of?(Symbol)
+			raise(ArgumentError, "BibTeX::Entry field value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.kind_of?(k) }.inject { |sum,n| sum || n }
+			@fields[name] = value.kind_of?(Array) ? value : [value]
+		end
+
+		# Removes the field with a given name from the entry.
+		# Returns the value of the deleted field; nil if the field was not set.
+		def delete(name)
+			@fields.delete(name.to_sym)
+		end
+
+		# Adds all the fields contained in a given hash to the entry.
+		def <<(fields)
+			raise(ArgumentError, "BibTeX::Entry fields must be of type Hash; was: #{fields.class.name}.") unless fields.kind_of?(Hash)
+			fields.each { |n,v| add(n,v) }
+			self
+		end
+
+		# Returns true if the entry currently contains no field.
+		def empty?
+			@fields.empty?
+		end
+
+		# Returns false if the entry is one of the standard entry types and does not have
+		# definitions of all the required fields for that type.
+		def valid?
+			!@@RequiredFields[@type].map { |f|
+				f.kind_of?(Array) ? !(f & @fields.keys).empty? : !@fields[f].nil?
+			}.include?(false)
+		end
+
+		# Called when the element was added to a bibliography.
+		def added_to_bibliography(bibliography)
+			super(bibliography)
+			bibliography.entries[@key] = self
+			self
+		end
+		
+		# Called when the element was removed from a bibliography.
+		def removed_from_bibliography(bibliography)
+			super(bibliography)
+			bibliography.entries[@key] = nil
+			self
+		end
+
+		# Replaces all constants in this entry's field values which are defined in +hsh+.
+		def replace!(hsh)
+			@fields.keys.each { |k| @fields[k] = StringReplacement.replace(@fields[k],hsh) }
+		end
+
+		# Returns a string of all the entry's fields.
+		def content
+			@fields.keys.map { |k| "#{k} = #{StringReplacement.to_s(@fields[k], :delimiter => ['{','}'])}" }.join(",\n")
+		end
+
+		# Returns a string representation of the entry.
+		def to_s
+			["@#{type}{#{key},",content.gsub(/^/,'  '),"}\n"].join("\n")
+		end
+		
+		def to_hash
+		  { @type.to_s => @fields.keys.map { |k| { k.to_s => StringReplacement.to_s(@fields[k], :delimiter => ['{','}']) } }.inject({ 'key' => @key }) { |sum,n| sum.merge(n) } }.to_yaml
+		end
+		
+		def to_xml
+  		xml = REXML::Element.new(@type.to_s)
+  		xml.attributes['key'] = @key
+      @fields.each do |k,v|
+        e = REXML::Element.new(k.to_s)
+        e.text = StringReplacement.to_s(v, :delimiter => ['',''])
+        xml.add_element(e)
+      end
+      xml
+		end
+	end
+end