flor 0.15.0 → 0.16.0

data/lib/flor/pcore/reverse.rb

@@ -17,6 +17,10 @@ class Flor::Pro::Reverse < Flor::Procedure
   # ```
   #
   # Will fail if it finds nothing reversable.
+  #
+  # # see also
+  #
+  # shuffle, sort, and sort_by
 
   name 'reverse'
 

data/lib/flor/pcore/sequence.rb

@@ -10,6 +10,13 @@ class Flor::Pro::Sequence < Flor::Procedure
   #   task 'charly'
   # ```
 
-  names %w[ sequence _apply begin ]
+  names %w[ sequence begin ]
+
+  def cancel_when_closed
+
+    return cancel if node_status_flavour == 'on-error'
+
+    []
+  end
 end
 

data/lib/flor/pcore/set.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Set < Flor::Procedure
   #
-  # sets a field or a variable.
+  # Sets a field or a variable.
   #
   # ```
   # sequence
@@ -67,12 +67,11 @@ class Flor::Pro::Set < Flor::Procedure
   def pre_execute
 
     unatt_unkeyed_children
+    reref_children
 
-    nacn = non_att_children.dup
-    sc = @node['single_child'] = nacn.size == 1
-    nacn = non_att_children[0..-2] unless sc
+    @node['single_child'] = (non_att_children.count == 1)
 
-    nacn.each_with_index { |_, i| stringify_child(i) }
+    rep_children
 
     @node['refs'] = []
   end
@@ -87,32 +86,92 @@ class Flor::Pro::Set < Flor::Procedure
 
   def receive_non_att
 
-    ret = payload['ret']
-    last = ! @node['single_child'] && (@fcid + 1) == children.size
+    ft = tree[1][@fcid] || []
 
-    @node['refs'] << ret if ! last && ret.is_a?(String)
+    if ft[0] == '_rep' || (Flor.is_string_tree?(ft) && ! last_receive?)
+      @node['refs'] << payload['ret']
+    elsif ft[0] == '_ref' &&
+      ft[1].size == 2 &&
+      ft[1][0][0, 2] == [ '_sqs', 'f' ] && ft[1][1][0, 2] == [ '_sqs', 'ret' ]
+    then
+      payload['ret'] = node_payload_ret
+    end
 
     super
   end
 
   def receive_last
 
-    ret = @node['single_child'] ? node_payload_ret : payload['ret']
+    ret =
+      if @node['single_child']
+        node_payload_ret
+      else
+        payload['ret']
+      end
+
+    refs = @node['refs']
 
-    if @node['refs'].size == 1
-      set_value(@node['refs'].first, ret)
-    else
-      Flor.splat(@node['refs'], ret).each { |k, v| set_value(k, v) }
+    case refs.size
+    when 0 then 0
+    when 1 then set_value(refs.first, ret)
+    else splat_value(refs, ret)
     end
 
     payload['ret'] =
-      if tree[0] == 'setr' || @node['refs'].last == 'f.ret'
+      if tree[0] == 'setr' || refs_include_f_ret?
         ret
       else
         node_payload_ret
       end
 
-    wrap_reply
+    wrap
+  end
+
+  protected
+
+  def refs_include_f_ret?
+
+    !! @node['refs']
+      .find { |ref|
+        ref.length == 2 &&
+        ref[1] == 'ret' &&
+        ref[0].match(/\Af(ld|ield)?\z/) }
+  end
+
+  def reref_children
+
+    t = tree
+
+    cn = t[1]
+      .collect { |ct|
+        hd, cn, ln = ct
+        if hd == '_dqs'
+          [ '_ref', [ ct ], ln ]
+        elsif Flor.is_single_ref_tree?(ct)
+          [ '_ref', [ [ '_sqs', hd, ln ] ], ln ]
+        else
+          ct
+        end }
+
+    @node['tree'] = [ t[0], cn, t[2] ] if cn != t[1]
+  end
+
+  def rep_children
+
+    t = tree
+    li = t[1].length - 1
+
+    cn = t[1]
+      .each_with_index
+      .collect { |ct, i|
+        hd, cn, ln = ct
+        if hd == '_ref' && (@node['single_child'] || li != i)
+          [ '_rep', cn, ln ]
+        else
+          ct
+        end }
+
+    @node['tree'] = [ t[0], cn, t[2] ] if cn != t[1]
   end
 end
 

