bibtex_to_scrapbox 0.1.0

data/gems/gems/bibtex-ruby-4.4.4/features/strings.feature

@@ -0,0 +1,53 @@
+Feature: BibTeX Strings
+	As a hacker who works with bibliographies
+	I want to be able to parse BibTeX files containing string assignments
+
+	@string
+	Scenario: A BibTeX file with string assignments
+		When I parse the following file:
+		"""
+		%%
+		%% This is a valid BibTeX file
+		%% String assignments Test
+		%%
+
+		@string{foo="bar"}
+		@ string{foo="bar"}
+		@string {foo="bar"}
+		@string{ foo="bar"}
+		@string{foo ="bar"}
+		@string{foo= "bar"}
+		@string{foo="bar" }
+		@ string { foo = "bar" }
+		@string   { foo=   "bar"}
+		@string{ foo = "bar" }
+
+		@string{foo="bar"}
+		@string{foo="'bar'"}
+		@string{foo="{"}bar{"}"}
+
+		Using some interesting symbols
+		@string{foo="@bar@"}
+		@string{foo="'bar'"}
+		@string{foo="{"}bar{"}"}
+		@string{foo="{bar}"}
+		"""
+		Then my bibliography should contain the following objects:
+			| type     | value     |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | bar       |
+			| string   | 'bar'     |
+			| string   | {"}bar{"} |
+			| string   | @bar@     |
+			| string   | 'bar'     |
+			| string   | {"}bar{"} |
+			| string   | {bar}     |

data/gems/gems/bibtex-ruby-4.4.4/features/support/env.rb

@@ -0,0 +1,21 @@
+begin
+  require 'simplecov'
+  require 'coveralls' if ENV['CI']
+rescue LoadError
+  # ignore
+end
+
+begin
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    require 'rubinius-debugger'
+  else
+    require 'debugger'
+  end
+rescue LoadError
+  # ignore
+end
+
+require 'minitest/unit'
+require 'bibtex'
+
+World(MiniTest::Assertions)

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

@@ -0,0 +1,83 @@
+#--
+# 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 'digest/md5'
+require 'forwardable'
+require 'logger'
+require 'open-uri'
+
+require 'json'
+
+require 'bibtex/version'
+
+# = BibTeX
+#
+# This module encompasses a parser for BibTeX files and
+# an API to the individual BibTeX objects: +String+,
+# +Preamble+, +Comment+, and +Entry+.
+#
+# Author:: {Sylvester Keil}[http://sylvester.keil.or.at]
+# Copyright:: Copyright (c) 2010-2014 Sylvester Keil
+# License:: GNU GPL 3.0
+#
+module BibTeX
+
+	#
+	# An instance of the Ruby core class +Logger+.
+	# Used for logging by BibTeX-Ruby.
+	#
+	@log = Logger.new(STDERR)
+	@log.level = ENV.has_key?('DEBUG') ? Logger::DEBUG : Logger::WARN
+	@log.datetime_format = '%Y-%m-%d %H:%M:%S'
+
+  class << self
+    attr_accessor :log
+  end
+
+end
+
+# Load debugger
+# require 'ruby-debug'
+# Debugger.start
+
+require 'bibtex/extensions'
+
+require 'bibtex/value'
+require 'bibtex/filters'
+require 'bibtex/name_parser'
+
+require 'bibtex/compatibility'
+
+require 'bibtex/names'
+require 'bibtex/replaceable'
+require 'bibtex/elements'
+require 'bibtex/entry'
+require 'bibtex/entry/bibtexml_converter'
+require 'bibtex/entry/citeproc_converter'
+require 'bibtex/error'
+require 'bibtex/parser'
+require 'bibtex/bibliography'
+require 'bibtex/utilities'
+
+begin
+  require 'rdf'
+  require 'bibtex/entry/rdf_converter'
+  require 'bibtex/bibliography/rdf_converter'
+rescue LoadError
+# ignored
+end

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

