youplot 0.4.6 → 0.5.0

data/lib/youplot/command.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'tempfile'
+require 'stringio'
+
 require_relative 'dsv'
 require_relative 'parser'
 
-# FIXME
 require_relative 'backends/unicode_plot'
 
 module YouPlot
@@ -42,23 +44,7 @@ module YouPlot
 
       # progressive mode
       if options[:progressive]
-        stop = false
-        Signal.trap(:INT) { stop = true }
-
-        # make cursor invisible
-        options[:output].print "\e[?25l"
-
-        # mainloop
-        while (input = Kernel.gets)
-          n = main_progressive(input)
-          break if stop
-
-          options[:output].print "\e[#{n}F"
-        end
-
-        options[:output].print "\e[0J"
-        # make cursor visible
-        options[:output].print "\e[?25h"
+        run_progressive
 
       # normal mode
       else
@@ -77,6 +63,47 @@ module YouPlot
 
     private
 
+    def run_progressive
+      out = progressive_output
+      stop = false
+      last_rendered_lines = 0
+      Signal.trap(:INT) { stop = true }
+
+      # make cursor invisible
+      out.print "\e[?25l"
+
+      # mainloop
+      begin
+        while (input = Kernel.gets)
+          n = main_progressive(input)
+          # Track the latest plot height so cleanup can move below the plot.
+          last_rendered_lines = n if n && n > 0
+          break if stop
+
+          out.print "\e[#{n}F" if n && n > 0
+        end
+      ensure
+        sanitize_progressive_output(out, last_rendered_lines)
+      end
+    end
+
+    def progressive_output
+      out = options[:output]
+      raise 'In progressive mode, output to a file is not possible.' if out.is_a?(String)
+      return out if out.respond_to?(:print) && out.respond_to?(:flush)
+
+      raise 'In progressive mode, output to a file is not possible.'
+    end
+
+    def sanitize_progressive_output(out = progressive_output, last_rendered_lines = 0)
+      # Move below the last rendered plot (CSI n E).
+      out.print "\e[#{last_rendered_lines}E" if last_rendered_lines > 0
+      # Clear from cursor to end of screen (CSI 0 J).
+      out.print "\e[0J"
+      # Show cursor again (CSI ?25 h).
+      out.print "\e[?25h"
+    end
+
     def main(input)
       # Outputs input data to a file or stdout.
       output_data(input)
@@ -110,31 +137,98 @@ module YouPlot
     def main_progressive(input)
       output_data(input)
 
-      # FIXME
-      # Worked around the problem of not being able to draw
-      # plots when there is only one header line.
-      if @raw_data.nil?
-        @raw_data = String.new
-        if options[:headers]
-          @raw_data << input
-          return
-        end
-      end
-      @raw_data << input
+      row = parse_progressive_row(input)
+      return 0 if row.nil?
 
-      # FIXME
-      @data = parse_dsv(@raw_data)
+      @data = progressive_update_data(row)
+      return 0 if @data.nil?
 
       plot = create_plot
       output_plot_progressive(plot)
     end
 
