bibtex_to_scrapbox 0.1.0

data/gems/gems/bibtex-ruby-4.4.4/test/bibtex/test_string.rb

@@ -0,0 +1,83 @@
+require 'helper.rb'
+
+module BibTeX
+  class StringTest < Minitest::Spec
+
+    describe 'when parsing a simple string' do
+      before do
+        @bib = BibTeX.parse('@string{ foo = "bar" }')
+      end        
+      it 'should should not be empty' do
+        assert_equal 1, @bib.length
+      end
+      it 'should have a symbol as key' do
+        assert_equal :foo, @bib[0].key
+      end
+      it 'should have a value string' do
+        assert_equal 'bar', @bib[0].value.to_s
+      end
+      it 'should have been registered' do
+        refute @bib.strings[:foo].nil?
+      end
+    end
+
+    # 
+    # def test_replacement
+    #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
+    #   refute_nil(bib)
+    #   assert(bib.kind_of?(BibTeX::Bibliography))
+    #   refute(bib.empty?)
+    #   assert_equal(7,bib.length)
+    #   assert_equal([BibTeX::String,BibTeX::Preamble,BibTeX::Entry], bib.data.map(&:class).uniq) 
+    #   assert_equal(["foo"], bib.strings[:foo])
+    #   assert_equal(["bar"], bib.strings[:bar])
+    #   assert_equal([:foo, "bar"], bib.strings[:foobar])
+    #   assert_equal([:foobar, :foo], bib.strings[:foobarfoo])
+    #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # foo # foobarfoo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:preamble]})
+    #   assert_equal(["foo"], bib.strings[:foo])
+    #   assert_equal(["bar"], bib.strings[:bar])
+    #   assert_equal([:foo, "bar"], bib.strings[:foobar])
+    #   assert_equal([:foobar, :foo], bib.strings[:foobarfoo])
+    #   assert_equal([:bar, "foo", :bar], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:string]})
+    #   assert_equal(['foo','bar'], bib.strings[:foobar])
+    #   assert_equal(['foo', 'bar','foo'], bib.strings[:foobarfoo])
+    #   assert_equal(['bar','foo','bar'], bib.strings[:barfoobar])
+    #   assert_equal('"foo" # "foo" # foobar # foo # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # barfoobar', bib[:'manual:1'].title)
+    # 
+    #   bib.replace_strings({ :filter => [:preamble,:entry]})
+    #   assert_equal('"foo" # "foo" # "foo" # "bar" # "foo" # "bar"', bib.preambles[0].content)
+    #   assert_equal('"foo" # "bar" # "foo" # "bar"', bib[:'manual:1'].title)
+    # end
+    #   
+    # def test_roundtrip
+    #   bib = BibTeX::Bibliography.open(Test.fixtures(:string_replacement), :debug => false)
+    #   refute_nil(bib)
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = foo # "bar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = foobar # foo }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = bar # "foo" # bar }', bib.data[4].to_s)
+    #   bib.replace_strings
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = "foo" # "bar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = "foo" # "bar" # "foo" }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = "bar" # "foo" # "bar" }', bib.data[4].to_s)
+    #   bib.join_strings
+    #   assert_equal('@string{ foo = "foo" }', bib.data[0].to_s)
+    #   assert_equal('@string{ bar = "bar" }', bib.data[1].to_s)
+    #   assert_equal('@string{ foobar = "foobar" }', bib.data[2].to_s)
+    #   assert_equal('@string{ foobarfoo = "foobarfoo" }', bib.data[3].to_s)
+    #   assert_equal('@string{ barfoobar = "barfoobar" }', bib.data[4].to_s)
+    # end
+  end
+end

data/gems/gems/bibtex-ruby-4.4.4/test/bibtex/test_utilities.rb

