flor 0.13.0 → 0.14.0

data/lib/flor/core/texecutor.rb

@@ -182,7 +182,10 @@ module Flor
 
       vs = Hash.new { |h, k| k }
       class << vs
-        def has_key?(k); ! Flor::Procedure[k]; end
+        def has_key?(k)
+          prc = Flor::Procedure[k]
+          ( ! prc) || ( ! prc.core?) # ignore non-core procedures
+        end
       end
 
       vs['root'] = determine_root(path)

data/lib/flor/deep.rb

@@ -32,97 +32,89 @@ module Flor
         end }
   end
 
-  def self.deep_get(o, k) # --> success(boolean), value
+  # Returns a symbol in case of failure.
+  #
+  def self.deep_get(o, k)
 
-    return [ true, o ] unless k
+    return o unless k
 
-    val = o
+    split_deep_path(k).inject([ o, [] ]) do |(val, seen), kk|
 
-    split_deep_path(k).each do |kk|
+      seen << kk
 
       case val
       when Array
         i = to_array_index(kk)
-        return [ false, nil ] unless i
-        val = val[i]
+        return seen.join('.').to_sym unless i
+        [ val[i], seen ]
       when Hash
-        val = val[kk]
+        [ val[kk], seen ]
       else
-        return [ false, nil ]
+        return seen[0..-2].join('.').to_sym
       end
-    end
 
-    [ true, val ]
+    end.first
   end
 
-  def self.deep_set(o, k, v) # --> [ success(boolean), value ]
+  def self.deep_set(o, k, v)
 
     ks = split_deep_path(k)
     key = ks.pop
-
-    b, col = deep_get(o, ks)
-
-    return [ false, v ] unless b
+    col = deep_get(o, ks)
 
     case col
+    when Symbol
+      col
     when Array
       i = to_array_index(key)
-      return [ false, v ] unless i
+      return ks.join('.').to_sym unless i
       col[i] = v
     when Hash
       col[key] = v
     else
-      return [ false, v ]
+      ks.join('.').to_sym
     end
-
-    [ true, v ]
   end
 
-  def self.deep_insert(o, k, v) # --> [ success(boolean), value ]
+  def self.deep_insert(o, k, v)
 
     ks = split_deep_path(k)
     key = ks.pop
-
-    b, col = deep_get(o, ks)
-
-    return [ false, nil ] unless b
+    col = deep_get(o, ks)
 
     case col
+    when Symbol
+      col
     when Array
       i = to_array_index(key)
-      return [ false, v ] unless i
+      return ks.join('.').to_sym unless i
       col.insert(i, v)
+      v
     when Hash
       col[key] = v
     else
-      return [ false, v ]
+      ks.join('.').to_sym
     end
-
-    [ true, v ]
   end
 
-  def self.deep_unset(o, k) # --> [ success(boolean), value ]
+  def self.deep_unset(o, k)
 
     ks = split_deep_path(k)
     key = ks.pop
+    col = deep_get(o, ks)
 
-    b, col = deep_get(o, ks)
-
-    return [ false, nil ] unless b
-
-    v =
-      case col
-      when Array
-        i = to_array_index(key)
-        return [ false, nil ] unless i
-        col.delete_at(i)
-      when Hash
-        col.delete(key)
-      else
-        return [ false, nil ]
-      end
-
-    [ true, v ]
+    case col
+    when Symbol
+      col
+    when Array
+      i = to_array_index(key)
+      return ks.join('.').to_sym unless i
+      col.delete_at(i)
+    when Hash
+      col.delete(key)
+    else
+      return ks.join('.').to_sym
+    end
   end
 
   def self.deep_has_key?(o, k)
@@ -137,14 +129,14 @@ module Flor
       case val
       when Array
         i = to_array_index(kk)
-        return false unless i
-        return (i < 0 ? -i < val.length : i < val.length) if ks.empty?
+        break false unless i
+        break (i < 0 ? -i < val.length : i < val.length) if ks.empty?
         val = val[i]
       when Hash
-        return val.has_key?(kk) if ks.empty?
-        val = val[kk]
+        break val.has_key?(kk.to_s) if ks.empty? # nota bene: #to_s
+        val = val[kk.to_s]
       else
-        return false
+        break false
       end
     end
   end

data/lib/flor/dollar.rb

