flor 0.14.0 → 0.15.0

data/lib/flor/pcore/_pat_or.rb

@@ -20,6 +20,10 @@ class Flor::Pro::PatOr < Flor::Pro::PatContainer
       b = payload.delete('_pat_binding')
       return wrap_match_reply(b) if b
 
+    elsif ct == '_' && val != '_'
+
+      return wrap_no_match_reply
+
     elsif payload['ret'] == val
 
       return wrap_match_reply({})

data/lib/flor/pcore/_pat_regex.rb

@@ -0,0 +1,24 @@
+
+require 'flor/pcore/_pat_'
+
+
+class Flor::Pro::PatRegex < Flor::Pro::PatContainer
+
+  name '_pat_regex'
+
+  def execute
+
+    return wrap_no_match_reply unless val.is_a?(String)
+
+    rex = Flor.to_regex(tree[1])
+    m = rex.match(val)
+
+    return wrap_no_match_reply unless m
+
+    payload['_pat_binding'] = { 'matched' => val, 'match' => m.to_a }
+    payload.delete('_pat_val')
+
+    wrap_reply
+  end
+end
+

data/lib/flor/pcore/_skip.rb

@@ -14,6 +14,10 @@ class Flor::Pro::Skip < Flor::Procedure
   #     _skip 7 # after 7 messages will go on
   #     break ref: 'xx'
   # ```
+  #
+  # ## see also
+  #
+  # Stall.
 
   name '_skip'
 

data/lib/flor/pcore/_val.rb

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

data/lib/flor/pcore/all.rb

@@ -0,0 +1,111 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::All < Flor::Pro::Iterator
+  #
+  # Returns true if all the elements in a collection return true
+  # for the given function.
+  #
+  # ```
+  # all? [ 1, 2, 3 ]
+  #   def elt \ elt > 0
+  #     #
+  #     # yields true
+  #
+  # all? [ 1, 2, 3 ]
+  #   def elt \ elt > 2
+  #     #
+  #     # yields false
+  # ```
+  #
+  # ```
+  # all? { a: 'A', b: 'B' }
+  #   def key, val \ val == 'A' or val == 'B'
+  #     #
+  #     # yields true
+  # ```
+  #
+  # ### without a function
+  #
+  # For an array, yields true if all the elements are "trueish" (not nil,
+  # not false).
+  #
+  # ```
+  # all? []                            # yields true
+  # all? [ 1 2 3 ]                     # yields true
+  # all? [ 1 false 3 ]                 # yields false
+  # ```
+  #
+  # For an object, yields true if all the values are trueish.
+  #
+  # ```
+  # all? {}                            # yields true
+  # all? { a: 'A', b: 'B', c: 'C' }    # yields true
+  # all? { a: 'A', f: false, c: 'C' }  # yields false
+  # ```
+  #
+  # ## incoming ret
+  #
+  # ```
+  # []
+  # all?  # yields true
+  # [ 1 2 3 ]
+  # all?  # yields true
+  # [ 1 false 3 ]
+  # all?  # yields false
+  # ```
+  #
+  # ## iterating and functions
+  #
+  # Iterating functions accept 0 to 3 arguments when iterating over an
+  # array and 0 to 4 arguments when iterating over an object.
+  #
+  # Those arguments are `[ value, index, length ]` for arrays.
+  # They are `[ key, value, index, length ]` for objects.
+  #
+  # The corresponding `key`, `val`, `idx` and `len` variables are also
+  # set in the closure for the function call.
+  #
+  # ## see also
+  #
+  # Any?
+
+  name 'all?'
+
+  protected
+
+  def receive_iteration
+
+    # nothing to do
+  end
+
+  def function_mandatory?
+
+    false
+  end
+
+  def no_iterate
+
+    ret =
+      case col = @node['ocol']
+      when Array then col.all?
+      when Hash then col.values.all?
+      else false
+      end
+
+    wrap_reply('ret' => ret)
+  end
+
+  def iterator_over?
+
+    super ||
+    (@node['idx'] > 0 && ( ! Flor.true?(payload['ret'])))
+  end
+
+  def iterator_result
+
+    Flor.true?(payload['ret'])
+  end
+end
+

data/lib/flor/pcore/any.rb

