flor 0.15.0 → 0.16.0

data/lib/flor/pcore/merge.rb

@@ -0,0 +1,134 @@
+
+class Flor::Pro::Merge < Flor::Procedure
+  #
+  # Merges objects or arrays.
+  #
+  # With objects:
+  # ```
+  # merge {}           # => {}
+  # merge { a: 0 }     # => { 'a' => 0 }
+  # {}; merge _        # => {}
+  # { a: 0 }; merge _  # => { 'a' => 0 }
+  #
+  # merge { a: 0 b: 1 } { b: 'B' c: 'C' }
+  #  # => { 'a' => 0, 'b' => 'B', 'c' => 'C' }
+  # merge { b: 'B' c: 'C' } { a: 0 b: 1 }
+  #  # => { 'a' => 0, 'b' => 1, 'c' => 'C' },
+  # ```
+  #
+  # With arrays:
+  # ```
+  # merge [ 0 1 2 3 ] [ 'a' 'b' 'c' ]
+  #   # => [ 'a', 'b', 'c', 3 ],
+  #
+  # merge []            # => []
+  # merge [ 0 1 2 ]     # => [ 0, 1, 2 ]
+  # []; merge _         # => []
+  # [ 0 1 2 ]; merge _  # => [ 0, 1, 2 ]
+  # ```
+  #
+  # It determines if it has to deal with arrays or objects by looking at its
+  # first argument (not the incoming ret).
+  #
+  # It fails if the arguments are not all objects or not all arrays.
+  #
+  # If the attribute `lax:` (or `loose:`) is set to `true`, it doesn't care
+  # about non matching arguments and merges anyway:
+  # ```
+  # merge { a: 0 } { b: 1 } 'nada' { c: 2 } lax: true
+  #   # => { 'a' => 0, 'b' => 1, 'c' => 2 }
+  # merge { a: 0 } { b: 1 } { c: 2 }
+  #   # => { 'a' => 0, 'b' => 1, 'c' => 2 }
+  # merge { a: 0 } { b: 1 } 'nada' { c: 2 } tags: 'xxx' loose: true
+  #   # => { 'a' => 0, 'b' => 1, 'c' => 2 }
+  # ```
+  #
+  # `strict: false` is OK as well:
+  # ```
+  # merge { a: 0 } { b: 1 } 'nada' { c: 2 } strict: false
+  #   # => { 'a' => 0, 'b' => 1, 'c' => 2 }
+  # ```
+  #
+  # ## incoming ret
+  #
+  # "merge" only draws in the incoming ret if necessary. If there are
+  # enough arguments to perform a merge, the incoming ret will not be taken
+  # into account.
+  # You can add the incoming to the merge simply with `f.ret`.
+  #
+  # ```
+  # [ 0 1 2 ]; merge [ 0 1 'deux' 3 ]                    # => [ 0 1 'deux' 3 ]
+  # [ 0 1 2 3 4 ]; merge [ 0 1 2 3 ] [ 0 'un' 2 ]        # => [ 0 'un' 2 3 ]
+  # [ 0 1 2 3 4 ]; merge f.ret [ 0 1 2 3 ] [ 0 'un' 2 ]  # => [ 0 'un' 2 3 ]
+  # [ 0 1 2 3 4 ]; merge [ 0 1 2 3 ] [ 0 'un' 2 ] f.ret  # => [ 0 1 2 3 4 ]
+  # [ 0 ]; merge { a: 1 } { a: 'one' }                   # => { a: 'one' }
+  # ```
+  #
+  # ## see also
+  #
+  # reverse, length, keys
+
+  name 'merge'
+
+  def pre_execute
+
+    @node['atts'] = []
+    @node['rets'] = []
+
+    unatt_unkeyed_children
+  end
+
+  def receive_last
+
+    indexes = @node['rets']
+      .each_with_index
+      .inject({ array: [], object: [], other: [] }) { |is, (e, i)|
+        case e
+        when Array then is[:array]
+        when Hash then is[:object]
+        else is[:other]
+        end << i
+        is }
+
+    a0 = indexes[:array].first || @node['rets'].length
+    o0 = indexes[:object].first || @node['rets'].length
+
+    kln = a0 < o0 ? :array : :object
+    okln = kln == :array ? :object : :array
+
+    cols = indexes[kln].collect { |i| @node['rets'][i] }
+
+    cols.unshift(node_payload_ret) \
+      if cols.length == 1 && Flor.type(node_payload_ret) == kln
+
+    fail Flor::FlorError.new('found no array or object to merge', self) \
+      if cols.empty?
+
+    unless att('lax', 'loose') == true || att('strict') == false
+
+      others = (indexes[:other] + indexes[okln]).sort
+
+      fail Flor::FlorError.new(
+        "found a non-#{kln} item (#{Flor.type(@node['rets'][others[0]])} item)",
+        self
+      ) if others.any?
+    end
+
+    wrap('ret' => send(kln == :array ? :merge_arrays : :merge_objects, cols))
+  end
+
+  protected
+
+  def merge_arrays(as)
+
+    as
+      .inject([]) { |r, a| a.each_with_index { |e, i| r[i] = e }; r }
+  end
+
+  def merge_objects(os)
+
+    os
+      .inject({}) { |r, o| r.merge(o) }
+  end
+end
+