@@ -61,7 +61,7 @@ module Flor
       def rewrite_span(t)
         t.children.collect { |c| rewrite(c) }
       end
-    end
+    end # module Parser
 
     module PipeParser include Raabro
 
@@ -72,7 +72,7 @@ module Flor
       def rewrite_elt(t); t.string; end
       def rewrite_pipe(t); t.string == '|' ? :pipe : :dpipe; end
       def rewrite_elts(t); t.children.collect { |e| rewrite(e) }; end
-    end
+    end # module PipeParser
 
     #def lookup(s)
     #  # ...
@@ -196,7 +196,6 @@ module Flor
 
         result =
           if mode == :lookup
-            #k[0, 1] == "'" ? k[1..-1] : do_lookup(k)
             k[0, 1] == "'" ? k[1..-1] : lookup(k)
           else # :call
             call(k, result)

data/lib/flor/flor.rb

@@ -264,16 +264,26 @@ module Flor
     t[2].is_a?(Integer)
   end
 
+  def self.is_string_tree?(t, s=nil)
+
+    t.is_a?(Array) &&
+    t[2].is_a?(Integer) &&
+    %w[ _sqs _dqs ].include?(t[0]) &&
+    (s ? (t[1] == s) : t[1].is_a?(String))
+  end
+
   def self.is_att_tree?(t)
 
     t.is_a?(Array) &&
+    t[2].is_a?(Integer) &&
     t[0] == '_att' &&
     t[1].is_a?(Array)
   end
 
   def self.is_array_of_trees?(o)
 
-    o.is_a?(Array) && o.all? { |e| Flor.is_tree?(e) }
+    o.is_a?(Array) &&
+    o.all? { |e| Flor.is_tree?(e) }
   end
 
 #  # Array, object or atom tree
@@ -311,14 +321,6 @@ module Flor
     o[1]['task'].is_a?(String)
   end
 
-  def self.is_tree_head_tree?(o)
-
-    o.is_a?(Array) &&
-    Flor.is_tree?(o[0]) &&
-    Flor.is_array_of_trees?(o[1]) &&
-    o[2].is_a?(Integer)
-  end
-
   # Returns [ st, i ], the parent subtree for the final i index of the nid
   # Used when inserting updated subtrees.
   #
@@ -343,5 +345,32 @@ module Flor
     return st if i == nil
     st[1][i]
   end
+
+
+  #
+  # splat
+
+  SPLAT_REGEX = /\A(.*)__(_|\d+)\z/.freeze
+
+  def self.splat(keys, array)
+
+    ks = keys.dup
+    a = array.dup
+    h = {}
+
+    while k = ks.shift
+
+      if m = SPLAT_REGEX.match(k)
+        r, l = m[1, 2]
+        l = (l == '_') ? a.length - ks.length : l.to_i
+        h[r] = a.take(l) if r.length > 0
+        a = a.drop(l)
+      else
+        h[k] = a.shift
+      end
+    end
+
+    h
+  end
 end
 

data/lib/flor/parser.rb

@@ -19,7 +19,10 @@ module Flor
     def pbend(i); str(nil, i, '}'); end
 
     def null(i); str(:null, i, 'null'); end
