bibtex_to_scrapbox 0.1.0

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/names.rb

@@ -0,0 +1,315 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010-2015  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
+
+  # A BibTeX Names value is an ordered list of name values.
+  class Names < Value
+    include Enumerable
+
+    def_delegators :@tokens, :each, :sort
+
+    def self.parse(string)
+      new(NameParser.new.parse(string))
+    rescue => e
+      BibTeX.log.info(e.message)
+      nil
+    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(options = {})
+      @tokens.map { |n| n.to_s(options) }.join(' and ')
+    end
+
+    def to_s(options = {})
+      return value unless options.has_key?(:quotes)
+      q = [options[:quotes]].flatten
+      [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 to_citeproc(options = {})
+      map { |n| n.to_citeproc(options) }
+    end
+
+    def strip_braces
+      gsub!(/\{|\}/,'')
+    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
+
+    [: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
+      end
+    end
+
+    def <=>(other)
+      other.respond_to?(:to_a) ? to_a <=> other.to_a  : super
+    end
+
+  end
+
+  # A Name comprises individual name parts (first, last, prefix and suffix),
+  # but behaves almost like an atomic string value.
+  class Name < Struct.new(:first, :last, :prefix, :suffix)
+    extend Forwardable
+    include Comparable
+
+    BibTeXML = {
+      :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|!$/ }
+
+    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 = {})
+      set(attributes)
+    end
+
+    def initialize_copy(other)
+      other.each_pair do |k,v|
+        self[k] = v.dup unless v.nil?
+      end
+    end
+
+    # Set the name tokens to the values defined in the passed-in hash.
+    def set(attributes = {})
+      attributes.each_pair do |key, value|
+        send("#{key}=", value) if respond_to?(key)
+      end
+
+      self
+    end
+
+    def blank?
+      to_a.compact.empty?
+    end
+
+    # Returns the first name (or the passed-in string) as initials.
+    def initials(token = first)
+      token.to_s.gsub(/([[:upper:]])[^[:upper:]\s-]*\s*/, '\1.')
+    end
+
+    def normalize_initials(token = first)
+      token = token.dup.to_s
+      token.gsub!(/([[:upper:]])([[:upper:]])/, '\1 \2')
+      token.gsub!(/\b([[:upper:]])\b[^[:alpha:]-]*/, '\1.')
+      token.gsub!(/\b([[:upper:]]\.)([[:upper:]][[:lower:]]+)/, '\1 \2')
+      token
+    end
+
+    # Returns true if the first name consists solely of initials.
+    def initials?
+      !(first.nil? || first.empty? || first.to_s =~ /[[:alpha:]]{2,}[^\.]/)
+    end
+
+    # 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|
+        if name.last == for_last
+          mine = name.initials.split(/\.[^[:alpha:]]*/)
+          other = initials(with_first).split(/\.[^[:alpha:]]*/)
+
+          mine == other || mine.length < other.length && mine == other[0, mine.length]
+        end
+      end
+    end
+
+    # Renames the tokens according to the passed-in attributes if all of the
+    # conditions match or if the given block returns true.
+    def rename_if(attributes, conditions = {})
+      if block_given?
+        set(attributes) if yield self
+      else
+        set(attributes) if conditions.all? do |key, value|
+          respond_to?(key) && send(key) == value
+        end
+      end
+
+      self
+    end
+
+    def rename_unless(attributes, conditions = {})
+      if block_given?
+        set(attributes) unless yield self
+      else
+        set(attributes) unless conditions.all? do |key, value|
+          respond_to?(key) && send(key) == value
+        end
+      end
+
+      self
+    end
+
+    # call-seq:
+    #   name.display_order #=> 'Edgar Allen Poe'
+    #   name.display_order :initials => true #=> 'E.A. Poe'
+    #
+    # Returns the name as a string in display order.
+    def display_order(options = {})
+      [options[:initials] ? initials : first, prefix, last, suffix].compact.join(' ')
+    end
+
+    alias display display_order
+
+    # call-seq:
+    #   name.sort_order #=> 'Poe, Edgar Allen'
+    #   name.sort_order :initials => true #=> 'Poe, E.A.'
+    #
+    # Returns the name as a string in sort order.
+    def sort_order(options = {})
+      [[prefix, last].compact.join(' '), suffix, options[:initials] ? initials : first].compact.join(', ')
+    end
+
+    alias to_s sort_order
+
+    def <=>(other)
+      other.is_a?(Name) ? sort_order <=> other.sort_order : super
+    end
+
+    def to_hash
+      Hash[each_pair.to_a]
+    end
+
+    def to_xml
+      require 'rexml/document'
+      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
+      end
+
+      xml
+    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) unless part.nil?
+        end
+        self
+      end
+    end
+
+    def convert(*filters)
+      dup.convert!(*filters)
+    end
+
+    def convert!(*filters)
+      filters.flatten.each do |filter|
+
+        f = Filters.resolve(filter) ||
+          raise(ArgumentError, "Failed to load filter #{filter.inspect}")
+
+        each_pair do |k, v|
+          self[k] = f.apply(v) unless v.nil?
+        end
+      end
+
+      self
+    end
+
+    def to_citeproc(options = {})
+      hash = {}
+      hash['family'] = family unless family.nil?
+      hash['given'] = given unless given.nil?
+      hash['suffix'] = suffix unless suffix.nil?
+      hash[options[:particle] || 'non-dropping-particle'] = prefix unless prefix.nil?
+      hash
+    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/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/names.y

