ctioga2 0.4 → 0.5

data/Changelog

@@ -1,3 +1,19 @@
+ctioga2 (0.5)
+
+  * Choose the side of axis ticks 
+  * Multicolumn legends
+  * Much more control about the details of the legends
+  * A drop command to remove datasets from the stack
+  * A much simpler format for command files
+  * Improved error detection/report (including now LaTeX errors, with
+    Tioga version 1.16)
+  * Real contour plots
+  * Specify text size/shift with real dimensions
+  * Many bug fixes
+  * Default size of tick labels is now larger
+  
+ -- Vincent <vincent.fourmond@9online.fr>  Mon 26 Aug 22:04:05 CEST 2013
+
 ctioga2 (0.4)
 
   * Fixed a bug in /which (dataset) options

data/lib/ctioga2/commands/arguments.rb

@@ -16,7 +16,7 @@ require 'ctioga2/commands/type'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 355 $', '$Date: 2012-12-26 00:19:04 +0100 (Wed, 26 Dec 2012) $')
+  Version::register_svn_info('$Revision: 383 $', '$Date: 2013-03-11 21:57:53 +0100 (Mon, 11 Mar 2013) $')
 
   module Commands
 
@@ -42,7 +42,10 @@ module CTioga2
       # name
       attr_accessor :option_target
 
-      # Whether or not the option is deprecated
+      # Whether or not the option is deprecated.
+      #
+      # If evaluates as true and different from _true_, is converted
+      # into a string used as an explanation to the user
       attr_accessor :option_deprecated
 
       # _type_ is a named CommandType

data/lib/ctioga2/commands/commands.rb

@@ -17,7 +17,7 @@ require 'ctioga2/commands/groups'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 355 $', '$Date: 2012-12-26 00:19:04 +0100 (Wed, 26 Dec 2012) $')
+  Version::register_svn_info('$Revision: 430 $', '$Date: 2013-08-23 14:23:52 +0200 (Fri, 23 Aug 2013) $')
 
   module Commands
 
@@ -90,6 +90,14 @@ module CTioga2
       # The context of definition [file, line]
       attr_accessor :context
 
