bibtex-ruby 1.2.1 → 1.3.0

data/lib/bibtex/names.rb

@@ -0,0 +1,162 @@
+#--
+# BibTeX-Ruby
+# 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
+# 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 'forwardable'
+
+module BibTeX
+
+  class Names < Value
+    include Enumerable
+    
+    def_delegators :@tokens, :each, :sort
+    
+    def self.parse(string)
+      Names.new(NameParser.new.parse(string))
+    end
+    
+    def initialize(*arguments)
+      @tokens = []
+      arguments.flatten.compact.each do |argument|
+        add(argument)
+      end
+    end
+
+    def replace(*arguments); self; end
+    
+    def join; self; end
+    
+    def value
+      @tokens.join(' and ')
+    end
+    
+    def to_s(options = {})
+      return value unless options.has_key?(:quotes)
+      *q = options[:quotes]
+      [q[0], value, q[-1]].compact.join
+    end
+    
+    def name?; true; end
+    def numeric?; false; end
+    def atomic?; true; end
+    
+    alias :names? :name?
+    alias :symbol? :numeric?
+    
+    def to_name; self; end
+    
+    def add(name)
+      case
+      when name.is_a?(Name)
+        @tokens << name
+      when name.respond_to?(:to_s)
+        @tokens += Names.parse(name.to_s)
+      else
+        raise ArgumentError, "failed to add #{name.inspect}: not a name."
+      end
+      self
+    end
+    
+    alias :<< :add
+    alias :push :add
+    
+    def <=>(other)
+      other.respond_to?(:to_a) ? to_a <=> other.to_a  : super
+    end
+    
+  end
+
+  class Name < Struct.new(:first, :last, :prefix, :suffix)
+    extend Forwardable
+    include Comparable
+    
+    def_delegators :to_s, :empty?, :=~, :match, :length, :intern, :to_sym, :end_with?, :start_with?, :include?, :upcase, :downcase, :reverse, :chop, :chomp, :rstrip, :gsub, :sub, :size, :strip, :succ, :to_str, :split, :each_byte, :each_char, :each_line
+    
+    class << self    
+      def parse(string)
+        [NameParser.new.parse(string)].flatten[0]
+      end
+      
+      # Returns true if thing looks like a name.
+      # Actually converts thing to a string and tries to parse it.
+      def looks_like?(thing)
+        thing.respond_to?(:to_s) && [Name.new.parse(string)].flatten.compact.empty?
+      end
+    end
+    
+    def initialize(attributes = {})
+      attributes.each do |key,value|
+        send("#{key}=", value) if respond_to?(key)
+      end
+    end
+    
+    def initalize_copy(other)
+      each_pair { |k,v| self[k] = v }
+    end
+    
+    def blank?
+      to_a.compact.empty?
+    end
+    
+    def display_order
+      [prefix, last, first, suffix].compact.join(' ')
+    end
+    
+    alias :display :display_order
+    
+    def sort_order
+      [[prefix,last].compact.join(' '), suffix, first].compact.join(', ')
+    end
+    
+    alias :to_s :sort_order
+    
+    def <=>(other)
+      other.is_a?(Name) ? [last, prefix, first, suffix].compact.join(' ') <=> [other.last, other.prefix, other.first, other.suffix].compact.join(' ') : super
+    end
+    
+    def to_hash
+      Hash[each_pair.to_a]
+    end
+
+    [:strip!, :upcase!, :downcase!, :sub!, :gsub!, :chop!, :chomp!, :rstrip!].each do |method_id|
+      define_method(method_id) do |*arguments, &block|
+        each do |part|
+          part.send(method_id, *arguments, &block)
+        end
+        self
+      end
+    end
+    
+    def to_citeproc
+      {
+        'family' => [prefix, last].compact.join(' '),
+        'given' =>  [first, suffix].compact.join(', '),
+        'parse-names' => true
+      }
+    end
+    
+    alias :family :last
+    alias :family= :last=    
+    alias :given :first
+    alias :given= :first=
+    alias :jr :suffix
+    alias :jr= :suffix=
+    alias :von :prefix
+    alias :von= :prefix=    
+    
+  end
+end

data/lib/bibtex/names.y

