bibtex-ruby 1.1.2 → 1.2.0

data/examples/bib2html.rb

@@ -3,7 +3,7 @@ require 'bibtex'
 
 
 # Open a bibliography file
-bib = BibTeX::Bibliography.open(File.expand_path('../markdown.bib',__FILE__),
+bib = BibTeX.open(File.expand_path('../markdown.bib',__FILE__),
   :include => [:meta_comments])
 
 
@@ -13,7 +13,7 @@ content = bib.data.map do |d|
   
   if d.class == BibTeX::Entry
     d.replace!(bib.strings)
-    result = [d[:author], '. ', d[:title], '. ', d[:publisher], ': ', d[:address], ', ', d[:year], '.'].join
+    result = [d.author, '. ', d.title, '. ', d.publisher, ': ', d.address, ', ', d.year, '.'].join
   end
   
   if d.class == BibTeX::MetaComment

data/examples/bib2yaml.rb

@@ -8,5 +8,5 @@ if ARGV.length < 1
   puts "Usage: #{$0} <bib> [<yml>]" 
 else
   out = ARGV.length == 2 ? File.open(ARGV[1], 'w') : STDOUT
-  out.puts BibTeX::Bibliography.open(ARGV[0]).to_yaml
+  out.puts BibTeX.open(ARGV[0]).to_yaml
 end

data/lib/bibtex.rb

@@ -43,11 +43,16 @@ module BibTeX
 	Log.level = ENV.has_key?('DEBUG') ? Logger::DEBUG : Logger::WARN
 	Log.datetime_format = "%Y-%m-%d %H:%M:%S"
 
-  require 'bibtex/string_replacement'
+  # Load debugger
+  # require 'ruby-debug'
+  # Debugger.start
+
+  require 'bibtex/extensions'
   require 'bibtex/elements'
   require 'bibtex/entry'
   require 'bibtex/error'
   require 'bibtex/parser'
   require 'bibtex/bibliography'
+  require 'bibtex/utilities'
 
 end

data/lib/bibtex/bibliography.rb

@@ -39,7 +39,7 @@ module BibTeX
     end
     
     #
-    # Creates a new bibliography; empty if no path is specified, otherwise
+    # Creates a new bibliography; empty if no data attribute is specified, otherwise
     # by parsing the file at the given path.
     #
     def initialize(data=[])
@@ -53,8 +53,8 @@ module BibTeX
     
     # Adds a new element, or a list of new elements to the bibliography.
     def add(data)
-      raise(ArgumentError,'BibTeX::Bibliography.add data expected to be enumerable or of type BibTeX::Element; was: ' + data.class.name) unless data.respond_to?(:each) || data.kind_of?(Element)
-      data.kind_of?(Element) ? self << data : data.each { |d| self << d }
+      raise(ArgumentError,'BibTeX::Bibliography.add data expected to be enumerable or of type BibTeX::Element; was: ' + data.class.name) unless data.respond_to?(:each) || data.is_a?(Element)
+      data.is_a?(Element) ? self << data : data.each { |d| self << d }
       self
     end
     
@@ -70,7 +70,7 @@ module BibTeX
     
     # Add an object to the bibliography. Returns the bibliography.
     def <<(obj)
-      raise(ArgumentError, 'A BibTeX::Bibliography can contain only BibTeX::Elements; was: ' + obj.class.name) unless obj.kind_of?(Element)
+      raise(ArgumentError, 'A BibTeX::Bibliography can contain only BibTeX::Elements; was: ' + obj.class.name) unless obj.is_a?(Element)
       @data << obj.added_to_bibliography(self)
       self
     end
@@ -95,7 +95,7 @@ module BibTeX
     def [](key)
       @entries[key.to_s]
     end
-
+          
     # Returns all @comment objects.
     def comments
       find_by_type(BibTeX::Comment)
@@ -116,6 +116,12 @@ module BibTeX
       !errors.empty?
     end
 
+    # Returns true if the +Bibliography+ contains no errors and only
+    # valid BibTeX objects (meta comments are ignored).
+    def valid?
+      !errors? && !@entries.values.map(&:valid?).uniq.include?(false)
+    end
+    
     # Replaces all string constants which are defined in the bibliography.
     #
     # By default constants in @string, @preamble and entries are defined; this
@@ -134,6 +140,11 @@ module BibTeX
       find_by_type(options[:include]).each { |e| e.replace!(@strings) if e.respond_to?(:replace!)}
     end
 
+    def join_strings(options={})
+      options[:include] ||= [BibTeX::String, BibTeX::Preamble, BibTeX::Entry]
+      find_by_type(options[:include]).each { |e| e.join! if e.respond_to?(:join!)}
+    end
+    
     # Returns true if the bibliography is currently empty.
     def empty?
       @data.empty?
@@ -144,6 +155,11 @@ module BibTeX
       @data.length
     end
 
+    # Returns the bibliography as an array of +BibTeX::Element+
+    def to_a
+      @data
+    end
+    
     # Returns a string representation of the bibliography.
     def to_s
       @data.map(&:to_s).join
@@ -172,9 +188,9 @@ module BibTeX
     private
 
     def find_by_type(type)
-      @data.find_all { |x| type.respond_to?(:inject) ? type.inject(false) { |s,n| s || x.kind_of?(n) } : x.kind_of?(type) }
+      @data.find_all { |x| type.respond_to?(:inject) ? type.inject(false) { |s,n| s || x.is_a?(n) } : x.is_a?(type) }
     end
-    
+
     def find_entry(key)
       entries.find { |e| e.key == key.to_s }
     end

data/lib/bibtex/bibtex.y

@@ -66,7 +66,7 @@ rule
         | 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]) }
