bibtex-ruby 1.3.5 → 1.3.6

data/lib/bibtex/entry.rb

@@ -227,6 +227,8 @@ module BibTeX
 		def added_to_bibliography(bibliography)
 			super
 			bibliography.entries[key] = self
+			parse_names if bibliography.options[:parse_names]
+			parse_months if bibliography.options[:parse_months]
 			self
 		end
 				
@@ -262,10 +264,10 @@ module BibTeX
     # Parses all name values of the entry. Tries to replace and join the
     # value prior to parsing.
     def parse_names
+      strings = bibliography ? bibliography.strings.values : []
       NAME_FIELDS.each do |key|
         if name = @fields[key]
-          name.replace(bibliography.q('@string')) unless bibliography.nil?
-          name.join
+          name.replace(strings).join
           name = name.to_name
           @fields[key] = name
         end

data/lib/bibtex/lexer.rb

@@ -17,7 +17,7 @@
 #++
 
 require 'strscan'
-
+require 'forwardable'
 
 module BibTeX
 	
@@ -25,12 +25,19 @@ module BibTeX
 	# The BibTeX::Lexer handles the lexical analysis of BibTeX bibliographies.
 	#
 	class Lexer
+	  extend Forwardable
+    include Enumerable
 
-		attr_reader :data, :options, :stack, :mode
+		attr_reader :options, :stack, :mode, :scanner
+		attr_writer :mode
+		
+    def_delegator :@scanner, :string, :data
+    def_delegators :@stack, :each
 
     DEFAULTS = { :include => [:errors], :strict => true }.freeze
     
-    		
+    MODE = Hash.new(:meta).merge(:bibtex => :bibtex, :entry => :bibtex, :string => :bibtex, :preamble => :bibtex, :comment => :bibtex, :meta => :meta, :literal => :literal, :content => :content).freeze
+    
 		#
 		# Creates a new instance. Possible options and their respective
 		# default values are:
@@ -45,53 +52,38 @@ module BibTeX
 		#
 		def initialize(options = {})
       @options = DEFAULTS.merge(options)
-			@data = nil
+      reset
 		end
 
+    def reset
+			@stack, @brace_level, @mode, @active_object = [], 0, :meta, nil
+			@scanner.reset if @scanner
+			
+			# cache options for speed
+			@include_meta_content = @options[:include].include?(:meta_content)
+			@include_errors = @options[:include].include?(:errors)
+			
+			self
+    end
+    
 		# Sets the source for the lexical analysis and resets the internal state.
-		def data=(string)
-			@stack = []
-			@brace_level = 0
-			@mode = :meta
-			@active_object = nil
-			@data = StringScanner.new(string)
-
-      # @line_breaks = []
-      # @line_breaks << @data.pos until @data.scan_until(/\n|$/).empty?
-      # @data.reset
+		def data=(data)
+			@scanner = StringScanner.new(data)
+		  reset
 		end
 
-		# Returns the line number at a given position in the source.
-		def line_number_at(index)
-			0 # (@line_breaks.find_index { |n| n >= index } || 0) + 1
-		end
-		
+    def symbols; @stack.map(&:first); end
+    
 		# Returns the next token from the parse stack.
-		def next_token
-			@stack.shift
-		end
+		def next_token; @stack.shift; end
 
-		def mode=(mode)
-      # Log.debug("Lexer: switching to #{mode} mode...")
-
-			@active_object = case
-				when [:comment,:string,:preamble,:entry].include?(mode) then mode
-				when mode == :meta then nil
-				else @active_object
-			end
-
-			@mode = mode
-		end
-		
 		# Returns true if the lexer is currenty parsing a BibTeX object.
 		def bibtex_mode?
-			[:bibtex,:comment,:string,:preamble,:entry].include?(self.mode)
+			MODE[@mode] == :bibtex
 		end
 				
-		%w{ meta literal content }.each do |m|
-      define_method "#{m}_mode?" do
-        mode == m.to_sym
-      end
+		[:meta, :literal, :content].each do |m|
+      define_method("#{m}_mode?") { @mode == m }
 		end
 
 		# Returns true if the lexer is currently parsing the given object type.
