flor 0.10.0 → 0.11.0

data/lib/flor/pcore/apply.rb

@@ -1,29 +1,28 @@
-#--
-# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
-
 
 class Flor::Pro::Apply < Flor::Procedure
+  #
+  # Applies a function.
+  #
+  # ```
+  # sequence
+  #   define sum a b
+  #     +
+  #       a
+  #       b
+  #   apply sum 1 2
+  # ```
+  #
+  # It is usually used implicitely, as in
+  # ```
+  # sequence
+  #   define sum a b
+  #     +
+  #       a
+  #       b
+  #   sum 1 2
+  # ```
+  # where flor figures out by itself it has to use this "apply" procedure
+  # to call the function.
 
   name 'apply'
 

data/lib/flor/pcore/case.rb

@@ -82,39 +82,37 @@ class Flor::Pro::Case < Flor::Procedure
 #    ot = tree; return if ot[1].size < 2
 #    t = Flor.dup(ot)
 #
-#    nchildren = [ t[1].first ]
+#    nchildren = []
 #    mode = :array
 #
-#    t[1][1..-1].each do |ct|
+#    #t[1][1..-1].each do |ct|
+#    non_att_children.each do |ct|
 #
-#      if mode == :array
+#      if nchildren.empty? || mode == :clause
+#        nchildren << ct
+#        mode = :array
+#        next
+#      end
 #
-#        if ct[0].is_a?(String)
-#          puts "---"
-#          dct0 = deref(ct[0])
-#          hct0 = toheap(ct, dct0)
-#          p dct0
-#          p hct0
-#          puts "/---"
-#        end
+#      ct0, ct1, ct2 = ct
 #
-#        if (Flor.is_tree?(ct[0]) || ct[0] == 'else') && ct[1].any?
-#          nchildren << (ct[0] == 'else' ? [ 'else', [], ct[2] ] : ct[0])
-#          if ct[1].size == 1
-#            nchildren << ct[1].first
-#          else # ct[1].size > 1
-#            sequence = [ 'sequence', ct[1], ct[1].first[2] ]
-#            nchildren << sequence
-#          end
-#        else
-#          nchildren << ct
-#          mode = :clause
+#      if (Flor.is_tree?(ct0) || ct0 == 'else') && ct1.any?
+#        nchildren << (ct0 == 'else' ? [ 'else', [], ct2 ] : ct0)
+#        if ct1.size == 1
+#          nchildren << ct1.first
+#        else # ct1.size > 1
+#          sequence = [ 'sequence', ct1, ct1.first[2] ]
+#          nchildren << sequence
 #        end
-#
-#      else # mode == :clause
-#
+#      #elsif ct0.is_a?(String) && ct1.is_a?(Array) && ct1.any?
+#      #  p ct
+#      #  dct0 = deref(ct0)
+#      #  hct0 = reheap(ct, dct0)
+#      #  p dct0
+#      #  p hct0
+#      else
 #        nchildren << ct
-#        mode = :array
+#        mode = :clause
 #      end
 #    end
 #

data/lib/flor/pcore/fail.rb

@@ -1,5 +1,15 @@
 
 class Flor::Pro::Fail < Flor::Procedure
+  #
+  # Explicitely raises an error.
+  #
+  # ```
+  # fail "not enough water in the tank"
+  #   # or
+  # error "not enough water in the tank"
+  # ```
+  #
+  # (I prefer "fail" because it's a verb over "error", pick the one you like)
 
   names 'fail', 'error'
 

data/lib/flor/pcore/if.rb

@@ -2,10 +2,45 @@
 class Flor::Pro::If < Flor::Procedure
   #
   # The classical "if" (and its "unless" sidequick)
+  #
+  # ```
+  # if
+  #   > f.age 3
+  #   set f.designation 'child' # then
+  #   set f.designation 'baby' # else
+  #
+  # if (f.age > 3)
+  #   sequence # then
+  #     set f.designation 'child'
+  #   sequence # else
+  #     set f.designation 'baby'
+  #     order_baby_food
+  # ```
+  #
+  # Warning, the direct children are relevant. In the following snip,
+  # `order_child_seat` is considered the "else" part of the `if`
+  # ```
+  # if (f.age > 3)
+  #   set f.designation 'child'
+  #   order_child_seat
+  # ```
+  #
+  # ## postfix `if` and `unless`
+  #
+  # The flor parser will automatically turn
+  # ```
+  # task 'bob' if a > b
+  # ```
+  # into the syntax tree that would result from
+  # ```
+  # if
+  #   a > b
+  #   task 'bob'
+  # ```
 
   names %w[ if unless ife unlesse ]
     #
