flor 0.15.0 → 0.16.0

data/lib/flor/pcore/cursor.rb

@@ -57,16 +57,16 @@ class Flor::Pro::Cursor < Flor::Procedure
 
   def receive_first
 
-    @node['vars'] =
-      {}
+    # break/continue/move are set as variables so that they can
+    # be aliases, it's useful in nested loops
 
-    @node['vars']['break'] =
-      [ '_proc', { 'proc' => 'break', 'nid' => nid }, tree[-1] ]
-    @node['vars']['continue'] =
-      [ '_proc', { 'proc' => 'continue', 'nid' => nid }, tree[-1] ]
-
-    @node['vars']['move'] =
-      [ '_proc', { 'proc' => 'move', 'nid' => nid }, tree[-1] ]
+    @node['vars'] = {
+      'break' =>
+        [ '_proc', { 'proc' => 'break', 'nid' => nid }, tree[-1] ],
+      'continue' =>
+        [ '_proc', { 'proc' => 'continue', 'nid' => nid }, tree[-1] ],
+      'move' =>
+        [ '_proc', { 'proc' => 'move', 'nid' => nid }, tree[-1] ] }
 
     super
   end
@@ -92,7 +92,8 @@ class Flor::Pro::Cursor < Flor::Procedure
 
   def cancel_when_closed
 
-    return [] unless @message['flavour'] == 'break'
+    return cancel if node_status_flavour == 'on-error'
+    return [] if @message['flavour'] != 'break'
 
     cancel
   end
@@ -117,7 +118,7 @@ class Flor::Pro::Cursor < Flor::Procedure
       @node['on_receive_last'] = nil
     end
 
-    super#.tap { |ms| pp ms }
+    super
   end
 
   protected

data/lib/flor/pcore/define.rb

@@ -32,6 +32,10 @@ class Flor::Pro::Define < Flor::Procedure
   #   define "$(prefix)-sum" a b
   #     + a b
   # ```
+  #
+  # ## see also
+  #
+  # apply.
 
   names %w[ def fun define ]
 
@@ -46,7 +50,7 @@ class Flor::Pro::Define < Flor::Procedure
 
   def receive_att
 
-    t = tree
+    t = flatten_tree
     cnode = lookup_var_node(@node, 'l')
     cnid = cnode['nid']
     fun = counter_next('funs') - 1
@@ -58,7 +62,7 @@ class Flor::Pro::Define < Flor::Procedure
       { 'nid' => nid, 'tree' => t, 'cnid' => cnid, 'fun' => fun },
       t[2] ]
 
-    if t[0] == 'define'
+    if heap == 'define'
       name =
         if @message['point'] == 'execute'
           t[1].first[1].first[0]
@@ -68,9 +72,31 @@ class Flor::Pro::Define < Flor::Procedure
       set_var('', name, val)
     end
 
-    payload['ret'] = val
+    wrap('ret' => val)
+  end
+
+  protected
+
+  def flatten_tree
+
+    off = heap == 'define' ? 1 : 0
+    sig = tree[1][off..-1].select { |t| t[0] == '_att' }
+
+    return tree if sig.all? { |a| a[1][0][1] == [] }
+
+    # There is a parenthese around the parameters, let's unwrap that...
+
+    hed = Flor.dup(tree[1][0, off])
+    sig = Flor.dup(sig)
+    bdy = Flor.dup(tree[1][(off + sig.length)..-1])
+
+    att0 = sig[0][1][0]
+    att0atts = att0[1]
+    att0[1] = []
+
+    sig = sig + att0atts
 
-    wrap_reply
+    [ heap, hed + sig + bdy, *tree[2..-1] ]
   end
 end
 

data/lib/flor/pcore/do_return.rb

@@ -17,6 +17,9 @@ class Flor::Pro::DoReturn < Flor::Macro
   #   do-this-failure-prone-thing _
   # ```
   #
+  # ## see also
+  #
+  # return
 
   name 'do-return'
 

data/lib/flor/pcore/flatten.rb

