bibtex-ruby 1.2.1 → 1.3.0

data/lib/bibtex/replaceable.rb

@@ -0,0 +1,52 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010	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 Replaceable module provides methods that expose a Value attribute
+  # and the ability to join or replace the contained BibTeX symbols.
+  #
+  module Replaceable
+    extend Forwardable
+    
+    attr_reader :value
+
+		def value=(value)
+		  @value = Value.new(value)
+		end
+
+		def replace(*arguments)
+			@value.replace(*arguments)
+			self
+		end
+
+    def join
+      @value.join
+      self
+    end
+
+		def <<(value)
+			@value << value
+			self
+		end
+		
+    alias :v :value
+    
+  end
+end

data/lib/bibtex/utilities.rb

@@ -19,20 +19,38 @@
 module BibTeX
 
   class << self
-    # Opens a BibTeX file and returns a corresponding +Bibliography+ object.
-    def open(file, options={})
-      Bibliography.open(file, options)
+    
+    # Opens a BibTeX file or URI and returns a corresponding +Bibliography+
+    # object or, if a block is given, yields the Bibliography to the block,
+    # ensuring that the file is saved.
+    def open(file, options = {}, &block)
+      Bibliography.open(file, options, &block)
     end
   
     # Parses the given string and returns a corresponding +Bibliography+ object.
-    def parse(string, options={})
-      BibTeX::Parser.new(options).parse(string)
+    # Delegates to BibTeX.open if the string is a filename or URI.
+    def parse(string, options = {}, &block)
+      if File.exists?(string) || string =~ /^[a-z]+:\/\//i
+        open(string, options, &block)
+      else
+        Bibliography.parse(string, options)
+      end
     end
   
     # Returns true if the given file is a valid BibTeX bibliography.
     def valid?(file)
       Bibliography.open(file).valid?
     end
+    
+    # Parses the given string as a BibTeX name value and returns a Names object.
+    def names(string)
+      Names.parse(string)
+    end
+    
+    alias :name :names
+    alias :parse_name :names
+    alias :parse_names :names
+    
   end
 
 end

data/lib/bibtex/value.rb