+    def parse_progressive_row(input)
+      line = normalize_input_encoding!(input)
+
+      begin
+        row = CSV.parse_line(line, col_sep: options[:delimiter])
+      rescue CSV::MalformedCSVError => e
+        warn 'Failed to parse the text. '
+        warn 'Please try to set the correct character encoding with --encoding option.'
+        warn e.backtrace.grep(/youplot/).first
+        exit 1
+      rescue ArgumentError => e
+        warn 'Failed to parse the text. '
+        warn e.backtrace.grep(/youplot/).first
+        exit 1
+      end
+
+      return nil if row.nil? || row.empty? || row.all?(&:nil?)
+
+      row
+    end
+
+    def progressive_update_data(row)
+      init_progressive_state
+
+      return nil if consume_progressive_header?(row)
+
+      append_progressive_row(row)
+      progressive_data
+    end
+
+    def init_progressive_state
+      return if @progressive_initialized
+
+      @progressive_initialized = true
+      @progressive_headers = options[:headers] ? [] : nil
+      @progressive_series = []
+      @progressive_header_consumed = false
+      @progressive_row_count = 0
+    end
+
+    def consume_progressive_header?(row)
+      return false unless options[:headers]
+      return false if options[:transpose]
+      return false if @progressive_header_consumed
+
+      @progressive_headers = row
+      @progressive_header_consumed = true
+      true
+    end
+
+    def append_progressive_row(row)
+      if options[:headers] && options[:transpose]
+        @progressive_headers << row[0]
+        @progressive_series << row[1..-1]
+      elsif options[:transpose]
+        @progressive_series << row
+      else
+        append_progressive_columns(row)
+      end
+    end
+
+    def progressive_data
+      DSV.build_data(@progressive_headers, @progressive_series)
+    end
+
+    def append_progressive_columns(row)
+      if row.size > @progressive_series.size
+        (@progressive_series.size...row.size).each do |i|
+          @progressive_series[i] = Array.new(@progressive_row_count, nil)
+        end
+      end
+
+      0.upto(@progressive_series.size - 1) do |i|
+        @progressive_series[i] << row[i]
+      end
+
+      @progressive_row_count += 1
+    end
+
     def parse_dsv(input)
       # If encoding is specified, convert to UTF-8
-      if options[:encoding]
-        input.force_encoding(options[:encoding])
-             .encode!('utf-8')
-      end
+      normalize_input_encoding!(input)
 
       begin
         data = DSV.parse(input, options[:delimiter], options[:headers], options[:transpose])
@@ -152,6 +246,13 @@ module YouPlot
       data
     end
 
+    def normalize_input_encoding!(input)
+      return input unless options[:encoding]
+
+      input.force_encoding(options[:encoding])
+           .encode!('utf-8')
+    end
+
     def create_plot
       case command
       when :bar, :barplot
@@ -179,50 +280,67 @@ module YouPlot
 
     def output_data(input)
       # Pass the input to subsequent pipelines
-      case options[:pass]
-      when IO, StringIO
-        options[:pass].print(input)
-      else
-        if options[:pass]
-          File.open(options[:pass], 'w') do |f|
-            f.print(input)
-          end
+      out = options[:pass]
+      # Handle Tempfile first to keep tests and behavior consistent.
+      # Ruby 2.7 Tempfile is Delegator-based and does not match IO/File checks.
+      # Then handle path strings and IO-like objects.
+      case out
+      when Tempfile
+        # Keep file descriptor state consistent with the Tempfile object.
+        out.truncate(0)   # clear existing content
+        out.rewind        # move pointer to the beginning
+        out.print(input)  # write new content
+        out.flush         # flush buffered writes before immediate read
+        out.rewind        # move pointer back to the beginning for out.read
+      when String
+        File.open(out, 'w') do |f|
+          f.print(input)
         end
+      else
+        out.print(input) if out.respond_to?(:print)
       end
     end
 
     def output_plot(plot)
-      case options[:output]
-      when IO, StringIO
-        plot.render(options[:output])
-      when String, Tempfile
-        File.open(options[:output], 'w') do |f|
+      out = options[:output]
+      # Handle Tempfile first to keep tests and behavior consistent.
+      # Ruby 2.7 Tempfile is Delegator-based and does not match IO/File checks.
+      # Then handle path strings and IO-like objects.
+      case out
+      when Tempfile
+        # Keep file descriptor state consistent with the Tempfile object.
+        out.truncate(0)   # clear existing content
+        out.rewind        # move pointer to the beginning
+        plot.render(out)  # write new content
+        out.flush         # flush buffered writes before immediate read
+        out.rewind        # move pointer back to the beginning for out.read
+      when String
+        File.open(out, 'w') do |f|
           plot.render(f)
         end
+      else
+        plot.render(out) if out.respond_to?(:write)
       end
     end
 
     def output_plot_progressive(plot)