@@ -0,0 +1,39 @@
+
+class Flor::Pro::Flatten < Flor::Procedure
+  #
+  # Flattens the given array
+  #
+  # ```
+  # flatten [ 1, [ 2, [ 3 ], 4 ] ]     # ==> [ 1, 2, 3, 4 ]
+  # flatten [ 1, [ 2, [ 3 ], 4 ] ], 1  # ==> [ 1, 2, [ 3 ], 4 ]
+  #
+  # [ 1, [ 2, [ 3 ], 4 ] ]
+  # flatten 1  # ==> [ 1, 2, [ 3 ], 4 ]
+  #
+  # [ 1, [ 2, [ 3 ], 4 ] ]
+  # flatten _  # ==> [ 1, 2, 3, 4 ]
+  # ```
+
+  name 'flatten'
+
+  def pre_execute
+
+    @node['rets'] = []
+
+    unatt_unkeyed_children
+  end
+
+  def receive_last
+
+    col = (@node['rets'] + [ node_payload_ret ])
+      .find { |r| r.is_a?(Array) }
+
+    lvl = @node['rets']
+      .find { |r| r.is_a?(Integer) } || -1
+
+    fail Flor::FlorError.new('missing collection', self) if col == nil
+
+    wrap('ret' => col.flatten(lvl))
+  end
+end
+

data/lib/flor/pcore/if.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::If < Flor::Procedure
   #
-  # The classical "if" (and its "unless" sidequick)
+  # The classical "if" (and its "unless" sidekick)
   #
   # ```
   # if
@@ -14,7 +14,7 @@ class Flor::Pro::If < Flor::Procedure
   #     set f.designation 'child'
   #   sequence # else
   #     set f.designation 'baby'
-  #     order_baby_food
+  #     order_baby_food _
   # ```
   #
   # Warning, the direct children are relevant. In the following snip,
@@ -22,7 +22,7 @@ class Flor::Pro::If < Flor::Procedure
   # ```
   # if (f.age > 3)
   #   set f.designation 'child'
-  #   order_child_seat
+  #   order_child_seat _
   # ```
   #
   # ## postfix `if` and `unless`
@@ -37,8 +37,17 @@ class Flor::Pro::If < Flor::Procedure
   #   a > b
   #   task 'bob'
   # ```
+  #
+  # ## else-if
+  #
+  # Currently, if an "else if" is needed, it's better to use [cond](cond.md).
+  #
+  #
+  # ## see also
+  #
+  # Cond, case, match.
 
-  names %w[ if unless ife unlesse ]
+  names %w[ if unless ife unlesse _if _unless ]
     #
     # removing "ife" and "unlesse" leads to
     # LoadError: cannot load such file -- sequel/adapters/
@@ -56,7 +65,8 @@ class Flor::Pro::If < Flor::Procedure
       # "else" or "then" answered, replying to parent...
 
     off =
-      if tree[0] == 'unless' || tree[0] == 'unlesse'
+      case heap
+      when 'unless', 'unlesse', '_unless'
         Flor.false?(payload['ret']) ? 1 : 2
       else # 'if' or 'ife'
         Flor.true?(payload['ret']) ? 1 : 2

data/lib/flor/pcore/includes.rb

@@ -16,17 +16,20 @@ class Flor::Pro::Includes < Flor::Procedure
     elt = :nil
 
     @node['rets'].each do |ret|
-      if col == nil && (ret.is_a?(Array) || ret.is_a?(Hash))
+      if col == nil && Flor.is_collection?(ret)
         col = ret
       elsif elt == :nil
         elt = ret
       end
     end
 
+    ret = (col == nil) && node_payload_ret
+    col = ret if Flor.is_collection?(ret)
+
     fail Flor::FlorError.new('missing collection', self) if col == nil
     fail Flor::FlorError.new('missing element', self) if elt == :nil
 
-    wrap_reply('ret' => col.include?(elt))
+    wrap('ret' => col.include?(elt))
   end
 end
 

data/lib/flor/pcore/inject.rb

@@ -4,7 +4,7 @@ require 'flor/pcore/iterator'
 
 class Flor::Pro::Inject < Flor::Macro::Iterator
   #
