bibtex-ruby 1.2.1 → 1.3.0

data/lib/bibtex/bibtex.y

@@ -1,6 +1,6 @@
 #--
 # BibTeX-Ruby
-# Copyright (C) 2010  Sylvester Keil <http://sylvester.keil.or.at>
+# Copyright (C) 2010-2011  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
@@ -23,21 +23,21 @@
 
 class BibTeX::Parser
 
-token AT COMMA COMMENT CONTENT ERROR EQ LBRACE META_COMMENT
+token AT COMMA COMMENT CONTENT ERROR EQ LBRACE META_CONTENT
       NAME NUMBER PREAMBLE RBRACE SHARP STRING STRING_LITERAL
 
 expect 0
 
 rule
 
-  bibliography : /* empty */                       { result = Bibliography.new }
+  bibliography : /* empty */                       { result = BibTeX::Bibliography.new }
                | objects                           { result = val[0] }
 
-  objects : object                                 { result = Bibliography.new << val[0] }
+  objects : object                                 { result = BibTeX::Bibliography.new << val[0] }
           | objects object                         { result << val[1] }
 
   object : AT at_object                            { result = val[1] }
-         | META_COMMENT                            { result = BibTeX::MetaComment.new(val[0]) }
+         | META_CONTENT                            { result = BibTeX::MetaContent.new(val[0]) }
          | ERROR                                   { result = BibTeX::Error.new(val[0]) }
 
   at_object : comment                              { result = val[0] }
@@ -89,32 +89,35 @@ require 'bibtex/lexer'
 
   attr_reader :lexer
   
-  def initialize(options={})
-    @options = options
-    @options[:include] ||= [:errors]
-    @lexer = Lexer.new(options)
+  def initialize(options = {})
+		self.options.merge!(options)
+    @lexer = Lexer.new(@options)
   end
 
+	def options
+		@options ||= { :include => [:errors], :debug => ENV['DEBUG'] == true }
+	end
+	
   def parse(input)
-    @yydebug = self.debug?
+    @yydebug = debug?
     
-    self.lexer.src = input
-    self.lexer.analyse
+    @lexer.src = input
+    @lexer.analyse
     
     do_parse
   end
   
   def next_token
-    token = self.lexer.next_token
+    token = @lexer.next_token
     if token[0] == :ERROR
-      self.include_errors? ? token : next_token
+      include_errors? ? token : next_token
     else
       [token[0],token[1][0]]
     end
   end
   
   def debug?
-    @options[:debug] == true || ENV['DEBUG'] == true
+    @options[:debug] == true
   end
   
   def include_errors?

data/lib/bibtex/elements.rb

@@ -1,6 +1,6 @@
 #--
 # BibTeX-Ruby
-# Copyright (C) 2010	Sylvester Keil <sylvester.keil.or.at>
+# Copyright (C) 2010-2011	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
@@ -24,45 +24,100 @@ module BibTeX
 	class Element
     include Comparable
     
+    attr_writer :id
 		attr_reader :bibliography
 		
 		# Returns an array of BibTeX elements.
-    def self.parse(string, options={})
-      BibTeX::Parser.new(options).parse(string).to_a
+    def self.parse(string, options = {})
+      BibTeX::Parser.new(options).parse(string).data
     end
     
-		def initialize
-			@bibliography = nil
-		end
-		
 		# Returns a string containing the object's content.
-		def content
-			""
+		def content(options = {})
+			''
 		end
 
-		# Returns a string representation of the object.
-		def to_s
-			self.content
-		end
+    # Invokes BibTeX string replacement on this element.
+    def replace(*arguments); self; end
+
+    # Invokes BibTeX string joining on this element.
+    def join; self; end
+    
+    # Returns the element's id.
+    def id; @id ||= object_id.to_s.intern; end
+    
+    # Returns the BibTeX type (if applicable) or the normalized class name.
+    def type
+      self.class.name.split(/::/).last.gsub(/([[:lower:]])([[:upper:]])/) { "#{$1}_#{$2}" }.downcase.intern
+    end
+  
+    def has_type?(type)
+      self.type == type.intern || defined?(type) == 'constant' && is_a?(type)
+    end
+    
+    [:entry, :book, :article, :collection, :string, :preamble, :comment]. each do |type|
+      method_id = "#{type}?"
+      unless method_defined?(method_id)
+        define_method(method_id) { has_type?(type) }
+        alias_method("is_#{method_id}", method_id)
+      end
+    end
+    
+    # Returns true if the element matches the given query.
+    def matches?(query)
+      return true if query.nil? || query.respond_to?(:empty?) && query.empty?
+      
+      case query
+      when Element
+        self == query
+      when Symbol
+        id == query
+      when Regexp
+        to_s.match(query)
+      when /^\/(.+)\/$/
+        to_s.match(Regexp.new($1))
+      when /@(\w+)(?:\[([^\]]*)\])?/
+        query.scan(/@(\w+)(?:\[([^\]]*)\])?/).any? do |type, condition|
+          has_type?(type) && ( condition.nil? || meets?(condition.split(/,\s*/)) )
+        end
+      else
+        id == query.to_sym
+      end      
+    end
+    
+    alias :=== :matches?
+    alias :match? :matches?
+    
+    # Returns true if the element meets all of the given conditions.
+    def meets?(*conditions)
+      conditions.flatten.all? do |condition|
+        property, value = condition.split(/\s*=\s*/)
+        property.nil? || send(property).to_s == value
+      end
+    end
+    
+    alias :meet? :meets?
+    
+		alias :to_s :content
 		
-		def to_hash
-		  { self.class.name.downcase => content }
+		def to_hash(options = {})
+		  { type => content }
 	  end
 	  
