bibtex-ruby 1.2.1 → 1.3.0

data/features/replacement.feature

@@ -0,0 +1,68 @@
+Feature: BibTeX String Replacement
+	As a hacker who works with bibliographies
+	I want to be able to parse BibTeX files with string assignments
+	And replace string symbols in other values
+	Because that is a cool BibTeX feature
+	
+	@string @replacement
+	Scenario: A BibTeX file with string assignments and symbols
+		When I parse the following file:
+		"""
+		%%
+		%% A valid BibTeX file
+		%% String assignment and replacement
+		%%
+
+		@string{ foo = "foo" }
+		@string{ bar = "bar" }
+		@string{ foobar = foo # "bar" }
+		@string{ foobarfoo = foobar # foo }
+		@string{ barfoobar = bar # "foo" # bar }
+
+		@preamble { "foo" # foo # foobarfoo # "bar" }
+
+		@manual {manual:1,
+			title = "foo" # barfoobar
+		}
+		"""
+		Then my bibliography should contain these strings:
+			| value             |
+			| foo               |
+			| bar               |
+			| foo # "bar"       |
+			| foobar # foo      |
+			| bar # "foo" # bar |
+		And my bibliography should contain these preambles:
+			| content                         |
+			| "foo" # foo # foobarfoo # "bar" |
+		And my bibliography should contain these manuals:
+			| title             |
+			| "foo" # barfoobar |
+		When I replace all strings in my bibliography
+		Then my bibliography should contain these strings:
+			| content                           |
+			| foo = "foo"                       |
+			| bar = "bar"                       |
+			| foobar = "foo" # "bar"            |
+			| foobarfoo = "foo" # "bar" # "foo" |
+			| barfoobar = "bar" # "foo" # "bar" |
+		And my bibliography should contain these preambles:
+			| content                                       |
+			| "foo" # "foo" # "foo" # "bar" # "foo" # "bar" |
+		And my bibliography should contain these manuals:
+			| title                         |
+			| "foo" # "bar" # "foo" # "bar" |
+		When I join all strings in my bibliography
+		Then my bibliography should contain these strings:
+			| content                 |
+			| foo = "foo"             |
+			| bar = "bar"             |
+			| foobar = "foobar"       |
+			| foobarfoo = "foobarfoo" |
+			| barfoobar = "barfoobar" |
+		And my bibliography should contain these preambles:
+			| content              |
+			| "foofoofoobarfoobar" |
+		And my bibliography should contain these manuals:
+			| title        |
+			| foobarfoobar |

data/features/step_definitions/bibtex_steps.rb

@@ -0,0 +1,74 @@
+Given /^the bibliography:$/ do |string|
+  @bibliography = BibTeX.parse(string)
+end
+
+When /^I parse the following file:$/ do |string|
+  @bibliography = BibTeX.parse(string)
+end
+
+When /^I search for "([^"]*)"$/ do |query|
+  @result = @bibliography.query(query)
+end
+
+When /^I search for :(.+)$/ do |query|
+  @result = @bibliography.query(query.to_sym)
+end
+
+When /^I search for \/(.+)\/$/ do |query|
+  @result = @bibliography.query(Regexp.new(query))
+end
+
+When /^I (replace|join) all strings(?: in my bibliography)$/ do |method|
+  @bibliography.send("#{method}_strings")
+end
+
+When /^I replace and join all strings(?: in my bibliography)$/ do
+  @bibliography.replace_strings.join_strings
+end
+
+
+
+Then /^my bibliography should contain the following objects:$/ do |table|
+  @bibliography.each_with_index do |object, index|
+    table.hashes[index].each_pair do |key, value|
+      assert_equal value, object.send(key).to_s
+    end
+  end
+end
+
+Then /^my bibliography should contain th(?:ese|is) (\w+):$/ do |type, table|
+  @bibliography.q("@#{type.chomp!('s')}").zip(table.hashes).each do |object, expected|
+    expected.each_pair do |key, value|
+      assert_equal value, object.send(key).to_s
+    end
+  end
+end
+
+Then /^my bibliography should contain the following numbers of elements:$/ do |table|
+  counts = table.hashes.first
+  counts[[]] = counts.delete('total') if counts.has_key?('total')
+  counts.each_pair do |type, length|
+    assert_equal length.to_i, @bibliography.find_by_type(type).length
+  end
+end
+
+Then /^my bibliography should contain an entry with key "([^"]*)"$/ do |key|
+  refute_nil @bibliography[key.to_s]
+end
+
+Then /^my bibliography should not contain an entry with key "([^"]*)"$/ do |key|
+  assert_nil @bibliography[key.to_sym]
+end
+
+Then /^there should be exactly (\d+) match(?:es)?$/ do |matches|
+  assert_equal matches.to_i, @result.length
+end
+
+
+Then /^my bibliography should contain (\d+) (\w+) published in (\d+)$/ do |count, type, year|
+  assert_equal @bibliography.q("@#{type.chomp!('s')}[year=#{year}]").length, count.to_i
+end
+
+Then /^my bibliography should contain an? (\w+) with id "([^"]*)"$/ do |type, id|
+  assert_equal @bibliography[id.to_sym].type, type.to_sym
+end

