flor 1.6.2 → 1.6.4

data/lib/flor/pcore/define.rb

@@ -103,7 +103,7 @@ class Flor::Pro::Define < Flor::Procedure
 
     return [ tre, sig ] unless wrapped?(sig)
 
-    # There is a parenthese around the parameters, let's unwrap that...
+    # There are parentheses around the parameters, let's unwrap that...
 
     hed = Flor.dup(tre[1][0, off])
     sig = Flor.dup(sig)

data/lib/flor/pcore/del.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+
+class Flor::Pro::Del < Flor::Procedure
+  #
+  # Removes a field or a variable.
+  #
+  # ```
+  # sequence
+  #   del f.a  # blanks field 'a' from the payload
+  #   del a    # blanks variable 'a'
+  # ```
+  #
+  # Returns the value held in the field or variable or `null` else.
+  #
+  # `del` will raise an error if the target field cannot be reached,
+  # but `delf` will not raise and simply return `null`.
+
+  names %w[ del delf ]
+
+  def pre_execute
+
+    unatt_unkeyed_children
+    rerep_children
+
+    @node['refs'] = []
+  end
+
+  def receive_non_att
+
+    ft = tree[1][@fcid] || []
+
+    if ft[0] == '_rep'
+      @node['refs'] << payload['ret']
+    else
+      payload['ret'] = node_payload_ret
+    end
+
+    super
+  end
+
+  def receive_last
+
+    ret = nil
+
+    @node['refs'].each do |ref|
+
+      ret = (lookup_value(ref) rescue nil)
+      begin
+        unset_value(ref)
+      rescue
+        raise unless tree[0] == 'delf'
+      end
+    end
+
+    wrap('ret' => ret)
+  end
+
+  protected
+
+  def rerep_children
+
+    t = tree
+
+    cn = t[1]
+      .collect { |ct|
+        hd, cn, ln = ct
+        if hd == '_ref'
+          [ '_rep', cn, ln ]
+        elsif hd == '_dqs'
+          [ '_rep', [ ct ], ln ]
+        elsif Flor.is_single_ref_tree?(ct)
+          [ '_rep', [ [ '_sqs', hd, ln ] ], ln ]
+        else
+          ct
+        end }
+
+    @node['tree'] = [ t[0], cn, t[2] ] if cn != t[1]
+  end
+end
+

data/lib/flor/pcore/fail.rb

@@ -2,7 +2,7 @@
 
 class Flor::Pro::Fail < Flor::Procedure
   #
-  # Explicitely raises an error.
+  # Explicitly raises an error.
   #
   # ```
   # fail "not enough water in the tank"

data/lib/flor/pcore/if.rb

@@ -43,6 +43,27 @@ class Flor::Pro::If < Flor::Procedure
   #
   # Currently, if an "else if" is needed, it's better to use [cond](cond.md).
   #
+  # ## improving readability with else and then
+  #
+  # "then" and "else" can be aliased to "sequence" and be used within if to
+  # make the flow definition easier to read, and especially less confusing.
+  #
+  # ```
+  # # at the top of the workflow definition
+  # # alias "then" and "else" to "sequence"
+  #
+  # set then sequence
+  # set else sequence
+  #
+  # # ...
+  #
+  # if (f.age > 3)
+  #   then
+  #     set f.designation 'child'
+  #   else
+  #     set f.designation 'baby'
+  #     order_baby_food _
+  # ```
   #
   # ## see also
   #

data/lib/flor/pcore/iterator.rb

@@ -146,12 +146,11 @@ class Flor::Macro::Iterator < Flor::Macro
 
   def rewrite_iterator_tree(procedure_name)
 
-    atts = att_children
-
     l = tree[2]
 
     th = [ procedure_name, [], l, *tree[3] ]
-    atts.each { |ac| th[1] << Flor.dup(ac) }
+
+    att_children.each { |ac| th[1] << Flor.dup(ac) }
 
     if non_att_children.any?
 

data/lib/flor/pcore/match.rb

@@ -156,7 +156,7 @@ class Flor::Pro::Match < Flor::Pro::Case
   #
   # ## "bind"
   #