@@ -0,0 +1,83 @@
+
+require 'flor/pcore/find'
+
+
+class Flor::Pro::Any < Flor::Pro::Find
+  #
+  # Returns `true` if at least one of the member of a collection returns
+  # something trueish for the given function. Returns `false` else.
+  #
+  # ```
+  # any? [ 1, 2, 3 ]
+  #   def elt
+  #     (elt % 2) == 0
+  # # yields `true` thanks to element `2`
+  # ```
+  #
+  # ```
+  # any? { a: 'A', b: 'B', c: 'C' }
+  #   def key, val \ val == 'B'
+  # # yields `true` thanks to entry { b: 'B' }
+  # ```
+  #
+  # ## without a function
+  #
+  # It's OK to use "any?" without a function, it'll simply return
+  # false if the collection is empty, true else.
+  #
+  # ```
+  # any? []          # yields false
+  # any? [ 1 ]       # yields true
+  # any? {}          # yields false
+  # any? { a: 'A' }  # yields true
+  # ```
+  #
+  # ## iterating and functions
+  #
+  # Iterating functions accept 0 to 3 arguments when iterating over an
+  # array and 0 to 4 arguments when iterating over an object.
+  #
+  # Those arguments are `[ value, index, length ]` for arrays.
+  # They are `[ key, value, index, length ]` for objects.
+  #
+  # The corresponding `key`, `val`, `idx` and `len` variables are also
+  # set in the closure for the function call.
+  #
+  # ## incoming ret array/object
+  #
+  # If not fed an array or object directly, "any?" will pick it from the
+  # payload "ret" field.
+  #
+  # ```
+  # [ 1, 2, 3 ]
+  # any? _                    # yields true
+  # any? (def elt \ elt == 3) # yields true
+  # []
+  # any? _                    # yields false
+  # any? (def elt \ elt == 3) # yields false
+  # ```
+  #
+  # ## see also
+  #
+  # Find, all?.
+
+  name 'any?'
+
+  protected
+
+  def function_mandatory?
+
+    false
+  end
+
+  def no_iterate
+
+    wrap_reply('ret' => @node['ocol'].any?)
+  end
+
+  def iterator_result
+
+    super != nil
+  end
+end
+

data/lib/flor/pcore/arith.rb

@@ -1,5 +1,29 @@
 
 class Flor::Pro::Arith < Flor::Procedure
+  #
+  # The base implementation for + - + / %
+  #
+  # ```
+  # (+ 1 2 3) # ==> 6
+  #
+  # +
+  #   1
+  #   2
+  #   3 # ==> 6
+  #
+  # + \ 1; 2; 3 # ==> 6
+  # ```
+  #
+  # ```
+  # 1 - 2 - 3 # ==> -4
+  #
+  # -
+  #   1
+  #   2
+  #   3 # ==> -4
+  # ```
+  #
+  # ...
 
   names %w[ + - * / % ]
 
@@ -15,12 +39,17 @@ class Flor::Pro::Arith < Flor::Procedure
     sign = tree.first.to_sym
     count = @node['rets'].size
 
-    if sign == :% && count < 2
-      fail ArgumentError.new(
-        "modulo % requires at least 2 arguments (line #{tree[2]})")
-    end
-
-    payload['ret'] = @node['rets'].reduce(&sign) || DEFAULTS[sign]
+    fail Flor::FlorError.new('modulo % requires at least 2 arguments', self) \
+      if sign == :% && count < 2
+
+    payload['ret'] =
+      if @node['rets'].compact.empty?
+        DEFAULTS[sign]
+      elsif sign == :+
+        @node['rets'].reduce { |r, e| r + (r.is_a?(String) ? e.to_s : e) }
+      else
+        @node['rets'].reduce(&sign)
+      end
 
     wrap_reply
   end

data/lib/flor/pcore/break.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Break < Flor::Procedure
   #
-  # Breaks or continues a "while" or "until".
+  # Breaks or continues a "while", "until", "loop" or an "cursor".
   #
   # ```
   # until false
@@ -10,6 +10,44 @@ class Flor::Pro::Break < Flor::Procedure
   #   break if f.x == 1
   #   # do something more
   # ```
