ctioga2 0.8 → 0.9

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

@@ -108,7 +108,7 @@ module CTioga2
           attr_accessor :target
           
           # _target_ is the name of the target, which can be of _type_
-          # 'group', 'command', 'backend', 'type' and 'url'
+          # 'group', 'command', 'backend', 'type', 'function' and 'url'
           def initialize(doc, target, type)
             super(doc)
             if type =~ /url/
@@ -279,7 +279,7 @@ module CTioga2
         protected 
 
         # A few constants to help writing out the paragraph markup
-        LinkRE = /\{(group|type|command|backend|url):\s*([^}]+?)\s*\}/
+        LinkRE = /\{(group|type|command|backend|url|function):\s*([^}]+?)\s*\}/
 
         MarkOnceRE = /@([^@]+)@/
         

data/lib/ctioga2/commands/function.rb

@@ -0,0 +1,90 @@
+# function.rb: makefile-like functions
+# copyright (c) 2014 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/strings'
+
+module CTioga2
+
+  module Commands
+
+    # A Function is a makefile-like "macro" or "function" that takes
+    # one or more arguments (no argumentless functions for now).
+    #
+    # This class provides both the definition and handling of a
+    # function and the global registry of functions.
+    class Function
+
+      # The underlying proc object. The first argument to the code is
+      # *always* the plotmaker object.
+      attr_accessor :code
+
+      # The name of the function. Probably better lowercase ?
+      attr_accessor :name
+
+      # A short description
+      attr_accessor :short_description
+
+      # Long description, ie a help text like the rest
+      attr_accessor :description
+
+      # Registers a function.
+      #
+      # @todo Have self-documenting capacities !
+      def initialize(name, short_desc, &blk)
+        @code = blk
+        @name = name
+        @short_description = short_desc
+        
+        Function.register(self)
+      end
+
+      def describe(txt)
+        @description = txt
+      end
+
+      # Expands the function, and returns the corresponding string.
+      def expand(string, interpreter)
+        if @code.arity == 2
+          args = [string.expand_to_string(interpreter)]
+        else
+          args = string.expand_and_split(/\s+/, interpreter)
+        end
+        if (@code.arity > 0) and (args.size != (@code.arity - 1))
+          raise "Function #{@name} expects #{@code.arity} arguments, but was given #{args.size}"
+        end
+        return @code.call(interpreter.plotmaker_target, *args).to_s
+      end
+
+      # Registers the given function definition
+      def self.register(func)
+        @functions ||= {}
+        @functions[func.name] = func
+      end
+
+      # Returns the named function definition, or nil if there isn't
+      # such.
+      def self.named_function(name)
+        return @functions[name]
+      end
+
+      # Returns the functions hash
+      def self.functions
+        return @functions
+      end
+      
+    end
+  end
+
+end
+

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

@@ -85,6 +85,18 @@ EOH
     
     EvalCommand.describe("Runs the given commands", <<EOH, GeneralGroup)
 Runs the given strings as commands, as if given from a command file.
+EOH
+
+    # Evaluate a series of commands.
+    SetCommand =  Cmd.new("set", nil, "--set", 
+                          [ CmdArg.new('text'), 
+                            CmdArg.new('text') ]) do |plotmaker, variable, value|
+      plotmaker.interpreter.variables.define_variable(variable, value)
+    end
+    
+    SetCommand.describe("Sets the value of a variable", <<EOH, GeneralGroup)
+Sets the value of the variable (first argument) to the given second argument.
+No parsing is done.
 EOH
 
     # Increases verbosity

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