@@ -0,0 +1,34 @@
+require 'helper.rb'
+
+module BibTeX
+
+  class TestBibtex < Minitest::Unit::TestCase
+
+    def test_empty?
+      assert BibTeX.open(Test.fixtures(:empty)).empty?
+      refute BibTeX.open(Test.fixtures(:bibdesk)).empty?
+    end
+
+    def test_parse
+      bib = BibTeX.parse %q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia" } ]
+      assert_equal 1, bib.length
+      assert_equal 'Ligeia', bib[:id].title
+      assert_equal 'Poe, Edgar Allen', bib[:id].author.to_s
+    end
+
+    def test_validation
+      log_level = BibTeX.log.level
+      BibTeX.log.level = Logger::ERROR
+
+      refute BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia" } ]).valid?
+      assert BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      assert BibTeX.parse(%q[ @book{ id, editor = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      refute BibTeX.parse(%q[ @book{ id, xxxxxx = {Poe, Edgar Allen}, title = "Ligeia", publisher = "Penguin", year = 1996 } ]).valid?
+      refute BibTeX.parse(%q[ @book{ id, author = {Poe, Edgar Allen}, title = "Lig"eia", publisher = "Penguin", year = 1996 } ]).valid?
+      assert BibTeX.valid?(Test.fixtures(:bibdesk))
+
+      BibTeX.log.level = log_level
+    end
+  end
+
+end

data/gems/gems/bibtex-ruby-4.4.4/test/bibtex/test_value.rb

@@ -0,0 +1,189 @@
+require 'helper.rb'
+
+class Upcase < BibTeX::Filter
+  def apply(value)
+    value.is_a?(::String) ? value.upcase : value
+  end
+end
+
+class SuffixA < BibTeX::Filter
+  def apply(value)
+    value.is_a?(::String) ? "#{value}a" : value
+  end
+end
+
+module BibTeX
+  class ValueTest < Minitest::Spec
+
+    describe "::create" do
+      it "should return a duplicate when called with a Value subclass" do
+        val   = Value.new('value')
+        names = Names.new(Name.new(:first => 'first_name'))
+
+        assert_equal val.dup,   Value.create(val)
+        assert_equal names.dup, Value.create(names)
+      end
+
+      it "should return a new Value object when called with other arguments" do
+        assert_equal Value.new('value'), Value.create('value')
+      end
+    end
+
+    describe "when empty" do
+      it "should be equal to an empty string" do
+        assert Value.new == ''
+        assert Value.new('') == ''
+      end
+      it "should be empty" do
+        assert Value.new.empty?
+        assert Value.new('').empty?
+      end
+      it "should match an empty pattern" do
+        assert Value.new =~ //
+        assert Value.new('') =~ //
+      end
+    end
+
+    describe "#join" do
+      it "should return empty string when empty" do
+        assert_equal '', Value.new.join.to_s
+        assert_equal '', Value.new('').join.to_s
+      end
+      it "should return the string if atomic" do
+        assert_equal 'foo', Value.new('foo').join.to_s
+      end
+      it "should return a string concatenation of all strings when containing only strings" do
+        assert_equal 'foobar', Value.new('foo', 'bar').join.to_s
+        assert_equal 'foobar', Value.new(['foo', 'bar']).join.to_s
+      end
+      it "should should be atomic after join when containing only strings" do
+        refute Value.new('foo', 'bar').atomic?
+        assert Value.new('foo', 'bar').join.atomic?
+      end
+      it "should do nothing when containing only symbols" do
+        value = Value.new(:foo)
+        assert_equal value, value.join
+        value = Value.new(:foo, :bar)
+        assert_equal value, value.join
+      end
+      it "should do nothing when containing only symbols and a single string" do
+        value = Value.new(:foo, 'bar')
+        assert_equal value, value.join
+        value = Value.new('foo', :bar)
+        assert_equal value, value.join
+      end
+    end
+
+    describe '#merge!' do
+      it 'merges two strings by combining them' do
+        assert_equal '"foo" # "bar"', Value.new('foo').merge!(Value.new('bar')).to_s
+      end
+
+      it 'does not duplicate existing tokens' do
+        assert_equal 'foo', Value.new('foo').merge!(Value.new('foo')).to_s
+      end
+    end
+
+    describe "#to_s" do
+      it "should return the string if atomic" do
+        assert_equal 'foo bar', Value.new('foo bar').to_s
+      end
+      it "should return the symbol as string when containing only a single symbol" do
+        assert_equal 'foo', Value.new(:foo).to_s
+      end
+      it "should return all string tokens concatenated by #" do
+        assert_equal '"foo" # "bar"', Value.new('foo', 'bar').to_s
+      end
+      it "should return all symbol tokens concatenated by #" do
+        assert_equal 'foo # bar', Value.new(:foo, :bar).to_s
+      end
+      it "should return all symbol and string tokens concatenated by #" do
+        assert_equal 'foo # "bar"', Value.new(:foo, 'bar').to_s
+        assert_equal '"foo" # bar', Value.new('foo', :bar).to_s
+      end
+    end
+
+    describe "conversions" do
+      before do
+        @values = [Value.new('foo'), Value.new('foo', :bar)]
+      end
+
+      describe "#convert" do
+        it "converts the value when given a filter instance" do
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase.instance).to_s }
+        end
+
+        it "converts the value when given a filter class" do
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(Upcase).to_s }
+        end
+
+        it "converts the value when given the name of a filter" do
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert(:upcase).to_s }
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert('upcase').to_s }
+          assert_equal ['fooa', '"fooa" # bar'], @values.map { |v| v.convert('suffixa').to_s }
+        end
+
+        it "applies multiple filters in the order passed" do
+          @values.map { |v| v.convert(:upcase, :suffixa).to_s }.must_equal ['FOOa', '"FOOa" # bar']
+          @values.map { |v| v.convert(:suffixa, :upcase).to_s }.must_equal ['FOOA', '"FOOA" # bar']
+        end
+
+        it "converts the value when using a ghost method" do
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert_upcase.to_s }
+        end
+
+        it "does not alter the value when using a filter name" do
+          @values.each { |v| v.convert(:upcase) }
+          assert_equal ['foo', '"foo" # bar'], @values.map(&:to_s)
+        end
+
+        it "does not alter the value when using a ghost method" do
+          @values.each { |v| v.convert_upcase }
+          assert_equal ['foo', '"foo" # bar'], @values.map(&:to_s)
+        end
+
+        it "raises argument error when a filter cannot be resolved" do
+          assert_raises ArgumentError do
+            @values[0].convert(:foo)
+          end
+
+          assert_raises ArgumentError do
+            @values[0].convert(:upcase, :foo)
+          end
+        end
+      end
+
+      describe "#convert!" do
+        it "converts the value when given the name of a filter" do
+          assert_equal ['FOO', '"FOO" # bar'], @values.map { |v| v.convert!(:upcase).to_s }
+        end
+
+        it "alters the value when given the name of a filter" do
+          @values.each { |v| v.convert!(:upcase) }
+          assert_equal ['FOO', '"FOO" # bar'], @values.map(&:to_s)
+        end
+
+        it "alters the value when using a ghost method" do
+          @values.each { |v| v.convert_upcase! }
+          assert_equal ['FOO', '"FOO" # bar'], @values.map(&:to_s)
+        end
+      end
+
+      describe "value" do
+        it 'returns numbers as strings' do
+          assert Value.new(42).v.is_a?(::String)
+          assert Value.new(-42).v.is_a?(::String)
+          assert Value.new('a42').v.is_a?(::String)
+        end
+      end
+
+      describe "#to_s" do
+        it 'accepts a :filter option and convert the values accordingly without changing the value' do
+          assert_equal '"FOO" # bar', @values[1].to_s(:filter => :upcase)
+          assert_equal '"foo" # bar', @values[1].to_s
+        end
+      end
+    end
+
+  end
+end