@@ -0,0 +1,196 @@
+#--
+# BibTeX-Ruby
+# 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
+# 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::NameParser
+
+token COMMA UWORD LWORD PWORD AND ERROR
+
+expect 0
+
+rule
+
+  result :                           { result = [] }
+         | names                     { result = val[0] }
+
+  names : name                       { result = [val[0]] }
+        | names AND name             { result << val[2] }
+  
+  name : last                        { result = Name.new(:von => val[0][0], :last => val[0][1]) }
+       | u_words last                { result = Name.new(:first => val[0], :von => val[1][0], :last => val[1][1]) }
+       | sort COMMA first            { result = Name.new(:von => val[0][0], :last => val[0][1], :jr => val[2][0], :first => val[2][1]) }
+  
+  sort : u_words                     { result = [nil,val[0]]}
+       | LWORD                       { result = [nil,val[0]]}
+       | von LWORD                   { result = [val[0],val[1]]}
+       | von u_words                 { result = [val[0],val[1]]}
+  
+  last : word                        { result = [nil,val[0]]}
+       | von LWORD                   { result = [val[0],val[1]]}
+       | von u_words                 { result = [val[0],val[1]]}
+  
+  first : opt_words                  { result = [nil,val[0]] }
+        | opt_words COMMA opt_words  { result = [val[0],val[2]] }
+  
+  u_words : u_word                   { result = val[0] }
+          | u_words u_word           { result = val[0,2].join(' ') }
+
+  u_word : UWORD                     { result = val[0] }
+         | PWORD                     { result = val[0] }
+
+  von : LWORD                        { result = val[0] }
+      | von u_words LWORD            { result = val[0,3].join(' ') }
+      | von LWORD                    { result = val[0,2].join(' ') }
+    
+  words : word                       { result = val[0] }
+        | words word                 { result = val[0,2].join(' ') }
+
+  opt_words :                        { result = nil }
+            | words                  { result = val[0] }
+  
+  word : LWORD                       { result = val[0] }
+       | UWORD                       { result = val[0] }
+       | PWORD                       { result = val[0] }
+
+end
+
+---- header
+require 'strscan'
+
+---- inner
+  
+  def initialize(options = {})
+    self.options.merge!(options)
+  end
+
+  def options
+    @options ||= { :debug => ENV['DEBUG'] == true }
+  end
+  
+  def parse(input)
+    @yydebug = options[:debug]
+    scan(input)
+    do_parse
+  end
+  
+  def next_token
+    @stack.shift
+  end
+  
+  def on_error(tid, val, vstack)
+    BibTeX.log.error("Failed to parse BibTeX Name on value %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect])
+  end
+
+  def scan(input)
+    @src = StringScanner.new(input)
+    @brace_level = 0
+    @stack = []
+    @word = [:PWORD,'']
+    do_scan
+  end
+  
+  private
+
+  def do_scan
+    until @src.eos?
+      case
+      when @src.scan(/,?\s+and\s+/io)
+        push_word
+        @stack.push([:AND,@src.matched])
+        
+      when @src.scan(/[\t\r\n\s]+/o)
+        push_word
+      
+      when @src.scan(/,/o)
+        push_word
+        @stack.push([:COMMA,@src.matched])
+        
+      when @src.scan(/[[:lower:]][^\t\r\n\s\{\}\d\\,]*/o)
+        is_lowercase
+        @word[1] << @src.matched
+
+      when @src.scan(/[[:upper:]][^\t\r\n\s\{\}\d\\,]*/o)
+        is_uppercase
+        @word[1] << @src.matched
+        
+      when @src.scan(/(\d|\\.)+/o)
+        @word[1] << @src.matched
+        
+      when @src.scan(/\{/o)
+        scan_literal(@src.matched)
+        
+      when @src.scan(/\}/o)
+        error_unbalanced
+
+      when @src.scan(/./o)
+        @word[1] << @src.matched
+      end
+    end
+    
+    push_word
+    @stack
+  end
+  
+  def push_word
+    unless @word[1].empty?
+      @stack.push(@word)
+      @word = [:PWORD,'']
+    end
+  end
+  
+  def is_lowercase
+    @word[0] = :LWORD if @word[0] == :PWORD
+  end
+
+  def is_uppercase
+    @word[0] = :UWORD if @word[0] == :PWORD
+  end
+  
+  def scan_literal(content = '')
+    @brace_level += 1
+    content << @src.scan_until(/[^\\][\{\}]/o).to_s # TODO accept empty braces {}
+    case @src.matched
+    when /\{/
+      scan_braced_expression(content)
+    when /\}/
+      @brace_level -= 1
+      if @brace_level >= 0
+        @word[1] << content
+      else
+        error_unbalanced
+      end
+    else
+      error_unbalanced
+    end
+  end
+
+  def error_unexpected
+    @stack.push [:ERROR,@src.matched]
+    BibTeX.log.warn("NameParser: unexpected token `#{@src.matched}' at position #{@src.pos}; brace level #{@brace_level}.")
+  end
+  
+  def error_unbalanced
+    @stack.push [:ERROR,'}']
+    BibTeX.log.warn("NameParser: unbalanced braces at position #{@src.pos}; brace level #{@brace_level}.")
+  end
+  
+# -*- racc -*-

data/lib/bibtex/parser.output

@@ -7,7 +7,7 @@ rule 2 bibliography: objects
 rule 3 objects: object
 rule 4 objects: objects object
 rule 5 object: AT at_object
-rule 6 object: META_COMMENT
+rule 6 object: META_CONTENT
 rule 7 object: ERROR
 rule 8 at_object: comment
 rule 9 at_object: string
@@ -106,7 +106,7 @@ rule 33 value: LBRACE content RBRACE
   ERROR (6) 7
   EQ (7) 17 30
   LBRACE (8) 12 15 16 25 33
-  META_COMMENT (9) 6
+  META_CONTENT (9) 6
   NAME (10) 17 20 25 26 30
   NUMBER (11) 27 32
   PREAMBLE (12) 15
@@ -122,7 +122,7 @@ state 0
 
   AT            shift, and go to state 4
   ERROR         shift, and go to state 6
-  META_COMMENT  shift, and go to state 5
+  META_CONTENT  shift, and go to state 5
   $default      reduce using rule 1 (bibliography)
 
   bibliography  go to state 1
@@ -142,7 +142,7 @@ state 2
 
   AT            shift, and go to state 4
   ERROR         shift, and go to state 6
-  META_COMMENT  shift, and go to state 5
+  META_CONTENT  shift, and go to state 5
   $default      reduce using rule 2 (bibliography)
 
   object        go to state 8
@@ -172,7 +172,7 @@ state 4
 
 state 5
 
-   6) object : META_COMMENT _
+   6) object : META_CONTENT _
 
   $default      reduce using rule 6 (object)
 