+  entry_head : NAME LBRACE key COMMA               { result = BibTeX::Entry.new(:type => val[0].downcase.to_sym, :key => val[2]) }
 
   key : NAME                                       { result = val[0] }
       | NUMBER                                     { result = val[0] }

data/lib/bibtex/elements.rb

@@ -16,9 +16,6 @@
 # along with this program.	If not, see <http://www.gnu.org/licenses/>.
 #++
 
-require 'rexml/document'
-require 'yaml'
-
 module BibTeX
 
 	#
@@ -28,6 +25,11 @@ module BibTeX
 
 		attr_reader :bibliography
 		
+		# Returns an array of BibTeX elements.
+    def self.parse(string, options={})
+      BibTeX::Parser.new(options).parse(string).to_a
+    end
+    
 		def initialize
 			@bibliography = nil
 		end
@@ -47,7 +49,8 @@ module BibTeX
 	  end
 	  
 	  def to_yaml
-	    self.to_hash.to_yaml
+	    require 'yaml'
+      self.to_hash.to_yaml
 	  end
 	  
 	  def to_json
@@ -56,6 +59,7 @@ module BibTeX
 	  end
 	  
 	  def to_xml
+	    require 'rexml/document'
 	    xml = REXML::Element.new(self.class.name.downcase)
 	    xml.text = self.content
 	    xml
@@ -85,8 +89,8 @@ module BibTeX
 	# @string and @preamble objects, as well as in field values
 	# of regular entries.
 	#
-	class String < Element
-		attr_reader :key, :value
+	class String < Element	  
+		attr_reader :key
 
 		# Creates a new instance.
 		def initialize(key=nil,value=nil)
@@ -96,28 +100,32 @@ module BibTeX
 
 		# 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)