@@ -0,0 +1,106 @@
+# general-functions.rb: useful function definitions
+# copyright (c) 2014 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/data/point'
+
+module CTioga2
+
+  module Commands
+
+    FuncEval = Function.new("eval", "Evaluate Ruby code") do |pm, code|
+      eval(code)
+    end
+
+    FuncEval.describe <<EOD
+Evaluate its argument as Ruby code
+
+# a := $(eval 2 + 2)
+# # a is now 4
+
+Keep in mind that variables in @ctioga2@ work by plain text replacement. 
+They have no type. In particular, while this will work:
+
+# a := 3
+# b := $(eval $(a) * 3)
+# # b is now 9
+
+Doing the same kind of things with text will be somewhat not satisfying:
+
+# a := "two words"
+# b := $(eval $(a).split(/ /).first)
+
+Running this will give the following syntax error:
+
+@ [FATAL] (eval):1: syntax error, unexpected $end, expecting ')'
+@ two words.split(/ /
+@                    ^ while processing line 2 in file 'c.ct2'
+
+Doing it right would require the use of a decent amount of quotes.
+EOD
+
+    FuncPoint = Function.new("point", "Get dataset point information") do |pm, what, spec, *rest|
+      dataset = if rest.first
+                  pm.data_stack.stored_dataset(rest.first)
+                else
+                  nil
+                end
+      
+      point = Data::DataPoint::from_text(pm, spec, dataset)
+
+      case what
+      when "x", "X"
+        point.x.to_s
+      when "y", "Y"
+        point.y.to_s
+      when "xy", "XY"
+        "%g,%g" % point.point
+      else
+        # The \ are not strictly speaking necessary, but they make
+        # ruby-mode happier
+        raise "\'#{what}\' unkown: which coordinate(s) of the point do you want ?"
+      end
+
+    end
+
+    FuncPoint.describe <<EOD
+
+Returns the requested information about the given point in a
+dataset. Run this way:
+
+# $(point x @234)
+
+The first argument, here @x@ tells what we want to know about the
+given point: its @x@ value (passing @x@), its @y@ value (passing @y@),
+both its @x@ and @y@ ready to be used as coordinates for drawing
+commands using @xy@. For instance, to draw a circle marker right in
+the middle of the last dataset plotted, just run
+
+# draw-marker $(point xy 0.5) Circle
+
+The second argument specifies a dataset point, just like for 
+{type: data-point}.
+
+An optional third argument specifies the dataset from which one wants
+the point information. Note that the dataset can also be specified
+within the second argument, but it may be more readable to do it as an
+optional third. It is parsed as {type: stored-dataset}
+
+
+EOD
+
+
+    
+  end
+end
+

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

@@ -102,16 +102,21 @@ EOD
     # afterwards, actually, since an access to a plotmaker object is
     # necessary.
     DataPointType = CmdType.new('data-point', :data_point, <<EOD)
-A point from a Dataset.
+A point from an already-loaded Dataset. You have two ways to choose the point:
 
-\todo document ;-)...
+ * @@13@ takes the 13th point in the last dataset;
+ * @0.2@ takes the point the closest to 20% of the dataset.
+
+If you need another dataset than the last one, give its number or
+named within brackets: @{-2}0.2@ is the point closest to the 20% of
+the one-before-last dataset.
 EOD
 
     # A LaTeX font
     LaTeXFontType = CmdType.new('latex-font', :latex_font, <<EOD)
 A LaTeX font.
 
-\todo document !
+@todo document !
 EOD
 
     # A color map

data/lib/ctioga2/commands/interpreter.rb

@@ -16,6 +16,8 @@ require 'ctioga2/commands/commands'
 require 'ctioga2/commands/context'
 require 'ctioga2/commands/variables'
 require 'ctioga2/commands/strings'
+require 'ctioga2/commands/function'
+require 'ctioga2/commands/general-functions'
 require 'ctioga2/commands/parsers/command-line'
 require 'ctioga2/commands/doc/doc'
 
@@ -192,6 +194,15 @@ module CTioga2
         @context = ParsingContext.new
       end
 
+      # Calls the given function and returns the result
+      def call_function(name, args)
+        func = Function.named_function(name)
+        if ! func
+          raise "Unkown function #{name}"
+        end
+        return func.expand(args, self)
+      end
+
 
       # Parses and run the given command-line, sending the commands to
       # the #plotmaker_target.

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

@@ -1,5 +1,5 @@
 # file.rb: new style file parser for ctioga2
-# copyright (c) 2013 by Vincent Fourmond
+# copyright (c) 2013, 2014 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
@@ -115,12 +115,14 @@ module CTioga2
           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*(.*)/
+            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)
+              value = InterpreterString.parse_until_unquoted(StringIO.new($4),"\n", false)
+              override = !($2 == '?')
+              rec = (($3 == "=") ? nil : interpreter)
+              
                       
-              interpreter.variables.define_variable(symbol, value, rec)
+              interpreter.variables.define_variable(symbol, value, rec, override)
             elsif l =~ /^\s*#/
                 # comment...
             else

data/lib/ctioga2/commands/strings.rb

@@ -137,6 +137,17 @@ module CTioga2
               if ch == ")"
                 push_current_element
                 @state = (@state == :var ? :top : :double)
+              elsif ch =~ /\s/
+                # We don't have a variable, but a function...
+                @accessory = InterpreterString.parse_until_unquoted(@io, ")", true)
+                ch = @io.getc   # Slurp the closing )
+                ns = (@state == :var ? :top : :double)
+                @state = (:var ? :funcall : :dq_funcall)
+                push_current_element
+                @state = ns
+                ## @todo Optional: instead of having a space, use a ,
+                ## or . or # to signify different separators ? (but
+                ## quoting makes this more-or-less unnecessary, hey ?)
               else
                 @current_string += ch
               end