data/features/step_definitions/name_steps.rb

@@ -0,0 +1,13 @@
+When /^I parse the name "(.*)"$/ do |string|
+  @name = BibTeX::Name.parse(string)
+end
+
+Then /^the parts should be:$/ do |table|
+  table.hashes.each do |row|
+    assert_equal [row['first'], row['von'], row['last'], row['jr']],
+      [@name.first, @name.von, @name.last, @name.jr].map(&:to_s)
+    # row.each do |k,v|
+    #   assert_equal v, @name.send(k).to_s
+    # end
+  end
+end

data/features/strings.feature

@@ -0,0 +1,52 @@
+Feature: BibTeX Strings
+	As a hacker who works with bibliographies
+	I want to be able to parse BibTeX files containing string assignments
+
+	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/features/support/env.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+require 'bibtex'
+require 'minitest/unit'
+
+World do
+  extend MiniTest::Assertions
+end

data/lib/bibtex.rb

@@ -31,7 +31,7 @@ require 'logger'
 # +Entry+.
 #
 # Author:: {Sylvester Keil}[http://sylvester.keil.or.at]
-# Copyright:: Copyright (c) 2010 Sylvester Keil
+# Copyright:: Copyright (c) 2010-2011 Sylvester Keil
 # License:: GNU GPL 3.0
 #
 module BibTeX
@@ -52,6 +52,10 @@ end
 # Debugger.start
 
 require 'bibtex/extensions'
+require 'bibtex/value'
+require 'bibtex/name_parser'
+require 'bibtex/names'
+require 'bibtex/replaceable'
 require 'bibtex/elements'
 require 'bibtex/entry'
 require 'bibtex/error'

data/lib/bibtex/bibliography.rb

@@ -1,6 +1,6 @@
 #--
 # BibTeX-Ruby
-# Copyright (C) 2010  Sylvester Keil <sylvester.keil.or.at>
+# 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
@@ -16,6 +16,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 
+require 'forwardable'
+require 'open-uri'
+
 module BibTeX
 
   #
@@ -23,94 +26,157 @@ module BibTeX
   # typically, it corresponds to a `.bib' file.
   #
   class Bibliography
+    extend Forwardable
+    
+    include Enumerable
+    include Comparable
+        
+    class << self    
+
+      # 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.
+      #
+      def open(path, options = {})
+        b = parse(Kernel.open(path).read, options)
+        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(bibtex, options = {})
+        b = Parser.new(options).parse(bibtex)
+        b.parse_names unless options[:parse_names] == false
+        b
+      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
 
-    #
-    # Opens and parses the `.bib' file at the given +path+. Returns
-    # a new Bibliography instance corresponding to the file.
-    #
-    # The options argument is passed on to BibTeX::Parser.new.
-    #
-    def self.open(path, options={})
-      Log.debug('Opening file ' + path.to_s)
-      BibTeX::Parser.new(options).parse(File.read(path))
-    end
+    attr_by_type :article, :book, :journal, :collection, :preamble, :comment, :meta_content
+    
+    def_delegators :@data, :length, :size, :each, :empty?
+
     
     #
