rbibtex 0.0.2 → 0.1.0

data/lib/rbibtex/rbibtex.y

@@ -2,10 +2,10 @@ class BibTeX::Parser
 
 rule
 
-  file            : opt_space_element                 { result = File.new(Space.new(val[0])) }
+  file            : opt_space_element                 { result = BibTeXFile.new(Space.new(val[0])) }
                   | opt_space_element 
-		      object_list 
-		      opt_space_element               { result = File.new(*([val[0]] + val[1] + [val[2]]) ) }
+		      object_list
+		      opt_space_element               { result = BibTeXFile.new(*([val[0]] + val[1] + [val[2]]) ) }
                   ;
 
   object_list     : object                            { result = [val[0]]  }
@@ -16,16 +16,24 @@ rule
                   ;
 
   at_object       : comment                           { result = val[0]     }
+                  | string                            { result = val[0]     }
                   | entry                             { result = val[0]     }
                   ;
 
-  comment         : COMMENT opt_space value           { result = Comment.new(val[2]) } 
+  string          : STRING    opt_space 
+                      LBRACE  opt_space 
+		      WORD    opt_space
+  		      EQUALS  opt_space
+		      value   opt_space
+		      RBRACE                            { result = Abbreviation.new(val[4], val[8]) }
+
+  comment         : COMMENT opt_space value_element   { result = Comment.new(val[2]) } 
                   ;
 		  
   entry           : entry_head assignment_list
-                      RBRACE                          { val[0].properties = val[1]; result = val[0] }
+                      RBRACE                          { val[0].merge val[1]; result = val[0] }
 		  | entry_head assignment_list        /* Allow additional comma after last entry */
-                      COMMA opt_space RBRACE          { val[0].properties = val[1]; result = val[0] }
+                      COMMA opt_space RBRACE          { val[0].merge val[1]; result = val[0] }
                   | entry_head RBRACE                 { result = val[0] } /* Empty entry */
 		  ;
 
@@ -39,49 +47,60 @@ rule
                   ;
 
   key_name        :                                   { result = "" }
-                  | CHARACTER 
-                  | WORD                            
-                  | key_name CHARACTER                { result << val[1]  }
-                  | key_name WORD                     { result << val[1]  }
+                  | key_name_token                    { result = val[0] }             
+                  | key_name key_name_token           { result << val[1]  }
                   ;
 
+  key_name_token  : WORD
+                  | CHARACTER
+		  | number_as_str
+		  ;
+                    
+
   assignment_list : assignment                        { result = val[0] }
                   | assignment_list COMMA opt_space
                         assignment                    { result.merge!(val[3]) }
                   ;
 
   assignment      : assignment_lhs opt_space
-                    EQUALS opt_space              
-                        value opt_space               { result = {val[0].downcase.to_sym => val[4]} }
+                      EQUALS opt_space              
+                      value opt_space                 { result = {val[0].downcase.to_sym => val[4]} }
                   ;
 
   assignment_lhs  : WORD
                   ;
 
-  value           : LBRACE      value_content RBRACE             { result = val[1] }
-                  | SINGLE_ANFZ value_content_single_del SINGLE_ANFZ   { result = val[1] }
-		  | DOUBLE_ANFZ value_content_double_del DOUBLE_ANFZ   { result = val[1] }
-		  | WORD
+  value           : value_element                     { result = Value.new(val[0]) }
+                  | value opt_space 
+		    CONCATENATION opt_space 
+		    value                             { result = val[0] + val[4] }
+		  ;		
+
+  value_element   : LBRACE       value_content RBRACE                  { result = val[1] }
+                  | SINGLE_QUOTE value_content_single_del SINGLE_QUOTE { result = val[1] }
+		  | DOUBLE_QUOTE value_content_double_del DOUBLE_QUOTE { result = val[1] }
+		  | WORD                                               { result = AbbreviationRef.new(val[0]) }
+		  | NUMBER                                             { result = val[0] }
 		  ;  
 
   brace           : LBRACE
                   | RBRACE
 		  ;
 		  
