ctioga2 0.0

data/lib/ctioga2/commands/general-types.rb

@@ -0,0 +1,118 @@
+# general-types.rb: various useful command types
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 101 $', '$Date: 2009-07-21 23:29:59 +0200 (Tue, 21 Jul 2009) $')
+
+  module Commands
+ 
+    # A file name.
+    FileType = CmdType.new('file', :string, <<EOD)
+A file name.
+EOD
+
+    # Plain text
+    TextType = CmdType.new('text', :string, <<EOD)
+Plain text.
+EOD
+
+    # A series of datasets
+    DatasetType = CmdType.new('dataset', :string, <<EOD)
+One expandable dataset.
+EOD
+
+    # Commands
+    CommandsType = CmdType.new('commands', :string, <<EOD)
+ctioga2 commands, such as the ones that could be found in
+command files.
+EOD
+
+    BooleanType = CmdType.new('boolean', :boolean, <<EOD)
+Yes or no.
+EOD
+
+
+
+    FloatType = CmdType.new('float', :float, <<EOD)
+A floating-point number.
+EOD
+
+    IntegerType = CmdType.new('integer', :integer, <<EOD)
+An integer.
+EOD
+
+    PartialFloatRangeType = CmdType.new('partial-float-range', 
+                                        :partial_float_range, <<EOD)
+A beginning:end range, where either of the endpoints can be ommitted.
+EOD
+
+    FloatRangeType = CmdType.new('float-range', 
+                                 :float_range, <<EOD)
+A beginning:end range.
+EOD
+
+    StringOrRegexp = CmdType.new('regexp', 
+                                 :string_or_regexp, <<EOD)
+A plain string or a regular expression (the latter being enclosed 
+within /.../).
+EOD
+
+    # Data-point. Unlike other types, this one needs to be processed
+    # afterwards, actually, since an access to a plotmaker object is
+    # necessary.
+    DataPointType = CmdType.new('data-point', :string, <<EOD)
+A point from a Dataset.
+
+TODO: document ;-)...
+EOD
+
+
+
+    # This ones get here since they mess up with syntax highlighting
+
+    # A stored dataset.
+    StoredDatasetType = CmdType.new('stored-dataset', 
+                                    :string, <<EOD)
+A dataset that has already been loaded. It is either:
+ * A number, in which case it specifies the index inside the stack. 0
+   is the first on that was pushed onto the stack (the oldest
+   dataset), 1 the second, -1 the last one, -2 the one before the last
+   and so on. (it works just like Ruby's arrays).
+ * The name of a named dataset.
+EOD
+
+    # Something meant to be fed to PlotStyle#get_axis_style
+    AxisType = CmdType.new('axis', :string, <<EOD)
+The name of an axis. It can be:
+ * left, top, bottom or right;
+ * x, xaxis, y, yaxis, which return one of the above depending 
+   on the preferences of the current plot;
+ * one of the named axes.
+EOD
+
+    # Something meant to be fed to PlotStyle#get_label_style
+    LabelType = CmdType.new('label', :string, <<EOD)
+The name of an label. It can be:
+ * title to mean the current plot's title.
+ * axis_tick or axis_ticks or simply axis, where axis is a a valid
+   {type: axis}.  It means the ticks of the given axis.
+ * axis_label, same as above but targets the label of the given axis.
+EOD
+
+    
+  end
+end
+

data/lib/ctioga2/commands/groups.rb

@@ -0,0 +1,73 @@
+# groups.rb: a group of commands
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/metabuilder/types'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 14 $', '$Date: 2009-04-27 21:49:16 +0200 (Mon, 27 Apr 2009) $')
+
+  module Commands
+
+    # A group of commands, organized along a same theme.
+    class CommandGroup
+
+      # The commands belonging to the group
+      attr_accessor :commands
+
+      # The name of the group
+      attr_accessor :name
+
+      # A short, unique, codelike name for the group.
+      attr_accessor :id
+
+      # A (longer) description of the group
+      attr_accessor :description
+
+      # The priority of the group. It influences the positioning of
+      # its command-line options in the --help display. Lower
+      # priorities come first.
+      attr_accessor :priority
+
+      # Whether the group is blacklisted or not, ie whether the group's
+      # help text will be displayed at all. 
+      attr_accessor :blacklisted
+
+      # The context of definition [file, line]
+      attr_accessor :context
+      
+      def initialize(id, name, desc = nil, priority = 0, blacklist = false,
+                     register = true)
+        @commands = []
+        @name = name
+        @id = id
+        @description = desc || name
+        @priority = priority
+        @blacklisted = blacklist
+
+        if register 
+          Interpreter.register_group(self)
+        end
+
+        # The context in which the group was defined
+        caller[1].gsub(/.*\/ctioga2\//, 'lib/ctioga2/') =~ /(.*):(\d+)/
+        @context = [$1, $2.to_i]
+      end
+      
+    end
+
+  end
+
+end
+

data/lib/ctioga2/commands/interpreter.rb

@@ -0,0 +1,257 @@
+# interpreter.rb: the interpreter of commands
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/commands/commands'
+require 'ctioga2/commands/variables'
+require 'ctioga2/commands/strings'
+require 'ctioga2/commands/parsers/command-line'
+require 'ctioga2/commands/doc/doc'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 18 $', '$Date: 2009-04-28 23:43:54 +0200 (Tue, 28 Apr 2009) $')
+
+  # This module contains the real core of ctioga2: a set of classes
+  # that implement the concept of commands. Each command translates
+  # into an action (of any kind).
+  #
+  # Commands can be specified using several ways: either using command-line
+  # options/arguments or through a commands file.
+  module Commands
+
+    # An exception raised when a command is defined twice
+    class DoubleDefinition < Exception
+    end
+
+    # An exception raised when a command is not known to the interpreter
+    class UnknownCommand < Exception
+    end
+
+    # An exception raised upon invalid names.
+    class InvalidName < Exception
+    end
+
+    # An exception raised when a CommandType is not known
+    class InvalidType < Exception
+    end
+
+    # A CommandGroup#id or Command#name should match this regular
+    # expression.
+    NameValidationRE = /^[a-z0-9-]+$/
+
+    # The core class interpreting all the commands and executing them.
+    # It holds a hash class variable containing all the Command
+    # objects defined so far.
+    class Interpreter
+
+      # All commands defined so far.
+      @@commands = {}
+
+      # All command groups defined so far.
+      @@groups = {}
+
+      # All types defined so fat
+      @@types = {}
+
+
+
+      # Registers a given command. This is called automatically from
+      # Command.new, so you should not have to do it yourself.
+      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
+
+      # Registers a given group. This is called automatically from
+      # CommandGroup.new, so you should not have to do it yourself.
+      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
+
+      # Registers a given type. This is called automatically from
+      # CommandType.new, so you should not have to do it yourself.
+      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
+
+
+      # Returns the named CommandType
+      def self.type(name)
+        return @@types[name]
+      end
+
+      # Returns all registered CommandType objects
+      def self.types
+        return @@types
+      end
+
+      # Deletes a command whose name is given
+      def self.delete_command(cmd)
+        @@commands.delete(cmd)
+      end
+
+      # Returns the command given by its name _cmd_, or nil if none was found.
+      def self.command(cmd)
+        return @@commands[cmd]
+      end
+
+      # Returns the groups given by its _id_, or nil if none was found.
+      def self.group(id)
+        return @@groups[id]
+      end
+
+      # Returns the commands hash
+      def self.commands
+        return @@commands
+      end
+
+      # Returns the groups hash
+      def self.groups
+        return @@groups
+      end
+
+      # A Variables object holding the ... variables ! (I'm sure you
+      # guessed it !)
+      attr_accessor :variables
+
+      # The PlotMaker object that will receive the commands of the
+      # Interpreter. 
+      attr_accessor :plotmaker_target
+
+      # The Parsers::CommandLineParser object used to... parse the command-line.
+      # (surprising, isn't it ??)
+      attr_reader :command_line_parser
+
+      # The Documentation::Doc object that can interact with documentation
+      attr_reader :doc
+
+      # The Parsers::FileParser object used to... parse files ?
+      attr_reader :file_parser
+
+      # 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.
+      def initialize(target)
+        @plotmaker_target = target
+        @command_line_parser = 
+          Parsers::CommandLineParser.new(@@commands.values, 
+                                         CTioga2::PlotMaker::PlotCommand)
+
+        @doc = Documentation::Doc.new()
+        @variables = Variables.new
+
+        @file_parser = Parsers::FileParser.new
+      end
+
+
+      # Parses and run the given command-line, sending the commands to
+      # the #plotmaker_target.
+      def run_command_line(args)
+        @command_line_parser.parse_command_line(args, self) do |arg|
+          puts "Non-optional argument: #{arg.first}"
+        end
+      end
+
+      # Parses and runs the given file. Sets PlotMaker#figure_name to
+      # the base name of the given file if no figure name was
+      # specified.
+      def run_command_file(file)
+        @file_parser.run_command_file(file, self)
+        if ! @plotmaker_target.figure_name
+          @plotmaker_target.figure_name = file.gsub(/\.[^.]+$/,'')
+        end
+      end
+
+      # Parses and runs the given string.
+      def run_commands(string)
+        @file_parser.run_commands(string, self)
+      end
+
+      # Returns a Command object corresponding to the given _symbol_, or
+      # raises an UnknownCommand exception.
+      def get_command(symbol)
+        if @@commands.key? symbol
+          return @@commands[symbol]
+        else
+          raise UnknownCommand, "Unknown command: #{symbol}"
+        end
+      end
+
+      # Returns the list of all know command names
+      def command_names
+        return @@commands.keys
+      end
+
+      # 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.
+      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
+    end
+  end
+  
+  # An alias for Commands::Command
+  Cmd = Commands::Command
+
+  # An alias for Commands::CommandArgument
+  CmdArg = Commands::CommandArgument
+
+  # An alias for Commands::CommandGroup
+  CmdGroup = Commands::CommandGroup
+
+  # An alias for Commands::CommandType
+  CmdType = Commands::CommandType
+end
+