-    # removing "ife" and "unlesse" leas to
+    # removing "ife" and "unlesse" leads to
     # LoadError: cannot load such file -- sequel/adapters/
     # when running spec/unit/ and spec/punit/
     # weird...

data/lib/flor/pcore/twig.rb

@@ -0,0 +1,32 @@
+
+class Flor::Pro::Twig < Flor::Procedure
+
+  name 'twig'
+
+  def pre_execute
+
+    unatt_unkeyed_children
+    stringify_first_child
+  end
+
+  def receive_first
+
+    nac = non_att_children
+
+    if nac.size == 1
+      reply('ret' => nac.first)
+    else
+      super
+    end
+  end
+
+  def receive_non_att
+
+    t = non_att_children.last
+
+    set_value(payload['ret'], t)
+
+    reply
+  end
+end
+

data/lib/flor/pcore/val.rb

@@ -6,7 +6,7 @@ class Flor::Pro::Val < Flor::Procedure
   def execute
 
     heat = @node['heat']
-    heat = nil if heat == [ '_proc', 'val', -1 ]
+    heat = nil if heat == [ '_proc', 'val', -1 ] || heat[0] == '_nul'
 
     payload['ret'] = heat
 

data/lib/flor/punit/graft.rb

@@ -1,5 +1,43 @@
 
 class Flor::Pro::Graft < Flor::Procedure
+  #
+  # Graft a subtree into the current flo
+  #
+  # Given
+  # ```
+  # # sub0.flo
+  # sequence
+  #   task 'a'
+  #   task 'b'
+  # ```
+  # and
+  # ```
+  # # sub1.flo
+  # sequence
+  #   task 'c'
+  #   task 'd'
+  # ```
+  # then
+  # ```
+  # # main.flo
+  # concurrence
+  #   graft 'sub0.flo'
+  #   graft 'sub1' # suffix can be omitted
+  #   graft 'sub0'
+  #     #
+  #     # which is thus equivalent to
+  #     #
+  # concurrence
+  #   sequence
+  #     task 'a'
+  #     task 'b'
+  #   sequence
+  #     task 'c'
+  #     task 'd'
+  #   sequence
+  #     task 'a'
+  #     task 'b'
+  # ```
 
   names 'graft', 'import'
 
@@ -14,7 +52,7 @@ class Flor::Pro::Graft < Flor::Procedure
     # look up subtree
 
     sub =
-      att('tree', 'subtree', 'flow', 'subflow', nil)
+      att('tree', 'subtree', 'flow', 'subflow', 'twig', nil)
     source_path, source =
       @executor.unit.loader.library(domain, sub, subflows: true)
 

data/lib/flor/unit.rb

@@ -5,7 +5,9 @@ require 'sequel/extensions/migration'
 require 'fugit'
 
 require 'flor'
+require 'flor/unit/hook'
 require 'flor/unit/hooker'
+require 'flor/unit/runner'
 require 'flor/unit/wlist'
 require 'flor/unit/logger'
 require 'flor/unit/journal'
@@ -16,6 +18,7 @@ require 'flor/unit/scheduler'
 require 'flor/unit/models'
 require 'flor/unit/loader'
 require 'flor/unit/ganger'
+require 'flor/unit/spooler'
 require 'flor/unit/taskers'
 
 Flor.load_procedures('punit')

data/lib/flor/unit/executor.rb

@@ -12,6 +12,7 @@ module Flor
 
       super(
         unit,
+        unit.loader.load_hooks(@exid),
         unit.storage.fetch_traps(@exid),
         unit.storage.load_execution(@exid))
 

data/lib/flor/unit/ganger.rb

@@ -42,26 +42,26 @@ module Flor
         "tasker #{tname.inspect} not found"
       ) unless tconf
 
