class Infoboxer::Templates::Set

Base class for defining set of templates, used for some site/domain.

Currently only can be plugged in via {MediaWiki::Traits.templates}.

Template set defines a DSL for creating new template definitions – also simplest ones and very complicated.

You can look at implementation of English Wikipedia [common templates set](github.com/molybdenum-99/infoboxer/blob/master/lib/infoboxer/definitions/en.wikipedia.org.rb) in Infoboxer's repo.

Public Class Methods

new(&definitions) click to toggle source
# File lib/infoboxer/templates/set.rb, line 17
def initialize(&definitions)
  @templates = []
  define(&definitions) if definitions
end

Public Instance Methods

clear() click to toggle source

@private

# File lib/infoboxer/templates/set.rb, line 34
def clear
  @templates.clear
end
define(&definitions) click to toggle source

@private

# File lib/infoboxer/templates/set.rb, line 29
def define(&definitions)
  instance_eval(&definitions)
end
find(name) click to toggle source

@private

# File lib/infoboxer/templates/set.rb, line 23
def find(name)
  _, template = @templates.detect { |m, _t| m === name.downcase }
  template || Base
end
literal(*names) click to toggle source

Define list of “literally rendered templates”. It means, when rendering text, template is replaced with just its name.

Explanation: in MediaWiki, there are contexts (deeply in other templates and tables), when you can't just type something like `“,”` and not have it interpreted. So, wikis oftenly define wrappers around those templates, looking like `{{,}}` – so, while rendering texts, such templates can be replaced with their names.

Expected to be used inside Set definition block.

# File lib/infoboxer/templates/set.rb, line 157
def literal(*names)
  names.each do |name|
    setup_class(name, Literal)
  end
end
replace(*replacements) click to toggle source

Define list of “replacements”: templates, which text should be replaced with arbitrary value.

Example:

“`ruby # …inside template set definition… replace(

'!!' => '||',
'!(' => '['

) “` Now, all templates with name `!!` will render as `||` when you call their (or their parents') {Tree::Node#text}.

Expected to be used inside Set definition block.

# File lib/infoboxer/templates/set.rb, line 102
def replace(*replacements)
  case
  when replacements.count == 2 && replacements.all? { |r| r.is_a?(String) }
    name, what = *replacements
    setup_class(name, Replace) do
      define_method(:replace) do
        what
      end
    end
  when replacements.count == 1 && replacements.first.is_a?(Hash)
    replacements.first.each do |nm, rep|
      replace(nm, rep)
    end
  else
    fail(ArgumentError, "Can't call :replace with #{replacements.join(', ')}")
  end
end
setup_class(name, base_class, options = {}, &definition) click to toggle source

@private

# File lib/infoboxer/templates/set.rb, line 164
def setup_class(name, base_class, options = {}, &definition)
  match = options.fetch(:match, name.downcase)
  base = options.fetch(:base, base_class)
  base = find(base) if base.is_a?(String)

  Class.new(base, &definition).tap do |cls|
    cls.template_name = name
    cls.template_options = options
    @templates.unshift [match, cls]
  end
end
show(*names) click to toggle source

Define list of “show children” templates. Those ones, when rendered as text, just provide join of their children text (space-separated).

Example:

“`ruby #…in template set definition… show 'Small' “` Now, wikitext paragraph looking like…

“` This is {{small|text}} in template “` …before this template definition had rendered like `“This is in template”` (template contents ommitted), and after this definition it will render like `“This is text in template”` (template contents rendered as is).

Expected to be used inside Set definition block.

# File lib/infoboxer/templates/set.rb, line 140
def show(*names)
  names.each do |name|
    setup_class(name, Show)
  end
end
template(name, options = {}, &definition) click to toggle source

Most common form of template definition.

Can be used like:

“`ruby template 'Age' do

def from
  fetch_date('1', '2', '3')
end

def to
  fetch_date('4', '5', '6') || Date.today
end

def value
  (to - from).to_i / 365 # FIXME: obviously
end

def text
  "#{value} years"
end

end “`

@param name Definition name. @param options Definition options.

Currently recognized options are:
* `:match` -- regexp or string, which matches template name to
  add this definition to (if not provided, `name` param used
  to match relevant templates);
* `:base` -- name of template definition to use as a base class;
  for example you can do things like:

```ruby
# ...inside template set definition...
template 'Infobox', match: /^Infobox/ do
  # implementation
end

template 'Infobox cheese', base: 'Infobox' do
end
```

Expected to be used inside Set definition block.

# File lib/infoboxer/templates/set.rb, line 82
def template(name, options = {}, &definition)
  setup_class(name, Base, options, &definition)
end