-  # Inject is a simplified version of [reduce](reduce.md).
+  # A simplified version of [reduce](reduce.md).
   #
   # Inject takes a collection and a block. It reduces the collection
   # to a single result thanks to the block.

data/lib/flor/pcore/iterator.rb

@@ -66,21 +66,20 @@ class Flor::Pro::Iterator < Flor::Procedure
       .each { |a|
         if Flor.is_func_tree?(a)
           @node['fun'] ||= a
-        elsif a.is_a?(Array) || a.is_a?(Hash)
+        elsif Flor.is_collection?(a)
           @node['ocol'] ||= a
         end }
 
-    @node['ocol'] ||= node_payload_ret
-    ocol = @node['ocol']
+    ocol = (@node['ocol'] ||= node_payload_ret)
 
     fail Flor::FlorError.new(
       "function not given to #{heap.inspect}", self
     ) if function_mandatory? && ( ! @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']) if @node['fun']
+    @node['col'] = Flor.to_coll(ocol) if @node['fun']
     @node['args'] = nil
   end
 
@@ -91,25 +90,31 @@ class Flor::Pro::Iterator < Flor::Procedure
 
   def apply_iteration
 
-    vars = determine_iteration_vars
+    #vars = determine_iteration_vars
+    #args = vars.values
+    #vars.each { |k, v| @node['vars'][k] = v }
+    #
+    #apply(@node['fun'], args, tree[2])
 
-    args = vars.values
-    vars.each { |k, v| @node['vars'][k] = v }
-
-    apply(@node['fun'], args, tree[2])
+    apply(@node['fun'], determine_iteration_args, tree[2])
   end
 
-  def determine_iteration_vars
+  def determine_iteration_args
 
     idx = @node['idx']
     elt = @node['col'][idx]
     len = @node['col'].length
 
-    if @node['ocol'].is_a?(Array)
-      { 'elt' => elt, 'idx' => idx, 'len' => len }
-    else
-      { 'key' => elt[0], 'val' => elt[1], 'idx' => idx, 'len' => len }
-    end
+    args =
+      if @node['ocol'].is_a?(Array)
+        [ [ 'elt', elt ] ]
+      else
+        [ [ 'key', elt[0] ], [ 'val', elt[1] ] ]
+      end
+    args << [ 'idx', idx ]
+    args << [ 'len', len ]
+
+    args
   end
 
   def iterator_over?
@@ -138,8 +143,13 @@ class Flor::Macro::Iterator < Flor::Macro
     if non_att_children.any?
 
       td = [ 'def', [], l ]
-      td[1] << [ '_att', [ [ 'res', [], l ] ], l ] if procedure_name == 'reduce'
-      td[1] << [ '_att', [ [ 'elt', [], l ] ], l ]
+
+      #td[1] << [ '_att', [ [ 'res', [], l ] ], l ] \
+      #  if procedure_name == 'reduce'
+      #td[1] << [ '_att', [ [ 'elt', [], l ] ], l ]
+        #
+        # the "_apply" does that work now and it distinguishes elt vs key/val
+
       non_att_children.each { |nac| td[1] << Flor.dup(nac) }
 
       th[1] << td

data/lib/flor/pcore/keys.rb

@@ -27,7 +27,7 @@ class Flor::Pro::Keys < Flor::Procedure
   #
   # length
 
-  names %w{ keys values }
+  names %w[ keys values ]
 
   def pre_execute
 
@@ -45,7 +45,7 @@ class Flor::Pro::Keys < Flor::Procedure
     ) if ret.nil?
     fail Flor::FlorError.new(
       "received argument of class #{ret.class}, no #{heap}", self
-    ) unless ret.is_a?(Array) || ret.is_a?(Hash)
+    ) unless Flor.is_collection?(ret)
 
     r =
       if ret.is_a?(Hash)

data/lib/flor/pcore/map.rb

@@ -63,9 +63,17 @@ class Flor::Pro::Map < Flor::Pro::Iterator
   # The corresponding `key`, `val`, `idx` and `len` variables are also
   # set in the closure for the function call.
   #