-  anfz            : SINGLE_ANFZ
-                  | DOUBLE_ANFZ
+  anfz            : SINGLE_QUOTE
+                  | DOUBLE_QUOTE
 		  ;
 
   value_content_single_del   :                       { result = "" }
                   | value_content general_vc_token   { result << val[1] }
                   | value_content brace              { result << val[1] }
-                  | value_content DOUBLE_ANFZ        { result << val[1] }
+                  | value_content DOUBLE_QUOTE        { result << val[1] }
 		  ;
 
   value_content_double_del   :                       { result = "" }
                   | value_content general_vc_token   { result << val[1] }
                   | value_content brace              { result << val[1] }
-                  | value_content SINGLE_ANFZ        { result << val[1] }
+                  | value_content SINGLE_QUOTE        { result << val[1] }
 		  ;
 
   value_content   :                                  { result = "" }
@@ -93,12 +112,17 @@ rule
 
   general_vc_token : SPACE
                   | WORD		
+		  | STRING
                   | COMMA		       
                   | EQUALS                      
                   | CHARACTER                    
+		  | CONCATENATION
                   | AT                            
+		  | number_as_str
 		  ;
 
+  number_as_str   : NUMBER                          { result = val[0].to_s }
+
   opt_space_element :
                     | space_element
 		    ;
@@ -117,37 +141,7 @@ end
 
 ---- header ----
 
-module BibTeX
-  Entry = Struct.new(:type, :key, :properties)
-
-  class Space < String; end
-
-  class Comment
-    def initialize(comment)
-      @comment = comment
-    end
-
-    def to_s
-      @comment
-    end
-
-    alias :to_str :to_s
-  end  
-  
-  class File
-    def initialize(*elements)
-      @elements = elements.compact
-    end
-
-    def elements
-      @elements
-    end
-
-    def entries
-      @elements.select { | e | e.is_a?Entry }
-    end
-  end
-end
+require "rbibtex/types"
 
 ---- inner ----
 
@@ -158,7 +152,7 @@ end
   def parse( str )
     @q = []
 
-#   @yydebug = true
+   #@yydebug = true
 
     while str.size > 0 do
       case str
@@ -166,6 +160,8 @@ end
         @q.push [:SPACE, $&]
       when /\Acomment/io
         @q.push [:COMMENT, $&]
+      when /\Astring/io
+        @q.push [:STRING, $&]
       when /\A\,/o
         @q.push [:COMMA, $&]
       when /\A@/o
@@ -177,11 +173,15 @@ end
       when /\A\=/o
         @q.push [:EQUALS, $&]
       when /\A\'/o
-        @q.push [:SINGLE_ANFZ, $&]
+        @q.push [:SINGLE_QUOTE, $&]
       when /\A\"/o
-        @q.push [:DOUBLE_ANFZ, $&]
+        @q.push [:DOUBLE_QUOTE, $&]
+      when /\A\d+\b/o
+        @q.push [:NUMBER, $&.to_i]
       when /\A\w+/o
         @q.push [:WORD, $&]
+      when /\A#/o
+        @q.push [:CONCATENATION, $&]
       when /\A./o
         @q.push [:CHARACTER, $&]
       when /\A\d+/o
@@ -199,4 +199,8 @@ end
   end
 
 
+  def on_error(*args)
+    p args
+    super
+  end
 ---- footer ----

data/lib/rbibtex/string.rb

