bibtex-ruby 4.4.7 → 5.0.0

data/lib/bibtex/error.rb

@@ -1,13 +1,12 @@
 module BibTeX
+  class BibTeXError < StandardError
+    attr_reader :original
 
-	class BibTeXError < StandardError
-		attr_reader :original
-
-		def initialize(message = nil, original = $!)
-			super(message)
-			@original = original
-		end
-	end
+    def initialize(message = nil, original = $ERROR_INFO)
+      super(message)
+      @original = original
+    end
+  end
 
   class ParseError < BibTeXError; end
   class ArgumentError < BibTeXError; end
@@ -16,15 +15,15 @@ module BibTeX
   # Represents a lexical or syntactical error.
   #
   class Error < Element
-
     attr_reader :trace
 
-    def initialize(trace=[])
+    def initialize(trace = [])
       @trace = trace
     end
 
     def trace=(trace)
-      raise(ArgumentError, "BibTeX::Error trace must be of type Array; was: #{trace.class.name}.") unless trace.kind_of?(Array)
+      raise(ArgumentError, "BibTeX::Error trace must be of type Array; was: #{trace.class.name}.") unless trace.is_a?(Array)
+
       @trace = trace
     end
 

data/lib/bibtex/extensions.rb

@@ -17,9 +17,6 @@
 #++
 
 module BibTeX
-
-	module Extensions
-
-	end
-
+  module Extensions
+  end
 end

data/lib/bibtex/filters.rb

@@ -23,11 +23,10 @@ module BibTeX
 
     alias convert apply
     alias << apply
-
   end
 
   module Filters
-    LOAD_PATH = [File.expand_path('..', __FILE__), 'filters'].join('/').freeze
+    LOAD_PATH = [File.expand_path(__dir__), 'filters'].join('/').freeze
 
     Dir.glob("#{LOAD_PATH}/*.rb").each do |filter|
       require filter
@@ -38,18 +37,14 @@ module BibTeX
     end
 
     def self.resolve(filter)
-      case
-      when filter.respond_to?(:apply)
+      if filter.respond_to?(:apply)
         filter
-      when filter.respond_to?(:to_s)
+      elsif filter.respond_to?(:to_s)
         klass = Filter.subclasses.detect do |c|
           c.name == filter.to_s || c.name.split(/::/)[-1] =~ /^#{filter}$/i
         end
-        klass && klass.instance
-      else
-        nil
+        klass&.instance
       end
     end
   end
 end
-

data/lib/bibtex/filters/latex.rb

@@ -2,12 +2,10 @@ require 'latex/decode'
 
 module BibTeX
   module Filters
-
     class LaTeX < Filter
       def apply(value)
         ::LaTeX.decode(value)
       end
     end
-
   end
 end

data/lib/bibtex/filters/linebreaks.rb

@@ -1,11 +1,9 @@
 module BibTeX
   module Filters
-
     class LineBreaks < Filter
       def apply(value)
         value.to_s.gsub(/\n\s*/, ' ')
       end
     end
-
   end
 end

data/lib/bibtex/lexer.rb

@@ -19,7 +19,6 @@
 require 'strscan'
 
 module BibTeX
-
   #
   # The BibTeX::Lexer handles the lexical analysis of BibTeX bibliographies.
   #
