Class: BibTeX::Element

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/bibtex/elements.rb

Overview

The base class for BibTeX objects.

Direct Known Subclasses

Comment, Entry, Error, MetaContent, Preamble, String

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#bibliography ⇒ Object (readonly)

Returns the value of attribute bibliography.



28
29
30
 
# File 'lib/bibtex/elements.rb', line 28

def bibliography
  @bibliography
end

#id ⇒ Object

Returns the element’s id.



59
 
# File 'lib/bibtex/elements.rb', line 59

def id; @id ||= object_id.to_s; end

Class Method Details

.parse(input, options = {}) ⇒ Object

Returns an array of BibTeX elements.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/bibtex/elements.rb', line 31

def self.parse(input, options = {})
  case input
  when Element
    [input]
  when Hash
    [Entry.new(input)]
  when Array
    input.inject([]) { |s,a| s.concat(parse(a, options)) }
  when ::String
    Parser.new(options).parse(input).data.each do |e|
      e.parse_names unless !e.respond_to?(:parse_names) || options[:parse_names] == false
      e.parse_month unless !e.respond_to?(:parse_month) || options[:parse_months] == false
    end
  else
    raise ArgumentError, "failed to parse Element from #{input.inspect}"
  end
end

Instance Method Details

#<=>(other) ⇒ Object 



168
169
170
171
 
# File 'lib/bibtex/elements.rb', line 168

def <=>(other)
  return nil unless other.respond_to? :type and other.respond_to? :to_s
  [type, to_s] <=> [other.type, other.to_s]
end

#added_to_bibliography(bibliography) ⇒ Object

Called when the element was added to a bibliography.



156
157
158
159
160
 
# File 'lib/bibtex/elements.rb', line 156

def added_to_bibliography(bibliography)
  # raise BibTeXError, "failed to add element to Bibliography: already registered with another Bibliography" unless @bibliography.nil?
  @bibliography = bibliography
  self
end

#content(options = {}) ⇒ Object Also known as: to_s

Returns a string containing the object’s content.



50
 
# File 'lib/bibtex/elements.rb', line 50

def content(options = {}); ''; end

#has_type?(type) ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
 
# File 'lib/bibtex/elements.rb', line 71

def has_type?(type)
  self.type == type.intern || defined?(type) == 'constant' && is_a?(type)
end

#inspect ⇒ Object

Returns the Element as a nicely formatted string.



174
175
176
 
# File 'lib/bibtex/elements.rb', line 174

def inspect
  "#<#{self.class} #{content.gsub(/\n/, ' ')}>"
end

#join ⇒ Object

Invokes BibTeX string joining on this element.



56
 
# File 'lib/bibtex/elements.rb', line 56

def join; self; end

#matches?(query) ⇒ Boolean Also known as: ===, match?

Returns true if the element matches the given query.

Returns:

  • (Boolean) 


81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/bibtex/elements.rb', line 81

def matches?(query)
  return true if query.nil? || query.respond_to?(:empty?) && query.empty?
  
  case query
  when Symbol
    query.to_s == id.to_s
  when Element
    query == self
  when Regexp
    to_s.match(query)
  when /@(\*|\w+)(?:\[([^\]]*)\])?/
    query.scan(/@(\*|\w+)(?:\[([^\]]*)\])?/).any? do |type, condition|
      has_type?(type) && ( condition.nil? || meets?(condition.split(/,\s*/)) )
    end
  when /^\/(.+)\/$/
    to_s.match(Regexp.new($1))
  else
    id.to_s == query
  end      
end

#meets?(*conditions) ⇒ Boolean Also known as: meet?

Returns true if the element meets all of the given conditions.

Returns:

  • (Boolean) 


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/bibtex/elements.rb', line 106

def meets?(*conditions)
  conditions.flatten.all? do |condition|
    property, operator, value = condition.split(/\s*([!~\/\^<>]?=)\s*/)
    
    if property.nil?
      true
    else
      case operator
      when '!=', '/='
        !respond_to?(property) || send(property).to_s != value
      when '^='
        respond_to?(property) && send(property).to_s.match("^#{value}")
      when '~='
        respond_to?(property) && send(property).to_s.match(value)
      when '<='
        respond_to?(property) && send(property).to_i <= value.to_i
      when '>='
        respond_to?(property) && send(property).to_i >= value.to_i
      else
        respond_to?(property) && send(property).to_s == value
      end
    end
  end
end

#names ⇒ Object

Returns a list of names for that Element. All Elements except Entries return an empty list.



67
68
69
 
# File 'lib/bibtex/elements.rb', line 67

def names
  []
end

#removed_from_bibliography(bibliography) ⇒ Object

Called when the element was removed from a bibliography.



163
164
165
166
 
# File 'lib/bibtex/elements.rb', line 163

def removed_from_bibliography(bibliography)
  @bibliography = nil
  self
end

#replace(*arguments) ⇒ Object

Invokes BibTeX string replacement on this element.



53
 
# File 'lib/bibtex/elements.rb', line 53

def replace(*arguments); self; end

#to_hash(options = {}) ⇒ Object 



135
136
137
 
# File 'lib/bibtex/elements.rb', line 135

def to_hash(options = {})
  { type => content }
end

#to_json(options = {}) ⇒ Object 



144
145
146
 
# File 'lib/bibtex/elements.rb', line 144

def to_json(options = {})
  MultiJson.dump(to_hash(options))
end

#to_xml(options = {}) ⇒ Object 



148
149
150
151
152
153
 
# File 'lib/bibtex/elements.rb', line 148

def to_xml(options = {})
  require 'rexml/document'
  xml = REXML::Element.new(type)
  xml.text = content
  xml
end

#to_yaml(options = {}) ⇒ Object 



139
140
141
142
 
# File 'lib/bibtex/elements.rb', line 139

def to_yaml(options = {})
  require 'yaml'
  to_hash.to_yaml
end

#type ⇒ Object

Returns the BibTeX type (if applicable) or the normalized class name.



62
63
64
 
# File 'lib/bibtex/elements.rb', line 62

def type
  self.class.name.split(/::/).last.gsub(/([[:lower:]])([[:upper:]])/) { "#{$1}_#{$2}" }.downcase.intern
end