-      case options[:output]
-      when IO, StringIO
-        # RefactorMe
-        out = StringIO.new(String.new)
-        def out.tty?
-          true
-        end
-        plot.render(out)
-        lines = out.string.lines
-        lines.each do |line|
-          options[:output].print line.chomp
-          options[:output].print "\e[0K"
-          options[:output].puts
-        end
-        options[:output].print "\e[0J"
-        options[:output].flush
-        out.string.lines.size
-      else
-        raise 'In progressive mode, output to a file is not possible.'
+      target = progressive_output
+
+      # RefactorMe
+      out = StringIO.new(String.new)
+      def out.tty?
+        true
+      end
+      plot.render(out)
+      lines = out.string.lines
+      lines.each do |line|
+        target.print line.chomp
+        target.print "\e[0K"
+        target.puts
       end
+      target.print "\e[0J"
+      target.flush
+      lines.size
     end
   end
 end

data/lib/youplot/dsv.rb

@@ -23,9 +23,24 @@ module YouPlot
       # get series
       series = get_series(arr, headers, transpose)
 
+      build_data(headers, series)
+    end
+
+    # Transpose different sized ruby arrays
+    # https://stackoverflow.com/q/26016632
+    def transpose2(arr)
+      Array.new(arr.map(&:length).max) { |i| arr.map { |e| e[i] } }
+    end
+
+    def build_data(headers, series)
       # Return if No header
       return Data.new(headers, series) if headers.nil?
 
+      h_size, s_size = validate_headers(headers, series)
+      Data.new(headers, series) if h_size == s_size
+    end
+
+    def validate_headers(headers, series)
       # Warn if header contains nil
       warn "\e[35mHeaders contains nil in it.\e[0m" if headers.include?(nil)
 
@@ -39,19 +54,12 @@ module YouPlot
       if h_size > s_size
         warn "\e[35mThe number of headers is greater than the number of series.\e[0m"
         exit 1 if YouPlot.run_as_executable?
-
       elsif h_size < s_size
         warn "\e[35mThe number of headers is less than the number of series.\e[0m"
         exit 1 if YouPlot.run_as_executable?
       end
 
-      Data.new(headers, series) if h_size == s_size
-    end
-
-    # Transpose different sized ruby arrays
-    # https://stackoverflow.com/q/26016632
-    def transpose2(arr)
-      Array.new(arr.map(&:length).max) { |i| arr.map { |e| e[i] } }
+      [h_size, s_size]
     end
 
     def get_headers(arr, headers, transpose)

data/lib/youplot/options.rb

@@ -15,4 +15,24 @@ module YouPlot
     :color_names,  # color
     :debug
   )
+
+  # Default values for options.
+  # These are applied in Parser#resolve_options.
+  # Based on the following priority:
+  # 1. CLI options (highest priority)
+  # 2. Config file options
+  # 3. Default values (lowest priority) specified here.
+  Options::DEFAULTS = {
+    delimiter: "\t",
+    transpose: false,
+    headers: nil,
+    pass: false,
+    output: nil, # resolved to $stderr at parse time (late binding)
+    fmt: 'xyy',
+    progressive: false,
+    encoding: nil,
+    reverse: false,
+    color_names: false,
+    debug: false
+  }.freeze
 end

data/lib/youplot/parser.rb

@@ -14,28 +14,14 @@ module YouPlot
 
     def initialize
       @command = nil
-
-      @options = Options.new(
-        "\t",    # elimiter:
-        false,   # transpose:
-        nil,     # headers:
-        false,   # pass:
-        $stderr, # output:
-        'xyy',   # fmt:
-        false,   # progressive:
-        nil,     # encoding:
-        false,   # color_names:
-        false    # debug:
-      )
-
-      @params = Parameters.new
+      @options = Options.new
+      @params  = Parameters.new
     end
 
     def apply_config_file
       return if !config_file && find_config_file.nil?
 
       read_config_file
-      configure
     end
 
     def config_file_candidate_paths
@@ -70,20 +56,45 @@ module YouPlot
       @config = YAML.load_file(config_file)
     end
 
