flor 0.14.0 → 0.15.0

data/lib/flor/pcore/cmp.rb

@@ -13,9 +13,9 @@ class Flor::Pro::Cmp < Flor::Procedure
     payload['ret'] =
       if @node['rets'].size > 1
         case tree[0]
-          when '=', '==' then check_equal
-          when '<', '>' then check_lesser
-          else true
+        when '=', '==' then check_equal
+        when '<', '>' then check_lesser
+        else true
         end
       else
         true
@@ -36,10 +36,10 @@ class Flor::Pro::Cmp < Flor::Procedure
     a, b = @node['rets'][-2], @node['rets'][-1]
 
     case tree[0]
-      when '<' then return false if a >= b
-      when '<=' then return false if a > b
-      when '>' then return false if a <= b
-      when '>=' then return false if a < b
+    when '<' then return false if a >= b
+    when '<=' then return false if a > b
+    when '>' then return false if a <= b
+    when '>=' then return false if a < b
     end
 
     true

data/lib/flor/pcore/collect.rb

@@ -0,0 +1,50 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::Collect < Flor::Macro::Iterator
+  #
+  # Collect is a simplified version of [map](map.md).
+  #
+  # ```
+  # map [ 1, 2, 3 ]
+  #   def x
+  #     + x 3
+  #   #
+  #   # becomes
+  #   #
+  # collect [ 1, 2, 3 ]
+  #   + elt 3
+  # ```
+  # Collect accepts, instead of a function, a block, where `elt` contains
+  # the current element and `idx` the current index.
+  #
+  # ```
+  # collect [ 'a', 'b' ]
+  #   [ idx, elt ]
+  # ```
+  #
+  # ## iterating blocks
+  #
+  # Iterating blocks are given 3 to 4 local variables.
+  #
+  # A block iterating over an array will receive `elt` (the current element
+  # of the iteration), `idx` (the zero-based index of the current element),
+  # and `len` (the length of the array).
+  #
+  # A block iterating over an object will receive `key` (the current string
+  # key), `val` (the current value), `idx` (the zero-based index of the
+  # current key/val), and `len` (the length of the object).
+  #
+  # ## see also
+  #
+  # Map.
+
+  name 'collect'
+
+  def rewrite_tree
+
+    rewrite_iterator_tree('map')
+  end
+end
+

data/lib/flor/pcore/cond.rb

@@ -19,11 +19,25 @@ class Flor::Pro::Cond < Flor::Procedure
   # ```
   # set a 11
   # cond
-  #   a < 4 ;; "less than four"
-  #   a < 7 ;; "less than seven"
-  #   else ;; "ten or bigger"
+  #   a < 4 ; "less than four"
+  #   a < 7 ; "less than seven"
+  #   else ; "ten or bigger"
   # ```
   # will yield "ten or bigger".
+  #
+  # The semicolon is used to place condition and clause on the same line.
+  # A pipe can be used instead of a semicolon.
+  # ```
+  # set a 11
+  # cond
+  #   a < 4 | "less than four"
+  #   a < 7 | "less than seven"
+  #   else | "ten or bigger"
+  # ```
+  #
+  # ## see also
+  #
+  # If, match.
 
   name 'cond'
 

data/lib/flor/pcore/cursor.rb

@@ -43,6 +43,10 @@ class Flor::Pro::Cursor < Flor::Procedure
   #   do-that _ # got skipped
   #   do-that-other-thing _
   # ```
+  #
+  # ## see also
+  #
+  # Break, continue, loop.
 
   name 'cursor'
 
@@ -122,14 +126,16 @@ class Flor::Pro::Cursor < Flor::Procedure
 
     to = @message['to']
 
-    fail("move target #{to.inspect} is not a string") unless to.is_a?(String)
+    fail Flor::FlorError.new(
+      "move target #{to.inspect} is not a string", self
+    ) unless to.is_a?(String)
 
     find_tag_target(to) ||
     find_string_arg_target(to) ||
     find_string_target(to) ||
     find_name_target(to) ||
     find_att_target(to) ||
