flor 0.14.0 → 0.15.0

data/lib/flor/core/texecutor.rb

@@ -19,14 +19,12 @@ module Flor
         @archive = nil
       end
 
-      def notify(executor, o)
+      def notify(executor, msg)
 
-        return [] if o['consumed']
+        return [] if msg['consumed']
 
-        Flor.log_message(executor, o) \
-          if @conf['log_msg']
-
-        @journal << o
+        @logger.notify(executor, msg)
+        @journal << msg
 
         []
       end
@@ -47,13 +45,38 @@ module Flor
       def initialize(unit)
 
         @unit = unit
+
+        @out = Flor::Logger::Out.prepare(unit)
+      end
+
+      def notify(executor, message)
+
+        return if message['point'] == 'end'
+        return unless @unit.conf['log_msg']
+
+        @out.puts(Flor.message_to_one_line_s(executor, message, out: @out))
       end
 
       def log_err(executor, message, opts={})
 
         return unless @unit.conf['log_err']
 
-        Flor.print_detail_msg(executor, message, flag: true)
+        @out.puts(
+          Flor.msg_to_detail_s(executor, message, opts.merge(flag: true)))
+      end
+
+      def log_src(source, opts, log_opts={})
+
+        return unless @unit.conf['log_src']
+
+        @out.puts(Flor.src_to_s(source, opts, log_opts))
+      end
+
+      def log_tree(tree, nid='0', opts={})
+
+        return unless @unit.conf['log_tree']
+
+        @out.puts(Flor.tree_to_s(tree, nid, opts.merge(out: @out)))
       end
     end
 
@@ -83,11 +106,11 @@ module Flor
       @unit.opts = opts
       @unit.archive ||= {} if opts[:archive]
 
-      Flor.print_src(tree, opts) if conf['log_src']
+      @unit.logger.log_src(tree, opts)
 
       messages = [ Flor.make_launch_msg(@execution['exid'], tree, opts) ]
 
-      Flor.print_tree(messages.first['tree']) if conf['log_tree']
+      @unit.logger.log_tree(messages.first['tree'], '0', opts)
 
       walk(messages, opts)
     end
@@ -111,13 +134,22 @@ module Flor
 
         messages.concat(msgs)
 
-        return messages if message_match?(message, opts[:until_after])
-        return messages if message_match?(messages, opts[:until])
+        return messages \
+          if message_match?(message, opts[:until_after])
+        return messages \
+          if message_match?(messages, opts[:until])
+            #
+            # Walk is suspended if options :until_after or :until
+            # are satisfied.
+            # Returns the remaining messages.
 
         return message \
           if message['point'] == 'terminated'
         return message \
           if message['point'] == 'failed' && message['on_error'] == nil
+            #
+            # Walk exits when execution terminates or fails (without on_error).
+            # Returns the last message
       end
     end
 
@@ -158,68 +190,109 @@ module Flor
 
   class ConfExecutor < TransientExecutor
 
-    def self.interpret(path)
+    class << self
 