@@ -0,0 +1,594 @@
+#--
+# 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 Bibliography class models a BibTeX bibliography;
+  # typically, it corresponds to a `.bib' file.
+  #
+  class Bibliography
+    extend Forwardable
+
+    include Enumerable
+    include Comparable
+
+    @defaults = { :parse_names => true, :parse_months => true }.freeze
+
+    class << self
+
+      attr_reader :defaults
+
+      # Opens and parses the `.bib' file at the given +path+. Returns
+      # a new Bibliography instance corresponding to the file, or, if a block
+      # is given, yields the instance to the block, ensuring that the file
+      # is saved after the block's execution (use the :out option if you want
+      # to specify a save path other than the path from where the file is
+      # loaded).
+      #
+      # The options argument is passed on to BibTeX::Parser.new. Additional
+      # option parameters are:
+      #
+      # -:parse_names: set to false to disable automatic name parsing
+      # -:parse_months: set to false to disable automatic month conversion
+      # -:filter: convert all entries using the sepcified filter (not set by default)
+      #
+      def open(path, options = {})
+        b = parse(Kernel.open(path, 'r:UTF-8').read, options)
+        b.path = path
+        return b unless block_given?
+
+        begin
+          yield b
+        ensure
+          b.save_to(options[:out] || path)
+        end
+      end
+
+      # Parses the given string and returns a corresponding Bibliography instance.
+      def parse(input, options = {})
+        case input
+        when Array, Hash, Element
+          Bibliography.new(options).add(input)
+        when ::String
+          Parser.new(options).parse(input) || Bibliography.new(options)
+        else
+          raise ArgumentError, "failed to parse #{input.inspect}"
+        end
+      end
+
+      # Defines a new accessor that selects elements by type.
+      def attr_by_type(*arguments)
+        arguments.each do |type|
+          method_id = "#{type}s"
+          define_method(method_id) { find_by_type(type) } unless respond_to?(method_id)
+        end
+      end
+    end
+
+    attr_accessor :path
+
+    attr_reader :data, :strings, :entries, :errors, :options
+
+    attr_by_type :article, :book, :journal, :collection, :preamble,
+      :comment, :meta_content
+
+    def_delegators :@data, :length, :size, :empty?
+    def_delegators :@entries, :key?, :has_key?, :values_at
+
+    alias entries_at values_at
+
+    # Creates a new bibliography.
+    def initialize(options = {})
+      @options = Bibliography.defaults.merge(options)
+      @data, @strings, @errors = [], {}, []
+      @entries = Hash.new { |h,k| h.fetch(k.to_s, nil) }
+
+      yield self if block_given?
+    end
+
+    def initialize_copy(other)
+      @options = other.options.dup
+      @errors = other.errors.dup
+      @data, @strings = [], {}
+      @entries = Hash.new { |h,k| h.fetch(k.to_s, nil) }
+
+      other.each do |element|
+        add element.dup
+      end
+
+      self
+    end
+
+    # Adds a new element, or a list of new elements to the bibliography.
+    # Returns the Bibliography for chainability.
+    def add(*arguments)
+      Element.parse(arguments.flatten, @options).each do |element|
+        data << element.added_to_bibliography(self)
+      end
+      self
+    end
+
+    alias << add
+    alias push add
+
+
+    # Saves the bibliography to the current path.
+    def save(options = {})
+      save_to(@path, options)
+    end
+
+    # Saves the bibliography to a file at the given path. Returns the bibliography.
+    def save_to(path, options = {})
+      options[:quotes] ||= %w({ })
+
+      File.open(path, 'w:UTF-8') do |f|
+        f.write(to_s(options))
+      end
+
+      self
+    end
+
+
+    def each
+      if block_given?
+        data.each(&Proc.new)
+        self
+      else
+        to_enum
+      end
+    end
+
+
+    def parse_names
+      entries.each_value { |e| e.parse_names }
+      self
+    end
+
+    def parse_months
+      entries.each_value { |e| e.parse_month }
+      self
+    end
+
+
+    # Converts all enties using the given filter(s). If an optional block is given
+    # the block is used as a condition (the block will be called with each
+    # entry). @see Entry#convert!
+    def convert(*filters)
+      filters = filters.flatten.map { |f| Filters.resolve!(f) }
+
+      entries.each_value do |entry|
+        entry.convert!(*filters) if !block_given? || yield(entry)
+      end
+
+      self
+    end
+
+
+    # Deletes an object, or a list of objects from the bibliography.
+    # If a list of objects is to be deleted, you can either supply the list
+    # of objects or use a query or block to define the list.
+    #
+    # Returns the object (or the list of objects) that were deleted; nil
+    # if the object was not part of the bibliography.
+    def delete(*arguments, &block)
+      objects = q(*arguments, &block).map { |o| o.removed_from_bibliography(self) }
+      @data = @data - objects
+      objects.length == 1 ? objects[0] : objects
+    end
+
+    alias remove delete
+    alias rm delete
+
+
+    # call-seq:
+    # >> bib[-1]
+    # => Returns the last element of the Bibliography or nil
+    # >> bib[1,2]
+    # => Returns the second and third elements or nil
+    # >> bib[1..2]
+    # >> Same as above
+    # >> bib[:key]
+    # => Returns the first entry with key 'key' or nil
+    # >> bib['key']
+    # => Same as above
+    # >> bib['@article']
+    # => Returns all entries of type 'article' or []
+    # >> bib['@preamble']
+    # => Returns all preamble objects (this is the same as Bibliography#preambles) or []
+    # >> bib[/ruby/]
+    # => Returns all objects that match 'ruby' anywhere or []
+    # >> bib['@book[keywords=ruby]']
+    # => Returns all books whose keywords attribute equals 'ruby' or []
+    #
+    # Returns an element or a list of elements according to the given index,
+    # range, or query. Contrary to the Bibliography#query this method does
+    # not yield to a block for additional refinement of the query.
+    #
+    def [](*arguments)
+      raise(ArgumentError, "wrong number of arguments (#{arguments.length} for 1..2)") unless arguments.length.between?(1,2)
+
+      case
+      when arguments[0].is_a?(Numeric) || arguments[0].is_a?(Range)
+        data[*arguments]
+      when arguments.length == 1
+        case
+        when arguments[0].nil?
+          nil
+        when arguments[0].respond_to?(:empty?) && arguments[0].empty?
+          nil
+        when arguments[0].is_a?(Symbol)
+          entries[arguments[0]]
+        when arguments[0].respond_to?(:start_with?) && !arguments[0].start_with?('@', '!@')
+          entries[arguments[0]]
+        else
+          query(*arguments)
+        end
+      else
+        query(*arguments)
+      end
+    end
+
+
+    # Returns true if there are object which could not be parsed.
+    def errors?
+      !errors.empty?
+    end
+
+    # Returns true if the +Bibliography+ contains no errors and only
+    # valid BibTeX objects (meta content is ignored).
+    def valid?
+      !errors? && entries.values.all?(&:valid?)
+    end
+
+    # Returns a list of the names of all authors, editors and translators in the Bibliography.
+    def names
+      map(&:names).flatten
+    end
+
+    # Replaces all string symbols which are defined in the bibliography.
+    #
+    # By default symbols in @string, @preamble and entries are replaced; this
+    # behaviour can be changed using the optional query parameter.
+    #
+    # Note that strings are replaced in the order in which they occur in the
+    # bibliography.
+    #
+    # call-seq:
+    # bib.replace #=> replaces all symbols
+    # bib.replace('@string, @preamble')
+    # #=> replaces only symbols in @string and @preamble objects
+    #
+    def replace(filter = '')
+      q(filter) { |e| e.replace(@strings.values) }
+      self
+    end
+
+    alias :replace_strings :replace
+
+    def join(filter = '')
+      q(filter, &:join)
+      self
+    end
+
+    alias join_strings join
+
+    def rename(*arguments, &block)
+      q('@entry') { |e| e.rename(*arguments, &block) }
+      self
+    end
+
+    # call-seq:
+    #   b.extend_initials(['Edgar Allen', 'Poe'], ['Nathaniel', 'Hawthorne'])
+    #   #=> Extends the initials in names like 'E.A. Poe' or 'Hawethorne, N.'
+    #       in the bibliography.
+    #
+    # Extends the initials for the given names. Returns the Bibliography.
+    def extend_initials(*arguments)
+      arguments.each do |with_first, for_last|
+        names.each do |name|
+          name.extend_initials(with_first, for_last)
+        end
+      end
+
+      self
+    end
+
+    # This method combines all names in the bibliography that look identical
+    # when using initials as first names and then tries to extend the first
+    # names for all names in each group to the longest available form.
+    # Returns the bibliography.
+    #
+    # If your bibliography contains the names 'Poe, Edgar A.', 'Poe, E.A.',
+    # and 'Poe, E. A.' calling this method would convert all three names to
+    # 'Poe, Edgar A.'.
+    def extend_initials!
+      groups = Hash.new do |h,k|
+        h[k] = { :prototype => nil, :names => [] }
+      end
+
+      # group names together
+      names.each do |name|
+        group = groups[name.sort_order(:initials => true).downcase]
+        group[:names] << name
+
+        if group[:prototype].nil? || group[:prototype].first.to_s.length < name.first.to_s.length
+          group[:prototype] = name
+        end
+      end
+
+      # extend all names in group to prototype
+      groups.each_value do |group|
+        group[:names].each do |name|
+          name.set(group[:prototype])
+        end
+      end
+
+      self
+    end
+
+    # call-seq:
+    #   b.unify :publisher, /o'?reilly/i, "O'Reilly"
+    #   #=> Unifies the publisher name "O'Reilly" in the bibliography
+    #
+    # Sets all fields matching the passed-in pattern to the supplied value.
+    # If a block is given, each matching entry will be passed to the block
+    # instead. Returns the bibliography.
+    def unify(field, pattern, value = nil)
+      pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
+
+      block = if block_given?
+        Proc.new
+      else
+        Proc.new { |e| e[field] = value }
+      end
+
+      each_entry do |entry|
+        if entry.field?(field) && entry[field].to_s =~ pattern
+          block.call(entry)
+        end
+      end
+
+      self
+    end
+
+    def group_by(*arguments, &block)
+      groups = Hash.new { |h,k| h[k] = [] }
+
+      entries.values.each do |e|
+        groups[e.digest(arguments, &block)] << e
+      end
+
+      groups
+    end
+
+    def sort!(*arguments, &block)
+      data.sort!(*arguments, &block)
+      self
+    end
+
+    def sort(*arguments, &block)
+      dup.sort!(*arguments, &block)
+    end
+
+    def sort_by!(*arguments, &block)
+      data.sort_by!(*arguments, &block)
+      self
+    end
+
+    # Returns a string representation of the bibliography.
+    def to_s(options = {})
+      map { |o| o.to_s(options) }.join
+    end
+
+    def inspect
+      "#<#{self.class} data=[#{length}]>"
+    end
+
+    def to_a(options = {})
+      map { |o| o.to_hash(options) }
+    end
+
+    # Returns a Ruby hash representation of the bibliography.
+    def to_hash(options = {})
+      { :bibliography => map { |o| o.to_hash(options) } }
+    end
+
+    # Returns a YAML representation of the bibliography.
+    def to_yaml(options = {})
+      to_a(options).to_yaml
+    end
+
+    # Returns a JSON representation of the bibliography.
+    def to_json(options = {})
+      ::JSON.dump(to_a(options))
+    end
+
+    # Returns a CiteProc JSON representation of the bibliography. Only BibTeX enrties are exported.
+    def to_citeproc(options = {})
+      q('@entry').map { |o| o.to_citeproc(options) }
+    end
+
+    # Returns a REXML::Document representation of the bibliography using the
+    # BibTeXML format.
+    def to_xml(options = {})
+      require 'rexml/document'
+
+      xml =  REXML::Document.new
+      xml << REXML::XMLDecl.new('1.0','UTF-8')
+
+      root = REXML::Element.new('bibtex:file')
+      root.add_namespace('bibtex', 'http://bibtexml.sf.net/')
+
+      each { |e| root.add_element(e.to_xml(options)) if e.is_a?(Entry) }
+
+      xml.add_element(root)
+      xml
+    end
+
+    # Returns an RDF::Graph representation of the bibliography. The graph
+    # can be serialized using any of the RDF serializer plugins.
+    def to_rdf(options = {})
+      if defined?(::RDF)
+        RDFConverter.convert(self)
+      else
+        BibTeX.log.error 'Please `gem install rdf` for RDF support.'
+      end
+    end
+
+    # call-seq:
+    #   bib.query()          #=> returns all elements
+    #   bib.query('@book')   #=> returns all books
+    #   bib.query('@entry')  #=> returns all entries (books, articles etc.)
+    #   bib.query('@*')      #=> same as above
+    #   bib.query(:first, '@book, @article')
+    #     #=> returns the first book or article or nil
+    #   bib.query('@book[year<=2011], @article)
+    #     #=> returns all books published in 2011 or earlier and all articles
+    #   bib.query('@book, @article) { |o| o.year == '2011' }
+    #     #=> returns all books and articles published in 2011
+    #   bib.query('@book[year=2011], @article[year=2011])
+    #     #=> same as above without using a block
+    #
+    # Returns objects in the Bibliography which match the given selector and,
+    # optionally, the conditions specified in the given block.
+    #
+    # Queries offer syntactic sugar for common enumerator invocations:
+    #
+    #     >> bib.query(:all, '@book')
+    #     => same as bib.select { |b| b.has_type?(:book) }
+    #     >> bib.query('@book')
+    #     => same as above
+    #     >> bib.query(:first, '@book')
+    #     => same as bib.detect { |b| b.has_type?(:book) }
+    #     >> bib.query(:none, '@book')
+    #     => same as bib.reject { |b| b.has_type?(:book) }
+    #
+    def query(*arguments, &block)
+      case arguments.length
+      when 0
+        selector, q = :all, nil
+      when 1
+        selector, q = :all, arguments[0]
+      when 2
+        selector, q = arguments
+      else
+        raise ArgumentError, "wrong number of arguments (#{arguments.length} for 0..2)"
+      end
+
+      filter = block ? Proc.new { |e| e.match?(q) && block.call(e) } :
+        Proc.new { |e| e.match?(q) }
+
+      send(query_handler(selector), &filter)
+    end
+
+    alias q query
+
+    def each_entry
+      if block_given?
+        q('@entry').each(&Proc.new)
+      else
+        q('@entry').to_enum
+      end
+    end
+
+    def find_by_type(*types, &block)
+      q(types.flatten.compact.map { |t| "@#{t}" }.join(', '), &block)
+    end
+
+    alias find_by_types find_by_type
+
+    def <=>(other)
+      other.respond_to?(:to_a) ? to_a <=> other.to_a : nil
+    end
+
+    def select_duplicates_by(*arguments)
+      arguments = [:year, :title] if arguments.empty?
+      block = Proc.new if block_given?
+
+      group_by(*arguments) { |digest, entry|
+
+        # 1.8 compatibility
+        # digest = digest[0] if digest.is_a?(Array)
+
+        digest.gsub(/\s+/, '').downcase
+        digest = block.call(digest, entry) unless block.nil?
+        digest
+
+      }.values.select { |d| d.length > 1 }
+    end
+
+    alias duplicates select_duplicates_by
+
+    def duplicates?
+      !select_duplicates_by.empty?
+    end
+
+    # call-seq:
+    #   bib.uniq!                                 -> bib
+    #   bib.uniq!(:title, :year)                  -> bib
+    #   bib.uniq! { |digest, entry| ... }         -> bib
+    #   bib.uniq!(:title) { |digest, entry| ... } -> bib
+    #
+    # Removes duplicate entries from the Bibliography.
+    #
+    # All arguments given will be used to calculate a digest
+    # for each entry. If a block is given, it will be be passed
+    # the computed digest as well as each entry; the block
+    # must then yield the final digest that will be used to
+    # compute duplicates.
+    #
+    # This method will always retain the first entry and will
+    # discard subsequent duplicates on the basis of each entry's
+    # digest.
+    #
+    # @see Entry#digest
+    # @see @duplicates_by
+    #
+    def uniq!(*arguments, &block)
+      select_duplicates_by(*arguments, &block).each do |dupes|
+        dupes.shift
+        dupes.each do |dupe|
+          self.remove dupe
+        end
+      end
+
+      self
+    end
+
+    # Experimental!
+    # Returns a new Bibliography with all duplicates removed.
+    def uniq(*arguments, &block)
+      dup.uniq!
+    end
+
+    private
+
+    def query_handler(selector)
+      case selector.to_s
+      when /first|distinct|detect/i
+        :detect
+      when /none|reject|not/i
+        :reject
+      else
+        :select
+      end
+    end
+
+  end
+end