-    def number(i); rex(:number, i, /-?[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?/); end
+
+    def number(i)
+      rex(:number, i, /[-+]?[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?/)
+    end
 
     def tru(i); str(nil, i, 'true'); end
     def fls(i); str(nil, i, 'false'); end
@@ -99,13 +102,15 @@ module Flor
     #  %w[ or or ], %w[ and and ],
     #  %w[ equ == != <> ], %w[ lgt < > <= >= ], %w[ sum + - ], %w[ prd * / % ],
 
-    def ssprd(i); rex(:sop, i, /[\*\/%]/); end
+    def ssmod(i); str(:sop, i, /%/); end
+    def ssprd(i); rex(:sop, i, /[\*\/]/); end
     def sssum(i); rex(:sop, i, /[+-]/); end
     def sslgt(i); rex(:sop, i, /(<=?|>=?)/); end
     def ssequ(i); rex(:sop, i, /(==?|!=|<>)/); end
     def ssand(i); str(:sop, i, 'and'); end
     def ssor(i); str(:sop, i, 'or'); end
 
+    def smod(i); seq(nil, i, :ssmod, :eol, '?'); end
     def sprd(i); seq(nil, i, :ssprd, :eol, '?'); end
     def ssum(i); seq(nil, i, :sssum, :eol, '?'); end
     def slgt(i); seq(nil, i, :sslgt, :eol, '?'); end
@@ -113,7 +118,8 @@ module Flor
     def sand(i); seq(nil, i, :ssand, :eol, '?'); end
     def sor(i); seq(nil, i, :ssor, :eol, '?'); end
 
-    def eprd(i); jseq(:exp, i, :val_ws, :sprd); end
+    def emod(i); jseq(:exp, i, :val_ws, :smod); end
+    def eprd(i); jseq(:exp, i, :emod, :sprd); end
     def esum(i); jseq(:exp, i, :eprd, :ssum); end
     def elgt(i); jseq(:exp, i, :esum, :slgt); end
     def eequ(i); jseq(:exp, i, :elgt, :sequ); end
@@ -208,37 +214,52 @@ module Flor
       rewrite(t.c0)
     end
 
+    def invert(operation, operand)
+
+      l = operand[2]
+
+      case operation
+      when '+'
+        if operand[0] == '_num' && operand[1].is_a?(Numeric)
+          [ operand[0], - operand[1], l ]
+        else
+          [ '-', [ operand ], l ]
+        end
+      when '*'
+        [ '/', [ [ 'num', 1, l ], operand ], l ]
+      else
+fail "don't know how to invert #{operation.inspect}" # FIXME
+      end
+    end
+
     def rewrite_exp(t)
 
       return rewrite(t.c0) if t.children.size == 1
 
-      cn = [ rewrite(t.c0) ]
-      op = t.lookup(:sop).string
+      cn = t.children.collect { |ct| ct.lookup(nil) }
 
-      tcn = t.children[2..-1].dup
+      operation = cn.find { |ct| ct.name == :sop }.string
 
-      loop do
-        c = tcn.shift; break unless c
-        cn << rewrite(c)
-        o = tcn.shift; break unless o
-        o = o.lookup(:sop).string
-        next if o == op
-        cn = [ [ op, cn, cn.first[2] ] ]
-        op = o
-      end
+      operator = operation
+      operands = []
 
-      if op == '-' && cn.all? { |c| c[0] == '_num' }
-        op = '+'
-        cn[1..-1].each { |c| c[1] = -c[1] }
+      cn.each do |ct|
+        if ct.name == :sop
+          operator = ct.string
+        else
+          o = rewrite(ct)
+          o = invert(operation, o) if operator != operation
+          operands << o
+        end
       end
 
-      [ op, cn, cn.first[2] ]
+      [ operation, operands, operands.first[2] ]
     end
 
     class Nod
 
       attr_accessor :parent, :indent
-      attr_reader :children
+      attr_reader :type, :children
 
       def initialize(tree, outdent)
 
@@ -275,64 +296,65 @@ module Flor
 
       def to_a
 
+        return [ @head, @children, @line ] unless @children.is_a?(Array)
         return @head if @head.is_a?(Array) && @children.empty?
 
         cn = @children.collect(&:to_a)
 
-        # make sure `[ 1 2 3 ] timeout: '2h'`
-        # turns into `_arr timeout: '2h'; 1 | 2 | 3`
+        as, non_atts = cn.partition { |c| c[0] == '_att' }
+        atts, suff = [], nil
 
-        if (
-          @head.is_a?(Array) &&
-          (@head[0] == '_arr' || @head[0] == '_obj') &&
-          #Flor.is_array_of_trees?(@head[1]) &&
-          cn.all? { |c| c[0] == '_att' && c[1].size > 1 }
-        )
-          cn = @head[1] + cn
-          @head = @head[0]
-          att, non_att = cn.partition { |c| c[0] == '_att' }
-          cn = att + non_att
-        end
+        as.each do |c|
 
-        # detect if/unless suffix
+          c1 = c[1]; c10 = c1.size == 1 && c1[0]
+          suff = [] if c10 && c10[1] == [] && %w[ if unless ].include?(c10[0])
 
-        atts =
-          cn.inject([]) { |a, c| a << c[1] if c[0] == '_att'; a }
-        i =
-          atts.index { |c|
-            c.size == 1 && %w[ if unless ].include?(c[0][0]) && c[0][1] == []
-          }
+          (suff || atts) << c
+        end
 
-        return [ @head, cn, @line ] unless i
+        atts, non_atts = ta_rework_arr_or_obj(atts, non_atts)
 
-        # rewrite if/unless suffix
+        core = [ @head, atts + non_atts, @line ]
+        core = core[0] if core[0].is_a?(Array) && core[1].empty?
+        core = ta_rework_core(core) if core[0].is_a?(Array)
 
-        t = [ atts[i][0][0] == 'if' ? 'if' : 'unless', [], @line ]
-        t[1].concat(atts[i + 1..-1].collect(&:first))
+        return core unless suff
 
-        cn0i = cn[0, i]; if Flor.is_tree?(@head) && cn0i == []
-          t[1].push(@head)
-        else
-          t[1].push([ @head, cn0i, @line ])
-        end
+        iou = suff.shift[1][0][0]
 
-        t
+        [ iou, [ suff.first[1].first, core ], @line ]
       end
 
       protected
 
+      def ta_rework_arr_or_obj(atts, non_atts)
+
+        return [ atts, non_atts ] unless (
+          @head.is_a?(Array) &&
+          non_atts.empty? &&
+          %w[ _arr _obj ].include?(@head[0]))
+
+        cn = @head[1] + atts + non_atts
+        @head = @head[0]
+
+        cn.partition { |c| c[0] == '_att' }
+      end
+
+      def ta_rework_core(core)
+
+        l = core[2]
+
+        [ 'sequence', [
+          [ 'set', [
+            [ 'head_', [], l ],
+            core[0]
+          ], l ],
+          [ 'head_', core[1], l ]
+        ], l ]
+      end
+
       def read(tree)
 
-        #if it = tree.lookup(:indent)
-        #  #s = it.string
-        #  #semicount = s.count(';')
-        #  #pipe = s.index('|')
-        #  #
-        #  #@indent =
-        #  #  if semicount == 1 then :east
-        #  #  elsif semicount > 1 || pipe then :south
-        #  #  else s.length; end
-        #end
         @indent = tree.lookup(:indent).string.length
 
         ht = tree.lookup(:head)
@@ -341,8 +363,8 @@ module Flor
         @head = Flor::Lang.rewrite(ht.c0)
         @head = @head[0] if @head[0].is_a?(String) && @head[1] == []
 
-        atts =
-          tree.children[2..-1].inject([]) do |as, ct|
+        atts = tree.children[2..-1]
+          .inject([]) { |as, ct|
 
             kt = ct.children.size == 3 ? ct.children[1].lookup(:key) : nil
             v = Flor::Lang.rewrite(ct.clast)
@@ -350,20 +372,50 @@ module Flor
             if kt
               k = Flor::Lang.rewrite(kt.c0)
               as << [ '_att', [ k, v ], k[2] ]
-            elsif %w[ - + ].include?(@head) && v[0, 2] != [ '_', [] ]
-              if v[0] == '+'
-                as.concat(v[1])
-              else
-                as << v
-              end
             else
               as << [ '_att', [ v ], v[2] ]
             end
 
-            as
-          end
+            as }
 
         @children.concat(atts)
+
+        rework_subtraction if @head == '-'
+        rework_addition if @head == '+' || @head == '-'
+      end
+
+      def rework_subtraction
+
+        return unless @children.size == 1
+
+        c = @children.first
+        return unless c[0] == '_att' && c[1].size == 1
+
+        c = c[1].first
+
+        if c[0] == '_num'
+          @head = '_num'
+          @children = - c[1]
+        elsif %w[ - + ].include?(c[0])
+          @head = c[0]
+          @children = c[1]
+          @children[0] = Flor::Lang.invert('+', @children[0])
+        end
+      end
+
+      def rework_addition
+
+        katts, atts, cn = @children
+          .inject([ [], [], [] ]) { |cn, ct|
+            if ct[0] == '_att'
+              cn[ct[1].size == 2 ? 0 : 1] << ct
+            else
+              cn[2] << ct
+            end
+            cn }
+
+        @children =
+          katts + atts.collect { |ct| ct[1].first } + cn
       end
     end
 
@@ -371,10 +423,9 @@ module Flor
 
       prev = root = Nod.new(nil, nil)
 
-      #t.gather(:node).each do |nt|
       t.gather(:line).each do |lt|
         nt = lt.lookup(:node); next unless nt
-        ot = lt.lookup(:outdent).string
+        ot = lt.children.last.string
         n = Nod.new(nt, ot)
         prev.append(n)
         prev = n