-  # "bind" binds explicitely a value and allows for a sub-pattern.
+  # "bind" binds explicitly a value and allows for a sub-pattern.
   # ```
   # match [ 1 4 ]
   #   [ 1 (bind y (or 2 3)) ]; "match y:$(y)"

data/lib/flor/pcore/reverse.rb

@@ -17,7 +17,7 @@ class Flor::Pro::Reverse < Flor::Procedure
   # reverse _     # sets f.ret to [ 4, 6, 5 ]
   # ```
   #
-  # Will fail if it finds nothing reversable.
+  # Will fail if it finds nothing reversible.
   #
   # # see also
   #

data/lib/flor/pcore/set.rb

@@ -49,7 +49,7 @@ class Flor::Pro::Set < Flor::Procedure
   #   set __2 g h
   #     [ 9 10 11 12 13 ]
   #       # ==> g: 11, h: 12
-  #       # `__` is not prefixed by a var name, so it justs discard
+  #       # `__` is not prefixed by a var name, so it just discards
   #       # what it captures
   #   set i j___
   #     [ 14 15 16 17 18 19 ]

data/lib/flor/pcore/until.rb

@@ -2,7 +2,7 @@
 
 class Flor::Pro::Until < Flor::Procedure
   #
-  # Loops until or while a condiation evalutates to true.
+  # Loops until or while a condiation evaluates to true.
   #
   # ```
   # set i 0

data/lib/flor/punit/c_iterator.rb

@@ -156,6 +156,7 @@ class Flor::Pro::ConcurrentIterator < Flor::Procedure
     is.each { |i| t1[i][1][0][0] = '_reff' }
 
     @node['tree'] = [ t[0], t1, *t[2..-1] ]
+Flor.pp @node['tree']
   end
 end
 

data/lib/flor/punit/signal.rb

@@ -2,7 +2,7 @@
 
 class Flor::Pro::Signal < Flor::Procedure
   #
-  # Used in conjuction with "on".
+  # Used in conjunction with "on".
   #
   # An external (or internal) agent may send a signal to an execution and the
   # execution may have a "on" handler for it.

data/lib/flor/punit/trap.rb

@@ -139,7 +139,7 @@ class Flor::Pro::Trap < Flor::Procedure
   #
   # The range limit determines what is the range, or scope of the trap.
   # By default the trap only care about nodes below its parent. In other words,
-  # the trap binds itself to its parent and observes the messages occuring
+  # the trap binds itself to its parent and observes the messages occurring
   # in the execution in the branch of nodes whose root is the parent.
   #
   # The possible values for `range:` are:

data/lib/flor/to_string.rb

@@ -5,58 +5,61 @@ module Flor
   # used in procedure, cancel, until, cursor specs
   # when "walking" and "stepping"
 
-  def self.to_s(o=nil, k=nil)
+  class << self
 
-    return 'Flor' if o == nil && k == nil
-      # should it emerge somewhere...
+    def to_s(o=nil, k=nil)
 
-    return o.collect { |e| Flor.to_s(e, k) }.join("\n") if o.is_a?(Array)
+      return 'Flor' if o == nil && k == nil
+        # should it emerge somewhere...
 
-    if o.is_a?(Hash)
+      return o.collect { |e| Flor.to_s(e, k) }.join("\n") if o.is_a?(Array)
 
-      return send("message_#{k}_to_s", o) if k && o['point'].is_a?(String)
-      return message_to_s(o) if o['point'].is_a?(String)
+      if o.is_a?(Hash)
 
-      return send("node_#{k}_to_s", o) if k && o.has_key?('parent')
-      return node_to_s(o) if o['parent'].is_a?(String)
+        return send("message_#{k}_to_s", o) if k && o['point'].is_a?(String)
+        return message_to_s(o) if o['point'].is_a?(String)
+
+        return send("node_#{k}_to_s", o) if k && o.has_key?('parent')
+        return node_to_s(o) if o['parent'].is_a?(String)
+      end
+
+      return [ o, k ].inspect if k
+      o.inspect
     end
 
-    return [ o, k ].inspect if k
-    o.inspect
-  end
+    def message_to_s(m)
 
-  def self.message_to_s(m)
+      s = StringIO.new
+      s << '(msg ' << m['nid'] << ' ' << m['point']
+      %w[ from flavour ].each { |k|
+        s << ' ' << k << ':' << m[k].to_s if m.has_key?(k) }
+      s << ')'
 