-    def configure
-      option_members = @options.members
-      param_members = @params.members
-      # It would be more useful to be able to configure by plot type
-      config.each do |k, v|
-        k = k.to_sym
-        if option_members.include?(k)
-          @options[k] ||= v
-        elsif param_members.include?(k)
-          @params[k] ||= v
-        else
-          raise Error, "Unknown option/param in config file: #{k}"
+    # Resolve options by applying the following priority:
+    # 1. CLI options  -- cli_val = @options[k]
+    # 2. Config file  -- cfg_val = @config[k.to_s]
+    # 3. DEFAULTS     -- def_val from Options::DEFAULTS
+    def resolve_options
+      # Validate config keys up front.
+      if @config
+        known = (@options.members + @params.members).map(&:to_s)
+        @config.each_key do |k|
+          raise Error, "Unknown option/param in config file: #{k}" unless known.include?(k)
         end
       end
+
+      Options::DEFAULTS.each do |k, def_val|
+        cfg_val = @config && @config[k.to_s]
+        cli_val = @options[k]
+        @options[k] = if !cli_val.nil? # can be false
+                        cli_val
+                      elsif !cfg_val.nil? # can be false
+                        cfg_val
+                      else
+                        def_val
+                      end
+      end
+
+      # $stderr is evaluated here, not in DEFAULTS.
+      # DEFAULTS is a constant, so values in it are fixed at class load time.
+      # Tests redirect $stderr = tempfile after load, so placing $stderr in DEFAULTS
+      # would capture the original stderr and ignore the test redirect.
+      @options[:output] = $stderr if @options[:output].nil?
+      @options[:output] = $stdout if @options[:output] == '-'
+      @options[:pass] = $stdout if @options[:pass] == '-'
+
+      @params.members.each do |k|
+        cfg_val = @config && @config[k.to_s]
+        cli_val = @params[k]
+        # no def_val for params
+        @params[k] = cfg_val if cli_val.nil? && !cfg_val.nil?
+      end
     end
 
     def create_base_parser
@@ -96,11 +107,11 @@ module YouPlot
         parser.on('Common options:')
         parser.on('-O', '--pass [FILE]', 'file to output input data to [stdout]',
                   'for inserting YouPlot in the middle of Unix pipes') do |v|
-          options[:pass] = v || $stdout
+          options[:pass] = v.nil? || v == '-' ? $stdout : v
         end
         parser.on('-o', '--output [FILE]', 'file to output plots to [stdout]',
                   'If no option is specified, plot will print to stderr') do |v|
-          options[:output] = v || $stdout
+          options[:output] = v.nil? || v == '-' ? $stdout : v
         end
         parser.on('-d', '--delimiter DELIM', String, 'use DELIM instead of [TAB] for field delimiter') do |v|
           options[:delimiter] = v
@@ -217,8 +228,10 @@ module YouPlot
     end
 
     def show_config_info
-      if ENV['MYYOUPLOTRC']
-        puts "config file : #{ENV['MYYOUPLOTRC']}"
+      ensure_config_loaded
+
+      if @config_file
+        puts "config file : #{@config_file}"
         puts config.inspect
       else
         puts <<~EOS
@@ -234,6 +247,15 @@ module YouPlot
       exit if YouPlot.run_as_executable?
     end
 
+    def ensure_config_loaded
+      apply_config_file unless config
+    rescue StandardError => e
+      raise unless YouPlot.run_as_executable?
+
+      warn "YouPlot: #{e.message}"
+      exit 1
+    end
+
     def sub_parser_add_symbol
       sub_parser.on_head('--symbol STR', String, 'character to be used to plot the bars') do |v|
         params.symbol = v
@@ -383,6 +405,9 @@ module YouPlot
     end
 
     def parse_options(argv = ARGV)
+      # keep original ARGV intact.
+      argv = argv.equal?(ARGV) ? argv : argv.dup
+
       begin
         create_main_parser.order!(argv)
       rescue OptionParser::ParseError => e
@@ -399,12 +424,15 @@ module YouPlot
         exit 1 if YouPlot.run_as_executable?
       end
 
+      # Read config after CLI parsing, then resolve: defaults < config < CLI.
       begin
         apply_config_file
       rescue StandardError => e
         warn "YouPlot: #{e.message}"
         exit 1 if YouPlot.run_as_executable?
       end
+
+      resolve_options
     end
   end
 end

data/lib/youplot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YouPlot
-  VERSION = '0.4.6'
+  VERSION = '0.5.0'
 end