data/gems/gems/bibtex-ruby-4.4.4/test/fixtures/bibdesk.bib

@@ -0,0 +1,50 @@
+%% This BibTeX bibliography file was created using BibDesk.
+%% http://bibdesk.sourceforge.net/
+
+
+%% Created for Sylvester Keil at 2010-08-05 10:07:07 +0200 
+
+
+%% Saved with string encoding Unicode (UTF-8) 
+
+
+
+@book{rails,
+	Address = {Raleigh, North Carolina},
+	Author = {Ruby, Sam, and Thomas, Dave, and Hansson Heinemeier, David},
+	Booktitle = {Agile Web Development with Rails},
+	Date-Added = {2010-08-05 10:01:36 +0200},
+	Date-Modified = {2010-08-05 10:06:46 +0200},
+	Edition = {third},
+	Isbn = {978-1-9343561-6-6},
+	Keywords = {ruby, rails},
+	Publisher = {The Pragmatic Bookshelf},
+	Series = {The Facets of Ruby},
+	Title = {Agile Web Development with Rails},
+	Year = {2009}
+}
+
+@book{dragon,
+	Address = {Boston},
+	Author = {Aho, Alfred V., and Lam, Monica S., and Ullman, Jeffrey D.},
+	Booktitle = {Compilers: Principles, Techniques, and Tools},
+	Date-Added = {2010-08-05 09:57:15 +0200},
+	Date-Modified = {2010-08-05 10:06:32 +0200},
+	Edition = {second},
+	Keywords = {compiler, lex, yacc},
+	Publisher = {Addison Wesley},
+	Title = {Compilers: Principles, Techniques, and Tools},
+	Year = {2007}
+}
+
+@book{pickaxe,
+	Address = {Raleigh, North Carolina},
+	Author = {Thomas, Dave, and Fowler, Chad, and Hunt, Andy},
+	Date-Added = {2010-08-05 09:54:07 +0200},
+	Date-Modified = {2010-08-05 10:07:01 +0200},
+	Keywords = {ruby},
+	Publisher = {The Pragmatic Bookshelf},
+	Series = {The Facets of Ruby},
+	Title = {Programming Ruby 1.9: The Pragmatic Programmer's Guide},
+	Year = {2009}
+}

data/gems/gems/bibtex-ruby-4.4.4/test/fixtures/comment.bib

@@ -0,0 +1,15 @@
+%
+% A valid BibTeX file
+%
+
+% Simple comments
+
+@comment{ A comment can contain pretty much anything }
+
+Here a comment is used to comment out otherwise valid
+entries:
+@comment{
+@string{ foo = "bar" }
+
+@string{ bar = "foo" }
+}

data/gems/gems/bibtex-ruby-4.4.4/test/fixtures/decoret.bib

@@ -0,0 +1,83 @@
+%%
+%% This BibTeX file contains all the examples of valid BibTeX objects
+%% in Xavier Decoret's `A summary of BibTeX' at
+%% http://artis.imag.fr/~Xavier.Decoret/resources/xdkbibtex/bibtex_summary.html
+%%
+
+@Article{py03,
+  author = {Xavier D\'ecoret},
+  title  = "PyBiTex",
+  year   = 2003
+}
+
+@Article{key03,
+    title = "A {bunch {of} braces {in}} title"
+}
+
+@Article{key01,
+    author = "Simon {"}the {saint"} Templar", 
+    }
+
+@Article{key01,
+    title = "The history of @ sign"
+}
+
+Some {{comments} with unbalanced braces
+....and a "commented" entry...
+
+Book{landru21,
+  author =   {Landru, Henri D\'esir\'e},
+  title =  {A hundred recipes for you wife},
+  publisher =  {Culinary Expert Series},
+  year =   1921
+}
+
+..some other comments..before a valid entry...
+
+@Book{steward03,
+  author =   { Martha Steward },
+  title =  {Cooking behind bars},
+  publisher =  {Culinary Expert Series},
+  year =   2003
+}
+
+...and finally an entry commented by the use of the special Comment entry type.
+
+@Comment{steward03,
+  author =   {Martha Steward},
+  title =  {Cooking behind bars},
+  publisher =  {Culinary Expert Series},
+  year =   2003
+}
+[Note: here BibTeX-Ruby differs from bibtex in that it does not parse
+the nested book as an object, but treats it as a comment!]
+@Comment{
+  @Book{steward03,
+    author =   {Martha Steward},
+    title =  {Cooking behind bars},
+    publisher =  {Culinary Expert Series},
+    year =   2003
+  }
+}
+
+@String{mar = "march"}
+      
+@Book{sweig42,
+  Author =   { Stefan Sweig },
+  title =  { The impossible book },
+  publisher =  { Dead Poet Society},
+  year =   1942,
+  month =      "1~" # mar
+}
+
+
+@String {firstname = "Xavier"}
+@String {lastname  = "Decoret"}
+@String {email      = firstname # "." # lastname # "@imag.fr"}
+
+@preamble {"This bibliography was generated on \today"}
+
+@String {maintainer = "Xavier D\'ecoret"}
+
+@preamble { "Maintained by " # maintainer }
+