@@ -0,0 +1,201 @@
+#--
+# BibTeX-Ruby
+# Copyright (C) 2010-2011  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 Value is something very much like a string. In BibTeX files it
+  # can appear on the right hand side of @string or @entry field assignments
+  # or as @preamble contents. In the example below [VALUE] indicates possible
+  # occurences of values in BibTeX:
+  #
+  #     @preamble{ "foo" [VALUE] }
+  #     @string{ foo = "foo" [VALUE] }
+  #     @book{id,
+  #       author = {John Doe} [VALUE],
+  #       title = foo # "bar" [VALUE]
+  #     }
+  #
+  # All Values have in common that they can be simple strings in curly braces
+  # or double quotes or complex BibTeX string-concatenations (using the '#'
+  # symbol).
+  #
+  # Generally, Values try to behave as much as normal Ruby strings as possible;
+  # If you do not require any of the advanced BibTeX functionality (string
+  # replacement or concatentaion) you can simply convert them to strings using
+  # +to_s+. Note that BibTeX Names are special instances of Values which
+  # currently do not support string concatenation or replacement.
+  #
+  class Value
+    extend Forwardable
+    include Comparable
+    
+    attr_reader :tokens
+    alias :to_a :tokens
+    
+    def_delegators :to_s, :empty?, :=~, :match, :intern, :to_sym, :to_i, :to_f, :end_with?, :start_with?, :include?, :upcase, :downcase, :reverse, :chop, :chomp, :rstrip, :gsub, :sub, :size, :strip, :succ, :to_c, :to_r, :to_str, :split, :each_byte, :each_char, :each_line
+    def_delegators :@tokens, :[], :length
+    
+    def initialize(*arguments)
+      @tokens = []
+      arguments.flatten.compact.each do |argument|
+        add(argument)
+      end
+    end
+    
+    def initialize_copy(other)
+      @tokens = other.tokens.dup
+    end
+    
+    def add(argument)
+      case argument
+      when Value
+        @tokens += argument.tokens.dup
+      when ::String
+        @tokens << argument
+      when Symbol
+        @tokens << argument
+      else
+        raise(ArgumentError, "Failed to create Value from argument #{ argument.inspect }; expected String, Symbol or Value instance.")
+      end
+      self
+    end
+    
+    alias :<< :add
+    alias :push :add
+    
+    [:strip!, :upcase!, :downcase!, :sub!, :gsub!, :chop!, :chomp!, :rstrip!].each do |method_id|
+      define_method(method_id) do |*arguments, &block|
+        @tokens.each do |part|
+          part.send(method_id, *arguments, &block)
+        end
+        self
+      end
+    end
+    
+    def replace(*arguments)
+      return self unless has_symbol?
+      arguments.flatten.each do |argument|
+        case argument
+        when ::String # simulates Ruby's String#replace
+          @tokens = [argument]
+        when String
+          @tokens = @tokens.map { |v| argument.key == v ? argument.value.tokens : v }.flatten
+        when Hash
+          @tokens = @tokens.map { |v| argument[v] || v }
+        end
+      end
+      self
+    end
+
+
+    # Returns the Value instance with all consecutive String tokens joined.
+    #
+    # call-seq:
+    # Value.new('foo', 'bar').join #=> <'foobar'>
+    # Value.new(:foo, 'bar').join  #=> <:foo, 'bar'>
+    #
+    def join
+      @tokens = @tokens.inject([]) do |a,b|
+        a[-1].is_a?(::String) && b.is_a?(::String) ? a[-1] += b : a << b; a
+      end
+      self
+    end
+    
+    # Returns a the Value as a string. @see #value; the only difference is
+    # that single symbols are returned as String, too.
+    # If the Value is atomic and the option :quotes is given, the string
+    # will be quoted using the quote symbols specified.
+    #
+    # call-seq:
+    # Value.new('foo').to_s                       #=> "foo"
+    # Value.new(:foo).to_s                        #=> "foo"
+    # Value.new('foo').to_s(:quotes => '"')       #=> "\"foo\""
+    # Value.new('foo').to_s(:quotes => ['"','"']) #=> "\"foo\""
+    # Value.new('foo').to_s(:quotes => ['{','}']) #=> "{foo}"
+    # Value.new(:foo, 'bar').to_s                 #=> "foo # \"bar\""
+    # Value.new('foo', 'bar').to_s                #=> "\"foo\" # \"bar\""
+    #
+    def to_s(options = {})
+      return value.to_s unless options.has_key?(:quotes) && atomic?
+      *q = options[:quotes]
+      [q[0], value, q[-1]].compact.join
+    end
+
+    # Returns the Value as a string or, if it consists of a single symbol, as
+    # a Symbol instance. If the Value contains multiple tokens, they will be
+    # joined by a '#', additionally, all string tokens will be turned into
+    # string literals (i.e., delimitted by quotes).
+    def value
+      atomic? ? @tokens[0] : @tokens.map { |v|  v.is_a?(::String) ? v.inspect : v }.join(' # ')
+    end
+    
+    alias :v :value
+
+    def inspect
+      '<' + @tokens.map(&:inspect).join(', ') + '>'
+    end
+    
+    # Returns true if the Value is empty or consists of a single token.
+    def atomic?
+      @tokens.length < 2
+    end
+    
+    # Returns true if the Value looks like a BibTeX name value. 
+    def name?
+    end
+    
+    alias :names? :name?
+    alias :is_name? :name?
+    
+    def to_name
+      Names.parse(to_s)
+    end
+    
+    alias :to_names :to_name
+    
+    
+    
+    # Returns true if the Value's content is numeric.
+    def numeric?
+      to_s =~ /^\s*[+-]?\d+[\/\.]?\d*\s*$/
+    end
+    
+    alias :is_numeric? :numeric?
+    
+    # Returns true if the Value contains at least one symbol.
+    def symbol?
+      @tokens.detect { |v| v.is_a?(Symbol) }
+    end
+    
+    alias :has_symbol? :symbol?
+    
+    # Returns all symbols contained in the Value.
+    def symbols
+      @tokens.select { |v| v.is_a?(Symbol) }
+    end
+    
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+    
+  end
+
+end

data/lib/bibtex/version.rb

@@ -18,6 +18,6 @@
 
 module BibTeX
   module Version
-    STRING = '1.2.1'.freeze
+    STRING = '1.3.0'.freeze
   end
 end

data/test/benchmark.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../lib/bibtex.rb', __FILE__)
+require 'profile'
+
+module BibTeX
+  module Benchmark
+    def self.open
+      BibTeX.parse <<-END
+      @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}
+      }
+      END
+    end
+  end
+end
+
+BibTeX::Benchmark.open

data/test/bibtex/test_bibliography.rb

