Class: CTioga2::Commands::Interpreter

Inherits:
Object
  • Object
show all
Defined in:
lib/ctioga2/commands/interpreter.rb

Overview

The core class interpreting all the commands and executing them. It holds a hash class variable containing all the Command objects defined so far.

Constant Summary collapse

@@commands =

All commands defined so far.

{}
@@groups =

All command groups defined so far.

{}
@@types =

All types defined so fat

{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(target) ⇒ Interpreter

Creates an Interpreter with target as the PlotMaker target object.

As far as command-line and help is concerned, it takes a snapshot of the current commands known to the system, so please instantiate it last.

todo probably this behavior is not really desired. Easy to fix.



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/ctioga2/commands/interpreter.rb', line 178

def initialize(target)
  @plotmaker_target = target
  @command_line_parser = 
    Parsers::CommandLineParser.new(@@commands.values, 
                                   CTioga2::PlotMaker::PlotCommand)

  @doc = Documentation::Doc.new()
  @variables = Variables.new

  # We import the variables from the environment, just like a in
  # a Makefile
  for k, v in ENV
    @variables.define_variable(k, v)
  end

  @file_parser = Parsers::FileParser.new
  @context = ParsingContext.new
end

Instance Attribute Details

#command_line_parser ⇒ Object (readonly)

The Parsers::CommandLineParser object used to… parse the command-line. (surprising, isn’t it ??)



158
159
160
 
# File 'lib/ctioga2/commands/interpreter.rb', line 158

def command_line_parser
  @command_line_parser
end

#context ⇒ Object

The current context



167
168
169
 
# File 'lib/ctioga2/commands/interpreter.rb', line 167

def context
  @context
end

#doc ⇒ Object (readonly)

The Documentation::Doc object that can interact with documentation



161
162
163
 
# File 'lib/ctioga2/commands/interpreter.rb', line 161

def doc
  @doc
end

#file_parser ⇒ Object (readonly)

The Parsers::FileParser object used to… parse files ?



164
165
166
 
# File 'lib/ctioga2/commands/interpreter.rb', line 164

def file_parser
  @file_parser
end

#plotmaker_target ⇒ Object

The PlotMaker object that will receive the commands of the Interpreter.



154
155
156
 
# File 'lib/ctioga2/commands/interpreter.rb', line 154

def plotmaker_target
  @plotmaker_target
end

#variables ⇒ Object

A Variables object holding the … variables ! (I’m sure you guessed it !)



150
151
152
 
# File 'lib/ctioga2/commands/interpreter.rb', line 150

def variables
  @variables
end

Class Method Details

.command(cmd) ⇒ Object

Returns the command given by its name cmd, or nil if none was found.



129
130
131
 
# File 'lib/ctioga2/commands/interpreter.rb', line 129

def self.command(cmd)
  return @@commands[cmd]
end

.commands ⇒ Object

Returns the commands hash



139
140
141
 
# File 'lib/ctioga2/commands/interpreter.rb', line 139

def self.commands
  return @@commands
end

.delete_command(cmd) ⇒ Object

Deletes a command whose name is given



124
125
126
 
# File 'lib/ctioga2/commands/interpreter.rb', line 124

def self.delete_command(cmd)
  @@commands.delete(cmd)
end

.group(id) ⇒ Object

Returns the groups given by its id, or nil if none was found.



134
135
136
 
# File 'lib/ctioga2/commands/interpreter.rb', line 134

def self.group(id)
  return @@groups[id]
end

.groups ⇒ Object

Returns the groups hash



144
145
146
 
# File 'lib/ctioga2/commands/interpreter.rb', line 144

def self.groups
  return @@groups
end

.register_command(command) ⇒ Object

Registers a given command. This is called automatically from Command.new, so you should not have to do it yourself.



72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/ctioga2/commands/interpreter.rb', line 72

def self.register_command(command)
  if self.command(command.name)
    raise DoubleDefinition, "Command '#{command.name}' already defined"
  else
    if command.name =~ NameValidationRE
      @@commands[command.name] = command
    else
      raise InvalidName, "Name '#{command.name}' is invalid"
    end
  end
end

.register_group(group) ⇒ Object

Registers a given group. This is called automatically from CommandGroup.new, so you should not have to do it yourself.



86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ctioga2/commands/interpreter.rb', line 86

def self.register_group(group)
  if self.group(group.id)
    raise DoubleDefinition, "Group '#{group.id}' already defined"
  else
    if group.id =~ NameValidationRE
      @@groups[group.id] = group
    else
      raise InvalidName, "Name '#{group.id}' is invalid"
    end
  end
end

.register_type(type) ⇒ Object

Registers a given type. This is called automatically from CommandType.new, so you should not have to do it yourself.



100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/ctioga2/commands/interpreter.rb', line 100

def self.register_type(type)
  if self.type(type.name)
    raise DoubleDefinition, "Type '#{type.name}' already defined"
  else
    if type.name =~ NameValidationRE
      @@types[type.name] = type
    else
      raise InvalidName, "Name '#{type.name}' is invalid"
    end
  end
end

.type(name) ⇒ Object

Returns the named CommandType



114
115
116
 
# File 'lib/ctioga2/commands/interpreter.rb', line 114

def self.type(name)
  return @@types[name]
end

.types ⇒ Object

Returns all registered CommandType objects



119
120
121
 
# File 'lib/ctioga2/commands/interpreter.rb', line 119

def self.types
  return @@types
end

Instance Method Details

#call_function(name, args) ⇒ Object

Calls the given function and returns the result



198
199
200
201
202
203
204
 
# File 'lib/ctioga2/commands/interpreter.rb', line 198

def call_function(name, args)
  func = Function.named_function(name)
  if ! func
    raise "Unkown function #{name}"
  end
  return func.expand(args, self)
end

#command_names ⇒ Object

Returns the list of all know command names



248
249
250
 
# File 'lib/ctioga2/commands/interpreter.rb', line 248

def command_names
  return @@commands.keys
end

#get_command(symbol) ⇒ Object

Returns a Command object corresponding to the given symbol, or raises an UnknownCommand exception.



239
240
241
242
243
244
245
 
# File 'lib/ctioga2/commands/interpreter.rb', line 239

def get_command(symbol)
  if @@commands.key? symbol
    return @@commands[symbol]
  else
    raise UnknownCommand, "Unknown command: #{symbol}"
  end
end

#run_command(command, arguments, options = nil) ⇒ Object

Runs command with the given arguments and options, converting them as necessary. All the commands ran from this interpreter should be ran from here.

command can be either a String or a Command

Later, it could be a good idea to add a spying mechanism here.



259
260
261
262
263
264
265
266
267
268
 
# File 'lib/ctioga2/commands/interpreter.rb', line 259

def run_command(command, arguments, options = nil)
  converted_args = command.convert_arguments(arguments)
  if options
    converted_options = command.convert_options(options)
  else
    converted_options = nil
  end
  command.run_command(@plotmaker_target, converted_args,
                      converted_options)
end

#run_command_file(file) ⇒ Object

Parses and runs the given file. Sets PlotMaker#figure_name to the base name of the given file if no figure name was specified.



218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/ctioga2/commands/interpreter.rb', line 218

def run_command_file(file)
  if ! @plotmaker_target.figure_name
    @plotmaker_target.figure_name = file.gsub(/\.[^.]+$/,'').
      gsub(/%/, '%%')
  end

  dir = File::dirname(file)
  base = File::basename(file)

  Dir::chdir(dir) do
    @file_parser.run_command_file(base, self)
  end
end

#run_command_line(args) ⇒ Object

Parses and run the given command-line, sending the commands to the #plotmaker_target.



209
210
211
212
213
 
# File 'lib/ctioga2/commands/interpreter.rb', line 209

def run_command_line(args)
  @command_line_parser.parse_command_line(args, self) do |arg|
    puts "Non-optional argument: #{arg.first}"
  end
end

#run_commands(string) ⇒ Object

Parses and runs the given string.



233
234
235
 
# File 'lib/ctioga2/commands/interpreter.rb', line 233

def run_commands(string)
  @file_parser.run_commands(string, self)
end