-    # Creates a new bibliography; empty if no data attribute is specified, otherwise
-    # by parsing the file at the given path.
+    # Creates a new bibliography; empty if no data attribute is specified.
     #
-    def initialize(data=[])
-      @path = path
+    def initialize(data = [])
       @data = []
       @strings = {}
       @entries = {}
-      @errors = []
       add(data)
     end
     
     # Adds a new element, or a list of new elements to the bibliography.
-    def add(data)
-      raise(ArgumentError,'BibTeX::Bibliography.add data expected to be enumerable or of type BibTeX::Element; was: ' + data.class.name) unless data.respond_to?(:each) || data.is_a?(Element)
-      data.is_a?(Element) ? self << data : data.each { |d| self << d }
+    # Returns the Bibliography for chainability.
+    def add(*arguments)
+      arguments.flatten.each do |element|
+        raise(ArgumentError, "Failed to add #{ element.inspect } to Bibliography; instance of BibTeX::Element expected.") unless element.is_a?(Element)
+        @data << element.added_to_bibliography(self)
+      end
       self
     end
     
+    alias :<< :add
+    alias :push :add
+    
     # Saves the bibliography to the current path.
-    def save
-      save_to(@path)
+    def save(options = {})
+      save_to(@path, options)
     end
     
-    # Saves the bibliography to a file at the given path.
-    def save_to(path)
-      File.open(path, "w") do |f|
-        f.write to_s
-      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") { |f| f.write(to_s(options)) }
+      self
     end
     
-    # Add an object to the bibliography. Returns the bibliography.
-    def <<(obj)
-      raise(ArgumentError, 'A BibTeX::Bibliography can contain only BibTeX::Elements; was: ' + obj.class.name) unless obj.is_a?(Element)
-      @data << obj.added_to_bibliography(self)
+    def parse_names
+      q('@entry') { |e| e.parse_names }
       self
     end
     
-    # Delete an object from the bibliography. Returns the object, or nil
+    #
+    # 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(obj)
-      @data.delete(obj.removed_from_bibliography(self))
-    end
-    
-    def delete_all
-      @data.each { |obj| obj.removed_from_bibliography(self) }
-      @data = []
-    end
-    
-    # Returns all @preamble objects.
-    def preamble
-      find_by_type(BibTeX::Preamble)
+    #
+    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
     
-    # Returns the first entry with a given key.
-    def [](key)
-      @entries[key.to_s]
-    end
-          
-    # Returns all @comment objects.
-    def comments
-      find_by_type(BibTeX::Comment)
-    end
+    alias :remove :delete
+    alias :rm :delete
+
+    #
+    # 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.
+    #
+    # 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']
+    # => Returns all entries with key 'key' or []
+    # >> 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 []
+    #
+    def [](*arguments)
+      raise(ArgumentError, "wrong number of arguments (#{arguments.length} for 1..2)") unless arguments.length.between?(1,2)
 
-    # Returns all meta comments, i.e., all text outside of BibTeX objects.
-    def meta_comments
-      find_by_type(BibTeX::MetaComment)
+      case
+      when !([Range, Numeric] & arguments[0].class.ancestors).empty?
+        @data[*arguments] 
+      when arguments.length == 1 && arguments[0].is_a?(Symbol)
+        @entries[arguments[0]]
+      else
+        query(*arguments)
+      end
     end
 
     # Returns all objects which could not be parsed successfully.
     def errors
-      @errors
+      @errors ||= []
     end
 
     # Returns true if there are object which could not be parsed.
@@ -119,82 +185,139 @@ module BibTeX
     end
 
     # Returns true if the +Bibliography+ contains no errors and only
-    # valid BibTeX objects (meta comments are ignored).
+    # valid BibTeX objects (meta content is ignored).
     def valid?
-      !errors? && !@entries.values.map(&:valid?).uniq.include?(false)
+      !errors? && @entries.values.all?(&:valid?)
     end
     
-    # Replaces all string constants which are defined in the bibliography.
+    # Replaces all string symbols which are defined in the bibliography.
     #
