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.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/ctioga2/commands/interpreter.rb', line 174

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
end

Instance Attribute Details

#command_line_parser ⇒ Object (readonly)

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



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

def command_line_parser
  @command_line_parser
end

#doc ⇒ Object (readonly)

The Documentation::Doc object that can interact with documentation



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

def doc
  @doc
end

#file_parser ⇒ Object (readonly)

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



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

def file_parser
  @file_parser
end

#plotmaker_target ⇒ Object

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



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

def plotmaker_target
  @plotmaker_target
end

#variables ⇒ Object

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



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

def variables
  @variables
end

Class Method Details

.command(cmd) ⇒ Object

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



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

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

.commands ⇒ Object

Returns the commands hash



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

def self.commands
  return @@commands
end

.delete_command(cmd) ⇒ Object

Deletes a command whose name is given



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

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.



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

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

.groups ⇒ Object

Returns the groups hash



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

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.



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

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.



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

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.



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

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



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

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

.types ⇒ Object

Returns all registered CommandType objects



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

def self.types
  return @@types
end

Instance Method Details

#command_names ⇒ Object

Returns the list of all know command names



227
228
229
 
# File 'lib/ctioga2/commands/interpreter.rb', line 227

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.



218
219
220
221
222
223
224
 
# File 'lib/ctioga2/commands/interpreter.rb', line 218

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.



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

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.



204
205
206
207
208
209
 
# File 'lib/ctioga2/commands/interpreter.rb', line 204

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

#run_command_line(args) ⇒ Object

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



195
196
197
198
199
 
# File 'lib/ctioga2/commands/interpreter.rb', line 195

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.



212
213
214
 
# File 'lib/ctioga2/commands/interpreter.rb', line 212

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