-      message['tconf'] = tconf \
-        unless tconf['on_task']['include_tconf'] == false
-
-      message['vars'] = gather_vars(executor, tconf, message)
-
-      cot = tconf['on_task']
+      if tconf.is_a?(Array)
+        tconf =
+          tconf.find { |h| h['point'] == message['point'] } ||
+          tconf.find { |h| h['point'] == nil }
+        tconf ||=
+          tconf.find { |h| h['point'] == 'cancel' } \
+            if message['point'] == 'detask'
+      end
 
-      return ruby_task(message, tconf) if cot['require'] || cot['class']
-      return cmd_task(message, tconf) if cot['cmd']
+      message['tconf'] = tconf unless tconf['include_tconf'] == false
 
-      fail ArgumentError.new(
-        "don't know how to use tasker at #{tconf['_path']}"
-      )
-    end
-
-    def cancel(tasker_name, fei)
+      message['vars'] = gather_vars(executor, tconf, message)
 
-      # TODO use on_cancel || on_task
+      r = @unit.runner.run(self, tconf, message)
 
-      fail NotImplementedError
+      if is_a_message_array?(r)
+        r
+      else
+        []
+      end
     end
 
     def return(message)
@@ -78,53 +78,6 @@ module Flor
       o.first['point'].is_a?(String)
     end
 
-    def ruby_task(message, tconf)
-
-      root = File.dirname(tconf['_path'])
-
-      Array(tconf['on_task']['require'])
-        .each { |pa|
-          fail ArgumentError.new('".." not allowed in paths') if pa =~ /\.\./
-          require(File.join(root, pa)) }
-      Array(tconf['on_task']['load'])
-        .each { |pa|
-          fail ArgumentError.new('".." not allowed in paths') if pa =~ /\.\./
-          load(File.join(root, pa)) }
-
-      k = tconf['on_task']['class']
-      k = Flor.const_lookup(k)
-
-      ka = k.instance_method(:initialize).arity
-
-      m =
-        message['point'] == 'detask' ?
-        :cancel :
-        :task
-
-      r =
-        if ka == 2
-          k.new(self, tconf).send(m, message)
-        else # ka == 3
-          k.new(self, tconf, message).send(m)
-        end
-
-      # if the tasker returns something intelligible, use it
-      # else reply with "nothing further to do" (empty message array)
-
-      if is_a_message_array?(r)
-        r
-      else
-        []
-      end
-    end
-
-    def cmd_task(message, tconf)
-
-      fail NotImplementedError
-
-      []
-    end
-
     def var_match(k, filter)
 
       filter.each { |f| return true if (f.is_a?(String) ? k == f : f.match(k)) }
@@ -155,17 +108,15 @@ module Flor
 
     def gather_vars(executor, tconf, message)
 
-      ot = tconf['on_task']
-
       # try to return before calling executor.vars(nid) which my be costly...
 
-      return nil if (ot.keys & %w[ include_vars exclude_vars ]).empty?
+      return nil if (tconf.keys & %w[ include_vars exclude_vars ]).empty?
         # default behaviour, don't pass variables to taskers
 
-      iv = expand_filter(ot['include_vars'])
+      iv = expand_filter(tconf['include_vars'])
       return nil if iv == false
 
-      ev = expand_filter(ot['exclude_vars'])
+      ev = expand_filter(tconf['exclude_vars'])
       return {} if ev == true
 
       vars = executor.vars(message['nid'])

data/lib/flor/unit/hook.rb

@@ -0,0 +1,32 @@
+
+module Flor
+
+  class Hook
+
+    def initialize(unit, exid, h)
+
+      @unit = unit
+      @exid = exid
+      @h = h
+    end
+
+    def to_hook
+
+      opts = {}
+      opts[:consumed] = @h['consumed']
+      opts[:point] = Flor.h_fetch_a(@h, 'points', 'point', nil)
+      opts[:heap] = Flor.h_fetch_a(@h, 'heaps', 'heap', nil)
+      opts[:heat] = Flor.h_fetch_a(@h, 'heats', 'heat', nil)
+      #opts[:name] = data['names']
+
+      [ "hook#{object_id}", opts, self, nil ]
+    end
+
+
+    def notify(executor, message)
+
+      @unit.runner.run(executor, @h, message)
+    end
+  end
+end
+