data/lib/bibtex/parser.rb

@@ -15,32 +15,35 @@ module_eval(<<'...end bibtex.y/module_eval...', 'bibtex.y', 89)
 
   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?
@@ -156,7 +159,7 @@ racc_token_table = {
   :ERROR => 6,
   :EQ => 7,
   :LBRACE => 8,
-  :META_COMMENT => 9,
+  :META_CONTENT => 9,
   :NAME => 10,
   :NUMBER => 11,
   :PREAMBLE => 12,
@@ -195,7 +198,7 @@ Racc_token_to_s_table = [
   "ERROR",
   "EQ",
   "LBRACE",
-  "META_COMMENT",
+  "META_CONTENT",
   "NAME",
   "NUMBER",
   "PREAMBLE",
@@ -222,7 +225,7 @@ Racc_token_to_s_table = [
   "assignment",
   "value" ]
 
-Racc_debug_parser = true
+Racc_debug_parser = false
 
 ##### State transition tables end #####
 
@@ -230,7 +233,7 @@ Racc_debug_parser = true
 
 module_eval(<<'.,.,', 'bibtex.y', 32)
   def _reduce_1(val, _values, result)
-     result = Bibliography.new 
+     result = BibTeX::Bibliography.new 
     result
   end
 .,.,
@@ -244,7 +247,7 @@ module_eval(<<'.,.,', 'bibtex.y', 33)
 
 module_eval(<<'.,.,', 'bibtex.y', 35)
   def _reduce_3(val, _values, result)
-     result = Bibliography.new << val[0] 
+     result = BibTeX::Bibliography.new << val[0] 
     result
   end
 .,.,
@@ -265,7 +268,7 @@ module_eval(<<'.,.,', 'bibtex.y', 38)
 
 module_eval(<<'.,.,', 'bibtex.y', 39)
   def _reduce_6(val, _values, result)
-     result = BibTeX::MetaComment.new(val[0]) 
+     result = BibTeX::MetaContent.new(val[0]) 
     result
   end
 .,.,