@@ -0,0 +1,267 @@
+#--
+# 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 Names grammar for the parser generator +racc+
+#
+
+# -*- racc -*-
+
+class BibTeX::NameParser
+
+token COMMA UWORD LWORD PWORD ANDFL ANDLF ERROR
+
+expect 0
+
+rule
+
+  result : { result = [] } | names
+
+  names : name       { result = [val[0]] }
+        | names name { result << val[1] }
+
+  name : ANDFL flname { result = Name.new(val[1]) }
+       | ANDLF lfname { result = Name.new(val[1]) }
+
+  flname : word
+         {
+           result = { :last => val[0] }
+         }
+         | u_words word
+         {
+           result = { :first => val[0].join(' '), :last => val[1] }
+         }
+         | u_words von last
+         {
+           result = { :first => val[0].join(' '), :von => val[1], :last => val[2] }
+         }
+         | von last
+         {
+           result = { :von => val[0], :last => val[1] }
+         }
+         | comma
+
+  lfname : lastfirst
+         {
+           result = { :last => val[0][0], :first => val[0][1] }
+         }
+         | von lastfirst
+         {
+           result = { :von => val[0], :last => val[1][0], :first => val[1][1] }
+         }
+         | u_words von lastfirst
+         {
+           result = { :von => val[0..1].join(' '), :last => val[2][0], :first => val[2][1] }
+         }
+         | comma
+
+  comma : last COMMA first
+        {
+          result = { :last => val[0], :jr => val[2][0], :first => val[2][1] }
+        }
+        | von last COMMA first
+        {
+          result = { :von => val[0], :last => val[1], :jr => val[3][0], :first => val[3][1] }
+        }
+        | u_words von last COMMA first
+        {
+          result = { :von => val[0..1].join(' '), :last => val[2], :jr => val[4][0], :first => val[4][1] }
+        }
+
+  von : LWORD
+      | von LWORD         { result = val.join(' ') }
+      | von u_words LWORD { result = val.join(' ') }
+
+  lastfirst : LWORD         { result = [val[0], nil] }
+            | u_words       { result = [val[0][0], val[0][1] ? val[0][1..-1].join(' ') : nil] }
+            | u_words LWORD { result = [val[0][0], (val[0][1..-1] << val[1]).join(' ')] }
+
+  last : LWORD | u_words { result = val[0].join(' ') }
+
+  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[1] }
+
+  u_word : UWORD | PWORD
+
+  words : word
+        | words word { result = val.join(' ') }
+
+  opt_words : /* empty */ | words
+
+  word : LWORD | UWORD | PWORD
+
+end
+
+---- header
+require 'strscan'
+
+---- inner
+
+  @patterns = {
+    :and => /,?\s+and\s+/io,
+    :space => /\s+/o,
+    :comma => /,/o,
+    :lower => /[[:lower:]][[:lower:][:upper:]]*/uo,
+    :upper => /[[:upper:]][[:lower:][:upper:].]*/uo,
+    :other => /[^\s,\{\}\\[:upper:][:lower:]]+/uo,
+    :lbrace => /\{/o,
+    :rbrace => /\}/o,
+    :braces => /[\{\}]/o,
+    :escape => /\\./o,
+    :last_first => /[\p{Han}\p{Hiragana}\p{Katakana}\p{Hangul}]/uo
+  }
+
+  class << self
+    attr_reader :patterns
+  end
+
+  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.debug("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
+    @last_and = 0
+    @stack = [[:ANDFL,'(^start)']]
+    @word = [:PWORD,'']
+    do_scan
+  end
+
+  private
+
+  def do_scan
+    until @src.eos?
+      case
+      when @src.scan(NameParser.patterns[:and])
+        push_word
+        @last_and = @stack.length
+        @stack.push([:ANDFL,@src.matched])
+
+      when @src.skip(NameParser.patterns[:space])
+        push_word
+
+      when @src.scan(NameParser.patterns[:comma])
+        push_word
+        @stack.push([:COMMA,@src.matched])
+
+      when @src.scan(NameParser.patterns[:lower])
+        is_lowercase
+        @word[1] << @src.matched
+
+      when @src.scan(NameParser.patterns[:upper])
+        is_uppercase
+        @word[1] << @src.matched
+
+      when @src.scan(NameParser.patterns[:other])
+        check_name_order
+        @word[1] << @src.matched
+
+      when @src.scan(NameParser.patterns[:lbrace])
+        @word[1] << @src.matched
+        scan_literal
+
+      when @src.scan(NameParser.patterns[:rbrace])
+        error_unbalanced
+
+      when @src.scan(NameParser.patterns[:escape])
+        @word[1] << @src.matched
+
+      else
+        error_invalid
+      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 check_name_order
+    return if RUBY_VERSION < '1.9'
+    @stack[@last_and][0] = :ANDLF if @stack[@last_and][0] != :ANDLF && @src.matched =~ NameParser.patterns[:last_first]
+  end
+
+  def scan_literal
+    @brace_level = 1
+
+    while @brace_level > 0
+      @word[1] << @src.scan_until(NameParser.patterns[:braces]).to_s
+
+      case @src.matched
+      when '{'
+        @brace_level += 1
+      when '}'
+        @brace_level -= 1
+      else
+        @brace_level = 0
+        error_unbalanced
+      end
+    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
+
+  def error_invalid
+    @stack.push [:ERROR,@src.getch]
+    BibTeX.log.warn("NameParser: invalid character at position #{@src.pos}; brace level #{@brace_level}.")
+  end
+
+# -*- racc -*-