-    s = StringIO.new
-    s << '(msg ' << m['nid'] << ' ' << m['point']
-    %w[ from flavour ].each { |k|
-      s << ' ' << k << ':' << m[k].to_s if m.has_key?(k) }
-    s << ')'
+      s.string
+    end
 
-    s.string
-  end
+    def node_status_to_s(n)
 
-  def self.node_status_to_s(n)
+      stas = n['status'].reverse
 
-    stas = n['status'].reverse
+      s = StringIO.new
+      while sta = stas.shift
+        s << '(status ' << (sta['status'] || 'o') # o for open
+        s << ' pt:' << sta['point']
+        if f = sta['flavour']; s << ' fla:' << f; end
+        if f = sta['from']; s << ' fro:' << f; end
+        if m = sta['m']; s << ' m:' << m; end
+        s << ')'
+        s << "\n" if stas.any?
+      end
 
-    s = StringIO.new
-    while sta = stas.shift
-      s << '(status ' << (sta['status'] || 'o') # o for open
-      s << ' pt:' << sta['point']
-      if f = sta['flavour']; s << ' fla:' << f; end
-      if f = sta['from']; s << ' fro:' << f; end
-      if m = sta['m']; s << ' m:' << m; end
-      s << ')'
-      s << "\n" if stas.any?
+      s.string
     end
 
-    s.string
-  end
+    def node_to_s(n) # there is already a .node_to_s in log.rb
 
-  def self.node_to_s(n) # there is already a .node_to_s in log.rb
-
-    n.inspect
+      n.inspect
+    end
   end
 end
 

data/lib/flor/tools/env.rb

@@ -8,74 +8,77 @@ module Flor::Tools; end
 
 module Flor::Tools::Env
 
-  def self.make(path, envname=nil, opts={})
+  class << self
 
-    if envname.is_a?(Hash)
-      opts = envname
-      envname = nil
-    end
+    def make(path, envname=nil, opts={})
 
-    opts[:env] = envname || 'production'
-    opts[:sto_uri] ||= 'sqlite://tmp/dev.db'
-    opts[:gitkeep] = true unless opts.has_key?(:gitkeep)
+      if envname.is_a?(Hash)
+        opts = envname
+        envname = nil
+      end
 
-    mkdir(path, envname) if envname
+      opts[:env] = envname || 'production'
+      opts[:sto_uri] ||= 'sqlite://tmp/dev.db'
+      opts[:gitkeep] = true unless opts.has_key?(:gitkeep)
 
-    mk_etc(path, envname, opts)
-    mk_lib(path, envname, opts)
-    mk_usr(path, envname, opts)
-    mk_var(path, envname, opts)
-  end
+      mkdir(path, envname) if envname
+
+      mk_etc(path, envname, opts)
+      mk_lib(path, envname, opts)
+      mk_usr(path, envname, opts)
+      mk_var(path, envname, opts)
+    end
 
-  # protected, somehow
+    # protected, somehow
 
-  def self.mk_etc(*ps, opts)
+    def mk_etc(*ps, opts)
 
-    mkdir(*ps, 'etc')
-    mkdir(*ps, 'etc', 'variables')
-    touch(*ps, 'etc', 'variables', '.gitkeep') if opts[:gitkeep]
+      mkdir(*ps, 'etc')
+      mkdir(*ps, 'etc', 'variables')
+      touch(*ps, 'etc', 'variables', '.gitkeep') if opts[:gitkeep]
 
-    write(*ps, 'etc', 'conf.json') do
-      "env: #{opts[:env]}\n" +
-      "sto_uri: #{opts[:sto_uri].inspect}"
+      write(*ps, 'etc', 'conf.json') do
+        "env: #{opts[:env]}\n" +
+        "sto_uri: #{opts[:sto_uri].inspect}"
+      end
     end
-  end
 
-  def self.mk_lib(*ps, opts)
+    def mk_lib(*ps, opts)
 
