bibtex_to_scrapbox 0.1.0

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/bibliography/rdf_converter.rb

@@ -0,0 +1,27 @@
+class BibTeX::Bibliography::RDFConverter
+  # converts a BibTeX Bibliography to RDF
+  # @return [RDF::Graph] the RDF graph of the bibliography
+  def self.convert(bibtex)
+    new(bibtex).convert!
+  end
+
+  # @param [BibTeX::Entry] the bibliography to convert
+  def initialize(bibtex, graph = RDF::Graph.new)
+    @bibtex = bibtex
+    @graph = graph
+    @agent = {}
+  end
+
+  # @return [RDF::Graph] the RDF graph of this bibliography
+  def convert!
+    bibtex.q('@entry').each do |entry|
+      BibTeX::Entry::RDFConverter.convert(entry, graph, agent)
+    end
+
+    graph
+  end
+
+  protected
+
+  attr_reader :bibtex, :graph, :agent
+end

data/gems/gems/bibtex-ruby-4.4.4/lib/bibtex/bibtex.y

@@ -0,0 +1,141 @@
+#--
+# 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::Parser
+
+token AT COMMA COMMENT CONTENT ERROR EQ LBRACE META_CONTENT KEY
+      NAME NUMBER PREAMBLE RBRACE SHARP STRING STRING_LITERAL
+
+expect 0
+
+rule
+
+  bibliography : /* empty */                       { result = BibTeX::Bibliography.new(@options) }
+               | objects                           { result = val[0] }
+
+  objects : object                                 { result = BibTeX::Bibliography.new(@options) << val[0] }
+          | objects object                         { result << val[1] }
+
+  object : AT at_object                            { result = val[1] }
+         | META_CONTENT                            { result = BibTeX::MetaContent.new(val[0]) }
+         | ERROR                                   { result = BibTeX::Error.new(val[0]) }
+
+  at_object : comment                              { result = val[0] }
+            | string                               { result = val[0] }
+            | preamble                             { result = val[0] }
+            | entry                                { result = val[0] }
+
+  comment : COMMENT LBRACE content RBRACE          { result = BibTeX::Comment.new(val[2]) }
+
+  content : /* empty */                            { result = '' }
+          | CONTENT                                { result = val[0] }
+
+  preamble : PREAMBLE LBRACE string_value RBRACE   { result = BibTeX::Preamble.new(val[2]) }
+
+  string : STRING LBRACE string_assignment RBRACE  { result = BibTeX::String.new(val[2][0],val[2][1]); }
+
+  string_assignment : NAME EQ string_value         { result = [val[0].downcase.to_sym, val[2]] }
+
+  string_value : string_literal                    { result = [val[0]] }
+               | string_value SHARP string_literal { result << val[2] }
+
+  string_literal : NAME                            { result = val[0].downcase.to_sym }
+                 | LBRACE content RBRACE           { result = val[1] }
+                 | STRING_LITERAL                  { result = val[0] }
+
+  entry : entry_head assignments RBRACE            { result = val[0] << val[1] }
+        | entry_head assignments COMMA RBRACE      { result = val[0] << val[1] }
+        | entry_head RBRACE                        { result = val[0] }
+
+  entry_head : NAME LBRACE opt_key                 { result = BibTeX::Entry.new(:bibtex_type => val[0].downcase.to_sym, :bibtex_key => val[2]) }
+
+  opt_key :                                        { missing_key }
+          | KEY
+
+  assignments : assignment                         { result = val[0] }
+              | assignments COMMA assignment       { result.merge!(val[2]) }
+
+  assignment : NAME EQ value                       { result = { val[0].downcase.to_sym => val[2] } }
+
+  value : string_value                             { result = val[0] }
+        | NUMBER                                   { result = val[0] }
+
+end
+
+---- header
+require 'bibtex/lexer'
+
+---- inner
+
+  attr_reader :lexer, :options
+
+  @defaults = {
+    :include => [:errors],
+    :allow_missing_keys => false,
+    :debug => false
+  }.freeze
+
+  class << self
+    attr_reader :defaults
+  end
+
+  def initialize(options = {})
+    @options = Parser.defaults.merge(options)
+    @lexer = Lexer.new(@options)
+  end
+
+  def parse(input)
+    @yydebug = debug?
+
+    lexer.analyse(input)
+    do_parse
+    #yyparse(@lexer,:each)
+  end
+
+  def next_token
+    lexer.next_token
+  end
+
+  def debug?
+    options[:debug] || ENV['DEBUG']
+  end
+
+  def allow_missing_keys?
+    options[:allow_missing_keys]
+  end
+
+  def missing_key
+    unless allow_missing_keys?
+      raise ParseError, "Failed to parse BibTeX entry: cite-key missing"
+    end
+  end
+
+  def on_error(tid, val, vstack)
+    message =
+      "Failed to parse BibTeX on value #{val.inspect} (#{token_to_str(tid) || '?'}) #{ vstack.inspect}"
+
+    BibTeX.log.error message
+    raise ParseError, message
+  end
+
+# -*- racc -*-

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

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+module BibTeX
+  begin
+    original_verbosity, $VERBOSE = $VERBOSE, nil
+
+    require 'iconv'
+
+    @iconv = Iconv.new('ascii//translit//ignore', 'utf-8')
+
+    def self.transliterate(str)
+      @iconv.iconv(str)
+    end
+  rescue LoadError
+
+    @iconv_replacements = Hash[*%w(ä ae ö oe ü ue Ä Ae Ö Oe Ü Ue ß ss)]
+
+    # Returns +str+ transliterated containing only ASCII characters.
+    def self.transliterate(str)
+      str.gsub(/[äöüÄÖÜß]/, @iconv_replacements)
+    end
+  ensure
+    $VERBOSE = original_verbosity
+  end
+end

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