@@ -0,0 +1,64 @@
+# Some string handling routines for wordwrapping and tabifying.
+class String
+  # Do a wordwrap. Will not work correctly if the string contains tab characters
+  def wrap(width = 78)
+    raise "Invalid width" if width < 0
+    self.split("\n", -1).map { | line |
+      indent = line[/\A\s*/]
+      line = line[/\A\s*(.*)\Z/, 1]
+      result = [""]
+      line.split(/(?=\s+)/).each do | token |
+	if result[-1].length + token.length <= width
+	  result[-1] << token
+	else
+	  result << token[/\A\s*(.*)\Z/, 1]
+	end
+      end
+      result.shift if result.first == ""
+      result.map{ |subline| indent + subline }
+    }.join("\n")
+  end
+
+  # Indent everything but the first line
+  def indent_hanging(indent = 2)
+    first, rest = *self.split("\n", 2)
+    return "" unless first
+    if rest
+      first + "\n" + (rest.indent(indent))
+    else
+      first
+    end
+  end
+
+  # Indent by indent spaces
+  def indent(indent = 2)
+    self.gsub(/^/, " " * indent)
+  end
+
+  # Substitute tabs with spaces
+  def untabify(tab_width = 8)
+    self.gsub(/\t/, " "*tab_width)
+  end
+
+  # Deindent ignoring the first line. Will not work correctly if the string contains tab characters
+  def deindent_hanging(indent = self.scan(/(?:\n)(\s*)(?=\S)/).flatten.map{|e|e.length}.min)
+    deindent(indent)
+  end
+
+  def remove_trailing_whitespace
+    self.gsub(/\s+$/, "")
+  end
+
+  # Remove indentation. The optional argument gives the number of spaces to indent by. Will not work correctly if the string contains tab characters.
+  def deindent(indent = self.scan(/^\s*/).map{|e|e.length}.min)
+    self.gsub(/^ {0,#{indent}}/, "")
+  end
+
+  # Change paragraphs (delimited by two blank lines) into one liners. Indented text is left as is.
+  def unwrap
+    self.sub(/\A\n+/i, '').split(/\n(?:\s*\n)+/).map { | paragraph |
+      paragraph.gsub(/((?:\n|^)\S[^\n]*)\n(?=\S)/, "\\1 ")
+    }.join("\n\n")
+  end
+end
+

data/lib/rbibtex/transform.rb

@@ -0,0 +1,75 @@
+module BibTeX
+  
+  # Contains modules that can be included in OptionParser parsers and create
+  # switches there. Be sure to call super in the initialize methods.
+  module Options
+    
+    # Module to be included into an OptionParser parser. Creates output, help and
+    # version switches.
+    #
+    # This depends on a VERSION Constant being declared in the parser.
+    module ApplicationOptions 
+      attr_reader :output
+
+      def initialize
+	super()
+
+	@output = STDOUT
+	self.on("-o", "--output FILENAME", String,
+		"Set the output filename. Writes to stdout if nothing is given")   { | v | @output   = File.open(v, 'w') }
+	self.separator ""
+	self.on("-?", "--help",
+		"Show this help")                                                  {       puts self; exit }
+	self.on("-v", "--version", 
+		"Output version number and exit")                                  {       puts VERSION; exit }
+      end
+    end
+
+    # Module to be included into an OptionParser parser. Creates sort by switch.
+    module SortOptions
+      attr_reader :sort_by
+
+      def initialize
+	super()
+
+	self.separator ""
+	self.separator "Sorting of entries"
+	self.on("-s", "--sort-by", "--sort_by Field_1,Field2,...", Array,
+		"Specify fields that shall be used for sorting of the file")       { | v | @sort_by  = v.map { | e | e.downcase.to_sym  } }
+      end
+
+      def parse!(*args)      
+	super
+	raise "You can't specify an empty list of fields for sorting" if @sort_by and @sort_by.empty?
+      end
+    end
+
+    # Module to be included in an OptionParser parse. Creates top_fields and
+    # bottom_fields switches.
+    module SortFieldsOptions
+      attr_reader :top_fields, :bottom_fields
+
+      def initialize
+	super()
+
+	@top_fields    = [:author, :title, :year]
+	@bottom_fields = [:note, :pdf, :ps, :www]    
+
+	self.separator ""
+	self.separator "Sorting of fields"
+	self.on("-t", "--top-fields", "--top_fields Field_1,Field2,...", Array,
+		"Specify a list of fields that are written first in the output")   { | v |
+		  @top_fields     = v.map { | e | e.downcase.to_sym }
+	          @bottom_fields -= @top_fields 
+	}
+	self.on("-b", "--bottom-fields", "--bottom_fields Field_1,Field2,...", Array,
+		"Specify a list of fields that are written last in the output")    { | v | 
+		  @bottom_fields  = v.map { | e | e.downcase.to_sym }
+	          @top_fields -= @bottom_fields 
+	}
+      end
+
+    end
+
+  end
+end

data/lib/rbibtex/types.rb

@@ -0,0 +1,344 @@
+# TODO: Do not modify base class. (I want selector namespaces :-(
+require "rbibtex/string"
+
+module BibTeX
+  class Entry 
+    attr_accessor :type, :key
+
+    def self.norm_key(key)
+      key.to_s.downcase.to_sym
+    end
+
+    private
+    def norm_key(*args)
+      self.class.norm_key(*args)
+    end
+
+    public
+
+    CAPITALIZATION = Hash.new { | h, k | 
+      if k == norm_key(k)
+	k.to_s.capitalize 
+      else 
+       h[norm_key(k)] 
+      end
+    }
+    CAPITALIZATION.merge!({
+      :additional  => "additional",
+      :booktitle   => "BookTitle", 
+      :isbn        => "isbn", 
+      :issn        => "issn",
+      :pdf         => "pdf",
+      :ps          => "ps"
+    })
+
+    public    
+    def initialize(type, key, properties = {})
+      @properties = properties.inject({}) { | r, (k, v) | r[norm_key(k)] = v; r }
+      @key = key
+      @type = type
+    end
+
+    def method_missing(method, *args)
+      case args.length
+      when 0
+	if has_key?(method)
+	  return self[method]
+	else
+	  super
+	end
+      when 1	  
+	if /\A(.*)=\Z/ =~ method.to_s
+	  self[$1] = args[0] 
+	else
+	  super
+	end
+      else
+	super
+      end
+    end
+
+    def respond_to?(method, *args)
+      case args.length
+      when 0
+	if has_key?(method)
+	  true
+	else
+	  super
+	end
+      when 1	  
+	if /\A(.*)=\Z/ =~ method.to_s
+	  true  	
+	else
+	  super
+	end
+      else
+	super
+      end
+    end
+    
+    def normalize
+      res = self.class.new(self.type, self.key, @properties.inject({}) { | r, (k, v) |
+		     r[k] = v.map { | ve |
+				        if ve.is_a?AbbreviationRef
+					  ve
+				        elsif ve.is_a?String
+					  if /\A\d+\Z/ =~ ve
+					    Integer(ve)					    
+					  elsif ve.respond_to?:deindent_hanging
+					    ve.deindent_hanging.unwrap
+					  end
+					else
+					  ve
+					end
+                                      }		      
+		     r
+      })
+    end
+
+    def has_key?(key)
+      @properties.has_key?(norm_key(key))
+    end
+
+    def keys
+      @properties.keys + [:type, :key]
+    end
+
+    def merge(hash)
+      hash.each do | (k, v) |
+	self[k] = v
+      end
+    end
+
+    def each &block
+      @properties.each &block
+    end
+    include Enumerable
+
+    def [](key)
+      case norm_key(key) 
+      when :key
+	@key
+      when :type
+	@type
+      else	
+        @properties[norm_key(key)]
+      end
+    end
+      
+    def []=(key, value)
+      case norm_key(key) 
+      when :key
+	@key = value
+      when :type
+	@type = value
+      else	
+        @properties[norm_key(key)] = value
+      end
+    end
+  end
+
+  class Space < String; end
+
+  class Comment < String
+    def normalize
+      Comment.new(self.deindent_hanging.unwrap)
+    end
+  end    
+
+  class Value
+    attr_reader :elements
+    
+    def initialize(*elements)
+      @elements = elements
+    end
+
+    def to_s
+      @elements.map { | e | e.to_s }.join("")
+    end
+
+    def +(o)
+      self.class.new(*(@elements + o.elements))
+    end
+
+    def each(&block)
+      @elements.each(&block)
+      self
+    end
+    include Enumerable
+
+    # map each element of the value onto a new value
+    def map!(&block)
+      @elements.map!(&block)
+    end
+    
+    # Create a new Value object where each element is replaced by its map'ed element
+    def map(&block)
+      Value.new(*@elements.map(&block))
+    end
+
+    def to_bib
+      @elements.map { | ve |
+	  if ve.is_a?Numeric
+	    ve.to_s
+	  elsif ve.respond_to?:to_bib
+	    ve.to_bib
+	  elsif ve.respond_to?:to_str
+	    %({#{ve.to_str}})
+	  else
+	    raise "Don't know how to display #{ve.inspect} as a bibtex element"
+	  end
+      }.join(" # ")
+    end
+
+    # Create a flat version, where each element that is itself a value is included directly
+    def flatten
+      self.class.new(
+	*@elements.map { | e | e.respond_to?(:flatten)  ? e.flatten  : e}.
+	           map { | e | e.respond_to?(:elements) ? e.elements : e}.
+		   flatten
+      )		     
+    end
+
+    # Create a normalized version where:
+    #  - strings following each other are joined together
+    #  - Elements of the Value are normalized
+    #  -
+    def normalize
+      self.class.new(
+        *self.flatten.elements.
+		  inject([]) { | r, e |	    
+		    if r[-1].is_a?String and e.is_a?String
+		      r[-1] += e
+		    else
+		      r << e
+		    end
+		    r
+		  }
+      )
+    end
+  end
+  
+  class AbbreviationRef < String; end
+  class Abbreviation
+    attr_accessor :key, :string
+    
+    def initialize(key, string)
+      @key, @string = key, string
+    end
+
+    def to_s
+      @string
+    end
+
+    def to_bib
+      @key.dup
+    end
+
+    def normalize
+      self.class.new(@key, @string.map { | e | e.is_a?(String) ? e.deindent_hanging.unwrap : e })
+    end
+
+    alias :to_str :to_s
+  end
+
+  class BibTeXFile
+
+    private
+
+    def norm_key(key)
+      key.to_s.downcase.to_sym
+    end
+
+    public
+
+    attr_reader :elements
+
+    def each &block
+      @elements.each &block
+    end
+    include Enumerable
+    
+    def initialize(*elements)
+      @elements = elements.compact
+    end
+
+    # Create a File from a string
+    def self.parse(string)
+      Parser.new.parse(string)
+    end
+
+    # Return all entries in this file.
+    def entries
+      @elements.select { | e | e.is_a?Entry }
+    end
+
+    # When keys are given sorts the bibtex file according to the keys,
+    # discarding any empty spaces and sorting comments and strings to the top.
+    #
+    # When a block is given the sortorder need to be inferred in the block
+    def sort_by(*keys)
+      raise "Give either a block or keys to sort on" if block_given? and !keys.empty?      
+      self.normalize!
+      @elements = @elements.sort_by { | element |
+	case element
+	when Abbreviation
+	  [0, element.key]
+	when Comment
+	  [1, element.to_s]
+	when Entry
+	  [2, keys.map { | k | (element[k] || "").to_s }]
+	else 
+	  [10]
+	end
+      } 
+    end
+
+    # Return an array with the abbrevations in this file
+    def abbreviations
+      @elements.select { | element | element.is_a?Abbreviation }
+    end
+
+    # Get an abbrevation by key
+    def abbreviation(key)
+      abbreviations.select { | a | norm_key(a.key) == norm_key(key) }.first
+    end
+
+    # Check if abbreviation is defined
+    def has_abbreviation?(key)
+      abbreviation(key) != nil
+    end
+
+    # - Remove additional whitespace from the filelist
+    # - Deindent and unwrap text
+    def normalize!
+      @elements = @elements.reject { | e | e.is_a?Space }
+      @elements.map! { | e |
+	if e.respond_to?:normalize
+	  next e.normalize
+	end
+      }
+    end
+
+    # Replace abbreviations by their string equivalent. (Does not replace
+    # predefined abbreviations like jan, feb if they are not explicitely
+    # specified in this bibtex file
+    def interpolate!
+      self.entries.each do | entry |
+	entry.each do | (k, v) |
+          interpolated = v.map{ | e | 
+	    if e.is_a?AbbreviationRef and has_abbreviation?(e)
+	      abbreviation(e).string
+	    else
+	      e
+	    end
+          }
+	  shrunk = interpolated.normalize
+  	  entry[k] = Value.new(*shrunk)
+	end
+      end
+    end
+  end
+end
+
+

data/lib/rbibtex.rb

@@ -1 +1,8 @@
 require "rbibtex/rbibtex.tab"
+
+module BibTeX
+  # Convenience function parsing a string into a BibTeX::File object.
+  def self.parse(string)
+    Parser.new.parse(string)
+  end
+end