module Antelope::Grammar::Generation
Handles the generation of output for the grammar.
Public Instance Methods
Generates the output. First, it runs through every given modifier, and instintates it. It then calls every modifier, turns it into a hash, and passes that hash to each of the given generators.
@param options [Hash] options. @param generators [Array<Generator>] a list of generators
to use in generation.
@param modifiers [Array<Array<(Symbol, call)>>] a list of
modifiers to apply to the grammar.
@return [void]
# File lib/antelope/grammar/generation.rb, line 27 def generate(options = {}, generators = :guess, modifiers = DEFAULT_MODIFIERS) mods = modifiers.map(&:last) .map { |x| x.new(self) } mods.each do |mod| puts "Running mod #{mod.class}..." if options[:verbose] mod.call end hash = Hash[modifiers.map(&:first).zip(mods)] # This is when we'd generate find_generators(generators, options).each do |gen| puts "Running generator #{gen}..." if options[:verbose] gen.new(self, hash).generate end end
Private Instance Methods
Find the corresponding generators. If the first argument isn’t ‘:guess`, it returns the first argument. Otherwise, it tries to “intelligently guess” by checking the type from the options or the compiler. If it is unable to find the type, it will raise a {NoTypeError}.
@raise [NoTypeError] if it could not determine the type of
the generator.
@param generators [Symbol, Array<Generator>] @param options [Hash] @return [Array<Generator>]
# File lib/antelope/grammar/generation.rb, line 58 def find_generators(generators, options) return generators unless generators == :guess generators = [Generator::Output] # command line precedence... type = options[:type] || options['type'] || compiler.options.fetch(:type) generators << Generator.generators.fetch(type.to_s) generators rescue KeyError raise NoTypeError, "Undefined type #{type}" end