data/lib/flor/pcore/move.rb

@@ -31,7 +31,7 @@ class Flor::Pro::Move < Flor::Procedure
 
     wrap_cancel(
       'nid' => nid,
-      'flavour' => @node['heap'], # "move"
+      'flavour' => heap, # "move"
       'payload' => rep.any? ? payload.copy_current : payload.current,
       'to' => to) +
     rep

data/lib/flor/pcore/noret.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::NoRet < Flor::Procedure
   #
-  # executes its children, but doesn't alter the received f.ret
+  # Executes its children, but doesn't alter the received f.ret
   #
   # ```
   # sequence

data/lib/flor/pcore/not.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Not < Flor::Procedure
   #
-  # `not` negates its last child (or its last unkeyed attribute)
+  # Negates its last child (or its last unkeyed attribute)
   #
   # ```
   # not _      # --> true
@@ -16,6 +16,20 @@ class Flor::Pro::Not < Flor::Procedure
   #   true
   #   false  # --> true
   # ```
+  #
+  # ```
+  # not true false  # --> true
+  # ```
+  #
+  # ## Warning
+  #
+  # ```
+  # and not(false) not(false)  # --> false
+  # ```
+  # It is recommended to use:
+  # ```
+  # and (not false) (not false)  # --> true
+  # ```
 
   name 'not'
 

data/lib/flor/pcore/on.rb

@@ -44,6 +44,17 @@ class Flor::Pro::On < Flor::Macro
   # Please note that "error" in `on error` is not quoted, nor double quoted.
   # If it were, it would trap the signal named "error".
   #
+  # `on error` accepts the same criteria as [on_error](on_error.md), as in:
+  # ```
+  # sequence
+  #   on error (/timeout/)
+  #     charly "it timed out"
+  #   on error
+  #     charly "it failed", err
+  #   alice 'do this'
+  #   bob 'do that'
+  # ```
+  #
   #
   # ## cancel
   #

data/lib/flor/pcore/on_cancel.rb

@@ -48,7 +48,11 @@ class Flor::Pro::OnCancel < Flor::Procedure
 
     store_on(:cancel)
 
-    super
+    ms = super
+
+    ms.first['from_on'] = 'cancel'
+
+    ms
   end
 end
 

data/lib/flor/pcore/on_error.rb

@@ -16,7 +16,7 @@ class Flor::Pro::OnError < Flor::Procedure
   #   push f.l 1
   # ```
   # Where the field `l` ends up containing
-  # `[ 0, "don't know how to apply \"x\"" ]`.
+  # `[ 0, "cannot find \"x\"" ]`.
   #
   # ```
   # set f.l []
@@ -47,6 +47,48 @@ class Flor::Pro::OnError < Flor::Procedure
   #   # ...
   # ```
   #
+  # ## on_error kriteria
+  #
+  # Similarly to Ruby, one may catch certain types of errors.
+  #
+  # In the follow example, Charly is tasked with "it failed" and the err
+  # if there is a Ruby error of class `RuntimeError` happens in the sequence:
+  # ```
+  # sequence
+  #   on_error class: 'RuntimeError' (def err \ charly "it failed", err)
+  #   alice 'do this'
+  #   bob 'do that'
+  # ```
+  #
+  # One can shorten it to:
+  # ```
+  # sequence
+  #   on_error 'RuntimeError' (def err \ charly "it failed", err)
+  #   alice 'do this'
+  #   bob 'do that'
+  # ```
+  # But this short version will check the Ruby class name and then the error
+  # message.
+  #
+  # In the next example, Charly is tasked with "it timed out" if the error
+  # class or the error message match the regex `/timeout/`:
+  # ```
+  # sequence
+  #   on_error (/timeout/) (def err \ charly "it timed out")
+  #   on_error (def err \ charly "it failed", err)
+  #   alice 'do this'
+  #   bob 'do that'
+  # ```
+  # Order matters.
+  #
+  # Please note that you can't set a criteria when you're using the `on_error:`
+  # attribute, as in:
+  # ```
+  # sequence on_error: (def err \ charly "it failed", err)
+  #   alice 'do this'
+  #   bob 'do that'
+  # ```
+  #
   # ## see also
   #
   # On, on_cancel.
@@ -56,13 +98,36 @@ class Flor::Pro::OnError < Flor::Procedure
   def pre_execute
 
     unatt_unkeyed_children
+
+    @node['atts'] = []
+    @node['rets'] = []
   end
 
-  def receive_non_att
+  def receive_last
+
+    prc = @node['rets'].find { |r| Flor.is_func_tree?(r) }
+
+    line = tree[2]
+
+    cri = []
+    if cla = att('class', 'klass')
+      cri << [ 'class', cla, line ]
+    end
+    if str = @node['rets'].find { |r| r.is_a?(String) }
+      cri << [ 'string', str, line ]
+    end
+    if rex = @node['rets'].find { |r| Flor.is_regex_tree?(r) }
+      cri << [ 'regex', *rex[1..-1] ]
+    end
+    cri << '*' if cri.empty?
+
+    store_on(:error, prc, cri)
+
+    ms = super
 