data/lib/flor/pcore/shuffle.rb

@@ -0,0 +1,71 @@
+
+class Flor::Pro::Shuffle < Flor::Procedure
+  #
+  # Returns a shuffled version of an array.
+  #
+  # ## shuffle
+  #
+  # ```
+  # shuffle [ 0 1 2 3 4 ]
+  #   # might set [ 3 2 0 1 4 ] in f.ret
+  # shuffle [ 0 1 2 3 4 ] 2
+  #   # might set [ 4 2 ] in f.ret
+  # shuffle [ 0 1 2 3 4 ] count: 2
+  #   # might set [ 4 2 ] in f.ret
+  #
+  # [ 0 1 2 3 4 ]
+  # shuffle _
+  #   # might set [ 4 0 2 1 3 ] in f.ret
+  # ```
+  #
+  # ## sample
+  #
+  # When given a count integer, "sample" behaves exactly like "shuffle".
+  # When not given a count, it returns a single, random, element of the given
+  # array.
+  #
+  # ```
+  # sample [ 'a' 'b' 'c' ]
+  #   # might set 'b' in f.ret
+  #
+  # [ 'a' 'b' 'c' ]
+  # sample _
+  #   # might set 'b' in f.ret
+  #
+  # sample [ 'a' 'b' 'c' ] 2
+  #   # might set [ 'c', 'b' ] in f.ret
+  # ```
+  #
+  # ## see also
+  #
+  # slice, index, reverse, and length
+
+  names %w[ shuffle sample ]
+
+  def pre_execute
+
+    unatt_unkeyed_children
+
+    @node['atts'] = []
+    @node['rets'] = []
+  end
+
+  def receive_last
+
+    arr =
+      (@node['rets'] + [ node_payload_ret ])
+        .find { |r| r.is_a?(Array) }
+
+    fail Flor::FlorError.new("no array to #{heap}") unless arr
+
+    cnt =
+      att('count', nil) ||
+      @node['rets'].find { |r| r.is_a?(Integer) }
+
+    ret = arr.sample(cnt || arr.size)
+    ret = ret.first if cnt == nil && heap == 'sample'
+
+    wrap('ret' => ret)
+  end
+end
+

data/lib/flor/pcore/slice.rb

@@ -0,0 +1,137 @@
+
+class Flor::Pro::Slice < Flor::Procedure
+  #
+  # Takes an array or a string and returns a slice of it (a new
+  # array or a new string).
+  #
+  # "index" takes an array or a string and returns the element (character)
+  # at the given index.
+  #
+  # ## slice
+  #
+  # ```
+  # set a [ 'alpha' 'bravo' 'charly' ]
+  #
+  # slice a 1 -1            # sets [ 'bravo', 'charly' ] into the field 'ret'
+  # slice a from: 1 to: -1  # same as above
+  #
+  # a
+  # slice 1 -1  # sets [ 'bravo', 'charly' ] into the field 'ret'
+  # slice 1 -1  # sets [ 'charly' ] into the field 'ret'
+  # ```
+  #
+  # It slices the content of `f.ret` by default:
+  # ```
+  # set a [ 0 1 2 3 ]
+  # # ...
+  # a                  # (copy content of a into f.ret)
+  # slice 1 count: 2   # sets [ 1, 2 ] into the field 'ret'
+  # ```
+  #
+  # ## index
+  #
+  # ```
+  # set a [ 'alpha' 'bravo' 'charly' ]
+  #
+  # index a (-2)    # sets 'bravo' into the field 'ret'
+  # index a at: -2  # sets 'bravo' into the field 'ret'
+  # ```
+  #
+  # It indexes the content of `f.ret` by default:
+  # ```
+  # set a [ 0 1 2 3 4 ]
+  # # ...
+  # a                    # (copy content of a into f.ret)
+  # index (-2)           # sets 3 into the field 'ret'
+  # ```
+  #
+  # ## see also
+  #
+  # length
+
+  names 'slice', 'index'
+
+  # three cases: [ start, count ], [ start, end ], and [ start, end, step ]
+
+  def pre_execute
+
+    unatt_unkeyed_children
+
+    @node['atts'] = []
+    @node['rets'] = []
+  end
+
+  def receive_last
+
+    send(heap)
+  end
+
+  protected
+
+  def collection
+
+    coll =
+      @node['rets'].find { |e| e.respond_to?(:slice) } ||
+      node_payload_ret
+
+    fail Flor::FlorError.new(
+      "cannot slice instance of #{coll.class}", self
+    ) unless coll.respond_to?(:slice)
+
+    coll
+  end
+
+  def slice
+
+    coll = collection
+
+    ints = @node['rets'].select { |e| e.is_a?(Integer) }
+
+    st = att('from', 'start') || ints.shift || 0
+    en = att('to', 'end') || ints.shift
+    co = att('count')
+    sp = att('step') || 1
+
+    en ||= (st + co - 1)
+    en = coll.length + en if en < 0
+
+    ret =
+      case coll
+      when String
+        do_slice(coll.chars, st, en, sp, true)
+      when Array
+        do_slice(coll, st, en, sp)
+      else
+        fail Flor::FlorError.new("cannot slice instance of #{coll.class}", self)
+      end
+
+    ret ||= ''
+
+    wrap('ret' => ret)
+  end
+
+  def do_slice(coll, st, en, sp, join=false)
+
+    l = coll.length
+
+    return nil if st >= l
+
+    r = []
+
+    while st <= en && st < l
+      r << coll[st]
+      st = st + sp
+    end
+
+    join ? r.join : r
+  end
+
+  def index
+
+    coll = collection
+    index = att('at') || @node['rets'].find { |e| e.is_a?(Integer) }
+
+    wrap('ret' => coll[index] || '')
+  end
+end
+