-    # By default constants in @string, @preamble and entries are defined; this
-    # behaviour can be changed using the options argument by setting
-    # the :include option to a list of types.
+    # 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:
-    # replace_strings
-    # replace_strings({ :include => [BibTeX::String,BibTeX::Preamble]})
+    # bib.replace #=> replaces all symbols
+    # bib.replace('@string, @preamble')
+    # #=> replaces only symbols in @string and @preamble objects
     #
-    def replace_strings(options={})
-      options[:include] ||= [BibTeX::String, BibTeX::Preamble, BibTeX::Entry]
-      find_by_type(options[:include]).each { |e| e.replace!(@strings) if e.respond_to?(:replace!)}
+    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 join_strings(options={})
-      options[:include] ||= [BibTeX::String, BibTeX::Preamble, BibTeX::Entry]
-      find_by_type(options[:include]).each { |e| e.join! if e.respond_to?(:join!)}
+    def rename(*arguments, &block)
+      q('@entry') { |e| e.rename(*arguments, &block) }
+      self
     end
     
-    # Returns true if the bibliography is currently empty.
-    def empty?
-      @data.empty?
+    def sort(*arguments, &block)
+      @data.sort(*arguments, &block)
+      self
     end
     
-    # Returns the number of objects in the bibliography (including meta comments).
-    def length
-      @data.length
+    # Returns a string representation of the bibliography.
+    def to_s(options = {})
+      map { |o| o.to_s(options) }.join
     end
 
-    # Returns the bibliography as an array of +BibTeX::Element+
-    def to_a
-      @data
+    def to_a(options = {})
+      map { |o| o.to_hash(options) }
     end
     
-    # Returns a string representation of the bibliography.
-    def to_s
-      @data.map(&:to_s).join
+    # 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 YAML representation of the bibliography. Only BibTeX entries are exported.
-    def to_yaml
-      @entries.values.map(&:to_hash).to_yaml
+    # Returns a JSON representation of the bibliography.
+    def to_json(options = {})
+      to_a(options).to_json
     end
     
-    # Returns a JSON representation of the bibliography. Only BibTeX entries are exported.
-    def to_json
-      @entries.values.map(&:to_hash).to_json
+    # 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 an XML representation of the bibliography. Only BibTeX entries are exported.
     def to_xml
+      require 'rexml/document'
+	    
       xml = REXML::Document.new
       xml << REXML::XMLDecl.new('1.0','UTF-8')
       root = REXML::Element.new('bibliography')
-      @entries.values.each { |e| root.add_element(e.to_xml) }
+      each { |e| root.add_element(e.to_xml) }
       xml << root
       xml
     end
-    
-    private
 
-    def find_by_type(type)
-      @data.find_all { |x| type.respond_to?(:inject) ? type.inject(false) { |s,n| s || x.is_a?(n) } : x.is_a?(type) }
+    # Returns objects in the Bibliography which match the given selector and,
+    # optionally, the conditions specified in the given block.
+    #
+    # call-seq:
+    # bib.query()        #=> returns all objects
+    # bib.query(:all)    #=> returns all objects
+    # bib.query(:first)  #=> returns the first object
+    # bib.query('@book') #=> returns all books
+    # bib.query(:first, '@book, @article')
+    # #=> returns the first book or article
+    # bib.query('@book[year=2011], @article)
+    # #=> returns all books published in 2011 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
+    #
+    def query(*arguments, &block)
+      raise(ArgumentError, "wrong number of arguments (#{arguments.length} for 0..2)") unless arguments.length.between?(0,2)
+
+      q, selector = arguments.reverse
+      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 find_by_type(*types, &block)
+      q(types.flatten.compact.map { |t| "@#{t}" }.join(', '), &block)
     end
+    
+    alias :find_by_types :find_by_type
 
-    def find_entry(key)
-      entries.find { |e| e.key == key.to_s }
+    def <=>(other)
+      other.respond_to?(:to_a) ? to_a <=> other.to_a : nil
     end
+    
+    private
+    
+    def query_handler(selector)
+      case selector
+      when /first|distinct|detect/i
+        :detect
+      when /none|reject|not/i
+        :reject
+      else
+        :select
+      end
+    end
+    
   end
 end