class BibTeX::Value

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.

Attributes

to_a[R]
tokens[R]

Public Class Methods

create(other) → other.dup click to toggle source
create(*args) → Value.new(args)

Duplicates a Value object (or an object of any subclass of Value), or initializes a new one.

# File lib/bibtex/value.rb, line 65
def self.create(*args)
  args[0].class < Value && args.size == 1 ? args[0].dup : Value.new(args)
end
new(*arguments) click to toggle source
# File lib/bibtex/value.rb, line 69
def initialize(*arguments)
  @tokens = []
  arguments.flatten.compact.each do |argument|
    add(argument)
  end
end

Public Instance Methods

<<(argument)
Alias for: add
<=>(other) click to toggle source
# File lib/bibtex/value.rb, line 296
def <=>(other)
  if numeric? && other.respond_to?(:numeric?) && other.numeric?
    to_i <=> other.to_i
  else
    to_s <=> other.to_s
  end
end
add(argument) click to toggle source
# File lib/bibtex/value.rb, line 101
def add(argument)
  case argument
  when Value
    @tokens += argument.tokens.dup
  when ::String
    @tokens << argument
  when Symbol
    @tokens << argument
  else
    if argument.respond_to?(:to_s)
      @tokens << argument.to_s
    else
      raise(ArgumentError, "Failed to create Value from argument #{argument.inspect}; expected String, Symbol or Value instance.")
    end
  end
  self
end
Also aliased as: <<, push
atomic?() click to toggle source

Returns true if the Value is empty or consists of a single token.

# File lib/bibtex/value.rb, line 214
def atomic?
  @tokens.length < 2
end
convert(*filters) click to toggle source

Returns a new Value with all string values converted according to the given filter(s).

# File lib/bibtex/value.rb, line 270
def convert(*filters)
  dup.convert!(*filters)
end
convert!(*filters) click to toggle source

Converts all string values according to the given filter(s).

# File lib/bibtex/value.rb, line 275
def convert!(*filters)
  filters.flatten.each do |filter|
    f = Filters.resolve!(filter)
    @tokens.map! { |t| f.apply(t) }
  end

  self
end
date?() click to toggle source

Returns true if the Value’s content is a date.

# File lib/bibtex/value.rb, line 232
def date?
  !to_date.nil?
end
has_symbol?()
Alias for: symbol?
include_token?(token) click to toggle source
# File lib/bibtex/value.rb, line 97
def include_token?(token)
  @tokens.include?(token)
end
initialize_copy(other) click to toggle source
# File lib/bibtex/value.rb, line 76
def initialize_copy(other)
  @tokens = other.tokens.map do |token|
    if token.nil? then nil
    elsif token.is_a?(Symbol) then token
    else token.dup
    end
  end
end
inspect() click to toggle source
# File lib/bibtex/value.rb, line 209
def inspect
  "#<#{self.class} #{@tokens.map(&:inspect).join(', ')}>"
end
new('foo', 'bar').join #→ <'foobar'> click to toggle source
new(:foo, 'bar').join #→ <:foo, 'bar'>

@param {String} separator

@return {Value} the instance with all consecutive String tokens joined

# File lib/bibtex/value.rb, line 154
def join(separator = '')
  @tokens = @tokens.each_with_object([]) do |b, a|
    if a[-1].is_a?(::String) && b.is_a?(::String)
      a[-1] = [a[-1], b].join(separator)
    else
      a << b
    end
  end
  self
end
merge(other) click to toggle source
# File lib/bibtex/value.rb, line 85
def merge(other)
  dup.merge!(other)
end
merge!(other) click to toggle source
# File lib/bibtex/value.rb, line 89
def merge!(other)
  other.tokens.each do |token|
    add token unless include_token?(token)
  end

  self
end
method_missing(name, *args) click to toggle source
Calls superclass method
# File lib/bibtex/value.rb, line 284
def method_missing(name, *args)
  if name.to_s =~ /^(?:convert|from)_([a-z]+)(!)?$/
    Regexp.last_match(2) ? convert!(Regexp.last_match(1)) : convert(Regexp.last_match(1))
  else
    super
  end
end
name?() click to toggle source

Returns true if the value is a BibTeX name value.

# File lib/bibtex/value.rb, line 219
def name?
  false
end
Also aliased as: names?
names?()
Alias for: name?
numeric?() click to toggle source

Returns true if the Value’s content is numeric.

# File lib/bibtex/value.rb, line 245
def numeric?
  atomic? && @tokens[0] =~ /^\s*[+-]?\d+\s*$/
end
push(argument)
Alias for: add
replace(*arguments) click to toggle source
# File lib/bibtex/value.rb, line 131
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
respond_to?(method, include_all = false) click to toggle source
Calls superclass method
# File lib/bibtex/value.rb, line 292
def respond_to?(method, include_all = false)
  method =~ /^(?:convert|from)_([a-z]+)(!)?$/ || super
end
symbol?() click to toggle source

Returns true if the Value contains at least one symbol.

# File lib/bibtex/value.rb, line 258
def symbol?
  @tokens.detect { |v| v.is_a?(Symbol) }
end
Also aliased as: has_symbol?
symbols() click to toggle source

Returns all symbols contained in the Value.

# File lib/bibtex/value.rb, line 265
def symbols
  @tokens.select { |v| v.is_a?(Symbol) }
end
to_citeproc(options = {}) click to toggle source
# File lib/bibtex/value.rb, line 253
def to_citeproc(options = {})
  to_s(options)
end
to_date() click to toggle source

Returns the string as a date.

# File lib/bibtex/value.rb, line 237
def to_date
  require 'date'
  Date.parse(to_s)
rescue StandardError
  nil
end
to_i() click to toggle source
# File lib/bibtex/value.rb, line 249
def to_i
  @tokens[0].to_i
end
to_name() click to toggle source
# File lib/bibtex/value.rb, line 225
def to_name
  Names.parse(to_s)
end
Also aliased as: to_names
to_names()
Alias for: to_name
new('foo').to_s #→ "foo" click to toggle source
new(:foo).to_s #→ "foo"
new('foo').to_s(:quotes => '"') #→ "\"foo\""
new(:foo).to_s(:quotes => '"') #→ "foo"
new('foo').to_s(:quotes => ['"','"']) #→ "\"foo\""
new('foo').to_s(:quotes => ['{','}']) #→ "{foo}"
new(:foo, 'bar').to_s #→ "foo # \"bar\""
new('foo', 'bar').to_s #→ "\"foo\" # \"bar\""
new('\"u').to_s(:filter => :latex) #→ "ü"

Returns a the Value as a string. @see value; If the Value is atomic and the option :quotes is given, the string will be quoted using the quote symbols specified.

If the option :filter is given, the Value will be converted using the filter(s) specified.

# File lib/bibtex/value.rb, line 182
def to_s(options = {})
  if options.key?(:filter)
    return convert(options[:filter]).to_s(
      options.reject { |k,| k == :filter || (k == :quotes && (!atomic? || symbol?)) }
    )
  end

  return value.to_s unless options.key?(:quotes) && atomic? && !symbol?

  q = Array(options[:quotes])
  [q[0], value, q[-1]].compact.join
end
v()
Alias for: value
value() click to toggle source

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).

# File lib/bibtex/value.rb, line 199
def value
  if atomic?
    @tokens[0]
  else
    @tokens.map { |v| v.is_a?(::String) ? v.inspect : v }.join(' # ')
  end
end
Also aliased as: v