Class: Nanoc::RuleDSL::CompilerDSL Private

Inherits:
Core::Context
  • Object
show all
Defined in:
lib/nanoc/rule_dsl/compiler_dsl.rb

This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rules_collection, config) ⇒ CompilerDSL

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Creates a new compiler DSL for the given collection of rules.

Parameters:



20
21
22
23
24
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 20

def initialize(rules_collection, config)
  @rules_collection = rules_collection
  @config = config
  super({ config: })
end

Instance Attribute Details

#rules_filename ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The current rules filename.

Returns:

  • (String) —

    The current rules filename.



10
11
12
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 10

def rules_filename
  @rules_filename
end

Instance Method Details

#compile(identifier, rep: :default) { ... } ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a compilation rule for all items whose identifier match the given identifier, which may either be a string containing the * wildcard, or a regular expression.

This rule will be applicable to reps with a name equal to ‘:default`; this can be changed by giving an explicit `:rep` parameter.

An item rep will be compiled by calling the given block and passing the rep as a block argument.

Examples:

Compiling the default rep of the ‘/foo/` item


compile '/foo/' do
  rep.filter :erb
end

Compiling the ‘:raw` rep of the `/bar/` item


compile '/bar/', :rep => :raw do
  # do nothing
end

Parameters:

  • identifier (String) —

    A pattern matching identifiers of items that should be compiled using this rule

  • rep (Symbol) (defaults to: :default) —

    The name of the representation

Yields:

  • The block that will be executed when an item matching this compilation rule needs to be compiled

Raises:

  • (ArgumentError) 


71
72
73
74
75
76
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 71

def compile(identifier, rep: :default, &block)
  raise ArgumentError.new('#compile requires a block') unless block_given?

  rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, block)
  @rules_collection.add_item_compilation_rule(rule)
end

#create_pattern(arg) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 254

def create_pattern(arg)
  case @config[:string_pattern_type]
  when 'glob'
    Nanoc::Core::Pattern.from(arg)
  when 'legacy'
    Nanoc::Core::Pattern.from(identifier_to_regex(arg))
  else
    raise(
      Nanoc::Core::TrivialError,
      "Invalid string_pattern_type: #{@config[:string_pattern_type]}",
    )
  end
end

#ignore(identifier, rep: :default) ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a pair of compilation and routing rules that indicate that the specified item(s) should be ignored, e.g. compiled and routed with an empty rule. The items are selected using an identifier, which may either be a string containing the ‘*` wildcard, or a regular expression.

This meta-rule will be applicable to reps with a name equal to ‘:default`; this can be changed by giving an explicit `:rep` parameter.

Examples:

Suppressing compilation and output for all all ‘/foo/*` items.


ignore '/foo/*'

Parameters:

  • identifier (String) —

    A pattern matching identifiers of items that should be processed using this meta-rule

  • rep (Symbol) (defaults to: :default) —

    The name of the representation

Raises:

  • (ArgumentError) 


210
211
212
213
214
215
216
217
218
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 210

def ignore(identifier, rep: :default)
  raise ArgumentError.new('#ignore does not require a block') if block_given?

  compilation_rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, proc {})
  @rules_collection.add_item_compilation_rule(compilation_rule)

  routing_rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, proc {}, snapshot_name: :last)
  @rules_collection.add_item_routing_rule(routing_rule)
end

#include_rules(name) ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Includes an additional rules file in the current rules collection.

Examples:

Including two additional rules files, ‘rules/assets.rb’ and

'rules/content.rb'

  include_rules 'rules/assets'
  include_rules 'rules/content'

Parameters:

  • name (String) —

    The name of the rules file — an “.rb” extension is implied if not explicitly given

Raises:



232
233
234
235
236
237
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 232

def include_rules(name)
  filename = [name.to_s, "#{name}.rb", "./#{name}", "./#{name}.rb"].find { |f| File.file?(f) }
  raise Nanoc::RuleDSL::Errors::NoRulesFileFound.new if filename.nil?

  Nanoc::RuleDSL::RulesLoader.new(@config, @rules_collection).parse(filename)
end

#layout(identifier, filter_name, params = {}) ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a layout rule for all layouts whose identifier match the given identifier, which may either be a string containing the * wildcard, or a regular expression. The layouts matching the identifier will be filtered using the filter specified in the second argument. The params hash contains filter arguments that will be passed to the filter.

Examples:

Specifying the filter to use for a layout


layout '/default/', :erb

Using custom filter arguments for a layout


layout '/custom/',  :haml, :format => :html5