+      # The context of the documentation
+      attr_accessor :documentation_context
+
+      def self.get_calling_context(id=2)
+        caller[id].gsub(/.*\/ctioga2\//, 'lib/ctioga2/') =~ /(.*):(\d+)/
+        return [$1, $2.to_i]
+      end
+
       # Creates a Command, with all attributes set up. The code can be
       # set using #set_code.
       #
@@ -109,8 +117,7 @@ module CTioga2
         @code = code
         self.describe(d_short, d_long, group)
 
-        caller[1].gsub(/.*\/ctioga2\//, 'lib/ctioga2/') =~ /(.*):(\d+)/
-        @context = [$1, $2.to_i]
+        @context = Command.get_calling_context
 
         # Registers automatically the command
         if register
@@ -132,6 +139,7 @@ module CTioga2
       # Sets the descriptions of the command. If the long description
       # is ommitted, the short is reused.
       def describe(short, long = nil, group = nil)
+        @documentation_context = Command.get_calling_context(1)
         @short_description = short
         @long_description = long || short
         if(group)
@@ -140,6 +148,15 @@ module CTioga2
         end
       end
 
+      # Sets the long documentation of the given command
+      def self.document_command(cmd, desc)
+        tg = Commands::Interpreter.command(cmd)
+        if tg
+          tg.documentation_context = Command.get_calling_context(1)
+          tg.long_description = desc
+        end
+      end
+
       # Returns a list of three strings:
       # * the short option
       # * the long option with arguments
@@ -210,19 +227,24 @@ module CTioga2
       # instance for the OptionParser with boolean options)
       def convert_options(options)
         target_options = {}
+        conv = target_option_names()
         for k,v in options
-          if ! @optional_arguments.key? k
+          kn = normalize_option_name(k)
+          if ! conv.key? kn
             raise CommandOptionUnkown, "Unkown option #{k} for command #{@name}"
           end
-          opt = @optional_arguments[k]
+          opt = @optional_arguments[conv[kn]]
           if v.is_a? String
             v = opt.type.string_to_type(v)
           end
-          target = opt.option_target || k
+          target = opt.option_target || conv[kn]
           if opt.option_deprecated
             expl = ""
             if opt.option_target
               expl = " -- please use #{opt.option_target} instead"
+            elsif opt.option_deprecated != true # Ie more than plain
+                                                # true/false
+              expl = " -- #{opt.option_deprecated}"
             end
             Log::warn { "Deprecated option #{k}#{expl}" }
           end
@@ -232,15 +254,25 @@ module CTioga2
         return target_options
       end
 
+      # Returns a hash "normalized option names" => 'real option name'
+      def target_option_names
+        return @tg_op_names if @tg_op_names
+
+        @tg_op_names = {}
+        for k in @optional_arguments.keys
+          @tg_op_names[normalize_option_name(k)] = k
+        end
+        return @tg_op_names
+      end
+
+      # Returns a lowercase 
+      def normalize_option_name(opt)
+        return opt.gsub(/_/,"-").downcase
+      end
+
       # Whether the Command accepts the named _option_.
-      #
-      # \todo Several conversions could be used, to facilitate the
-      # writing of options:
-      #
-      # * convert everything to lowercase .
-      # * ignore the difference between _ and - (a bit delicate).
       def has_option?(option)
-        return @optional_arguments.key? option
+        return target_option_names.key?(normalize_option_name(option))
       end
 
       # Whether the Command accepts any option at all ?

data/lib/ctioga2/commands/context.rb

@@ -41,7 +41,15 @@ module CTioga2
         if @option
           "option #{@option} (##{@number})"
         else
-          "command #{@command} in file #{@file} line #{@number}"
+          file = @file.inspect
+          if @file.respond_to?(:path)
+            file = @file.path
+          end
+          if @command
+            "command #{@command} in file '#{file}' line #{@number}"
+          else
+            "line #{@number} in file '#{file}'"
+          end
         end
       end
 

data/lib/ctioga2/commands/doc/help.rb

@@ -18,7 +18,7 @@ require 'ctioga2/commands/doc/wordwrap'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 132 $', '$Date: 2010-01-14 23:18:19 +0100 (Thu, 14 Jan 2010) $')
+  Version::register_svn_info('$Revision: 409 $', '$Date: 2013-08-22 21:23:51 +0200 (Thu, 22 Aug 2013) $')
 
   module Commands
 
@@ -154,7 +154,7 @@ module CTioga2
           if cmd.has_options?
             op_start = '  options: '
             options = cmd.optional_arguments.
-              keys.sort.map { |x| "/#{x}"}.join(' ') 
+              keys.sort.map { |x| "/#{cmd.normalize_option_name(x)}"}.join(' ') 
             opts_lines = WordWrapper.wrap(options, size - op_start.size)
             str += "\n#{total_leading_spaces}#{style(op_start,'switch')}" + 
               style(opts_lines.join("\n#{total_leading_spaces}#{' ' * op_start.size}"), 'options')

data/lib/ctioga2/commands/doc/html.rb

@@ -16,7 +16,7 @@ require 'ctioga2/commands/commands'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 216 $', '$Date: 2010-12-31 16:18:17 +0100 (Fri, 31 Dec 2010) $')
+  Version::register_svn_info('$Revision: 409 $', '$Date: 2013-08-22 21:23:51 +0200 (Thu, 22 Aug 2013) $')
 
   module Commands
 
@@ -169,23 +169,23 @@ module CTioga2
           str << "<p class='synopsis'>\n<span class='bold'>Synopsis (file)</span>\n"
 
           str << "</p>\n<pre class='examples-cmdfile'>"
-          str << "<span class='cmd'>#{cmd.name}("
+          str << "<span class='cmd'>#{cmd.name} "
           str << cmd.arguments.map { |arg|
             "<a class='argument' href='#{@types_url}#type-#{arg.type.name}'>#{arg.displayed_name}</a>"
-          }.join(',')
+          }.join(' ')
           if cmd.has_options?
             if(cmd.arguments.size > 0)
-              str << ", "
+              str << " "
             end
-            str << "option=..."
+            str << "/option=..."
           end
-          str << ")</span>\n"
+          str << "</span>\n"
           str << "</pre>\n"
 
           # Command-line file synopsis
           str << "<p class='synopsis'>\n<span class='bold'>Synopsis  (command-line)</span>\n"
           args = cmd.arguments.map { |arg|
-            "<a class='argument' href='#{@types_url}#type-#{arg.type.name}'>#{arg.displayed_name.upcase}</a>"
+            "<a class='argument' href='#{@types_url}#type-#{arg.type.name}'>#{arg.displayed_name}</a>"
           }.join(' ')
           if cmd.has_options?
             args << " /option=..."
@@ -204,7 +204,7 @@ module CTioga2
           if cmd.has_options?
             str << "<p class='synopsis'><span class='bold'>Available options</span>:\n"
             opts = cmd.optional_arguments.sort.map do |k,arg|
-              "<a href='#{@types_url}#type-#{arg.type.name}'><code>#{k}</code></a>\n"
+              "<a href='#{@types_url}#type-#{arg.type.name}'><code>#{cmd.normalize_option_name(k)}</code></a>\n"
             end
             str << opts.join(' ')
             str << "</p>"

data/lib/ctioga2/commands/doc/introspection.rb

@@ -16,7 +16,7 @@ require 'ctioga2/commands/commands'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 336 $', '$Date: 2012-12-23 00:29:48 +0100 (Sun, 23 Dec 2012) $')
+  Version::register_svn_info('$Revision: 430 $', '$Date: 2013-08-23 14:23:52 +0200 (Fri, 23 Aug 2013) $')
 
   module Commands
 
@@ -106,10 +106,11 @@ module CTioga2
         end
 
         # Lauches an editor to edit the given command:
-        def edit_command(cmd)
+        def edit_command(cmd, doc)
           cmd = Interpreter::command(cmd)
           if cmd
-            edit_file(*cmd.context)
+            cntx = doc ? cmd.documentation_context : cmd.context
+            edit_file(*cntx)
           end
         end
 
@@ -205,8 +206,9 @@ EOH
 
       EditCommandCmd = 
         Cmd.new('edit-command', nil, '--edit-command',
-                [ CmdArg.new('text')]) do |plotmaker, cmd|
-        Introspection.new.edit_command(cmd)
+                [ CmdArg.new('text')], 
+                {'doc' => CmdArg.new('boolean')}) do |plotmaker, cmd, opts|
+        Introspection.new.edit_command(cmd, opts['doc'])
       end
 
       EditCommandCmd.describe("Edit the command",

data/lib/ctioga2/commands/parsers/file.rb

@@ -1,5 +1,5 @@
-# file.rb: a file parser for ctioga2
-# copyright (c) 2009 by Vincent Fourmond
+# file.rb: new style file parser for ctioga2
+# copyright (c) 2013 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
@@ -11,38 +11,28 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details (in the COPYING file).
 
-require 'stringio'
+
 require 'ctioga2/utils'
 require 'ctioga2/log'
 require 'ctioga2/commands/commands'
 require 'ctioga2/commands/strings'
+require 'ctioga2/commands/parsers/old-file'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 327 $', '$Date: 2012-11-28 14:47:52 +0100 (Wed, 28 Nov 2012) $')
+  Version::register_svn_info('$Revision: 420 $', '$Date: 2013-08-23 01:05:44 +0200 (Fri, 23 Aug 2013) $')
 
   module Commands
 
     module Parsers
 
-      # Raised when EOF is encountered during a symbol parsing
-      class UnterminatedSymbol < Exception
-      end
-
-      # Unexepected character.
-      class UnexpectedCharacter < Exception
-      end
-
-      # Syntax error
-      class ParserSyntaxError < Exception
-      end
-
-      # This class is in charge of parsing a command-line against a list
-      # of known commands. 
+      # This class parses a "new style" command file, delegating
       class FileParser
 
         include Log
 
+        
+
         # Runs a command file targeting the given _interpreter_.
         def self.run_command_file(file, interpreter)
           FileParser.new.run_command_file(file, interpreter)
@@ -68,122 +58,135 @@ module CTioga2
         # Parses a given _io_ object, sending commands/variable
         # definitions to the given _interpreter_.
         def parse_io_object(io, interpreter)
-          # The process is simple: we look for symbols and
-          # corresponding syntax element: parentheses or assignments
-
-          ## @todo It would be really great if assignments could be
-          ## made conditional (a bit like in makefiles)
-          while(1)
-            symbol = up_to_next_symbol(io)
-            break if not symbol
+
+          # We first split everything into lines
+          lines = io.readlines
+          
+          # First, we look for old-style commands to see if we
+          # delegate to the other parser. In any case, we build up a
+          # list of "unsplit" lines (ie gather lines that end with \)
+
+          parsed_lines = []
+          cur = nil 
+
+          lines_indices = []
+          idx = 0
+          
+
+          ## @todo line counting ?
+          for l in lines
+            idx += 1
+            # If we find something that looks like a command at the
+            # beginning of a line, we say this is an old style file.
+
+            ## @todo Find a way to disable this compatibility stuff --
+            ## or make it more accurate ? The problem is that in a
+            ## large command file, there may be things that look like
+            ## old style commands ?
             
-            while(1)
-              c = io.getc
-              if ! c              # EOF
-                raise ParserSyntaxError, "Expecting something after symbol #{symbol}"
-              end
-              ch = c.chr
-              if ch =~ /\s/      # blank...
-                next
-              elsif ch == '('    # beginning of a function call
-                # Parse string:
-                str = InterpreterString.parse_until_unquoted(io,")")
-                # Now, we need to split str.
-                args = str.expand_and_split(/\s*,\s*/, interpreter)
-
-                cmd = interpreter.get_command(symbol)
-                real_args = args.slice!(0, cmd.argument_number)
-                # And now the options:
-                options = {}
-
-                # Problem: the space on the right of the = sign is
-                # *significant*. 
-                for o in args
-                  if o =~ /^\s*\/?([\w-]+)\s*=(.*)/
-                    if cmd.has_option? $1
-                      options[$1] = $2
-                    else
-                      error { 
-                        "Command #{cmd.name} does not take option #{$1}" 
-                      }
-                    end
-                  end
-                end
+            if l =~ /^([a-z0-9-]+)\(/
+              path = io.respond_to?(:path) ? io.path : io.to_s
+              warn { "Found old style (deprecated) commands in '#{path}', using old style parser"}
+              return OldFileParser.new.
+                run_commands(lines.join(""), interpreter)
+            end
+            if cur
+              cur << l
+            else
+              cur = l
+            end
 
-                interpreter.context.parsing_file(symbol, io) # Missing line number
-                interpreter.run_command(cmd, real_args, options)
-                io.getc         # Slurp up the )
-                break
-              elsif ch == ':'   # Assignment
-                c = io.getc
-                if ! c          # EOF
-                  raise ParserSyntaxError, "Expecting = after :"
-                end
-                ch = c.chr
-                if ch != '='
-                  raise ParserSyntaxError, "Expecting = after :"
-                end
-                str = InterpreterString.parse_until_unquoted(io,"\n", false)
-                interpreter.variables.define_variable(symbol, str, 
-                                                      interpreter)
-                break
-              elsif ch == '='
-                str = InterpreterString.parse_until_unquoted(io,"\n", false)
-                interpreter.variables.define_variable(symbol, str, nil) 
-                break
-              else
-                raise UnexpectedCharacter, "Did not expect #{ch} after #{symbol}"
-              end
+            if cur =~ /\\$/ 
+              cur.gsub!(/\\$/,'')
+              cur.chomp!
+            else
+              # Strip all white space at the end of unfinished lines.
+              parsed_lines << cur.gsub(/\s+$/,"\n")
+              lines_indices << idx
+              cur = nil
             end
+            
           end
-        end
 
-        protected
+          # Flush any pending unfinished line
+          parsed_lines << cur if cur
+          lines_indices << idx if cur
+
+          # Now, we rearrange the lines...
+          idx = -1
+          for l in parsed_lines
+            idx += 1
+            interpreter.context.parsing_file(nil, io, lines_indices[idx])
+            if l =~ /^\s*([a-zA-Z0-9_-]+)\s*(=|:=)\s*(.*)/
+              symbol = $1
+              value = InterpreterString.parse_until_unquoted(StringIO.new($3),"\n", false)
+              rec = (($2 == "=") ? nil : interpreter)
+                      
+              interpreter.variables.define_variable(symbol, value, rec)
+            elsif l =~ /^\s*#/
+                # comment...
+            else
+              l += "\n"
+              str = InterpreterString.parse_until_unquoted(StringIO.new(l),"\n")
+              words = str.expand_and_split(/\s+/, interpreter)
 
-        SYMBOL_CHAR_REGEX = /[a-zA-Z0-9_-]/
-        
-        # Parses the _io_ stream up to and including the next
-        # symbol. Only white space or comments may be found on the
-        # way. This function returns the symbol.
-        #
-        # Symbols are composed of the alphabet SYMBOL_CHAR_REGEX.
-        def up_to_next_symbol(io)
-
-          symbol = nil          # As long as no symbol as been started
-          # it will stay nil.
-          while(1)
-            c = io.getc
-            if ! c              # EOF
-              if symbol
-                raise UnterminatedSymbol, "EOF reached during symbol parsing"
-              else
-                # File is finished and we didn't meet any symbol.
-                # Nothing to do !
-                return nil
+              # Take care of strings starting with spaces...
+              
+              if words.size == 0
+                next
               end
+              
+              symbol = words[0]
+              all_args = words[1..-1]
+              
+              cmd = interpreter.get_command(symbol)
+
+              args, opts = parse_args_and_opts(cmd, all_args)
+
+              interpreter.context.parsing_file(symbol, io, lines_indices[idx]) # Missing line number
+              interpreter.run_command(cmd, args, opts)
             end
-            ch = c.chr
-            if symbol           # We have started
-              if ch =~ SYMBOL_CHAR_REGEX
-                symbol += ch
+          end
+        end
+          
+        protected
+         
+        
+        # Parses the all_args into arguments and options.
+        def parse_args_and_opts(cmd, all_args)
+          
+          opts = {}
+          args = []
+          while all_args.size > 0
+            a = all_args.shift
+            if a =~ /^\/([a-zA-Z0-9_-]+)(=(.*))?$/
+              o = $1
+              if cmd.has_option?(o)
+                if $2
+                  if $3
+                    opts[o] = $3
+                  else
+                    opts[o] = all_args.shift
+                  end
+                else
+                  nxt = all_args.shift
+                  if nxt =~ /^\s*=\s*$/
+                    opts[o] = all_args.shift
+                  else
+                    opts[o] = nxt.gsub(/^\s*=/,'')
+                  end
+                end
               else
-                io.ungetc(c)
-                return symbol
+                warn { "#{o} looks like an option, but command #{cmd.name} does not have such an option" }
+                args << a
               end
             else
-              if ch =~ SYMBOL_CHAR_REGEX
-                symbol = ch
-              elsif ch =~ /\s/
-                # Nothing
-              elsif ch == '#'
-                io.gets
-              else
-                raise UnexpectedCharacter, "Unexpected character: #{ch}, when looking for a symbol"
-              end
+              args << a
             end
           end
-        end
 
+          return [args, opts]
+        end
       end
 
     end