+  #
+  # ## ref:
+  #
+  # Break and continue may be used from outside a loop, thanks to the
+  # `ref:` attribute:
+  #
+  # ```
+  # set l []
+  # concurrence
+  #   cursor tag: 'x0'
+  #     push l 0
+  #     stall _
+  #   sequence
+  #     push l 1
+  #     break ref: 'x0'
+  #
+  # # where l ends up containing [ 1, 0 ]
+  # ```
+  #
+  # ## "aliasing"
+  #
+  # A continue or a break may be "aliased", in other words stored in a
+  # local variable for reference in a sub-loop.
+  #
+  # ```
+  # cursor
+  #   set outer-continue continue
+  #   push f.l "$(nid)"
+  #   cursor
+  #     push f.l "$(nid)"
+  #     outer-continue _ if "$(nid)" == '0_2_1_0_0'
+  #
+  # # where l yields [ '0_1_1', '0_2_0_1', '0_1_1-1', '0_2_0_1-1' ]
+  # ```
+  #
+  # ## see also
+  #
+  # While, until, loop and cursor.
 
   name 'break', 'continue'
 

data/lib/flor/pcore/case.rb

@@ -24,6 +24,14 @@ class Flor::Pro::Case < Flor::Procedure
   #   'high'
   # ```
   #
+  # Non-array values are OK:
+  # ```
+  # case level
+  #   0; 'zero'
+  #   1; 'one'
+  #   else; 'dunno'
+  # ```
+  #
   # ## else
   #
   # As seen in the example above, an "else" in lieu of an array acts as
@@ -31,6 +39,55 @@ class Flor::Pro::Case < Flor::Procedure
   #
   # If there is no else and no matching array, the case terminates and
   # doesn't set the field "ret".
+  #
+  # ### v.matched and $(matched)
+  #
+  # When it successfully matches, the matched value (the argument of the
+  # "case") is placed in the local (local to the then or else branch)
+  # variables under 'matched'.
+  #
+  # ```
+  # case 6
+  #   5; 'five'
+  #   [ 1, 6 ]; v.matched
+  #   else; 'zilch'
+  # # returns, well, 6...
+  # ```
+  #
+  # ```
+  # case 6
+  #   5; 'five'
+  #   [ 1, 6 ]; "matched! >$(matched)<"
+  #   else; 'zilch'
+  # # returns "matched! >6<"
+  # ```
+  #
+  # ## regular expressions
+  #
+  # It's OK to match with regular expressions:
+  # ```
+  # case 'ovomolzin'
+  #   /a+/; 'ahahah'
+  #   [ /u+/, /o+/ ]; 'ohohoh'   # <--- matches here
+  #   else; 'else'
+  # ```
+  #
+  # ### v.match and $(match)
+  #
+  # When matching with a regular expression, the local variable 'matched' is
+  # set, as seen above, but also 'match':
+  #
+  # ```
+  # case 'ovomolzin'
+  #   /a+/; 'ahahah'
+  #   [ /u+/, /^ovo(.+)$/ ]; "matched:$(match.1)"
+  #   else; 'else'
+  # # yields "matched:molzin"
+  # ```
+  #
+  # ## see also
+  #
+  # Match.
 
   name 'case'
 
@@ -38,7 +95,7 @@ class Flor::Pro::Case < Flor::Procedure
 
     unatt_unkeyed_children
 
-    @node['val'] = payload['ret'] if non_att_children.size.even?
+    @node['val'] = payload['ret'] if non_att_count.even?
   end
 
   def receive
@@ -93,10 +150,31 @@ class Flor::Pro::Case < Flor::Procedure
 
   def match?
 
-    a = payload['ret']
-    a = a.nil? ? [ a ] : Array(a)
+    v = @node['val']
+
+    array.each do |e|
+      m = do_match?(e, v)
+      return m if m
+    end
 
-    a.include?(@node['val'])
+    nil
+  end
+
+  def do_match?(elt, val)
+
+    return { 'matched' => elt } if elt == val
+
+    m = val.is_a?(String) && elt.is_a?(Regexp) && elt.match(val)
+    return { 'matched' => elt, 'match' => m.to_a } if m
+
+    nil
+  end
+
+  def array
+
+    a = payload['ret']
+    a = [ a ] if Flor.is_regex_tree?(a) || ! a.is_a?(Array)
+    a.collect { |e| Flor.is_regex_tree?(e) ? Flor.to_regex(e) : e }
   end
 end