Class: Bake::Recipe

Inherits:
Object
  • Object
show all
Defined in:
lib/bake/recipe.rb

Overview

Structured access to an instance method in a bakefile.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(instance, name, method = nil) ⇒ Recipe

Initialize the recipe.

Parameters:

  • instance (Base) —

    The instance this recipe is attached to.

  • name (String) —

    The method name.

  • method (Method | Nil) (defaults to: nil) —

    The method if already known.



32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/bake/recipe.rb', line 32

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

Instance Attribute Details

#instance ⇒ Object (readonly)

The Base instance that this recipe is attached to.



45
46
47
 
# File 'lib/bake/recipe.rb', line 45

def instance
  @instance
end

#name ⇒ Object (readonly)

The name of this recipe.



48
49
50
 
# File 'lib/bake/recipe.rb', line 48

def name
  @name
end

Instance Method Details

#<=>(other) ⇒ Object

Sort by location in source file.



51
52
53
 
# File 'lib/bake/recipe.rb', line 51

def <=> other
	self.source_location <=> other.source_location
end

#arity ⇒ Object

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



95
96
97
98
99
100
101
 
# File 'lib/bake/recipe.rb', line 95

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

#call(*arguments, **options) ⇒ Object

Call the recipe with the specified arguments and options.



145
146
147
148
149
150
151
152
 
# File 'lib/bake/recipe.rb', line 145

def call(*arguments, **options)
	if options?
		@instance.send(@name, *arguments, **options)
	else
		# Ignore options...
		@instance.send(@name, *arguments)
	end
end

#command ⇒ Object

The command name for this recipe.



86
87
88
 
# File 'lib/bake/recipe.rb', line 86

def command
	@command ||= compute_command
end

#comments ⇒ Array(String)

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

Returns:

  • (Array(String)) —

    The comment lines.



156
157
158
 
# File 'lib/bake/recipe.rb', line 156

def comments
	@comments ||= read_comments
end

#documentation ⇒ Documentation

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

Returns:



162
163
164
 
# File 'lib/bake/recipe.rb', line 162

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

#method ⇒ Object

The method implementation.



56
57
58
 
# File 'lib/bake/recipe.rb', line 56

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

#options? ⇒ Boolean

Whether this recipe has optional arguments.

Returns:

  • (Boolean) 


77
78
79
80
81
82
83
 
# File 'lib/bake/recipe.rb', line 77

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

#parameters ⇒ Array | Nil

The recipe’s formal parameters, if any.

Returns:

  • (Array | Nil) 


67
68
69
70
71
72
73
 
# File 'lib/bake/recipe.rb', line 67

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

#prepare(arguments) ⇒ Object

Process command line arguments into the ordered and optional arguments.

Parameters:

  • arguments (Array(String)) —

    The command line arguments



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/bake/recipe.rb', line 107

def prepare(arguments)
	offset = 0
	ordered = []
	options = {}
	parameters = method.parameters.dup
	types = self.types
	
	while argument = arguments.first
		name, value = argument.split('=', 2)
		
		if name and value
			# Consume it:
			arguments.shift
			
			if type = types[name.to_sym]
				value = type.parse(value)
			end
			
			options[name.to_sym] = value
		elsif ordered.size < self.arity
			_, name = parameters.shift
			value = arguments.shift
			
			if type = types[name]
				value = type.parse(value)
			end
			
			# Consume it:
			ordered << value
		else
			break
		end
	end
	
	return ordered, options
end

#source_location ⇒ Object

The source location of this recipe.



61
62
63
 
# File 'lib/bake/recipe.rb', line 61

def source_location
	self.method.source_location
end

#to_s ⇒ Object 



90
91
92
 
# File 'lib/bake/recipe.rb', line 90

def to_s
	self.command
end

#types ⇒ Array

The documented type signature of the recipe.

Returns:

  • (Array) —

    An array of Types instances.



168
169
170
 
# File 'lib/bake/recipe.rb', line 168

def types
	@types ||= read_types
end