› Bake › Source › Bake › Recipe

class Recipe

Structured access to an instance method in a bakefile.

Definitions

def initialize(instance, name, method = nil)

Initialize the recipe.

Signature
parameter　instance　Base

The instance this recipe is attached to.

parameter　name　String

The method name.

parameter　method　Method | Nil

The method if already known.

Implementation

 
def initialize(instance, name, method = nil)
	@instance = instance
	@name = name
	@command = nil
	@comments = nil
	@signature = nil
	@documentation = nil
	
	@method = method
	@arity = nil
end

attr :instance

The class Bake::Base instance that this recipe is attached to.

attr :name

The name of this recipe.

def <=>(other)

Sort by location in source file.

Implementation

 
def <=> other
	(self.source_location || []) <=> (other.source_location || [])
end

def method

The method implementation.

Implementation

 
def method
	@method ||= @instance.method(@name)
end

def source_location

The source location of this recipe.

Implementation

 
def source_location
	self.method.source_location
end

def parameters

The recipe's formal parameters, if any.

Signature
returns　Array | Nil

Implementation

 
def parameters
	parameters = method.parameters
	
	unless parameters.empty?
		return parameters
	end
end

def options?

Whether this recipe has optional arguments.

Signature
returns　Boolean

Implementation

 
def options?
	if parameters = self.parameters
		parameters.any? do |type, name|
			type == :keyrest || type == :keyreq || type == :key
		end
	end
end

def output?

If a recipe produces output, we do not need to invoke the default output command.

Signature
returns　Boolean

Whether this recipe produces output.

Implementation

 
def output?
	@instance.output?(self)
end

def command

The command name for this recipe.

Implementation

 
def command
	@command ||= compute_command
end

def arity

The method's arity, the required number of positional arguments.

Implementation

 
def arity
	if @arity.nil?
		@arity = method.parameters.count{|type, name| type == :req}
	end
	
	return @arity
end

def prepare(arguments, last_result = nil)

Process command line arguments into the ordered and optional arguments.

Signature
parameter　arguments　Array(String)

The command line arguments

Implementation

 
def prepare(arguments, last_result = nil)
	Arguments.extract(self, arguments, input: last_result)
end

def call(*arguments, **options, &block)

Call the recipe with the specified arguments and options. If the recipe does not accept options, they will be ignored.

Implementation

 
def call(*arguments, **options, &block)
	if options.any? and self.options?
		@instance.send(@name, *arguments, **options, &block)
	else
		# Ignore options...
		@instance.send(@name, *arguments, &block)
	end
end

def comments

Any comments associated with the source code which defined the method.

Signature
returns　Array(String)

The comment lines.

Implementation

 
def comments
	@comments ||= read_comments
end

def documentation

The documentation object which provides structured access to the Bake::Recipe#comments.

Signature
returns　Documentation

Implementation

 
def documentation
	@documentation ||= Documentation.new(self.comments)
end

def signature

The documented type signature of the recipe.

Signature
returns　Array

An array of module Bake::Type instances.

Implementation

 
def signature
	@signature ||= read_signature
end

alias types signature

  • deprecated

Signature
deprecated

Use Bake::Recipe#signature instead.