@@ -0,0 +1,376 @@
+#--
+# 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/>.
+#++
+
+module BibTeX
+
+  #
+  # The base class for BibTeX objects.
+  #
+  class Element
+    include Comparable
+
+    attr_writer :id
+    attr_reader :bibliography
+
+    # Returns an array of BibTeX elements.
+    def self.parse(input, options = {})
+      case input
+      when Element
+        [input]
+      when Hash
+        [Entry.new(input)]
+      when Array
+        input.inject([]) { |s,a| s.concat(parse(a, options)) }
+      when ::String
+        Parser.new(options).parse(input).data.each do |e|
+          e.parse_names unless !e.respond_to?(:parse_names) || options[:parse_names] == false
+          e.parse_month unless !e.respond_to?(:parse_month) || options[:parse_months] == false
+        end
+      else
+        raise ArgumentError, "failed to parse Element from #{input.inspect}"
+      end
+    end
+
+    # Returns a string containing the object's content.
+    def content(options = {})
+      ''
+    end
+
+    # Returns a string containing the object's content.
+    def values_at(*arguments)
+      []
+    end
+
+    def digest(*arguments)
+      [type, content].join('|')
+    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; 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
+
+    # Returns a list of names for that Element. All Elements except Entries return an empty list.
+    def names
+      []
+    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}?"
+      define_method(method_id) { has_type?(type) } unless method_defined?(method_id)
+    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 Symbol
+        query.to_s == id.to_s
+      when Element
+        query == self
+      when Regexp
+        to_s.match(query)
+      when /^\/(.+)\/$/
+        to_s.match(Regexp.new($1))
+      when /@(\*|\w+)(?:\[([^\]]*)\])?/
+        query.scan(/(!)?@(\*|\w+)(?:\[([^\]]*)\])?/).any? do |non, type, condition|
+          if (non ? !has_type?(type) : has_type?(type))
+            if condition.nil? || condition.empty?
+              true
+            else
+              condition.to_s.split(/\s*\|\|\s*/).any? do |conditions|
+                meets_all? conditions.split(/\s*(?:,|&&)\s*/)
+              end
+            end
+          end
+        end
+      else
+        id.to_s == query
+      end
+    end
+
+    alias === matches?
+    alias match? matches?
+
+    def meets_all?(*conditions)
+      meets? conditions.flatten, :all?
+    end
+    alias meet_all? meets_all?
+
+    def meets_any?(*conditions)
+      meets? conditions.flatten, :any?
+    end
+    alias meet_any? meets_any?
+
+    # Returns true if the element meets all or any of the given conditions.
+    def meets?(conditions, op = :all?)
+      conditions.send(op) do |condition|
+        meets_condition? condition
+      end
+    end
+    alias meet? meets?
+
+    alias to_s content
+
+    def to_hash(options = {})
+      { type => content }
+    end
+
+    def to_yaml(options = {})
+      require 'yaml'
+      to_hash.to_yaml
+    end
+
+    def to_json(options = {})
+      # Some JSON implementations pass an argument
+      # to this method.
+      options = {} unless options.is_a?(::Hash)
+
+      ::JSON.dump(to_hash(options))
+    end
+
+    def to_xml(options = {})
+      require 'rexml/document'
+      xml = REXML::Element.new(type)
+      xml.text = content
+      xml
+    end
+
+    # Called when the element was added to a bibliography.
+    def added_to_bibliography(bibliography)
+      # raise BibTeXError, "failed to add element to Bibliography: already registered with another Bibliography" unless @bibliography.nil?
+      @bibliography = bibliography
+      self
+    end
+
+    # Called when the element was removed from a bibliography.
+    def removed_from_bibliography(bibliography)
+      @bibliography = nil
+      self
+    end
+
+    def <=>(other)
+      return nil unless other.respond_to? :type and other.respond_to? :to_s
+      [type, to_s] <=> [other.type, other.to_s]
+    end
+
+    # Returns the Element as a nicely formatted string.
+    def inspect
+      "#<#{self.class} #{content.gsub(/\n/, ' ')}>"
+    end
+
+    private
+
+    def meets_condition?(condition)
+      property, operator, value = condition.split(/\s*([!~\/\^<>]?=|!~)\s*/)
+
+      if property.nil?
+        true
+      else
+        property.strip!
+        value.strip! unless value.nil?
+
+        if operator.nil? && value.nil?
+          respond_to?(:provides?) && provides?(property)
+        else
+
+          # Hack: we need to get rid of #type returning the bibtex_type,
+          # because type is a valid BibTeX property. This mitigates the
+          # issue but is no fix!
+          if property == 'type'
+            actual = respond_to?(:fields) ? fields[:type] : nil
+          else
+            actual = respond_to?(property) ? send(property) : nil
+          end
+
+          case operator
+          when '!=', '/='
+            actual.nil? || actual.to_s != value
+          when '^='
+            !actual.nil? && actual.to_s.match("^#{value}")
+          when '~='
+            !actual.nil? && actual.to_s.match(value)
+          when '!~'
+            actual.nil? || !actual.to_s.match(value)
+          when '<='
+            !actual.nil? && actual.to_i <= value.to_i
+          when '>='
+            !actual.nil? && actual.to_i >= value.to_i
+          else
+            !actual.nil? && actual.to_s == value
+          end
+        end
+      end
+    end
+  end
+
+
+  #
+  # Represents a @string object.
+  #
+  # In BibTeX @string objects contain a single string constant
+  # assignment. For example, @string{ foo = "bar" } defines the
+  # constant `foo'; this constant can be used (using BibTeX's
+  # string concatenation syntax) in susbsequent
+  # @string and @preamble objects, as well as in field values
+  # of regular entries.
+  #
+  class String < Element
+    include Replaceable
+
+    attr_reader :key
+
+    # Creates a new instance.
+    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 symbol identifying the constant).
+    def 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
+
+    # Retuns the string's value if parameter matches the key; nil otherwise.
+    def [](key)
+      @key == key ? @value : nil
+    end
+
+
+    # Called when the element was added to a bibliography.
+    def added_to_bibliography(bibliography)
+      super
+      bibliography.strings[@key] = self
+      self
+    end
+
+    # Called when the element was removed from a bibliography.
+    def removed_from_bibliography(bibliography)
+      super
+      bibliography.strings[@key] = nil
+      self
+    end
+
+    # Returns a string representation of the @string's content.
+    def content
+      "#@key = #{@value.to_s(:quotes => '"')}"
+    end
+
+    # Returns a string representation of the @string object.
+    def to_s(options = {})
+      "@string{ #{content} }\n"
+    end
+
+    def to_hash(options = {})
+      { :string => { @key => @value.to_s(:quotes => '"') } }
+    end
+
+    def to_xml(options = {})
+      require 'rexml/document'
+
+      xml = REXML::Element.new(:string)
+
+      k, v = REXML::Element.new(:key), REXML::Element.new(:value)
+      k.text = key.to_s
+      v.text = value.to_s(:quotes => '"')
+
+      xml.add_elements(k)
+      xml.add_elements(v)
+
+      xml
+    end
+  end
+
+  #
+  # Represents a @preamble object.
+  #
+  # In BibTeX an @preamble object contains a single string literal,
+  # a single constant, or a concatenation of string literals and
+  # constants.
+  class Preamble < Element
+    include Replaceable
+
+    # Creates a new instance.
+    def initialize(value = '')
+      @value = Value.new(value)
+    end
+
+    # Returns a string representation of the @preamble's content.
+    def content
+      @value.to_s(:quotes => '"')
+    end
+
+    # Returns a string representation of the @preamble object
+    def to_s(options = {})
+      "@preamble{ #{content} }\n"
+    end
+  end
+
+  # Represents a @comment object.
+  class Comment < Element
+    attr_accessor :content
+
+    def initialize(content = '')
+      @content = content
+    end
+
+    def to_s(options = {})
+      "@comment{ #@content }\n"
+    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' content. If you
+  # want the parser to include +MetaComment+ objects, you
+  # need to add +:meta_content+ to the parser's +:include+
+  # option.
+  class MetaContent < Element
+    attr_accessor :content
+
+    def initialize(content = '')
+      @content = content
+    end
+
+    def to_s(options = {}); @content; end
+  end
+
+end