@@ -186,6 +197,10 @@ module CTioga2
             @parsed << [:unquoted_variable, @current_string]
           when :dq_var
             @parsed << [:quoted_variable, @current_string]
+          when :funcall
+            @parsed << [:unquoted_funcall, @current_string, @accessory]
+          when :dq_funcall
+            @parsed << [:quoted_funcall, @current_string, @accessory]
           when :dollar
             @parsed << [:unquoted, @current_string + '$']
           when :dq_dollar
@@ -272,12 +287,12 @@ module CTioga2
 
       protected
 
-      # Returns a new InterpreterString object with all variables
-      # expanded. _interpreter_ is the Interpreter in which the
-      # expansion takes place.
+      # Returns a new InterpreterString object with all variables and
+      # function calls expanded. _interpreter_ is the Interpreter in
+      # which the expansion takes place.
       def expand_all_variables(interpreter)
         c = []
-        for type, value in @contents
+        for type, value, args in @contents
           case type
           when :quoted_variable
             c << [:quoted, interpreter.variables.
@@ -285,6 +300,12 @@ module CTioga2
           when :unquoted_variable
             c << [:unquoted, interpreter.variables.
                   expand_variable(value, interpreter)]
+          when :quoted_funcall
+            c << [:quoted, interpreter.
+                  call_function(value, args)]
+          when :unquoted_funcall
+            c << [:unquoted, interpreter.
+                  call_function(value, args)]
           else
             c << [type, value]
           end

data/lib/ctioga2/commands/variables.rb

@@ -59,7 +59,11 @@ module CTioga2
       # expanded at the time of the definition, (immediate variable),
       # whereas if it stays _nil_, the variable is defined as a
       # recursively defined variable.
-      def define_variable(name, value, interpreter = nil)
+      def define_variable(name, value, interpreter = nil, override = true)
+        if (!override) && @variables.key?(name)
+          # Not redefining an already defined variable.
+          return
+        end
         if value.respond_to? :expand_to_string
           if interpreter
             value = value.expand_to_string(interpreter)

data/lib/ctioga2/data/point.rb

@@ -40,7 +40,7 @@ module CTioga2
       # accesses the data stack.
       #
       # Specification: ({_dataset_})?(_relative_|@_index_)
-      def self.from_text(plotmaker, text)
+      def self.from_text(plotmaker, text, dataset = nil)
         if text =~ /^(?:\s*\{([^}]+)\})?\s*(?:([.\d]+)|@(\d+))\s*$/
           which = $1 || -1
           if $2
@@ -48,7 +48,7 @@ module CTioga2
           else
             idx = $3.to_i
           end
-          dataset = plotmaker.data_stack.stored_dataset(which)
+          dataset ||= plotmaker.data_stack.stored_dataset(which)
           
           if ! dataset
             raise "Invalid or empty dataset: #{which}"
@@ -62,9 +62,17 @@ module CTioga2
         end
       end
 
-      # @todo functions returning xy values + slope for the given
-      # datapoint. For each, possibility to average over several points.
+      def x
+        return @dataset.x.values[@index]
+      end
+
+      def y
+        return @dataset.y.values[@index]
+      end
 
+      def point
+        return [self.x, self.y]
+      end
 
       # Returns the averaged X value around the datapoint
       def x_val(navg = 3)

data/lib/ctioga2/graphics/elements/curve2d.rb

@@ -74,6 +74,17 @@ module CTioga2
           return Types::Boundaries.bounds(@function.x, @function.y)
         end
 
+        def can_clip?
+          if @curve_style.clipped or 
+              ( @curve_style.fill && @curve_style.fill.fill?) or
+              ( parent.is_a?(Region))
+            return false
+          else
+            return true
+          end
+        end
+          
+
         # Creates a path for the given curve. This should be defined
         # with care, as it will be used for instance for region
         # coloring and stroking. The function should only append to
@@ -86,7 +97,7 @@ module CTioga2
             case @curve_style.path_style
             when /^splines/
               for f in func.split_monotonic
-                new_f = if @curve_style.clipped 
+                new_f = if can_clip?
                           f.bound_values(*bnds.extrema)
                         else
                           f.dup
@@ -103,7 +114,7 @@ module CTioga2
 
               # Hmmmm. This may get the wrong thing if you happen to
               # draw something completely outside.
-              if @curve_style.clipped 
+              if can_clip? 
                 f = func.bound_values(*bnds.extrema)
               else
                 f = func