-    store_on(:error)
+    ms.first['from_on'] = 'error'
 
-    super
+    ms
   end
 end
 

data/lib/flor/pcore/push.rb

@@ -39,7 +39,7 @@ class Flor::Pro::Push < Flor::Procedure
   def pre_execute
 
     unatt_unkeyed_children
-    stringify_first_child
+    rep_first_child
   end
 
   def receive_non_att
@@ -47,7 +47,7 @@ class Flor::Pro::Push < Flor::Procedure
     if ! @node['arr']
       @node['arr'] = payload['ret']
     else
-      @node['to_push'] = payload['ret']
+      @node['val'] = payload['ret']
     end
 
     super
@@ -55,7 +55,7 @@ class Flor::Pro::Push < Flor::Procedure
 
   def receive_last
 
-    push(@node.has_key?('to_push') ? @node['to_push'] : node_payload_ret)
+    push(@node.has_key?('val') ? @node['val'] : node_payload_ret)
 
     payload['ret'] = node_payload_ret \
       unless tree[0] == 'pushr'
@@ -67,12 +67,7 @@ class Flor::Pro::Push < Flor::Procedure
 
   def push(val)
 
-    arr = @node['arr']
-
-    if arr.is_a?(String)
-      payload.copy if arr[0, 1] == 'f'
-      arr = lookup(arr)
-    end
+    arr = lookup_value(@node['arr']) rescue nil
 
     fail Flor::FlorError.new(
       "cannot push to given target (#{arr.class})", self

data/lib/flor/pcore/range.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Range < Flor::Procedure
   #
-  # "range" is a procedure to generate ranges of integers.
+  # Generates ranges of integers.
   #
   # ```
   # # range {end}
@@ -41,15 +41,15 @@ class Flor::Pro::Range < Flor::Procedure
     edn = rets[1] || rets[0] || 0
     ste = rets[2] || ((sta > edn) ? -1 : 1)
 
-    asta = att('start') || att('from')
-    aedn = att('end') || att('to')
-    aste = att('step') || att('by') || att('inc')
+    asta = att('start', 'from')
+    aedn = att('end', 'to')
+    aste = att('step', 'by', 'inc')
 
     sta = asta if asta
     edn = aedn if aedn
     ste = aste if aste
 
-    fail Flor::FlorError.new("#{@node['heat0']} step is 0", self) \
+    fail Flor::FlorError.new("#{heap} step is 0", self) \
       if ste == 0
 
     #payload['ret'] = (sta..edn - 1).step(ste).to_a

data/lib/flor/pcore/reduce.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Reduce < Flor::Pro::Iterator
   #
-  # Reduce takes a collection and a function. It reduces the collection
+  # Takes a collection and a function, reduces the collection
   # to a single result thanks to the function.
   #
   # ```
@@ -54,7 +54,7 @@ class Flor::Pro::Reduce < Flor::Pro::Iterator
           @node['fun'] ||= a
         elsif Flor.is_proc_tree?(a)
           @node['fun'] ||= proc_to_fun(a)
-        elsif a.is_a?(Array) || a.is_a?(Hash)
+        elsif Flor.is_collection?(a)
           @node['ocol'] ||= a
         else
           @node['res'] ||= a
@@ -68,29 +68,16 @@ class Flor::Pro::Reduce < Flor::Pro::Iterator
     ) unless @node['fun']
     fail Flor::FlorError.new(
       "collection not given to #{heap.inspect}", self
-    ) unless ocol.is_a?(Array) || ocol.is_a?(Hash)
+    ) unless Flor.is_collection?(ocol)
 
     @node['col'] = Flor.to_coll(@node['ocol'])
-
     @node['res'] ||= @node['col'].shift
-
     @node['args'] = nil
   end
 
-  def determine_iteration_vars
-
-    res = @node['res']
-    idx = @node['idx']
-    elt = @node['col'][idx]
-    len = @node['col'].length
+  def determine_iteration_args
 
-    if @node['ocol'].is_a?(Array)
-      { 'res' => res, 'elt' => elt,
-        'idx' => idx, 'len' => len }
-    else
-      { 'res' => res, 'key' => elt[0], 'val' => elt[1],
-        'idx' => idx, 'len' => len }
-    end
+    super.unshift([ 'res', @node['res'] ])
   end
 
   def receive_iteration

data/lib/flor/pcore/return.rb

@@ -0,0 +1,26 @@
+
+class Flor::Pro::Return < Flor::Procedure
+
+  name 'return'
+
+  def receive_last
+
+    si = Flor.sub_nid(nid)
+    n = @node
+
+    target =
+      loop do
+        pn = parent_node(n)
+        break nil unless pn
+        psi = Flor.sub_nid(pn['nid'])
+        break n['nid'] if psi != si
+        n = pn
+      end
+
+    fail Flor::FlorError.new('"return" outside of function', self) \
+      unless target
+
+    wrap_cancel('nid' => target, 'flavour' => 'return')
+  end
+end
+