flor 0.13.0 → 0.14.0

data/lib/flor/pcore/_arr.rb

@@ -1,5 +1,20 @@
 
 class Flor::Pro::Arr < Flor::Procedure
+  #
+  # "_arr" is the procedure behind arrays.
+  #
+  # Writing
+  # ```
+  # [ 1 2 3 ]
+  # ```
+  # is in fact read as
+  # ```
+  # _arr
+  #   1
+  #   2
+  #   3
+  # ```
+  # by flor.
 
   name '_arr'
 

data/lib/flor/pcore/_atom.rb

@@ -6,11 +6,12 @@ class Flor::Pro::Atom < Flor::Procedure
   def execute
 
     payload['ret'] =
-      case tree[0]
-        when '_dqs' then expand(tree[1])
-        when '_rxs' then [ tree[0], expand(tree[1]), *tree[2..-1] ]
-        when '_func' then tree
-        else tree[1]
+      case @node['heat0']
+      when '_nul' then nil
+      when '_dqs' then expand(tree[1])
+      when '_rxs' then [ tree[0], expand(tree[1]), *tree[2..-1] ]
+      when '_func' then tree
+      else tree[1]
       end
 
     wrap_reply

data/lib/flor/pcore/_att.rb

@@ -121,12 +121,17 @@ class Flor::Pro::Att < Flor::Procedure
     wrap_reply
   end
 
-  def receive_tag
+  def parent_is_trap?
+
+    pt = parent_node_tree; return false unless pt
+    pt0 = pt[0]; return false unless pt0.is_a?(String)
+    pro = Flor::Procedure[pt0]; return false unless pro
+    pro.names.include?('trap')
+  end
 
-    pt = parent_node_tree
+  def receive_tag
 
-    return receive_att('tags') \
-      if pt && pt[0].is_a?(String) && Flor::Procedure[pt[0]].names[0] == 'trap'
+    return receive_att('tags') if parent_is_trap?
 
     ret = payload['ret']
     ret = unref(ret, :att)

data/lib/flor/pcore/_obj.rb

@@ -1,5 +1,21 @@
 
 class Flor::Pro::Obj < Flor::Procedure
+  #
+  # "_obj" is the procedure behind objects (maps).
+  #
+  # Writing
+  # ```
+  # { a: 1, b: 2 }
+  # ```
+  # is in fact read as
+  # ```
+  # _obj
+  #   'a'
+  #   1
+  #   'b'
+  #   2
+  # ```
+  # by flor.
 
   name '_obj'
 
@@ -9,53 +25,31 @@ class Flor::Pro::Obj < Flor::Procedure
     @node['atts'] = []
   end
 
-  def receive_last_att
+  def execute_child(index=0, sub=nil, h=nil)
 
-    return super unless att('quote') == 'keys'
-
-    t0 = tree
-    t1 = Flor.dup(t0)
-
-    (@ncid..t1[1].length - 1).step(2) do |i|
-
-      c = t1[1][i]
-
-      t1[1][i] = [ '_sqs', c[0], *c[2..-1] ] if c[0].is_a?(String) && c[1] == []
-    end
-
-    @node['tree'] = t1 if t1 != t0
-
-    super
-  end
+    return wrap_reply('ret' => {}) if children == 0
 
-  def receive_first
+    return super if @node['rets'].size.odd?
 
-    return wrap_reply('ret' => {}) if children == 0
+    ct = children[index]
+    q = (att('quote') == 'keys')
 
-    cn = children
-      .inject([]) { |a, e| a << (a.size.even? ? stringify(e) : e); a }
+    return super unless ct[1] == [] && (deref(ct[0]) == nil || q)
 
-    @node['tree'] = [ tree[0], cn, tree[2] ] if children != cn
+    t = tree
+    t[1][index] = [ '_sqs', ct[0], *ct[2..-1] ]
+    @node['tree'] = t
 
     super
   end
 
   def receive_last
 
-    payload['ret'] =
-      @node['rets']
-        .each_slice(2)
-        .inject({}) { |h, (k, v)| h[k.to_s] = v; h }
+    payload['ret'] = @node['rets']
+      .each_slice(2)
+      .inject({}) { |h, (k, v)| h[k.to_s] = v; h }
 
     wrap_reply
   end
-
-  protected
-
-  def stringify(t)
-
-    return t unless t[1] == [] && t[0].is_a?(String)
-    [ '_sqs', deref(t[0]) || t[0], t[2] ]
-  end
 end
 

data/lib/flor/pcore/_pat_.rb