-    fail("move target #{to.inspect} not found")
+    fail(Flor::FlorError.new("move target #{to.inspect} not found", self))
   end
 
   def is_tag_tree?(t, tagname)

data/lib/flor/pcore/detect.rb

@@ -0,0 +1,45 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::Detect < Flor::Macro::Iterator
+  #
+  # Detect is a simplified version of [find](find.md).
+  #
+  # ```
+  # detect [ 1, 2, 3 ]
+  #   (elt % 2) == 0
+  # # f.ret --> 2
+  # ```
+  #
+  # With objects (maps), it returns the first matching entry (pair).
+  # ```
+  # detect { a: 'A', b: 'B', c: 'C' }
+  #   val == 'B'
+  # # f.ret --> [ 'b', 'B' ]
+  # ```
+  #
+  # ## iterating blocks
+  #
+  # Iterating blocks are given 3 to 4 local variables.
+  #
+  # A block iterating over an array will receive `elt` (the current element
+  # of the iteration), `idx` (the zero-based index of the current element),
+  # and `len` (the length of the array).
+  #
+  # A block iterating over an object will receive `key` (the current string
+  # key), `val` (the current value), `idx` (the zero-based index of the
+  # current key/val), and `len` (the length of the object).
+  #
+  # ## see also
+  #
+  # find.
+
+  name 'detect'
+
+  def rewrite_tree
+
+    rewrite_iterator_tree('find')
+  end
+end
+

data/lib/flor/pcore/each.rb

@@ -0,0 +1,52 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::Each < Flor::Macro::Iterator
+  #
+  # Each is a simplified version of [for-each](for_each.md).
+  #
+  # Calls a function for each element in the argument collection.
+  #
+  # When the "each" ends, `f.ret` is pointing back to the argument
+  # collection.
+  #
+  # ```
+  # set l []
+  # each [ 0 1 2 3 4 5 6 7 ]
+  #   pushr l (2 * elt) if elt % 2 == 0
+  # ```
+  # the var `l` will yield `[ 0, 4, 8, 12 ]` after the `each`
+  # the field `ret` will yield `[ 0, 1, 2, 3, 4, 5, 6, 7 ]`.
+  #
+  # ```
+  # set l []
+  # each { a: 'A', b: 'B', c: 'C' }
+  #   pushr l (+ key val idx)
+  # ```
+  # the var `l` will yield `[ 'aA0', 'bB1', 'cC2' ]` after the `each`
+  #
+  # ## iterating blocks
+  #
+  # Iterating blocks are given 3 to 4 local variables.
+  #
+  # A block iterating over an array will receive `elt` (the current element
+  # of the iteration), `idx` (the zero-based index of the current element),
+  # and `len` (the length of the array).
+  #
+  # A block iterating over an object will receive `key` (the current string
+  # key), `val` (the current value), `idx` (the zero-based index of the
+  # current key/val), and `len` (the length of the object).
+  #
+  # ## see also
+  #
+  # for-each.
+
+  name 'each'
+
+  def rewrite_tree
+
+    rewrite_iterator_tree('for-each')
+  end
+end
+

data/lib/flor/pcore/empty.rb

@@ -0,0 +1,60 @@
+
+class Flor::Pro::Empty < Flor::Procedure
+  #
+  # Returns true if the given collection or string is empty.
+  #
+  # Returns true of the given argument is null, returns false for any
+  # other non-collection, non-string argument.
+  #
+  # ```
+  # empty? []           # --> true
+  # empty? {}           # --> true
+  # empty? ''           # --> true
+  # empty? null         # --> true
+  #
+  # empty? [ 1, 2, 3 ]  # --> false
+  # empty? { a: 'A' }   # --> false
+  # empty? 0            # --> false
+  # empty? 'aaa'        # --> false
+  # ```
+  #
+  # If the argument is not an array, an object, a string or null, an
+  # error is triggered.
+  #
+  # If there is no argument to the "empty?", the incoming payload['ret']
+  # is considered
+  #
+  # ```
+  # {}
+  # empty? _     # --> true
+  #
+  # [ 1, 2, 3 ]
+  # empty? _     # --> false
+  # ```
+  #
+  # ## see also
+  #
+  # any?
+
+  name 'empty?'
+
+  def pre_execute
+
+    unatt_unkeyed_children
+  end
+
+  def receive_last
+
+    ret =
+      case r = payload['ret']
+      when Array, Hash, String then r.empty?
+      when nil then true
+      else
+        fail Flor::FlorError.new(
+          'argument is not an array, an object, a string or null', self)
+      end
+
+    wrap_reply('ret' => ret)
+  end
+end
+