Parameters:

  • identifier (String) —

    A pattern matching identifiers of layouts that should be filtered using this rule

  • filter_name (Symbol) —

    The name of the filter that should be run when processing the layout

  • params (Hash) (defaults to: {}) —

    Extra filter arguments that should be passed to the filter when processing the layout (see Core::Filter.run)



142
143
144
145
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 142

def layout(identifier, filter_name, params = {})
  pattern = Nanoc::Core::Pattern.from(create_pattern(identifier))
  @rules_collection.layout_filter_mapping[pattern] = [filter_name, params]
end

#passthrough(identifier, rep: :default) ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a pair of compilation and routing rules that indicate that the specified item(s) should be copied to the output folder as-is. The items are selected using an identifier, which may either be a string containing the ‘*` wildcard, or a regular expression.

This meta-rule will be applicable to reps with a name equal to ‘:default`; this can be changed by giving an explicit `:rep` parameter.

Examples:

Copying the ‘/foo/` item as-is


passthrough '/foo/'

Copying the ‘:raw` rep of the `/bar/` item as-is


passthrough '/bar/', :rep => :raw

Parameters:

  • identifier (String) —

    A pattern matching identifiers of items that should be processed using this meta-rule

  • rep (Symbol) (defaults to: :default) —

    The name of the representation

Raises:

  • (ArgumentError) 


169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 169

def passthrough(identifier, rep: :default)
  raise ArgumentError.new('#passthrough does not require a block') if block_given?

  compilation_block = proc {}
  compilation_rule = Nanoc::RuleDSL::CompilationRule.new(create_pattern(identifier), rep, compilation_block)
  @rules_collection.add_item_compilation_rule(compilation_rule)

  # Create routing rule
  routing_block = proc do
    if item.identifier.full?
      item.identifier.to_s
    else
      # This is a temporary solution until an item can map back to its data
      # source.
      # ATM item[:content_filename] is nil for items coming from the static
      # data source.
      item[:extension].nil? || (item[:content_filename].nil? && item.identifier =~ %r{#{item[:extension]}/$}) ? item.identifier.chop : item.identifier.chop + '.' + item[:extension]
    end
  end
  routing_rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, routing_block, snapshot_name: :last)
  @rules_collection.add_item_routing_rule(routing_rule)
end

#postprocess { ... } ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a postprocessor block that will be executed after all data is loaded and the site is compiled.

Yields:

  • The block that will be executed after site compilation completes



245
246
247
248
249
250
251
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 245

def postprocess(&block)
  if @rules_collection.postprocessors[rules_filename]
    warn 'WARNING: A postprocess block is already defined. Defining ' \
      'another postprocess block overrides the previously one.'
  end
  @rules_collection.postprocessors[rules_filename] = block
end

#preprocess { ... } ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a preprocessor block that will be executed after all data is loaded, but before the site is compiled.

Yields:

  • The block that will be executed before site compilation starts



32
33
34
35
36
37
38
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 32

def preprocess(&block)
  if @rules_collection.preprocessors[rules_filename]
    warn 'WARNING: A preprocess block is already defined. Defining ' \
      'another preprocess block overrides the previously one.'
  end
  @rules_collection.preprocessors[rules_filename] = block
end

#route(identifier, rep: :default, snapshot: :last) { ... } ⇒ void

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This method returns an undefined value.

Creates a routing rule for all items whose identifier match the given identifier, which may either be a string containing the ‘*` wildcard, or a regular expression.

This rule will be applicable to reps with a name equal to ‘:default`; this can be changed by giving an explicit `:rep` parameter.

The path of an item rep will be determined by calling the given block and passing the rep as a block argument.

Examples:

Routing the default rep of the ‘/foo/` item


route '/foo/' do
  item.identifier + 'index.html'
end

Routing the ‘:raw` rep of the `/bar/` item


route '/bar/', :rep => :raw do
  '/raw' + item.identifier + 'index.txt'
end

Parameters:

  • identifier (String) —

    A pattern matching identifiers of items that should be routed using this rule

  • rep (Symbol) (defaults to: :default) —

    The name of the representation

  • snapshot (Symbol) (defaults to: :last) —

    The name of the snapshot

Yields:

  • The block that will be executed when an item matching this compilation rule needs to be routed

Raises:

  • (ArgumentError) 


111
112
113
114
115
116
 
# File 'lib/nanoc/rule_dsl/compiler_dsl.rb', line 111

def route(identifier, rep: :default, snapshot: :last, &block)
  raise ArgumentError.new('#route requires a block') unless block_given?

  rule = Nanoc::RuleDSL::RoutingRule.new(create_pattern(identifier), rep, block, snapshot_name: snapshot)
  @rules_collection.add_item_routing_rule(rule)
end