@@ -0,0 +1,77 @@
+
+class Flor::Pro::PatContainer < Flor::Procedure
+
+  def pre_execute
+
+    @node['binding'] = {}
+  end
+
+  def execute
+
+    if tree[1] == 0 || tree[1] == []
+      payload['_pat_binding'] = val == [] ? {} : nil
+      payload.delete('_pat_val')
+      return wrap_reply
+    end
+
+    super
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    ct = child_type(index)
+
+    if ct == :pattern || ct.is_a?(Array)
+      @node['_sub_pat_val'] = sv = sub_val(index)
+      payload['_pat_val'] = sv[1]
+    else
+      @node.delete('_sub_pat_val')
+      payload.delete('_pat_val')
+    end
+
+    return wrap_reply(
+      'nid' => nid, 'from' => Flor.child_nid(nid, index, sub)
+    ) if ct.is_a?(String) || ct.is_a?(Array)
+
+    super(index, sub, h)
+  end
+
+  protected
+
+  def val
+
+    node_payload['_pat_val'] || node_payload_ret
+  end
+
+  # A default implementation
+  #
+  def sub_val(child_index)
+
+    [ 1, val ]
+  end
+
+  def child_type(cid_or_tree)
+
+    ct = cid_or_tree.is_a?(Array) ? cid_or_tree : tree[1][cid_or_tree]
+    ct0 = ct[0]
+
+    return :att if ct0 == '_att'
+    return :pattern if /\A_pat_(arr|obj|or|guard)\z/ === ct0
+    return '_' if ct0 == '_'
+    return ct0 if /\A[a-z][a-z0-9]*\z/ === ct0 && ct[1] == []
+
+    m = ct0.match(Flor::SPLAT_REGEX)
+    return [ m[1], m[2] == '_' ? nil : m[2].to_i ] if m
+
+    nil # nothing special
+  end
+
+  def wrap_no_match_reply
+
+    payload['_pat_binding'] = nil
+    payload.delete('_pat_val')
+
+    wrap_reply
+  end
+end
+

data/lib/flor/pcore/_pat_arr.rb

@@ -0,0 +1,131 @@
+
+require 'flor/pcore/_pat_'
+
+
+class Flor::Pro::PatArr < Flor::Pro::PatContainer
+
+  name '_pat_arr'
+
+  def pre_execute
+
+    @node['index'] = 0
+
+    super
+  end
+
+  def receive_first
+
+    return wrap_no_match_reply unless val.is_a?(Array)
+
+    super
+  end
+
+  def receive_non_att
+
+    ct = child_type(@fcid)
+#p [ :rna, :fcid, @fcid, :index, @node['index'], :ct, ct ]
+
+    offset = 1
+
+    if ct == :pattern
+
+      if b = payload.delete('_pat_binding')
+        offset, _ = @node['_sub_pat_val']
+        @node['binding'].merge!(b)
+      else
+        return wrap_no_match_reply
+      end
+
+    elsif ct.is_a?(String)
+
+      @node['binding'][ct] = val[@node['index']] if ct != '_'
+
+    elsif ct.is_a?(Array)
+
+      offset, v = @node['_sub_pat_val']
+      @node['binding'][ct[0]] = v if ct[0].length > 0
+
+    elsif val[@node['index']] != payload['ret']
+
+      return wrap_no_match_reply
+    end
+
+    @node['index'] = @node['index'] + offset
+
+    return wrap_no_match_reply if @node['index'] > val.size
+
+    super
+  end
+
+  def receive_last
+
+    return wrap_no_match_reply if @node['index'] < val.size
+
+    payload['_pat_binding'] = @node['binding']
+    payload.delete('_pat_val')
+
+    super
+  end
+
+  protected
+
+  def sub_val(child_index)
+
+    ct = child_type(child_index)
+
+    q =
+      if ct.is_a?(Array)
+        ct
+      elsif ct == :pattern
+        count_pat(child_index, false)
+      else
+        nil
+      end
+
+    if q && q.is_a?(Array)
+      count = val[@node['index']..-1].size - remaining_index_count
+      count = q[1] if q[1] && count > q[1]
+      sv = val[@node['index'], count]
+      [ sv.size, sv ]
+    else
+      [ 1, val[@node['index']] ]
+    end
+  end
+
+  def remaining_index_count(ncid=@ncid)
+
+    (ncid + 1..children.size - 1).to_a
+      .inject(0) { |count, cid|
+        count +
+        case (ct = child_type(cid))
+        when :att then 0
+        when :pattern then count_pat(cid)
+        when Array then count_arr(ct)
+        else 1
+        end }
+  end
+
+  def count_arr(a)
+
+    a[1] || 1 # really?
+  end
+
+  def count_pat(cid, squash=true)
+
+    ct = children[cid]
+    return 1 if ct[0] != '_pat_guard'
+
+    ct = ct[1][0]
+    return 1 if ct[1] != []
+
+    m = ct[0].match(Flor::SPLAT_REGEX)
+    return 1 if m == nil
+
+    if squash
+      m[2] == '_' ? 1 : m[2].to_i
+    else
+      [ m[1], m[2] == '_' ? nil : m[2].to_i ]
+    end
+  end
+end
+

data/lib/flor/pcore/_pat_guard.rb