-      s =
-        if path.match(/[\r\n]/)
-          path.strip
+      def load(path)
+
+        src =
+          if path.match(/[\r\n]/)
+            path.strip
+          else
+            ls = File.readlines(path)
+            ls.reject! { |l| l.strip[0, 1] == '#' }
+            s = ls.join("\n").strip
+          end
+
+        az = "#{src[0, 1]}#{src[-1, 1]}"
+
+        if az == '{}' || az == '[]'
+          src
+        elsif src.match(/[^\r\n{]+:/) || src == ''
+          "{\n#{src}\n}"
         else
-          ls = File.readlines(path)
-          ls.reject! { |l| l.strip[0, 1] == '#' }
-          s = ls.join("\n").strip
+          "[\n#{src}\n]"
+        end
+      end
+
+      def interpret(path, source, context)
+
+        path ||= '.'
+
+        fs = context['payload'] || {}
+
+        vs = Hash.new { |h, k| k }
+          #
+        vs.merge!(context['vars'] || {})
+        vs['root'] = determine_root(path)
+        vs['ruby_version'] = RUBY_VERSION
+        vs['ruby_platform'] = RUBY_PLATFORM
+          #
+        class << vs
+          def has_key?(k)
+            prc = Flor::Procedure[k]
+            ( ! prc) || ( ! prc.core?) # ignore non-core procedures
+          end
         end
 
-      a, b = s[0, 1], s[-1, 1]
+        c = ! (ENV['FLOR_DEBUG'] || '').match(/conf/)
+        e = self.new('conf' => c)
+        r = e.launch(source, payload: fs, vars: vs)
 
-      s =
-        if (a == '{' && b == '}') || (a == '[' && b == ']')
-          s
-        elsif s.match(/[^\r\n{]+:/) || s == ''
-          "{\n#{s}\n}"
-        else
-          "[\n#{s}\n]"
+        unless r['point'] == 'terminated'
+          ae = ArgumentError.new(
+            "error while reading conf: #{r['error']['msg']}")
+          ae.set_backtrace(r['error']['trc'])
+          fail ae
         end
 
-      vs = Hash.new { |h, k| k }
-      class << vs
-        def has_key?(k)
-          prc = Flor::Procedure[k]
-          ( ! prc) || ( ! prc.core?) # ignore non-core procedures
+        o = Flor.dup(r['payload']['ret'])
+
+        if o.is_a?(Hash)
+          o['_path'] = path
+          o['root'] ||= Flor.relativize_path(vs['root'])
+        elsif o.is_a?(Array)
+          o.each { |e| e['_path'] = path }
         end
+
+        o
       end
 
-      vs['root'] = determine_root(path)
+      def interpret_path(path, context=nil)
 
-      vs['ruby_version'] = RUBY_VERSION
-      vs['ruby_platform'] = RUBY_PLATFORM
+        interpret(path, load(path), context || {})
+      end
 
-      c = (ENV['FLOR_DEBUG'] || '').match(/conf/) ? false : true
-      r = (self.new('conf' => c)).launch(s, vars: vs)
+      def interpret_source(source, context=nil)
 
-      unless r['point'] == 'terminated'
-        ae = ArgumentError.new("error while reading conf: #{r['error']['msg']}")
-        ae.set_backtrace(r['error']['trc'])
-        fail ae
+        interpret(nil, source, context || {})
       end
 
-      o = Flor.dup(r['payload']['ret'])
+      def interpret_path_or_source(s, context=nil)
 
-      if o.is_a?(Hash)
-        o['_path'] = path unless path.match(/[\r\n]/)
-        o['root'] ||= Flor.relativize_path(vs['root'])
-      elsif o.is_a?(Array)
-        o.each { |e| e['_path'] = path } unless path.match(/[\r\n]/)
+        if s.index("\n")
+          interpret_source(load(s), context)
+        else
+          interpret_path(s, context)
+        end
       end
 
-      o
-    end
+      # Used by "flosh" the flor shell
+      #
+      def interpret_line(s)
 
-    def self.determine_root(path)
+        r = interpret_source(s)
+        r.delete('root') if r.is_a?(Hash)
 
-      dir = File.absolute_path(File.dirname(path))
-      ps = dir.split(File::SEPARATOR)
+        r
+      end
+
+      def determine_root(path)
 
-      ps.last == 'etc' ? File.absolute_path(File.join(dir, '..')) : dir
+        dir = File.absolute_path(File.dirname(path))
+        ps = dir.split(File::SEPARATOR)
+
+        ps.last == 'etc' ? File.absolute_path(File.join(dir, '..')) : dir
+      end
     end
   end
 end

data/lib/flor/djan.rb

@@ -8,193 +8,222 @@ module Flor
 
   def self.to_d(x, opts={})
 
-    opts[:s] = StringIO.new
+    out = StringIO.new
     opts[:c] = Flor.colours(opts)
 
-    if opts[:width] == true
-      opts[:width] = IO.console.winsize[1]
+    if [ :console, true ].include?(opts[:width])
+      opts[:width] = IO.console.winsize[1] rescue 80
+    #elsif opts[:width].is_a?(Integer)
+      # let it go
     elsif mw = (opts[:mw] || opts[:maxwidth] || opts[:max_width])
-      opts[:width] = [ IO.console.winsize[1], mw ].min
+      opts[:width] = [ (IO.console.winsize[1] rescue 80), mw ].min
     end
+    opts[:indent] ||= 0 if opts[:width]
 
-    Djan.to_d(x, opts)
+    Djan.to_d(x, out, opts)
 
-    opts[:s].string
+    out.string
   end
 
   module Djan
     extend self
 
-    def to_d(x, opts)
+    def to_d(x, out, opts)
 
       case x
-      when nil then nil_to_d(x, opts)
-      when String then string_to_d(x, opts)
-      when Hash then object_to_d(x, opts)
-      when Array then array_to_d(x, opts)
-      when TrueClass then boolean_to_d(x.to_s, opts)
-      when FalseClass then boolean_to_d(x.to_s, opts)
-      else num_to_d(x.to_s, opts)
+      when nil then nil_to_d(x, out, opts)
+      when String then string_to_d(x, out, opts)
+      when Hash then object_to_d(x, out, opts)
+      when Array then array_to_d(x, out, opts)
+      when TrueClass then boolean_to_d(x.to_s, out, opts)
+      when FalseClass then boolean_to_d(x.to_s, out, opts)
+      else num_to_d(x.to_s, out, opts)
       end
     end
 
     def len(x, opts)
 
-      opts = opts.merge(
-        s: StringIO.new, c: Flor.no_colours, indent: nil, width: nil)
+      opts = opts.merge(c: Flor.no_colours, indent: nil, width: nil)
+      o = StringIO.new
 
-      to_d(x, opts)
+      to_d(x, o, opts)
 
-      opts[:s].string.length
+      o.string.length
     end
 
-    def newline(opts)
+    def adjust(x, opts)
+
+      i = opts[:indent]
+      w = opts[:width]
+
+      return opts unless i && w && (i + len(x, opts) < w)
+      opts.merge(indent: nil)
+    end
+
+    def newline(out, opts)
 
-      opts[:s] << "\n"
+      out << "\n"
     end
 
-    def space(opts, force=false)
+    def space(out, opts, force=false)
 
-      opts[:s] << ' ' if force || ! opts[:compact]
+      out << ' ' if force || ! opts[:compact]
     end
 
-    def newline_or_space(opts)
+    def newline_or_space(out, opts)
 
-      if opts[:indent]
-        newline(opts)
+      if kt = opts[:keytab]
+        out << ' ' * kt
+      elsif opts[:indent]
+        newline(out, opts)
       elsif ! opts[:compact]
-        space(opts)
+        space(out, opts)
       end
     end
 
-    def indent_space(opts)
+    def indent_space(out, opts)
 
       return if opts.delete(:first)
       i = opts[:indent]
-      opts[:s] << '  ' * i if i
+      out << ' ' * i if i
     end
 
     def indent(opts, os={})
 
-      if i = opts[:indent]
-        opts.merge(indent: i + (os[:inc] || 1), first: os[:first])
+      if kt = os[:keytab]
+        opts.merge(indent: nil, keytab: kt)
+      elsif i = opts[:indent]
+        opts.merge(indent: i + (os[:inc] || 1) * 2, first: os[:first])
       else
         opts
       end
     end
 
-    def adjust(x, opts)
-
-      i = opts[:indent]
-      w = opts[:width]
-
-      return opts unless i && w && i + len(x, opts) < w
-      opts.merge(indent: nil)
-    end
-
-    def object_to_d(x, opts)
+    def object_to_d(x, out, opts)
 
       inner = opts.delete(:inner)
 
-      indent_space(opts)
+      indent_space(out, opts)
 
-      return c_inf('{}', opts) if x.empty?
+      return c_inf('{}', out, opts) if x.empty?
 
       opts = adjust(x, opts)
 
       unless inner
-        c_inf('{', opts); space(opts)
+        c_inf('{', out, opts); space(out, opts)
       end
 
+      key_max_len =
+        if opts[:compact]
+          nil
+        else
+          i = opts[:indent]
+          w = opts[:width]
+            #
+          kml, vml =
+            x.inject([ 0, 0 ]) { |(kl, vl), (k, v)|
+              [ [ kl, len(k, opts) ].max, [ vl, len(v, opts) ].max ] }
+          kml += 1
+            #
+          if i && w && i + kml + 1 + vml < w
+            kml
+          else
+            nil
+          end
+        end
+
       x.each_with_index do |(k, v), i|
-        string_to_d(k, indent(opts, first: i == 0))
-        c_inf(':', opts)
-        newline_or_space(opts)
-        to_d(v, indent(opts, inc: 2))
+
+        kl = string_to_d(k, out, indent(opts, first: i == 0))
+        c_inf(':', out, opts)
+
+        kt = key_max_len ? key_max_len - kl : nil
+        newline_or_space(out, opts.merge(keytab: kt))
+
+        to_d(v, out, indent(opts, inc: 2, keytab: kt))
+
         if i < x.size - 1
-          c_inf(',', opts)
-          newline_or_space(opts)
+          c_inf(',', out, opts)
+          newline_or_space(out, opts)
         end
       end
 
       unless inner
-        space(opts); c_inf('}', opts)
+        space(out, opts); c_inf('}', out, opts)
       end
     end
 
-    def array_to_d(x, opts)
+    def array_to_d(x, out, opts)
 
       inner = opts.delete(:inner)
 
-      indent_space(opts)
+      indent_space(out, opts)
 
-      return c_inf('[]', opts) if x.empty?
+      return c_inf('[]', out, opts) if x.empty?
 
       opts = adjust(x, opts)
 
       unless inner
-        c_inf('[', opts); space(opts)
+        c_inf('[', out, opts); space(out, opts)
       end
 
       x.each_with_index do |e, i|
-        to_d(e, indent(opts, first: i == 0))
+        to_d(e, out, indent(opts, first: i == 0))
         if i < x.size - 1
-          c_inf(',', opts)
-          newline_or_space(opts)
+          c_inf(',', out, opts)
+          newline_or_space(out, opts)
         end
       end
 
       unless inner
-        space(opts); c_inf(']', opts)
+        space(out, opts); c_inf(']', out, opts)
       end
     end
 
-    def string_to_d(x, opts)
+    def string_to_d(x, out, opts)
 
       x = x.to_s
 
-      indent_space(opts)
+      indent_space(out, opts)
 
       if (
+        opts[:json] ||
         x.match(/\A[^: \b\f\n\r\t"',()\[\]{}#\\+%\/><^!=-]+\z/) == nil ||
         x.to_i.to_s == x ||
         x.to_f.to_s == x
-      )
-        c_inf('"', opts)
-        c_str(x.inspect[1..-2], opts)
-        c_inf('"', opts)
+      ) then
+        c_inf('"', out, opts)
+        c_str(x.inspect[1..-2], out, opts)
+        c_inf('"', out, opts)
+        x.inspect[1..-2].length + 2
       else
-        c_str(x, opts)
+        c_str(x, out, opts)
+        x.length
       end
     end
 
-    def boolean_to_d(x, opts)
+    def boolean_to_d(x, out, opts)
 
-      indent_space(opts)
-      if x
-        c_tru(x, opts)
-      else
-        c_fal(x, opts)
-      end
+      indent_space(out, opts); x ? c_tru(x, out, opts) : c_fal(x, out, opts)
     end
 
-    def num_to_d(x, opts)
+    def num_to_d(x, out, opts)
 
-      indent_space(opts); c_num(x, opts)
+      indent_space(out, opts); c_num(x, out, opts)
     end
 
-    def nil_to_d(x, opts)
+    def nil_to_d(x, out, opts)
 
-      indent_space(opts); c_nil('null', opts)
+      indent_space(out, opts); c_nil('null', out, opts)
     end
 
-    def c_inf(s, opts); opts[:s] << opts[:c].dark_gray(s); end
+    def c_inf(s, out, opts); out << opts[:c].dark_gray(s); end
 
-    def c_nil(s, opts); opts[:s] << opts[:c].dark_gray(s); end
-    def c_tru(s, opts); opts[:s] << opts[:c].green(s); end
-    def c_fal(s, opts); opts[:s] << opts[:c].red(s); end
-    def c_str(s, opts); opts[:s] << opts[:c].brown(s); end
-    def c_num(s, opts); opts[:s] << opts[:c].light_blue(s); end
+    def c_nil(s, out, opts); out << opts[:c].dark_gray(s); end
+    def c_tru(s, out, opts); out << opts[:c].green(s); end
+    def c_fal(s, out, opts); out << opts[:c].red(s); end
+    def c_str(s, out, opts); out << opts[:c].brown(s); end
+    def c_num(s, out, opts); out << opts[:c].light_blue(s); end
   end
 end