@@ -0,0 +1,141 @@
+require 'helper'
+
+module BibTeX
+  
+  class BibliographyTest < MiniTest::Spec
+    
+    context 'when newly created' do
+      should 'not be nil' do
+        assert Bibliography.new
+      end
+      should 'be empty' do
+        assert Bibliography.new.empty?
+      end
+    end
+
+    context '#open' do
+      should 'accept a block and save the file after execution' do
+        tmp = Tempfile.new('bibtex')
+        tmp.close
+        b = BibTeX.open(Test.fixtures(:bibdesk)).save_to(tmp.path)
+        
+        BibTeX.open(tmp.path) do |bib|
+          bib.delete(:rails)
+        end
+        
+        assert_equal b.length - 1, BibTeX.open(tmp.path).length
+      end
+    end
+    
+    context 'given a populated biliography' do
+      setup do
+        @bib = BibTeX.parse <<-END
+        @book{rails,
+          address = {Raleigh, North Carolina},
+          author = {Ruby, Sam, and Thomas, Dave, and Hansson Heinemeier, David},
+          booktitle = {Agile Web Development with Rails},
+          edition = {third},
+          keywords = {ruby, rails},
+          publisher = {The Pragmatic Bookshelf},
+          series = {The Facets of Ruby},
+          title = {Agile Web Development with Rails},
+          year = {2009}
+        }
+        @book{flanagan2008,
+          title={{The ruby programming language}},
+          author={Flanagan, D. and Matsumoto, Y.},
+          keywords = {ruby},
+          year={2008},
+          publisher={O'Reilly}
+        }
+        @article{segaran2007,
+          title={{Programming collective intelligence}},
+          author={Segaran, T.},
+          year={2007},
+          publisher={O'Reilly}
+        }
+        END
+      end
+      
+      should 'support access by index' do
+        assert_equal 'ruby', @bib[1].keywords 
+      end
+      
+      should 'support access by range' do
+        assert_equal %w{2008 2007}, @bib[1..2].map(&:year)
+      end
+
+      should 'support access by index and offset' do
+        assert_equal %w{2008 2007}, @bib[1,2].map(&:year)
+      end
+      
+      should 'support queries by symbol key' do
+        refute_nil @bib[:rails]
+        assert_nil @bib[:ruby]
+      end
+
+      should 'support queries by symbol key and selector' do
+        assert_equal 1, @bib.q(:all, :rails).length
+        refute_nil @bib.q(:first, :rails)
+        assert_nil @bib.q(:first, :railss)
+      end
+      
+      should 'support queries by string key' do
+        assert_equal 1, @bib['rails'].length
+        assert_equal 0, @bib['ruby'].length
+      end
+
+      should 'support queries by type string' do
+        assert_equal 2, @bib['@book'].length
+        assert_equal 1, @bib['@article'].length
+        assert_equal 0, @bib['@collection'].length
+      end
+
+      should 'support queries by type string and selector' do
+        assert_equal 2, @bib.q(:all, '@book').length
+        refute_nil @bib.q(:first, '@book')
+        assert_equal 1, @bib.q(:all, '@article').length
+        refute_nil @bib.q(:first, '@article')
+        assert_equal 0, @bib.q(:all, '@collection').length
+        assert_nil @bib.q(:first, '@collection')
+      end
+
+
+      should 'support queries by pattern' do
+        assert_equal 0, @bib[/reilly/].length
+        assert_equal 2, @bib[/reilly/i].length
+      end
+      
+      should 'support queries by type string and conditions' do
+        assert_equal 1, @bib['@book[keywords=ruby]'].length
+      end
+
+      should 'support queries by bibtex element' do
+        entry = Entry.parse(<<-END).first
+        @article{segaran2007,
+          title = {{Programming collective intelligence}},
+          author = {Segaran, T.},
+          year = {2007},
+          publisher = {O'Reilly}
+        }
+        END
+        assert_equal 1, @bib[entry].length
+        entry.year = '2006'
+        assert_equal 0, @bib[entry].length
+      end
+      
+      should 'support query and additional block' do
+        assert_equal 1, @bib.q('@book') { |e| e.keywords.split(/,/).length > 1 }.length
+      end
+    
+      should 'support saving the bibliography to a file' do
+        tmp = Tempfile.new('bibtex')
+        tmp.close
+        @bib.save_to(tmp.path)
+        assert_equal @bib, BibTeX.open(tmp.path)
+      end
+      
+    end
+    
+  end
+end