-	  def to_yaml
+	  def to_yaml(options = {})
 	    require 'yaml'
-      self.to_hash.to_yaml
+      to_hash.to_yaml
 	  end
 	  
-	  def to_json
+	  def to_json(options = {})
 	    require 'json'
-	    self.to_hash.to_json
+	    to_hash.to_json
 	  end
 	  
-	  def to_xml
+	  def to_xml(options = {})
 	    require 'rexml/document'
-	    xml = REXML::Element.new(self.class.name.downcase)
-	    xml.text = self.content
+	    xml = REXML::Element.new(type)
+	    xml.text = content
 	    xml
 	  end
 
@@ -79,7 +134,7 @@ module BibTeX
 		end
 		
 		def <=>(other)
-		  (type_comparison = self.class.name <=> other.class.name) == 0 ? self.to_s <=> other.to_s : type_comparison
+		  [type, to_s] <=> [other.type, other.to_s]
 		end
 		
 	end
@@ -96,105 +151,70 @@ module BibTeX
 	# of regular entries.
 	#
 	class String < Element	  
+    include Replaceable
+    
 		attr_reader :key
 
 		# Creates a new instance.
-		def initialize(key=nil,value=nil)
-			self.key = key.to_sym unless key.nil?
-			self.value = value unless value.nil?
+		def initialize(key = nil, value = nil)
+		  @key, @value = key.to_sym, Value.new(value)
+			yield self if block_given?
 		end
 
-		# Sets the string's key (i.e., the name of the constant)
+		# Sets the string's key (i.e., the symbol identifying the constant).
 		def key=(key)
-			raise(ArgumentError, "BibTeX::String key must be of type Symbol; was: #{key.class.name}.") unless key.is_a?(Symbol)
-			@key = key
+		  raise(ArgumentError, "keys must be convertible to Symbol; was: #{type.class.name}.") unless type.respond_to?(:to_sym)
+			
+      unless @bibliography.nil?
+  			@bibliography.strings.delete(@key)
+  			@bibliography.strings[key.to_sym] = self
+  		end
+  		
+			@key = key.to_sym
 		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.is_a?(k) }.inject { |sum,n| sum || n }
-			@value = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
-		end
-    
-    def value
-      @value.to_s(:quotes => %w(" "))
+    # Retuns the string's value if parameter matches the key; nil otherwise.
+    def [](key)
+      @key == key ? @value : nil
     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 => 'bar'})
-		# => "\"bar\" # \"bar\""
-		# s.to_s
-		# => "@string{ foobar = foo # "bar"}"
-		def replace(hash)
-		  @value.replace_strings(hash)
-		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 => 'bar'})
-		# => ["bar","bar"]
-		# s.to_s
-		# => "@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.is_a?(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
+			super
+			bibliography.strings[@key] = self
 			self
 		end
 		
 		# Called when the element was removed from a bibliography.
 		def removed_from_bibliography(bibliography)
-			super(bibliography)
+			super
 			bibliography.strings[@key] = nil
 			self
 		end
 
 		# Returns a string representation of the @string's content.
 		def content
-			[@key.to_s, value].join(' = ')
+			"#@key = #{@value.to_s(:quotes => '"')}"
 		end
 
 		# Returns a string representation of the @string object.
-		def to_s
+		def to_s(options = {})
 			"@string{ #{content} }"
 		end
 		
-		def to_hash
-		  { 'string' => { @key.to_s => @value.to_s(:quotes => %w(" ")) } }
+		def to_hash(options = {})
+		  { :string => { @key => @value.to_s(:quotes => '"') } }
 		end
 		
-		def to_xml
-		  xml = REXML::Element.new('string')
-		  key = REXML::Element.new('key')
-		  val = REXML::Element.new('value')
+		def to_xml(options = {})
+		  require 'rexml/document'
+	    
+		  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(:quotes => %w(" "))
+		  val.text = @value.to_s(:quotes => '"')
 		  xml
 		end
 	end
@@ -206,79 +226,53 @@ module BibTeX
 	# a single constant, or a concatenation of string literals and
 	# constants.
 	class Preamble < Element
-    
-		# 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.is_a?(k) }.inject { |sum,n| sum || n }
-			@value = Extensions.string_replacement(value.is_a?(Array) ? value : [value])
-		end
+	  include Replaceable
 
-		def replace(hash)
-			@value.replace_strings(hash)
-		end
-
-		def replace!(hash)
-			@value = @value.replace_strings(hash)
+		# Creates a new instance.
+		def initialize(value = '')
+      @value = Value.new(value)
 		end
-
-    def join!
-      @value = @value.join_strings
-    end
-
-    def value
-      content
-    end
     
 		# Returns a string representation of the @preamble's content.
 		def content
-			@value.to_s(:quotes => %w(" "))
+			@value.to_s(:quotes => '"')
 		end
 
 		# Returns a string representation of the @preamble object
-		def to_s
-			"@preamble{ #{ content } }"
+		def to_s(options = {})
+			"@preamble{ #{content} }"
 		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.is_a?(::String)
+    attr_accessor :content
+    
+		def initialize(content = '')
 			@content = content
 		end
 
-		def content
-			@content
+		def to_s(options = {})
+			"@comment{ #@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
+	# post-processing of this type of `meta' content. If you
 	# want the parser to include +MetaComment+ objects, you
-	# need to add +:meta_comments+ to the parser's +:include+
+	# need to add +:meta_content+ to the parser's +:include+
 	# option.
-	class MetaComment < Comment
-		def to_s
-			@content
+	class MetaContent < Element
+	  attr_accessor :content
+	  
+		def initialize(content = '')
+			@content = content
 		end
+
+		def to_s(options = {}); @content; end
 	end
 
 end