@@ -0,0 +1,70 @@
+
+require 'flor/pcore/_pat_'
+
+
+class Flor::Pro::PatGuard < Flor::Pro::PatContainer
+
+  name '_pat_guard'
+
+  # ```
+  # _pat_guard name
+  # _pat_guard name pattern
+  # _pat_guard name conditional
+  # _pat_guard name pattern conditional
+  # _pat_guard name conditional pattern
+  # ```
+
+  def pre_execute
+
+    unatt_unkeyed_children
+    stringify_first_child
+
+    @node['binding'] = {}
+  end
+
+  def receive_non_att
+
+    ct = child_type(@fcid)
+
+    if ct == nil && @node['key'] == nil && payload['ret'].is_a?(String)
+
+      k = payload['ret']
+      m = k.match(Flor::SPLAT_REGEX)
+      k = m ? k[0] : k
+
+      @node['key'] = k
+      @node['binding'].merge!(k => val) if k != '_'
+
+    elsif ct == nil && payload['ret'] == false
+
+      return wrap_no_match_reply
+
+    elsif ct == :pattern
+
+      b = payload['_pat_binding']
+      return wrap_no_match_reply unless b
+
+      @node['binding'].merge!(b)
+    end
+
+    super
+  end
+
+  def receive_last
+
+    payload['_pat_binding'] = @node['binding']
+
+    super
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    if (key = @node['key']) && child_type(index) == nil
+      h ||= {}
+      (h['vars'] ||= {}).merge!(@node['binding'])
+    end
+
+    super(index, sub, h)
+  end
+end
+

data/lib/flor/pcore/_pat_obj.rb

@@ -0,0 +1,143 @@
+
+require 'flor/pcore/_pat_'
+
+
+class Flor::Pro::PatObj < Flor::Pro::PatContainer
+
+  name '_pat_obj'
+
+  def pre_execute
+
+    @node['atts'] = []
+
+    t = tree
+
+    if (
+      i = t[1].index { |ct|
+         ct[0] == '_att' &&
+         ct[1].size == 1 &&
+         ct[1][0][0, 2] == [ 'only', [] ] }
+    ) then
+      t[1][i] =
+        [ '_att', [
+          [ '_sqs', 'only', -1 ],
+          [ '_boo', true, -1 ],
+        ], *t[1][i][2..-1] ]
+      @node['tree'] = [ t[0], t[1], *t[1][2..-1] ]
+    end
+
+    super
+  end
+
+  def receive_first
+
+    return wrap_no_match_reply unless val.is_a?(Hash)
+
+    super
+  end
+
+  def receive_last_att
+
+    rewrite_keys
+
+    @node['key'] = nil
+    @node['keys'] = [] if att('only')
+
+    super
+  end
+
+  def receive_non_att
+
+    key = @node['key']
+    ret = payload['ret']
+
+    unless key
+      ret = ret.to_s
+      return wrap_no_match_reply unless Flor.deep_has_key?(val, ret)
+      @node['key'] = ret
+      @node['keys'] << ret if @node['keys']
+      return super
+    end
+
+    ct = child_type(@fcid)
+
+    if ct == :pattern
+
+      if b = payload.delete('_pat_binding')
+        @node['binding'].merge!(b)
+      else
+        return wrap_no_match_reply
+      end
+
+    elsif ct.is_a?(String)
+
+      @node['binding'][ct] = val[@node['key']] if ct != '_'
+
+    elsif ct.is_a?(Array)
+
+      @node['binding'][ct[0]] = val[@node['key']] if ct[0].length > 0
+
+    elsif Flor.deep_get(val, key) != ret
+
+      return wrap_no_match_reply
+    end
+
+    @node['key'] = nil
+
+    super
+  end
+
+  def receive_last
+
+    ks = @node['keys']
+    return wrap_no_match_reply if ks && val.keys.sort != ks.sort
+
+    payload['_pat_binding'] = @node['binding']
+    payload.delete('_pat_val')
+
+    super
+  end
+
+  protected
+
+  def rewrite_keys
+
+    q = (att('quote') == 'keys')
+
+    key = true
+
+    cn = children
+      .collect { |ct|
+        next ct if ct[0] == '_att'
+        key = ! key
+        next ct if key
+        q ? quote_key(ct) : lookup_and_quote_key(ct) }
+
+    t = tree
+
+    @node['tree'] = [ t[0], cn, *t[2..-1] ] if cn != t[1]
+  end
+
+  def quote_key(t)
+
+    if t[1] == []
+      [ '_sqs', t[0], *t[2..-1] ]
+    elsif t[1].is_a?(Array)
+      t
+    else
+      [ '_sqs', t[1].to_s, *t[2..-1] ]
+    end
+  end
+
+  def lookup_and_quote_key(t)
+
+    return t unless t[1] == []
+    [ '_sqs', lookup(t[0], true) || t[0], t[2] ]
+  end
+
+  def sub_val(child_index)
+
+    [ 1, val[@node['key']] ]
+  end
+end
+