+			raise(ArgumentError, "BibTeX::String key must be of type Symbol; was: #{key.class.name}.") unless key.is_a?(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]
+			raise(ArgumentError, "BibTeX::String value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.is_a?(k) }.inject { |sum,n| sum || n }
+			@value = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
 		end
-
-		# Replaces all constants in this string's value which are defined in +hsh+.
+    
+    def value
+      @value.to_s(:quotes => %w(" "))
+    end
+    
+		# Replaces all constants in this string's value which are defined in +hash+.
 		# 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.replace({:foo => 'bar'})
+		# => "\"bar\" # \"bar\""
 		# s.to_s
 		# => "@string{ foobar = foo # "bar"}"
-		def replace(hsh)
-			StringReplacement.replace(@value,hsh)
+		def replace(hash)
+		  @value.replace_strings(hash)
 		end
 
 		# Replaces all constants in this string's value which are defined in +hsh+.
@@ -126,19 +134,24 @@ module BibTeX
 		# call-seq:
 		# s.to_s
 		# => "@string{ foobar = foo # "bar"}"
-		# s.replace({:foo => 'foo'})
-		# => ["foo","bar"]
+		# s.replace({:foo => 'bar'})
+		# => ["bar","bar"]
 		# s.to_s
-		# => "@string{ foobar = "foo" # "bar"}"
-		def replace!(hsh)
-			@value = replace(hsh)
-			@bibliography.strings[@key] = value unless @bibliography.nil?
+		# => "@string{ foobar = "bar" # "bar"}"
+		def replace!(hash)
+			@value = @value.replace_strings(hash)
+			@bibliography.strings[@key] = @value unless @bibliography.nil?
 		end
 
+    def join!
+			@value = @value.join_strings
+			@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 }
+			raise(ArgumentError, "BibTeX::String value can contain only instances of Symbol or String; was: #{value.class.name}.") unless [::String,Symbol].map { |k| value.is_a?(k) }.inject { |sum,n| sum || n }
 			@value << value
 		end
 
@@ -158,16 +171,16 @@ module BibTeX
 
 		# Returns a string representation of the @string's content.
 		def content
-			[@key.to_s,' = ',StringReplacement.to_s(@value)].join
+			[@key.to_s, value].join(' = ')
 		end
 
 		# Returns a string representation of the @string object.
 		def to_s
-			['@string{ ',content,'}'].join
+			"@string{ #{content} }"
 		end
 		
 		def to_hash
-		  { 'string' => { @key.to_s => StringReplacement.to_s(@value) } }
+		  { 'string' => { @key.to_s => @value.to_s(:quotes => %w(" ")) } }
 		end
 		
 		def to_xml
@@ -175,7 +188,7 @@ module BibTeX
 		  key = REXML::Element.new('key')
 		  val = REXML::Element.new('value')
 		  key.text = @key.to_s
-		  val.text = @value.to_s
+		  val.text = @value.to_s(:quotes => %w(" "))
 		  xml
 		end
 	end
@@ -187,40 +200,43 @@ module BibTeX
 	# 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]
+			raise(ArgumentError, "BibTeX::Preamble value must be of type Array, Symbol, or String; was: #{value.class.name}.") unless [Array,::String,Symbol].map { |k| value.is_a?(k) }.inject { |sum,n| sum || n }
+			@value = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
 		end
 
-		def replace(hsh)
-			StringReplacement.replace(@value,hsh)
+		def replace(hash)
+			@value.replace_strings(hash)
 		end
 
-		def replace!(hsh)
-			@value = replace(hsh)
-			@bibliography.strings[@key] = @value unless @bibliography.nil?
+		def replace!(hash)
+			@value = @value.replace_strings(hash)
 		end
 
+    def join!
+      @value = @value.join_strings
+    end
+
+    def value
+      content
+    end
+    
 		# Returns a string representation of the @preamble's content.
 		def content
-			StringReplacement.to_s(@value)
+			@value.to_s(:quotes => %w(" "))
 		end
 
 		# Returns a string representation of the @preamble object
 		def to_s
-			['@preamble{ ',content,'}'].join
+			"@preamble{ #{ content } }"
 		end
 		
-		def to_hash
-		  { 'preamble' => StringReplacement.to_s(@value) }
-		end
 	end
 
 	# Represents a @comment object.
@@ -231,7 +247,7 @@ module BibTeX
 		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)
+			raise(ArgumentError, "BibTeX::#{self.class.name} content must be of type String; was: #{content.class.name}.") unless content.is_a?(::String)
 			@content = content
 		end
 

data/lib/bibtex/entry.rb