data/lib/flor/pcore/filter.rb

@@ -0,0 +1,94 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::Filter < Flor::Pro::Iterator
+  #
+  # Filters a collection
+  #
+  # Expects a function in its arguments and a collection to filter
+  # in its arguments or as the incoming "ret".
+  #
+  # Fails if the collection or the function is missing.
+  #
+  # ```
+  # filter [ 1, 2, 3, 4, 5 ]
+  #   def x
+  #     = (x % 2) 1
+  #
+  # # f.ret --> [ 1, 3, 5 ]
+  # ```
+  #
+  # ## with objects (hashes)
+  #
+  # ```
+  # filter { a: 'A', b: 'B', c: 'C', d: 'D' }
+  #   def k v i
+  #     #or (k == 'a') (v == 'C') (i == 3)
+  #     k == 'a' or v == 'C' or i == 3
+  #
+  # # f.ret --> { 'a' => 'A', 'c' => 'C', 'd' => 'D' }
+  # ```
+  #
+  # ## filter-out
+  #
+  # Is the negative sibling of "filter".
+  #
+  # ```
+  # filter-out [ 1, 2, 3, 4, 5 ]
+  #   def x
+  #     = (x % 2) 0
+  #
+  # # f.ret --> [ 1, 3, 5 ]
+  # ```
+  #
+  # ## incoming ret
+  #
+  # When not given directly a collection, `filter` takes it from the
+  # incoming "ret"
+  #
+  # ```
+  # { a: 'A', b: 'B', c: 'C', d: 'D' }
+  # filter
+  #   def k v i l # key, value, index, length
+  #     i = (l - 1) or i = (l - 2)
+  # # f.ret --> { 'c' => 'C', 'd' => 'D' }
+  # ```
+  #
+  # ## 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
+  #
+  # map, select, and reject.
+
+  names %w[ filter filter-out ]
+
+  protected
+
+  def receive_iteration
+
+    @node['res'] << @node['col'][@node['idx']] \
+      if (
+        (heap == 'filter' && Flor.true?(payload['ret'])) ||
+        (heap == 'filter-out' && Flor.false?(payload['ret'])))
+  end
+
+  def iterator_result
+
+    if @node['ocol'].is_a?(Hash)
+      Hash[@node['res']]
+    else
+      @node['res']
+    end
+  end
+end
+

data/lib/flor/pcore/find.rb

@@ -0,0 +1,67 @@
+
+require 'flor/pcore/iterator'
+
+
+class Flor::Pro::Find < Flor::Pro::Iterator
+  #
+  # Finds the first matching element.
+  #
+  # ```
+  # find [ 1, 2, 3 ]
+  #   def elt
+  #     (elt % 2) == 0
+  # # f.ret --> 2
+  # ```
+  #
+  # With objects (maps), it returns the first matching entry (pair).
+  # ```
+  # find { a: 'A', b: 'B', c: 'C' }
+  #   def key, val
+  #     val == 'B'
+  # # f.ret --> [ 'b', 'B' ]
+  # ```
+  #
+  # ## 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
+  #
+  # Map and detect, any?.
+
+  name 'find'
+
+  protected
+
+  def pre_iterator
+
+    # nothing to do
+  end
+
+  def receive_iteration
+
+    # nothing to do
+  end
+
+  def iterator_over?
+
+    super || (@node['idx'] > 0 && Flor.true?(payload['ret']))
+  end
+
+  def iterator_result
+
+    if Flor.true?(payload['ret'])
+      @node['col'][@node['idx'] - 1]
+    else
+      nil
+    end
+  end
+end
+