@@ -102,155 +94,142 @@ module BibTeX
 		# Returns true if the lexer is currently in strict mode.
 		def strict?; !!(@options[:strict]); end
 		
-		# Pushes a value onto the parse stack.
+		# Pushes a value onto the parse stack. Returns the Lexer.
 		def push(value)
-			case
-			when ([:CONTENT,:STRING_LITERAL].include?(value[0]) && value[0] == @stack.last[0])
-				@stack.last[1][0] << value[1]
-				@stack.last[1][1] = line_number_at(@data.pos)
-			when value[0] == :ERROR
-				@stack.push(value) if @options[:include].include?(:errors)
-				leave_object
-			when value[0] == :META_CONTENT
-				if @options[:include].include?(:meta_content)
-					value[1] = [value[1], line_number_at(@data.pos)]
-					@stack.push(value)
+			case value[0]
+      when :CONTENT, :STRING_LITERAL
+        if !@stack.empty? && value[0] == @stack[-1][0]
+				  @stack[-1][1] << value[1]
+				else
+  				@stack.push(value)
 				end
+			when :ERROR
+				@stack.push(value) if @include_errors
+				leave_object
+			when :META_CONTENT				
+        @stack.push(value) if @include_meta_content
 			else
-				value[1] = [value[1], line_number_at(@data.pos)]
 				@stack.push(value)
 			end
+						
 			self
 		end
 
 		# Start the lexical analysis.
-		def analyse(data=nil)
-			raise(ArgumentError, 'Lexer: failed to start analysis: no source given!') if data.nil? && @data.nil?
-			Log.debug('Lexer: starting lexical analysis...')
-			
-			self.data = data || @data.string
-			@data.reset
+		def analyse(string = nil)
+			raise(ArgumentError, 'Lexer: failed to start analysis: no source given!') unless
+			  string || @scanner		
+
+			self.data = string || @scanner.string
 			
-			until @data.eos?
-				case
-				when bibtex_mode?
-					parse_bibtex
-				when meta_mode?
-					parse_meta
-				when content_mode?
-					parse_content
-				when literal_mode?
-					parse_literal
-				end
+      until @scanner.eos?
+        send("parse_#{MODE[@mode]}")
 			end
 			
-			Log.debug('Lexer: finished lexical analysis.')
-			push [false, '$end']
+			push([false, '$end'])
 		end
 
+    private
+    
 		def parse_bibtex
 			case
-			when @data.scan(/[\t\r\n\s]+/o)
-			when @data.scan(/\{/o)
+			when @scanner.scan(/[\t\r\n\s]+/o)
+			when @scanner.scan(/\{/o)
 				@brace_level += 1
-				push [:LBRACE,'{']
-				if (@brace_level == 1 && active?(:comment)) || (@brace_level == 2 && active?(:entry))
-					self.mode = :content
-				end
-			when @data.scan(/\}/o)
-				return error_unbalanced_braces if @brace_level < 1
+				push([:LBRACE,'{'])
+				@mode = :content if @brace_level > 1 || @brace_level == 1 && active?(:comment)
+			when @scanner.scan(/\}/o)
 				@brace_level -= 1