@@ -21,6 +21,7 @@ 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
@@ -42,28 +43,30 @@ module BibTeX
 			: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?
+		# Creates a new instance. If a hash is given, the entry is populated accordingly.
+		def initialize(hash={})
 			@fields = {}
+		  
+		  self.type = hash.delete(:type) if hash.has_key?(:type)
+		  self.key = hash.delete(:key) if hash.has_key?(:key)
+						
+			hash.each { |k, v| add(k.to_sym, v) }
 		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)
+			raise(ArgumentError, "BibTeX::Entry key must be of type String; was: #{key.class.name}.") unless key.is_a?(::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)
+			raise(ArgumentError, "BibTeX::Entry type must be of type Symbol; was: #{type.class.name}.") unless type.is_a?(Symbol)
 			@type = type
 		end
 		
 		def method_missing(name, *args)
-		  return @fields[name]if @fields.has_key?(name)
+		  return self[name] if @fields.has_key?(name)
 		  return self.send(:add, name.to_s.chop.to_sym, args[0]) if name.match(/=$/)		  
 		  super
 		end
@@ -74,21 +77,21 @@ module BibTeX
 		
 		# Returns the value of the field with the given name.
 		def [](name)
-			@fields[name.to_sym]
+			@fields[name.to_sym].to_s
 		end
 
 		# Adds a new field (name-value pair) to the entry.
 		# Returns the new value.
-		def []=(name,value)
-			add(name,value)
+		def []=(name, value)
+			add(name.to_sym, 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]
+		def add(name, value)
+			raise(ArgumentError, "BibTeX::Entry field name must be of type Symbol; was: #{name.class.name}.") unless name.is_a?(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.is_a?(k) }.inject { |sum,n| sum || n }
+			@fields[name] = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
 		end
 
 		# Removes the field with a given name from the entry.
@@ -99,7 +102,7 @@ module BibTeX
 
 		# 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)
+			raise(ArgumentError, "BibTeX::Entry fields must be of type Hash; was: #{fields.class.name}.") unless fields.is_a?(Hash)
 			fields.each { |n,v| add(n,v) }
 			self
 		end
@@ -113,7 +116,7 @@ module BibTeX
 		# 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?
+				f.is_a?(Array) ? !(f & @fields.keys).empty? : !@fields[f].nil?
 			}.include?(false)
 		end
 
@@ -131,14 +134,18 @@ module BibTeX
 			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) }
+		# Replaces all constants in this entry's field values which are defined in +hash+.
+		def replace!(hash)
+			@fields.keys.each { |k| @fields[k] = @fields[k].replace_strings(hash) }
 		end
 
+    def join!
+			@fields.keys.each { |k| @fields[k] = @fields[k].join_strings }
+    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")
+			@fields.keys.map { |k| "#{k} = #{ @fields[k].to_s(:quotes => %w({ })) }" }.join(",\n")
 		end
 
 		# Returns a string representation of the entry.
@@ -146,8 +153,9 @@ module BibTeX
 			["@#{type}{#{key},",content.gsub(/^/,'  '),"}\n"].join("\n")
 		end
 		
-		def to_hash
-		  @fields.keys.map { |k| { k.to_s => StringReplacement.to_s(@fields[k], :delimiter => ['{','}']) } }.inject({ 'key' => @key, 'type' => @type.to_s }) { |sum,n| sum.merge(n) }
+		def to_hash(options={})
+		  options[:quotes] ||= %w({ })
+		  @fields.keys.map { |k| { k.to_s => @fields[k].to_s(options) } }.inject({ 'key' => @key, 'type' => @type.to_s }) { |sum,n| sum.merge(n) }
 		end
 		
 		def to_xml
@@ -155,7 +163,7 @@ module BibTeX
   		xml.attributes['key'] = @key
       @fields.each do |k,v|
         e = REXML::Element.new(k.to_s)
-        e.text = StringReplacement.to_s(v, :delimiter => ['',''])
+        e.text = v.to_s
         xml.add_element(e)
       end
       xml