bibtex_to_scrapbox 0.2.0 → 0.2.1

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

@@ -1,83 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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

@@ -1,50 +0,0 @@
-%% 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

@@ -1,15 +0,0 @@
-%
-% 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

@@ -1,83 +0,0 @@
-%%
-%% 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 }
-