-				push [:RBRACE,'}']
-				leave_object if @brace_level == 0
-			when @data.scan( /=/o)
-				push [:EQ,'=']
-			when @data.scan(/,/o)
-				push [:COMMA,',']
-			when @data.scan(/#/o)
-				push [:SHARP,'#']
-			when @data.scan(/\d+/o)
-				push [:NUMBER,@data.matched]
-			when @data.scan(/[a-z\d\/:_!$\.%&*-]+/io)
-				push [:NAME,@data.matched]
-			when @data.scan(/"/o)
-				self.mode = :literal
-			when @data.scan(/@/o)
-				error_unexpected_token
-				enter_object
-			when @data.scan(/./o)
-				error_unexpected_token
+				push([:RBRACE,'}'])
+				return leave_object if @brace_level == 0
+				return error_unbalanced_braces if @brace_level < 0
+			when @scanner.scan( /=/o)
+				push([:EQ,'='])
+			when @scanner.scan(/,/o)
+				push([:COMMA,','])
+			when @scanner.scan(/\d+/o)
+				push([:NUMBER,@scanner.matched])
+			when @scanner.scan(/[a-z\d\/:_!$\.%&*-]+/io)
+				push([:NAME,@scanner.matched])
+			when @scanner.scan(/"/o)
+				@mode = :literal
+			when @scanner.scan(/#/o)
+				push([:SHARP,'#'])
+			when @scanner.scan(/@/o)
 				enter_object
+			when @scanner.scan(/./o)
+				error_unexpected_token				
 			end
 		end
 		
 		def parse_meta
-			match = @data.scan_until(strict? ? /@[\t ]*/o : /(^|\n)[\t ]*@[\t ]*/o)
-			unless @data.matched.nil?
-				push [:META_CONTENT, match.chop]
+			match = @scanner.scan_until(strict? ? /@[\t ]*/o : /(^|\n)[\t ]*@[\t ]*/o)
+			if @scanner.matched
+				push([:META_CONTENT,match.chop])
 				enter_object
 			else
-				push [:META_CONTENT,@data.rest]
-				@data.terminate
+				push([:META_CONTENT,@scanner.rest])
+				@scanner.terminate
 			end
 		end
 
 		def parse_content
-			match = @data.scan_until(/\{|\}/o)
-			case @data.matched
+			match = @scanner.scan_until(/\{|\}/o)
+			case @scanner.matched
 			when '{'
 				@brace_level += 1
-				push [:CONTENT,match]
+				push([:CONTENT,match])
 			when '}'
 				@brace_level -= 1
 				case
-				when @brace_level < 0
-					push [:CONTENT,match.chop]
-					error_unbalanced_braces
 				when @brace_level == 0
-					push [:CONTENT,match.chop]
-					push [:RBRACE,'}']
+					push([:CONTENT,match.chop])
+					push([:RBRACE,'}'])
 					leave_object
-				when @brace_level == 1 && active?(:entry)
-					push [:CONTENT,match.chop]
-					push [:RBRACE,'}']
-					self.mode = :bibtex
+				when @brace_level == 1 && !active?(:comment)
+					push([:CONTENT,match.chop])
+					push([:RBRACE,'}'])
+					@mode = :bibtex
+				when @brace_level < 0
+					push([:CONTENT,match.chop])
+					error_unbalanced_braces
 				else
-					push [:CONTENT, match]
+					push([:CONTENT,match])
 				end
 			else
-				push [:CONTENT,@data.rest]
-				@data.terminate
+				push([:CONTENT,@scanner.rest])
+				@scanner.terminate
 				error_unterminated_content
 			end
 		end
 		
 		def parse_literal
-			match = @data.scan_until(/[\{\}"\n]/o)
-			case @data.matched
+			match = @scanner.scan_until(/[\{\}"\n]/o)
+			case @scanner.matched
 			when '{'
 				@brace_level += 1
-				push [:STRING_LITERAL,match]
+				push([:STRING_LITERAL,match])
 			when '}'
 				@brace_level -= 1
 				if @brace_level < 1
-					push [:STRING_LITERAL,match.chop]
+					push([:STRING_LITERAL,match.chop])
 					error_unbalanced_braces
 				else
-					push [:STRING_LITERAL,match]
+					push([:STRING_LITERAL,match])
 				end
 			when '"'
 				if @brace_level == 1
-					push [:STRING_LITERAL,match.chop]
-					self.mode = :bibtex
+					push([:STRING_LITERAL,match.chop])
+					@mode = :bibtex
 				else
-					push [:STRING_LITERAL,match]
+					push([:STRING_LITERAL,match])
 				end
 			when "\n"
-				push [:STRING_LITERAL,match.chop]
+				push([:STRING_LITERAL,match.chop])
 				error_unterminated_string
 			else
-				push [:STRING_LITERAL,self.data.rest]
-				@data.terminate
+				push([:STRING_LITERAL,@scanner.rest])
+				@scanner.terminate
 				error_unterminated_string
 			end
 		end
@@ -258,63 +237,63 @@ module BibTeX
 		# Called when the lexer encounters a new BibTeX object.
 		def enter_object
 			@brace_level = 0
-			self.mode = :bibtex
 			push [:AT,'@']
 
 			case
-			when @data.scan(/string/io)
-				self.mode = :string
-				push [:STRING, @data.matched]
-			when @data.scan(/preamble/io)
-				self.mode = :preamble
-				push [:PREAMBLE, self.data.matched]
-			when @data.scan(/comment/io)
-				self.mode = :comment
-				push [:COMMENT, self.data.matched]
-			when @data.scan(/[a-z\d:_!\.$%&*-]+/io)
-				self.mode = :entry
-				push [:NAME, @data.matched]
+			when @scanner.scan(/string/io)
+				@mode = @active_object = :string
+				push [:STRING, @scanner.matched]
+			when @scanner.scan(/preamble/io)
+				@mode = @active_object = :preamble
+				push [:PREAMBLE, @scanner.matched]
+			when @scanner.scan(/comment/io)
+				@mode = @active_object = :comment
+				push [:COMMENT, @scanner.matched]
+			when @scanner.scan(/[a-z\d:_!\.$%&*-]+/io)
+				@mode = @active_object = :entry
+				push [:NAME, @scanner.matched]
+      else
+        error_unexpected_object
 			end
 		end
 
 		# Called when parser leaves a BibTeX object.
 		def leave_object
-			self.mode = :meta
-			@brace_level = 0
+			@mode, @active_object, @brace_level = :meta, nil, 0
 		end
 
-
 		def error_unbalanced_braces
-			n = line_number_at(@data.pos)
-			Log.warn("Lexer: unbalanced braces on line #{n}; brace level #{@brace_level}; mode #{@mode.inspect}.")
-			backtrace [:E_UNBALANCED_BRACES, [self.data.matched,n]]
+			Log.warn("Lexer: unbalanced braces at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			backtrace [:E_UNBALANCED, @scanner.matched]
 		end
 		
 		def error_unterminated_string
-			n = line_number_at(@data.pos)
-			Log.warn("Lexer: unterminated string on line #{n}; brace level #{@brace_level}; mode #{@mode.inspect}.")
-			backtrace [:E_UNTERMINATED_STRING, [@data.matched,n]]
+			Log.warn("Lexer: unterminated string at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			backtrace [:E_UNTERMINATED_STRING, @scanner.matched]
 		end
 
 		def error_unterminated_content
-			n = line_number_at(@data.pos)
-			Log.warn("Lexer: unterminated content on line #{n}; brace level #{@brace_level}; mode #{@mode.inspect}.")
-			backtrace [:E_UNTERMINATED_CONTENT, [@data.matched,n]]
+			Log.warn("Lexer: unterminated content at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			backtrace [:E_UNTERMINATED_CONTENT, @scanner.matched]
 		end
 		
 		def error_unexpected_token
-			n = line_number_at(@data.pos)
-			Log.warn("Lexer: unexpected token `#{@data.matched}' on line #{n}; brace level #{@brace_level}; mode #{@mode.inspect}.")
-			backtrace [:E_UNEXPECTED_TOKEN, [@data.matched,n]]
+			Log.warn("Lexer: unexpected token `#{@scanner.matched}' at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			backtrace [:E_UNEXPECTED_TOKEN, @scanner.matched]
 		end
-		
-		def backtrace(error)
-			trace = []
-			trace.unshift(@stack.pop) until @stack.empty? || (!trace.empty? && [:AT,:META_CONTENT].include?(trace[0][0]))
-			trace << error
-			push [:ERROR,trace]
+
+		def error_unexpected_object
+			Log.warn("Lexer: unexpected object at #{@scanner.pos}; brace level #{@brace_level}; mode #{@mode.inspect}.")
+			backtrace [:E_UNEXPECTED_OBJECT, '@']
 		end
 
+    def backtrace(error)
+      bt = []
+      bt.unshift(@stack.pop) until @stack.empty? || (!bt.empty? && [:AT,:META_CONTENT].include?(bt[0][0]))
+      bt << error
+      push [:ERROR,bt]
+    end
+    
 	end
 	
 end