Class: RCite::Style

Inherits:

Object

• Object
• RCite::Style

show all

Defined in:

lib/rcite/style.rb,
lib/rcite/style_options.rb,
lib/rcite/style_helpers.rb

Overview

Constant Summary

OPTIONS =

List of Options that determine the behaviour of Style methods and provide instructions for other class that deal with styles (most notably the TextProcessor).

For each of these options, a helper method named _<option name> is added to the RCite::Style class. Users can set options by calling _<option name>(value...) or get the value(s) of an option using the plain _<option name>.

TODO document individual options

Returns:

• (Array<Option>) —

  List of Options that determine the behaviour of Style methods and provide instructions for other class that deal with styles (most notably the TextProcessor).

  For each of these options, a helper method named _<option name> is added to the RCite::Style class. Users can set options by calling _<option name>(value...) or get the value(s) of an option using the plain _<option name>.

  TODO document individual options

[
  Option.new(:ordering,             default:     :last_first,
                                    good_values: [:last_first, :first_last],
                                    validator:   Proc.new { false },
                                    allow_nil:   false                    ),
  Option.new(:delim,                default:     '; ',
                                    transformer: String                   ),
  Option.new(:et_al,                default:     3,
                                    transformer: Integer                  ),
  Option.new(:et_al_string,         default:     'et al.',
                                    transformer: Integer                  ),
  Option.new(:around_each_bib,      transformer: String,
                                    default:     []                       ),
  Option.new(:around_each_cite,     transformer: String,
                                    default:     []                       ),
  Option.new(:around_all_bibs,      transformer: String,
                                    default:     []                       ),
  Option.new(:around_all_cites,     transformer: String,
                                    default:     []                       ),
  Option.new(:between_bibs,         transformer: String,
                                    default:     "\n"                     ),
  Option.new(:between_cites,        transformer: String,
                                    default:     "; "                     ),
  Option.new(:sort_bibliography_by, transformer: Symbol,
                                    default:     [:author, :title, :volume])
]

Instance Attribute Summary (collapse)

• - (Array<RCite::Element>) elements

  Array of Elements for the current #text.

• - (Hash<Symbol, Option>) opts

  This style's global Options.

• - (BibTeX::Entry) text

  A BibTeX::Entry that describes the text currently being processed.

Instance Method Summary (collapse)

• - (Object) add(*elements)

  Adds the specified elements to the variable @elements.

• - (String^?) authors (also: #author)

  Returns a list of all authors of the given text if any are defined.

• - (String) bib(text, fields = {})

  Generates a bibliography entry for the given text.

• - (String) cite(text, fields = {})

  Generates a citation for the given text.

• - (String^?) editors(options = {}) (also: #editor)

  Returns a list of all editors of the given text if any are defined.

• - (Style) initialize constructor

  Adds each style option in OPTIONS to #opts.

• - (String^?) method_missing(method, *args)

  Returns the value of a BibTeX field for the current #text.

• - (Element) sep(separator)

  Defines a separator element.

31
32
33
34

# File 'lib/rcite/style_helpers.rb', line 31

def initialize
  @opts = {}
  OPTIONS.each { |o| @opts.merge!(o.name => o.dup) }
end

22
23
24
25
26

# File 'lib/rcite/style_helpers.rb', line 22

def method_missing(method, *args)
  raise NoMethodError,
    "Can't look up BibTeX fields: Style#text is `nil`" unless @text
  @text[method.to_sym]
end

31
32
33

# File 'lib/rcite/style.rb', line 31

def elements
  @elements
end

10
11
12

# File 'lib/rcite/style_helpers.rb', line 10

def opts
  @opts
end

25
26
27

# File 'lib/rcite/style.rb', line 25

def text
  @text
end

45
46
47
48
49
50
51
52
53
54
55
56
57

# File 'lib/rcite/style_helpers.rb', line 45

def add(*elements)
  elements.map! do |e|
    if e.is_a? RCite::Element
      e
    elsif e && e.to_s == ''
      nil
    elsif e
      RCite::Element.new(:con, e)
    end
  end

  @elements.concat elements.compact
end

100
101
102

# File 'lib/rcite/style_helpers.rb', line 100

def authors()
  authors_or_editors(@text[:author].to_names) if @text[:author]
end

81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# File 'lib/rcite/style.rb', line 81

def bib(text, fields = {})
  method = "bib_#{text.type}".to_s
  if !respond_to?(method, true)
    raise ArgumentError.new("This style does not define the type"+
      " '#{text.type}'.")
  end
  @text = text.dup << fields
  @elements= []
  begin
    send(method) 
  ensure
    @text = nil
  end
  elements_to_string(@elements)
end

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

# File 'lib/rcite/style.rb', line 52

def cite(text, fields = {})
  method = "cite_#{text.type}"
  if !respond_to?(method, true)
    raise ArgumentError.new("This style does not define the type"+
      "' #{text.type}'.")
  end
  @text = text.dup << fields
  @elements = []
  begin
    send(method)
  ensure
    @text = nil
  end
  elements_to_string(@elements)
end

114
115
116

# File 'lib/rcite/style_helpers.rb', line 114

def editors(options = {})
  authors_or_editors(@text[:editor].to_names) if @text[:editor]
end

add authors
add sep ': '
add title

75
76
77

# File 'lib/rcite/style_helpers.rb', line 75

def sep(separator)
  RCite::Element.new(:sep, separator)
end