-    mkdir(*ps, 'lib')
-    mkdir(*ps, 'lib', 'flows')
-    touch(*ps, 'lib', 'flows', '.gitkeep') if opts[:gitkeep]
-    mkdir(*ps, 'lib', 'taskers')
-    touch(*ps, 'lib', 'taskers', '.gitkeep') if opts[:gitkeep]
-  end
+      mkdir(*ps, 'lib')
+      mkdir(*ps, 'lib', 'flows')
+      touch(*ps, 'lib', 'flows', '.gitkeep') if opts[:gitkeep]
+      mkdir(*ps, 'lib', 'taskers')
+      touch(*ps, 'lib', 'taskers', '.gitkeep') if opts[:gitkeep]
+    end
 
-  def self.mk_usr(*ps, opts)
+    def mk_usr(*ps, opts)
 
-    mkdir(*ps, 'usr')
+      mkdir(*ps, 'usr')
 
-    if opts[:acme] == false
-      touch(*ps, 'usr', '.gitkeep') if opts[:gitkeep]
-    else
-      mkdir(*ps, 'usr', 'com.acme')
-      mk_etc(*ps, 'usr', 'com.acme', opts)
-      mk_lib(*ps, 'usr', 'com.acme', opts)
+      if opts[:acme] == false
+        touch(*ps, 'usr', '.gitkeep') if opts[:gitkeep]
+      else
+        mkdir(*ps, 'usr', 'com.acme')
+        mk_etc(*ps, 'usr', 'com.acme', opts)
+        mk_lib(*ps, 'usr', 'com.acme', opts)
+      end
     end
-  end
 
-  def self.mk_var(*ps, opts)
+    def mk_var(*ps, opts)
 
-    mkdir(*ps, 'var')
-    mkdir(*ps, 'var', 'log')
-    touch(*ps, 'var', 'log', '.gitkeep') if opts[:gitkeep]
-  end
+      mkdir(*ps, 'var')
+      mkdir(*ps, 'var', 'log')
+      touch(*ps, 'var', 'log', '.gitkeep') if opts[:gitkeep]
+    end
 
-  def self.mkdir(*ps); FileUtils.mkdir(File.join(*ps.compact)); end
-  def self.touch(*ps); FileUtils.touch(File.join(*ps.compact)); end
+    def mkdir(*ps); FileUtils.mkdir(File.join(*ps.compact)); end
+    def touch(*ps); FileUtils.touch(File.join(*ps.compact)); end
 
-  def self.write(*ps, &block)
+    def write(*ps, &block)
 
-    File.open(File.join(*ps.compact), 'wb') { |f| f.write(block.call) }
+      File.open(File.join(*ps.compact), 'wb') { |f| f.write(block.call) }
+    end
   end
 end
 

data/lib/flor/tools/shell.rb

@@ -208,18 +208,21 @@ module Flor::Tools
 
     ALIASES = {}
 
-    def self.make_alias(a, b)
+    class << self
 
-      define_method("hlp_#{a}") { "alias to #{b.inspect}" }
-      alias_method "man_#{a}", "man_#{b}" rescue nil
-      alias_method "cmd_#{a}", "cmd_#{b}"
+      def make_alias(a, b)
 
-      (ALIASES[b] ||= []) << a
-    end
+        define_method("hlp_#{a}") { "alias to #{b.inspect}" }
+        alias_method "man_#{a}", "man_#{b}" rescue nil
+        alias_method "cmd_#{a}", "cmd_#{b}"
+
+        (ALIASES[b] ||= []) << a
+      end
 
-    def self.is_alias?(c)
+      def is_alias?(c)
 
-      !! ALIASES.values.find { |a| a.include?(c) }
+        !! ALIASES.values.find { |a| a.include?(c) }
+      end
     end
 
     def args(line); line.split(/\s+/); end
@@ -642,7 +645,7 @@ module Flor::Tools
         puts Flor.to_d(
           { key: @unit.conf[key] }, colour: true, indent: 1, width: true)
       elsif key
-        # alreay done
+        # already done
       else
         page(Flor.to_d(@unit.conf, colour: true, indent: 1, width: true))
       end

data/lib/flor/unit/journal.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
+
 module Flor
 
+  # As seen in docs/hooks.md
+  #
+  # ```ruby
+  # flor.hooker.add('journal', Flor::Journal)
+  # ```
+  #
+  #
   # A Journal hook, receives only "consumed" messages and
   # keeps a copy of all of them.
   #