+  # ## missing collection
+  #
+  # "map" fails if it is not given a collection.
+  #
+  # ## missing function
+  #
+  # "map" returns the collection as is if it is not given a function.
+  #
   # ## see also
   #
-  # Collect.
+  # Collect, cmap.
 
   name 'map'
 
@@ -80,5 +88,15 @@ class Flor::Pro::Map < Flor::Pro::Iterator
 
     @node['res']
   end
+
+  def function_mandatory?
+
+    false
+  end
+
+  def no_iterate
+
+    wrap('ret' => @node['ocol'])
+  end
 end
 

data/lib/flor/pcore/match.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Match < Flor::Pro::Case
   #
-  # "match" can be thought of as a "destructuring [case](case.md)".
+  # A kind of "destructuring [case](case.md)".
   #
   # "match", like "case", matches its first argument or the incoming `f.ret`.
   #
@@ -187,7 +187,7 @@ class Flor::Pro::Match < Flor::Pro::Case
   #
   # ## see also
   #
-  # Case.
+  # Case, if, cond.
 
   name 'match'
 

data/lib/flor/pcore/matchr.rb

@@ -9,6 +9,10 @@ class Flor::Pro::Matchr < Flor::Procedure
   # `match? s r` will return true if string `s` matches regular expression `r`.
   # It returns false else.
   #
+  # `pmatch s r` will return false it it doesn't match, it will return the
+  # string matched else. If there is a capture group (parentheses) in the
+  # pattern, it will return its content instead of the whole match.
+  #
   # ```
   # matchr "alpha", /bravo/
   #   # yields an empty array []
@@ -42,8 +46,17 @@ class Flor::Pro::Matchr < Flor::Procedure
   # match? (/black/)
   #   # => false
   # ```
+  #
+  # ```
+  # # pmatch
+  # pmatch 'string', /^str/                     # ==> 'str'
+  # pmatch 'string', /^str(.+)$/                # ==> 'ing'
+  # pmatch 'string', /^str(?:.+)$/              # ==> 'string'
+  # pmatch 'strogonoff', /^str(?:.{0,3})(.*)$/  # ==> 'noff'
+  # pmatch 'sutoringu', /^str/                  # ==> ''
+  # ```
 
-  names %w[ matchr match? ]
+  names %w[ matchr match? pmatch ]
 
   def pre_execute
 
@@ -57,10 +70,10 @@ class Flor::Pro::Matchr < Flor::Procedure
     m = rex.match(str)
 
     payload['ret'] =
-      if @node['heap'] == 'match?'
-        !! m
-      else
-        m ? m.to_a : []
+      case heap
+      when 'match?' then !! m
+      when 'pmatch' then (m && (m[1] || m[0])) || ''
+      else m ? m.to_a : []
       end
 
     wrap_reply

data/lib/flor/pcore/max.rb

@@ -0,0 +1,51 @@
+
+class Flor::Pro::Max < Flor::Procedure
+
+  names %w[ max min ]
+
+  def pre_execute
+
+    @node['atts'] = []
+    @node['ret'] ||= receive_payload_ret
+
+    unatt_unkeyed_children
+  end
+
+  def receive_payload_ret
+
+    case ret = payload['ret']
+    when Array then ret
+    when Hash then ret.values
+    else false
+    end
+  end
+
+  def receive_last
+
+    ret = @node['ret']
+
+    fail Flor::FlorError.new(
+      "found no argument that can #{@node['heap']}", self
+    ) unless ret
+
+    lax = att('lax', 'loose') == true
+    types = ret.collect { |e| Flor.type(e) }
+
+    ret = ret.collect { |x| JSON.dump(x) } if lax && types != [ 'number' ]
+
+    r =
+      begin
+        ret.send(@node['heap'])
+      rescue
+        fail unless lax
+        nil
+      end
+    res =
+      r ?
+      @node['ret'][ret.index { |e| e == r }] :
+      nil
+
+    wrap_reply('ret' => res)
+  end
+end
+