data/lib/flor/pcore/sort.rb

@@ -0,0 +1,244 @@
+
+class Flor::Pro::Sort < Flor::Procedure
+  #
+  # Sorts an array or an object.
+  #
+  # "sort" takes an array or an object and sorts its content.
+  #
+  # ```
+  # sort [ 0 7 1 5 3 4 2 6 ]
+  #   # => [ 0 1 2 3 4 5 6 7 ]
+  # ```
+  #
+  # Without a function, "sort" uses the underlying (Ruby) sort methods.
+  #
+  # One can use a function to sort in specific ways:
+  # ```
+  # [ { name: 'Alice', age: 33, function: 'ceo' }
+  #   { name: 'Bob', age: 44, function: 'cfo' }
+  #   { name: 'Charly', age: 27, function: 'cto' } ]
+  # sort (def a b \ - a.age b.age)
+  # ```
+  #
+  # The function should return a boolean or a number. `true` or a negative
+  # number indicates `a` comes  before `b`, anything else indicates `a`
+  # comes after `b`.
+  #
+  # ## behind the scenes
+  #
+  # Sorting an array results in a sorted array stored in `f.ret`, sorting
+  # an object results in a sorted (entries) object stored in `f.ret`.
+  #
+  # Using a function to sort is quite slow. Behind the scene a quicksort is
+  # used, to lower the number of calls to the sort function, but since
+  # the function is a flor function, calls are quite costly.
+  # By default, "sort" will cache the call results. For example, upon
+  # comparing 1 with 7, the results will be cached (the 7 vs 1 will be cached
+  # as well).
+  #
+  # It's OK to disable this caching:
+  # ```
+  # sort memo: false a (def a b \ < a b)
+  # ```
+  # (but why should we need that?)
+  #
+  # ## see also
+  #
+  # sort_by, reverse, and shuffle
+
+  name 'sort'
+
+  def pre_execute
+
+    @node['atts'] = []
+
+    @node['col'] = nil # collection
+    @node['fun'] = nil # function
+
+    unatt_unkeyed_children
+  end
+
+  def receive_non_att
+
+    if @node['ranges']
+
+      quick_partition_receive
+
+    else
+
+      r = payload['ret']
+
+      if Flor.is_func_tree?(r)
+        @node['fun'] ||= r
+      elsif Flor.is_collection?(r)
+        @node['col'] ||= r
+      end
+
+      super
+    end
+  end
+
+  def receive_last
+
+    @node['col'] ||= node_payload_ret
+
+    if @node['col'].empty?
+      wrap('ret' => @node['col'])
+    elsif @node['fun']
+      quick_sort
+    else
+      default_sort
+    end
+  end
+
+  protected
+
+  def receive_argument
+
+    @node['args'] << payload['ret']
+
+    if children[@ncid]
+      execute_child(@ncid)
+    else
+      iterate
+    end
+  end
+
+  #
+  # default_sort
+  #
+  # When no function is given, turns to a collection of string
+  # (or JSON representations) and sorts
+
+  def default_sort
+
+    col =
+      @node['col']
+    classes =
+      col.collect(&:class).uniq
+    f =
+      (classes.count > 1 || [ Hash ].include?(classes[0])) ?
+      lambda { |e| e.is_a?(String) ? e : JSON.dump(e) } :
+      lambda { |e| e }
+
+    ret = col.sort_by(&f)
+    ret = col.inject({}) { |h, (k, v)| h[k] = v; h } if col.is_a?(Hash)
+
+    wrap('ret' => ret)
+  end
+
+  #
+  # quick_sort
+  #
+  # A quicksort drives the game
+
+  def quick_sort
+
+    col = @node['col']
+    @node['colk'] = col.is_a?(Hash) ? 'object' : 'array'
+    @node['col'] = col.to_a
+
+    @node['ranges'] = {}
+
+    @node['memo'] =
+      att('memo', 'cache') == false ?
+      nil :
+      {}
+
+    quick_partition_execute(0, col.length - 1)
+  end
+
+  def quick_swap(a, b)
+
+    return if a == b
+
+    col = @node['col']
+    col[a], col[b] = col[b], col[a]
+  end
+
+  def quick_kab(va, vb)
+
+    return [] unless @node['memo']
+
+    kab = [ va, vb ]
+      .collect { |e|
+        case e
+        when Array, Hash, String then Digest::SHA256.hexdigest(JSON.dump(e))
+        else JSON.dump(e)
+        end }
+
+    [ kab.join('__'), kab.reverse.join('__') ]
+  end
+
+  def quick_compare(ra, a, b)
+
+    col = @node['col']
+    va, vb = col[a], col[b]
+
+    ra['kab'], ra['kba'] = quick_kab(va, vb)
+    kab = ra['kab']
+
+    if kab && @node['memo'].has_key?(kab)
+      quick_partition_receive(ra['sub'], @node['memo'][kab])
+    else
+      apply(@node['fun'], [ [ 'a', va ], [ 'b', vb ] ], tree[2])
+        .tap { |ms| ra['sub'] = Flor.sub_nid(ms.first['nid']) }
+    end
+  end
+
+  def quick_partition_execute(lo, hi)
+
+    return [] if lo >= hi
+
+    ra = @node['ranges']["#{lo}_#{hi}"] ||= { 'i' => lo, 'j' => lo }
+
+    quick_compare(ra, ra['j'], hi)
+      # compare element at j with pivot (element at hi)
+  end
+
+  def quick_partition_receive(sn=from_sub_nid, r=:none)
+
+    rk, ra = @node['ranges'].find { |_, v| v['sub'] == sn }
+    lo, hi = rk.split('_').collect(&:to_i)
+    i, j = ra['i'], ra['j']
+
+    if r == :none
+      ret = payload_ret
+      r = ret == true || (ret.is_a?(Numeric) && ret < 0)
+      if m = @node['memo']
+        m[ra['kab']], m[ra['kba']] = r, ! r
+      end
+    end
+
+    if r
+      quick_swap(i, j)
+      ra['i'] = i = (i + 1)
+    end
+
+    ra['j'] = j = (j + 1)
+
+    return quick_partition_execute(lo, hi) if j < hi # loop on
+
+    # partition loop is over...
+
+    quick_swap(i, hi)
+
+    @node['ranges'].delete(rk)
+
+    # partition at i...
+
+    ms =
+      quick_partition_execute(lo, i - 1) +
+      quick_partition_execute(i + 1, hi)
+
+    if ms.any?
+      ms
+    elsif @node['ranges'].any?
+      []
+    else # quicksort is over
+      col = @node['col']
+      wrap('ret' => (@node['colk'] === 'object' ? Hash[col] : col))
+    end
+  end
+end
+