@@ -32,43 +31,43 @@ module BibTeX
     def_delegator :@scanner, :string, :data
 
     @defaults = {
-      :include => [:errors],
-      :strict => true,
-      :allow_missing_keys => false,
-      :strip => true
+      include: [:errors],
+      strict: true,
+      allow_missing_keys: false,
+      strip: true
     }
 
     # Patterns Cache (#37: MacRuby does not cache regular expressions)
     @patterns = {
-      :space        => /[\s]+/o,
-      :lbrace       => /\s*\{/o,
-      :rbrace       => /\s*\}\s*/o,
-      :braces       => /\{|\}/o,
-      :eq           => /\s*=\s*/o,
-      :comma        => /\s*,\s*/o,
-      :number       => /[[:digit:]]+/o,
-      :name         => /[[:alpha:][:digit:]\/:_!$\?\.%+&\*-]+/io,
-      :quote        => /\s*"/o,
-      :unquote      => /[\{\}"]/o,
-      :sharp        => /\s*#\s*/o,
-      :object       => /@/o,
-      :period       => /./o,
-      :strict_next  => /@[\t ]*/o,
-      :next         => /(^|\n)[\t ]*@[\t ]*/o,
-      :entry        => /[a-z\d:_!\.$%&*-]+/io,
-      :string       => /string/io,
-      :comment      => /comment\b/io,
-      :preamble     => /preamble\b/io,
-      :key          => /\s*[[:alpha:][:digit:] \/:_!$\?\.%+;&\*'"-]+,/io,
-      :optional_key => /\s*[[:alpha:][:digit:] \/:_!$\?\.%+;&\*'"-]*,/io
+      space: /[\s]+/o,
+      lbrace: /\s*\{/o,
+      rbrace: /\s*\}\s*/o,
+      braces: /\{|\}/o,
+      eq: /\s*=\s*/o,
+      comma: /\s*,\s*/o,
+      number: /[[:digit:]]+/o,
+      name: %r{[[:alpha:][:digit:]/:_!$\?\.%+&\*-]+}io,
+      quote: /\s*"/o,
+      unquote: /[\{\}"]/o,
+      sharp: /\s*#\s*/o,
+      object: /@/o,
+      period: /./o,
+      strict_next: /@[\t ]*/o,
+      next: /(^|\n)[\t ]*@[\t ]*/o,
+      entry: /[a-z\d:_!\.$%&*-]+/io,
+      string: /string/io,
+      comment: /comment\b/io,
+      preamble: /preamble\b/io,
+      key: %r{\s*[[:alpha:][:digit:] /:_!$\?\.%+;&\*'"-]+,}io,
+      optional_key: %r{\s*[[:alpha:][:digit:] /:_!$\?\.%+;&\*'"-]*,}io
     }
 
-    MODE = Hash.new(:meta).merge({
-      :bibtex  => :bibtex,  :entry    => :bibtex,
-      :string  => :bibtex,  :preamble => :bibtex,
-      :comment => :bibtex,  :meta     => :meta,
-      :literal => :literal, :content  => :content
-    }).freeze
+    MODE = Hash.new(:meta).merge(
+      bibtex: :bibtex, entry: :bibtex,
+      string: :bibtex, preamble: :bibtex,
+      comment: :bibtex,  meta: :meta,
+      literal: :literal, content: :content
+    ).freeze
 
     class << self
       attr_reader :defaults, :patterns
@@ -94,7 +93,10 @@ module BibTeX
     end
 
     def reset
-      @stack, @brace_level, @mode, @active_object = [], 0, :meta, nil
+      @stack = []
+      @brace_level = 0
+      @mode = :meta
+      @active_object = nil
 
       # cache options for speed
       @include_meta_content = @options[:include].include?(:meta_content)
@@ -109,17 +111,21 @@ module BibTeX
       reset
     end
 
-    def symbols; @stack.map(&:first); 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
 
     # Returns true if the lexer is currenty parsing a BibTeX object.
     def bibtex_mode?
       MODE[@mode] == :bibtex
     end
 
-    [:meta, :literal, :content].each do |m|
+    %i[meta literal content].each do |m|
       define_method("#{m}_mode?") { @mode == m }
     end
 
@@ -171,9 +177,7 @@ module BibTeX
 
       self.data = string || @scanner.string
 
-      until @scanner.eos?
-        send("parse_#{MODE[@mode]}")
-      end
+      send("parse_#{MODE[@mode]}") until @scanner.eos?
 
       push([false, '$end'])
     end
@@ -184,25 +188,25 @@ module BibTeX
       case
       when @scanner.scan(Lexer.patterns[:lbrace])
         @brace_level += 1
-        push([:LBRACE,'{'])
+        push([:LBRACE, '{'])
         @mode = :content if @brace_level > 1 || @brace_level == 1 && active?(:comment)
       when @scanner.scan(Lexer.patterns[:rbrace])
         @brace_level -= 1
-        push([:RBRACE,'}'])
+        push([:RBRACE, '}'])
         return leave_object if @brace_level == 0
         return error_unbalanced_braces if @brace_level < 0
       when @scanner.scan(Lexer.patterns[:eq])
-        push([:EQ,'='])
+        push([:EQ, '='])
       when @scanner.scan(Lexer.patterns[:comma])
-        push([:COMMA,','])
+        push([:COMMA, ','])
       when @scanner.scan(Lexer.patterns[:number])
-        push([:NUMBER,@scanner.matched])
+        push([:NUMBER, @scanner.matched])
       when @scanner.scan(Lexer.patterns[:name])
-        push([:NAME,@scanner.matched.rstrip])
+        push([:NAME, @scanner.matched.rstrip])
       when @scanner.scan(Lexer.patterns[:quote])
         @mode = :literal
       when @scanner.scan(Lexer.patterns[:sharp])
-        push([:SHARP,'#'])
+        push([:SHARP, '#'])
       when @scanner.scan(Lexer.patterns[:object])
         enter_object
       when @scanner.scan(Lexer.patterns[:space])
@@ -215,10 +219,10 @@ module BibTeX
     def parse_meta
       match = @scanner.scan_until(Lexer.patterns[strict? ? :strict_next : :next])
       if @scanner.matched
-        push([:META_CONTENT,match.chop])
+        push([:META_CONTENT, match.chop])
         enter_object
       else
-        push([:META_CONTENT,@scanner.rest])
+        push([:META_CONTENT, @scanner.rest])
         @scanner.terminate
       end
     end
@@ -228,26 +232,25 @@ module BibTeX
       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])
-          push([:RBRACE,'}'])
+        if @brace_level == 0
+          push([:CONTENT, match.chop])
+          push([:RBRACE, '}'])
           leave_object
-        when @brace_level == 1 && !active?(:comment)
-          push([:CONTENT,match.chop])
-          push([:RBRACE,'}'])
+        elsif @brace_level == 1 && !active?(:comment)
+          push([:CONTENT, match.chop])
+          push([:RBRACE, '}'])
           @mode = :bibtex
-        when @brace_level < 0
-          push([:CONTENT,match.chop])
+        elsif @brace_level < 0
+          push([:CONTENT, match.chop])
           error_unbalanced_braces
         else
-          push([:CONTENT,match])
+          push([:CONTENT, match])
         end
       else
-        push([:CONTENT,@scanner.rest])
+        push([:CONTENT, @scanner.rest])
         @scanner.terminate
         error_unterminated_content
       end
@@ -258,24 +261,24 @@ module BibTeX
       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])
+          push([:STRING_LITERAL, match.chop])
           @mode = :bibtex
         else
-          push([:STRING_LITERAL,match])
+          push([:STRING_LITERAL, match])
         end
       else
-        push([:STRING_LITERAL,@scanner.rest])
+        push([:STRING_LITERAL, @scanner.rest])
         @scanner.terminate
         error_unterminated_string
       end
@@ -284,31 +287,28 @@ module BibTeX
     # Called when the lexer encounters a new BibTeX object.
     def enter_object
       @brace_level = 0
-      push [:AT,'@']
+      push [:AT, '@']
 
-      case
-      when @scanner.scan(Lexer.patterns[:string])
+      if @scanner.scan(Lexer.patterns[:string])
         @mode = @active_object = :string
         push [:STRING, @scanner.matched]
-      when @scanner.scan(Lexer.patterns[:preamble])
+      elsif @scanner.scan(Lexer.patterns[:preamble])
         @mode = @active_object = :preamble
         push [:PREAMBLE, @scanner.matched]
-      when @scanner.scan(Lexer.patterns[:comment])
+      elsif @scanner.scan(Lexer.patterns[:comment])
         @mode = @active_object = :comment
         push [:COMMENT, @scanner.matched]
-      when @scanner.scan(Lexer.patterns[:entry])
+      elsif @scanner.scan(Lexer.patterns[:entry])
         @mode = @active_object = :entry
         push [:NAME, @scanner.matched]
 
         # TODO: DRY - try to parse key
         if @scanner.scan(Lexer.patterns[:lbrace])
           @brace_level += 1
-          push([:LBRACE,'{'])
+          push([:LBRACE, '{'])
           @mode = :content if @brace_level > 1 || @brace_level == 1 && active?(:comment)
 
-          if @scanner.scan(Lexer.patterns[allow_missing_keys? ? :optional_key : :key])
-            push [:KEY, @scanner.matched.chop.strip]
-          end
+          push [:KEY, @scanner.matched.chop.strip] if @scanner.scan(Lexer.patterns[allow_missing_keys? ? :optional_key : :key])
         end
 
       else
@@ -318,7 +318,9 @@ module BibTeX
 
     # Called when parser leaves a BibTeX object.
     def leave_object
-      @mode, @active_object, @brace_level = :meta, nil, 0
+      @mode = :meta
+      @active_object = nil
+      @brace_level = 0
     end
 
     def error_unbalanced_braces
@@ -348,11 +350,9 @@ module BibTeX
 
     def backtrace(error)
       bt = []
-      bt.unshift(@stack.pop) until @stack.empty? || (!bt.empty? && [:AT,:META_CONTENT].include?(bt[0][0]))
+      bt.unshift(@stack.pop) until @stack.empty? || (!bt.empty? && %i[AT META_CONTENT].include?(bt[0][0]))
       bt << error
-      push [:ERROR,bt]
+      push [:ERROR, bt]
     end
-
   end
-
 end

data/lib/bibtex/names.rb

@@ -19,7 +19,6 @@
 require 'forwardable'
 
 module BibTeX
-
   # A BibTeX Names value is an ordered list of name values.
   class Names < Value
     include Enumerable
@@ -28,7 +27,7 @@ module BibTeX
 
     def self.parse(string)
       new(NameParser.new.parse(string))
-    rescue => e
+    rescue StandardError => e
       BibTeX.log.info(e.message)
       nil
     end
@@ -40,7 +39,7 @@ module BibTeX
       end
     end
 
-    def replace(*arguments)
+    def replace(*_arguments)
       self
     end
 
@@ -53,7 +52,8 @@ module BibTeX
     end
 
     def to_s(options = {})
-      return value unless options.has_key?(:quotes)
+      return value unless options.key?(:quotes)
+
       q = [options[:quotes]].flatten
       [q[0], value, q[-1]].compact.join
     end
@@ -82,14 +82,13 @@ module BibTeX
     end
 
     def strip_braces
-      gsub!(/\{|\}/,'')
+      gsub!(/\{|\}/, '')
     end
 
     def add(name)
-      case
-      when name.is_a?(Name)
+      if name.is_a?(Name)
         @tokens << name
-      when name.respond_to?(:to_s)
+      elsif name.respond_to?(:to_s)
         @tokens += Names.parse(name.to_s)
       else
         raise ArgumentError, "failed to add #{name.inspect}: not a name."
@@ -100,7 +99,7 @@ module BibTeX
     alias << add
     alias push add
 
-    [:convert!, :rename_if, :rename_unless, :extend_initials].each do |method_id|
+    %i[convert! rename_if rename_unless extend_initials].each do |method_id|
       define_method(method_id) do |*arguments|
         tokens.each { |t| t.send(method_id, *arguments) }
         self
@@ -108,9 +107,8 @@ module BibTeX
     end
 
     def <=>(other)
-      other.respond_to?(:to_a) ? to_a <=> other.to_a  : super
+      other.respond_to?(:to_a) ? to_a <=> other.to_a : super
     end
-
   end
 
   # A Name comprises individual name parts (first, last, prefix and suffix),
@@ -120,14 +118,14 @@ module BibTeX
     include Comparable
 
     BibTeXML = {
-      :first  => :first,
-      :last   => :last,
-      :prefix => :prelast,
-      :suffix => :lineage
+      first: :first,
+      last: :last,
+      prefix: :prelast,
+      suffix: :lineage
     }.freeze
 
     def_delegators :to_s, :=~, :===,
-      *String.instance_methods(false).reject { |m| m =~ /^\W|to_s|replace|each|first|last|!$/ }
+                   *String.instance_methods(false).reject { |m| m =~ /^\W|to_s|replace|each|first|last|!$/ }
 
     class << self
       def parse(string)
@@ -146,7 +144,7 @@ module BibTeX
     end
 
     def initialize_copy(other)
-      other.each_pair do |k,v|
+      other.each_pair do |k, v|
         self[k] = v.dup unless v.nil?
       end
     end
@@ -185,7 +183,7 @@ module BibTeX
     # Sets the name's first name to the passed-in name if the last name equals
     # for_last and the current first name has the same initials as with_first.
     def extend_initials(with_first, for_last)
-      rename_if :first => with_first do |name|
+      rename_if first: with_first do |name|
         if name.last == for_last
           mine = name.initials.split(/\.[^[:alpha:]]*/)
           other = initials(with_first).split(/\.[^[:alpha:]]*/)
@@ -256,20 +254,20 @@ module BibTeX
       xml = REXML::Element.new('bibtex:person')
 
       each_pair do |part, text|
-        unless text.nil?
-          element = REXML::Element.new("bibtex:#{BibTeXML[part]}")
-          element.text = text
-          xml.add_element(element)
-        end
+        next if text.nil?
+
+        element = REXML::Element.new("bibtex:#{BibTeXML[part]}")
+        element.text = text
+        xml.add_element(element)
       end
 
       xml
     end
 
-    [:strip!, :upcase!, :downcase!, :sub!, :gsub!, :chop!, :chomp!, :rstrip!].each do |method_id|
+    %i[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) unless part.nil?
+          part&.send(method_id, *arguments, &block)
         end
         self
       end
@@ -281,9 +279,8 @@ module BibTeX
 
     def convert!(*filters)
       filters.flatten.each do |filter|
-
         f = Filters.resolve(filter) ||
-          raise(ArgumentError, "Failed to load filter #{filter.inspect}")
+            raise(ArgumentError, "Failed to load filter #{filter.inspect}")
 
         each_pair do |k, v|
           self[k] = f.apply(v) unless v.nil?
@@ -310,6 +307,5 @@ module BibTeX
     alias jr= suffix=
     alias von prefix
     alias von= prefix=
-
   end
 end