data/lib/flor/unit/scheduler.rb

@@ -46,19 +46,22 @@ module Flor
       @spooler =
         (Flor::Conf.get_class(@conf, 'spooler') || Flor::Spooler).new(self)
 
-      @heart_rate = @conf[:sch_heart_rate] || 0.3
-      @reload_after = @conf[:sch_reload_after] || 60
+      @heart_rate = @conf['sch_heart_rate'] || 0.3
+      @reload_after = @conf['sch_reload_after'] || 60
         #
       @wake_up = true
       @next_time = nil
       @reloaded_at = Time.now
 
-      @msg_max_res_time = @conf[:sch_msg_max_res_time] || 10 * 60
+      @msg_max_res_time = @conf['sch_msg_max_res_time'] || 10 * 60
 
       @idle_count = 0
 
-      @max_executors = @conf[:sch_max_executors] || 1
-        #
+      @max_executor_count =
+        @conf['sch_max_executor_count'] ||
+        @conf['sch_max_executors'] ||
+        7
+
       @executors = []
 
       c = @conf['constant']
@@ -367,20 +370,22 @@ module Flor
       @wake_up = true
     end
 
-    def notify(executor, o)
+    def notify(executor, message)
 
       if executor
-        @hooker.notify(executor, o)
+        @hooker.notify(executor, message)
       else
-        @hooker.wlist.notify(nil, o)
+        @hooker.wlist.notify(nil, message)
       end
 
-    rescue => err
-      puts '-sch' * 19
-      puts "+ error in #{self.class}#notify"
-      p err
-      puts err.backtrace
-      puts ('-sch' * 19) + ' .'
+      # NO, let it fail...
+      #
+    #rescue => err
+    #  puts '-sch' * 19
+    #  puts "+ error in #{self.class}#notify"
+    #  p err
+    #  puts err.backtrace
+    #  puts ('-sch' * 19) + ' .'
     end
 
     def trap(node, tra)
@@ -710,18 +715,20 @@ module Flor
       @storage.trigger_timers
     end
 
+    def free_executor_count
+
+      [ 0, @max_executor_count - @executors.count ].max
+    end
+
     def trigger_executions
 
       @executors.select! { |e| e.alive? }
         # drop done executors
 
-      free_executor_count = @max_executors - @executors.size
-
-      return if free_executor_count < 1
-
-      messages = @storage.load_messages(free_executor_count)
+      @storage.load_messages(free_executor_count).each do |exid, ms|
+        # remember that load_messages load count + 2 executions...
 
-      messages.each do |exid, ms|
+        break if free_executor_count < 1
 
         next unless @storage.reserve_all_messages(ms)
 

data/lib/flor/unit/storage.rb

@@ -821,7 +821,8 @@ module Flor
       @db[:flor_pointers]
         .import(
           POINTER_COLUMNS,
-          pointers)
+          pointers,
+          skip_transaction: true)
 
       callback(:pointers, :update, exid)
     end

data/lib/flor.rb

@@ -16,7 +16,7 @@ require 'dense'
 
 module Flor
 
-  VERSION = '1.6.2'
+  VERSION = '1.6.4'
 end
 
 require 'flor/colours'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: flor
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.4
 platform: ruby
 authors:
 - John Mettraux
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-03 00:00:00.000000000 Z
+date: 2025-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: munemo
@@ -44,14 +43,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.1
 - !ruby/object:Gem::Dependency
   name: dense
   requirement: !ruby/object:Gem::Requirement
@@ -175,6 +180,7 @@ files:
 - lib/flor/pcore/cond.rb
 - lib/flor/pcore/cursor.rb
 - lib/flor/pcore/define.rb
+- lib/flor/pcore/del.rb
 - lib/flor/pcore/detect.rb
 - lib/flor/pcore/do_return.rb
 - lib/flor/pcore/each.rb
@@ -290,7 +296,6 @@ metadata:
   mailing_list_uri: https://groups.google.com/forum/#!forum/floraison
   homepage_uri: https://github.com/floraison/flor
   source_code_uri: https://github.com/floraison/flor
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -305,8 +310,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A Ruby workflow engine
 test_files: []