youplot 0.3.0 → 0.3.5

data/lib/youplot/command.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'preprocessing'
+require_relative 'dsv'
 require_relative 'command/parser'
 
 # FIXME
@@ -10,79 +10,173 @@ module YouPlot
   Data = Struct.new(:headers, :series)
 
   class Command
-    attr_accessor :params
-    attr_reader :data, :fmt, :parser
+    attr_accessor :command, :params, :options
+    attr_reader :data, :parser
 
     def initialize(argv = ARGV)
       @argv    = argv
-      @params  = Params.new
       @parser  = Parser.new
+      @command = nil
+      @params  = nil
+      @options = nil
       @backend = YouPlot::Backends::UnicodePlotBackend
     end
 
+    def run_as_executable
+      YouPlot.run_as_executable = true
+      run
+    end
+
     def run
       parser.parse_options(@argv)
-      command   = parser.command
-      params    = parser.params
-      delimiter = parser.delimiter
-      transpose = parser.transpose
-      headers   = parser.headers
-      pass      = parser.pass
-      output    = parser.output
-      fmt       = parser.fmt
-      @debug    = parser.debug
-
-      if command == :colors
-        @backend.colors(parser.color_names)
-        exit
+      @command ||= parser.command
+      @options ||= parser.options
+      @params  ||= parser.params
+
+      if %i[colors color colours colour].include? @command
+        plot = create_plot
+        output_plot(plot)
+      elsif options[:progressive]
+        stop = false
+        Signal.trap(:INT) { stop = true }
+        options[:output].print "\e[?25l" # make cursor invisible
+        while (input = Kernel.gets)
+          n = main_progressive(input)
+          break if stop
+
+          options[:output].print "\e[#{n}F"
+        end
+        options[:output].print "\e[0J"
+        options[:output].print "\e[?25h" # make cursor visible
+      else
+        # Sometimes the input file does not end with a newline code.
+        while (input = Kernel.gets(nil))
+          main(input)
+        end
       end
+    end
 
-      # Sometimes the input file does not end with a newline code.
-      while (input = Kernel.gets(nil))
-        input.freeze
-        @data = Preprocessing.input(input, delimiter, headers, transpose)
-        pp @data if @debug
-        plot = case command
-               when :bar, :barplot
-                 @backend.barplot(data, params)
-               when :count, :c
-                 @backend.barplot(data, params, count: true)
-               when :hist, :histogram
-                 @backend.histogram(data, params)
-               when :line, :lineplot
-                 @backend.line(data, params)
-               when :lines, :lineplots
-                 @backend.lines(data, params, fmt)
-               when :scatter, :s
-                 @backend.scatter(data, params, fmt)
-               when :density, :d
-                 @backend.density(data, params, fmt)
-               when :box, :boxplot
-                 @backend.boxplot(data, params)
-               else
-                 raise "unrecognized plot_type: #{command}"
-               end
-
-        case output
-        when IO
-          plot.render(output)
-        else
-          File.open(output, 'w') do |f|
-            plot.render(f)
-          end
+    private
+
+    def main(input)
+      output_data(input)
+
+      @data = read_dsv(input)
+
+      pp @data if options[:debug]
+
+      if YouPlot.run_as_executable?
+        begin
+          plot = create_plot
+        rescue ArgumentError => e
+          warn e.backtrace[0]
+          warn "\e[35m#{e}\e[0m"
+          exit 1
         end
+      else
+        plot = create_plot
+      end
+      output_plot(plot)
+    end
+
+    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
 
-        case pass
-        when IO
-          pass.print(input)
-        else
-          if pass
-            File.open(pass, 'w') do |f|
-              f.print(input)
-            end
+      # FIXME
+      @data = read_dsv(@raw_data)
+
+      plot = create_plot
+      output_plot_progressive(plot)
+    end
+
+    def read_dsv(input)
+      input = input.dup.force_encoding(options[:encoding]).encode('utf-8') if options[:encoding]
+      DSV.parse(input, options[:delimiter], options[:headers], options[:transpose])
+    end
+
+    def create_plot
+      case command
+      when :bar, :barplot
+        @backend.barplot(data, params, options[:fmt])
+      when :count, :c
+        @backend.barplot(data, params, count: true)
+      when :hist, :histogram
+        @backend.histogram(data, params)
+      when :line, :lineplot
+        @backend.line(data, params, options[:fmt])
+      when :lines, :lineplots
+        @backend.lines(data, params, options[:fmt])
+      when :scatter, :s
+        @backend.scatter(data, params, options[:fmt])
+      when :density, :d
+        @backend.density(data, params, options[:fmt])
+      when :box, :boxplot
+        @backend.boxplot(data, params)
+      when :colors, :color, :colours, :colour
+        @backend.colors(options[:color_names])
+      else
+        raise "unrecognized plot_type: #{command}"
+      end
+    end
+
+    def output_data(input)
+      # Pass the input to subsequent pipelines
+      case options[:pass]
+      when IO
+        options[:pass].print(input)
+      else
+        if options[:pass]
+          File.open(options[:pass], 'w') do |f|
+            f.print(input)
           end
         end
       end
     end
+
+    def output_plot(plot)
+      case options[:output]
+      when IO
+        plot.render(options[:output])
+      else
+        File.open(options[:output], 'w') do |f|
+          plot.render(f)
+        end
+      end
+    end
+
+    def output_plot_progressive(plot)
+      case options[:output]
+      when IO
+        # 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.'
+      end
+    end
   end
 end

data/lib/youplot/command/options.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module YouPlot
+  class Command
+    Options = Struct.new(
+      :delimiter,
+      :transpose,
+      :headers,
+      :pass,
+      :output,
+      :fmt,
+      :progressive,
+      :encoding,
+      :color_names,
+      :debug,
+      keyword_init: true
+    )
+  end
+end

data/lib/youplot/command/parser.rb

@@ -1,259 +1,303 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require_relative 'params'
+require_relative 'options'
+require_relative 'plot_params'
 
 module YouPlot
   class Command
     class Parser
-      attr_reader :command, :params,
-                  :delimiter, :transpose, :headers, :pass, :output, :fmt,
-                  :color_names, :debug
+      class Error < StandardError; end
+
+      attr_reader :command, :options, :params,
+                  :main_parser, :sub_parser
 
       def initialize
-        @command     = nil
-        @params      = Params.new
-
-        @delimiter   = "\t"
-        @transpose   = false
-        @headers     = nil
-        @pass        = false
-        @output      = $stderr
-        @fmt         = 'xyy'
-        @debug       = false
-        @color_names = false
+        @command = nil
+
+        @options = Options.new(
+          delimiter: "\t",
+          transpose: false,
+          headers: nil,
+          pass: false,
+          output: $stderr,
+          fmt: 'xyy',
+          progressive: false,
+          encoding: nil,
+          color_names: false,
+          debug: false
+        )
+
+        @params = PlotParams.new
       end
 
       def create_default_parser
-        OptionParser.new do |opt|
-          opt.program_name  = 'YouPlot'
-          opt.version       = YouPlot::VERSION
-          opt.summary_width = 24
-          opt.on_tail('') # Add a blank line at the end
-          opt.separator('')
-          opt.on('Common options:')
-          opt.on('-O', '--pass [VAL]', 'file to output standard input data to [stdout]',
-                 'for inserting YouPlot in the middle of Unix pipes') do |v|
-            @pass = v || $stdout
+        OptionParser.new do |parser|
+          parser.program_name  = 'YouPlot'
+          parser.version       = YouPlot::VERSION
+          parser.summary_width = 24
+          parser.on_tail('') # Add a blank line at the end
+          parser.separator('')
+          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
           end
-          opt.on('-o', '--output VAL', 'file to output results to [stderr]') do |v|
-            @output = v
+          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
           end
-          opt.on('-d', '--delimiter VAL', String, 'use DELIM instead of TAB for field delimiter') do |v|
-            @delimiter = v
+          parser.on('-d', '--delimiter DELIM', String, 'use DELIM instead of [TAB] for field delimiter') do |v|
+            options[:delimiter] = v
           end
-          opt.on('-H', '--headers', TrueClass, 'specify that the input has header row') do |v|
-            @headers = v
+          parser.on('-H', '--headers', TrueClass, 'specify that the input has header row') do |v|
+            options[:headers] = v
           end
-          opt.on('-T', '--transpose', TrueClass, 'transpose the axes of the input data') do |v|
-            @transpose = v
+          parser.on('-T', '--transpose', TrueClass, 'transpose the axes of the input data') do |v|
+            options[:transpose] = v
           end
-          opt.on('-t', '--title VAL', String, 'print string on the top of plot') do |v|
+          parser.on('-t', '--title STR', String, 'print string on the top of plot') do |v|
             params.title = v
           end
-          opt.on('-x', '--xlabel VAL', String, 'print string on the bottom of the plot') do |v|
+          parser.on('-x', '--xlabel STR', String, 'print string on the bottom of the plot') do |v|
             params.xlabel = v
           end
-          opt.on('-y', '--ylabel VAL', String, 'print string on the far left of the plot') do |v|
+          parser.on('-y', '--ylabel STR', String, 'print string on the far left of the plot') do |v|
             params.ylabel = v
           end
-          opt.on('-w', '--width VAL', Integer, 'number of characters per row') do |v|
+          parser.on('-w', '--width INT', Integer, 'number of characters per row') do |v|
             params.width = v
           end
-          opt.on('-h', '--height VAL', Numeric, 'number of rows') do |v|
+          parser.on('-h', '--height INT', Numeric, 'number of rows') do |v|
             params.height = v
           end
-          opt.on('-b', '--border VAL', String, 'specify the style of the bounding box') do |v|
+          border_options = UnicodePlot::BORDER_MAP.keys.join(', ')
+          parser.on('-b', '--border STR', String, 'specify the style of the bounding box', "(#{border_options})") do |v|
             params.border = v.to_sym
           end
-          opt.on('-m', '--margin VAL', Numeric, 'number of spaces to the left of the plot') do |v|
+          parser.on('-m', '--margin INT', Numeric, 'number of spaces to the left of the plot') do |v|
             params.margin = v
           end
-          opt.on('-p', '--padding VAL', Numeric, 'space of the left and right of the plot') do |v|
+          parser.on('--padding INT', Numeric, 'space of the left and right of the plot') do |v|
             params.padding = v
           end
-          opt.on('-c', '--color VAL', String, 'color of the drawing') do |v|
+          parser.on('-c', '--color VAL', String, 'color of the drawing') do |v|
             params.color = v =~ /\A[0-9]+\z/ ? v.to_i : v.to_sym
           end
-          opt.on('--[no-]labels', TrueClass, 'hide the labels') do |v|
+          parser.on('--[no-]labels', TrueClass, 'hide the labels') do |v|
             params.labels = v
           end
-          opt.on('--fmt VAL', String, 'xyxy : header is like x1, y1, x2, y2, x3, y3...', 'xyy  : header is like x, y1, y2, y2, y3...') do |v|
-            @fmt = v
+          parser.on('-p', '--progress', TrueClass, 'progressive mode [experimental]') do |v|
+            options[:progressive] = v
+          end
+          parser.on('-C', '--color-output', TrueClass, 'colorize even if writing to a pipe') do |v|
+            UnicodePlot::StyledPrinter.define_method(:color?){ |o| true }
+          end
+          parser.on('-M', '--monochrome', TrueClass, 'no colouring even if writing to a tty') do |v|
+            UnicodePlot::StyledPrinter.define_method(:color?){ |o| false }
+          end
+          parser.on('--encoding STR', String, 'Specify the input encoding') do |v|
+            options[:encoding] = v
           end
           # Optparse adds the help option, but it doesn't show up in usage.
           # This is why you need the code below.
-          opt.on('--help', 'print sub-command help menu') do
-            puts opt.help
-            exit
+          parser.on('--help', 'print sub-command help menu') do
+            puts parser.help
+            exit if YouPlot.run_as_executable?
           end
-          opt.on('--debug', TrueClass, 'print preprocessed data') do |v|
-            @debug = v
+          parser.on('--debug', TrueClass, 'print preprocessed data') do |v|
+            options[:debug] = v
           end
-          yield opt if block_given?
+          # yield opt if block_given?
         end
       end
 
-      def main_parser
-        @main_parser ||= create_default_parser do |main_parser|
-          # Here, help message is stored in the banner.
-          # Because help of main_parser may be referred by `sub_parser`.
-          
-          main_parser.banner = \
-            <<~MSG
-              
-              Program: YouPlot (Tools for plotting on the terminal)
-              Version: #{YouPlot::VERSION} (using UnicodePlot #{UnicodePlot::VERSION})
-              Source:  https://github.com/kojix2/youplot
-
-              Usage:   uplot <command> [options] <in.tsv>
-
-              Commands:
-                  barplot    bar           draw a horizontal barplot
-                  histogram  hist          draw a horizontal histogram
-                  lineplot   line          draw a line chart
-                  lineplots  lines         draw a line chart with multiple series
-                  scatter    s             draw a scatter plot
-                  density    d             draw a density plot
-                  boxplot    box           draw a horizontal boxplot
-                  colors                   show the list of available colors
-
-                  count      c             draw a baplot based on the number of 
-                                           occurrences (slow)
-              
-              General options:
-                  --help                   print command specific help menu
-                  --version                print the version of YouPlot 
-            MSG
-
-          # Actually, main_parser can take common optional arguments.
-          # However, these options dose not be shown in the help menu.
-          # I think the main help should be simple.
-          main_parser.on('--help', 'print sub-command help menu') do
-            puts main_parser.banner
-            puts
-            exit
-          end
+      def create_main_parser
+        @main_parser = create_default_parser
+        main_parser.banner = \
+          <<~MSG
+
+            Program: YouPlot (Tools for plotting on the terminal)
+            Version: #{YouPlot::VERSION} (using UnicodePlot #{UnicodePlot::VERSION})
+            Source:  https://github.com/kojix2/youplot
+
+            Usage:   uplot <command> [options] <in.tsv>
+
+            Commands:
+                barplot    bar           draw a horizontal barplot
+                histogram  hist          draw a horizontal histogram
+                lineplot   line          draw a line chart
+                lineplots  lines         draw a line chart with multiple series
+                scatter    s             draw a scatter plot
+                density    d             draw a density plot
+                boxplot    box           draw a horizontal boxplot
+                colors     color         show the list of available colors
+
+                count      c             draw a baplot based on the number of
+                                         occurrences (slow)
+
+            General options:
+                --help                   print command specific help menu
+                --version                print the version of YouPlot
+          MSG
+
+        # Help for the main parser is simple.
+        # Simply show the banner above.
+        main_parser.on('--help', 'print sub-command help menu') do
+          puts main_parser.banner
+          puts
+          exit if YouPlot.run_as_executable?
         end
       end
 
-      def sub_parser
-        @sub_parser ||= create_default_parser do |parser|
-          parser.banner = <<~MSG
+      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
+        end
+      end
+
+      def sub_parser_add_xscale
+        xscale_options = UnicodePlot::ValueTransformer::PREDEFINED_TRANSFORM_FUNCTIONS.keys.join(', ')
+        sub_parser.on_head('--xscale STR', String, "axis scaling (#{xscale_options})") do |v|
+          params.xscale = v.to_sym
+        end
+      end
+
+      def sub_parser_add_canvas
+        sub_parser.on_head('--canvas STR', String, 'type of canvas') do |v|
+          params.canvas = v.to_sym
+        end
+      end
+
+      def sub_parser_add_xlim
+        sub_parser.on_head('--xlim FLOAT,FLOAT', Array, 'plotting range for the x coordinate') do |v|
+          params.xlim = v
+        end
+      end
+
+      def sub_parser_add_ylim
+        sub_parser.on_head('--ylim FLOAT,FLOAT', Array, 'plotting range for the y coordinate') do |v|
+          params.ylim = v
+        end
+      end
+
+      def sub_parser_add_grid
+        sub_parser.on_head('--[no-]grid', TrueClass, 'draws grid-lines at the origin') do |v|
+          params.grid = v
+        end
+      end
+
+      def create_sub_parser
+        @sub_parser = create_default_parser
+        sub_parser.banner = \
+          <<~MSG
 
             Usage: YouPlot #{command} [options] <in.tsv>
 
             Options for #{command}:
           MSG
 
-          case command
+        case command
 
-          # If you type only `uplot` in the terminal.
-          when nil
-            warn main_parser.banner
-            warn "\n"
-            exit 1
+        # If you type only `uplot` in the terminal.
+        when nil
+          warn main_parser.banner
+          warn "\n"
+          exit 1 if YouPlot.run_as_executable?
 
-          when :barplot, :bar
-            parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
-              params.symbol = v
-            end
-            parser.on_head('--xscale VAL', String, 'axis scaling') do |v|
-              params.xscale = v
-            end
-
-          when :count, :c
-            parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
-              params.symbol = v
-            end
-
-          when :histogram, :hist
-            parser.on_head('-n', '--nbins VAL', Numeric, 'approximate number of bins') do |v|
-              params.nbins = v
-            end
-            parser.on_head('--closed VAL', String) do |v|
-              params.closed = v
-            end
-            parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
-              params.symbol = v
-            end
-
-          when :lineplot, :line
-            parser.on_head('--canvas VAL', String, 'type of canvas') do |v|
-              params.canvas = v
-            end
-            parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
-              params.xlim = v.take(2)
-            end
-            parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
-              params.ylim = v.take(2)
-            end
-
-          when :lineplots, :lines
-            parser.on_head('--canvas VAL', String) do |v|
-              params.canvas = v
-            end
-            parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
-              params.xlim = v.take(2)
-            end
-            parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
-              params.ylim = v.take(2)
-            end
-
-          when :scatter, :s
-            parser.on_head('--canvas VAL', String) do |v|
-              params.canvas = v
-            end
-            parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
-              params.xlim = v.take(2)
-            end
-            parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
-              params.ylim = v.take(2)
-            end
-
-          when :density, :d
-            parser.on_head('--grid', TrueClass) do |v|
-              params.grid = v
-            end
-            parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
-              params.xlim = v.take(2)
-            end
-            parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
-              params.ylim = v.take(2)
-            end
-
-          when :boxplot, :box
-            parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
-              params.xlim = v.take(2)
-            end
-
-          when :colors
-            parser.on_head('-n', '--names', 'show color names only', TrueClass) do |v|
-              @color_names = v
-            end
+        when :barplot, :bar
+          sub_parser_add_symbol
+          sub_parser.on_head('--fmt STR', String, 'xy : header is like x, y...', 'yx : header is like y, x...') do |v|
+            options[:fmt] = v
+          end
+          sub_parser_add_xscale
 
-          else
-            warn "uplot: unrecognized command '#{command}'"
+        when :count, :c
+          sub_parser_add_symbol
+          sub_parser_add_xscale
+
+        when :histogram, :hist
+          sub_parser_add_symbol
+          sub_parser.on_head('--closed STR', String, 'side of the intervals to be closed [left]') do |v|
+            params.closed = v
+          end
+          sub_parser.on_head('-n', '--nbins INT', Numeric, 'approximate number of bins') do |v|
+            params.nbins = v
+          end
+
+        when :lineplot, :line
+          sub_parser_add_canvas
+          sub_parser_add_grid
+          sub_parser.on_head('--fmt STR', String, 'xy : header is like x, y...', 'yx : header is like y, x...') do |v|
+            options[:fmt] = v
+          end
+          sub_parser_add_ylim
+          sub_parser_add_xlim
+
+        when :lineplots, :lines
+          sub_parser_add_canvas
+          sub_parser_add_grid
+          sub_parser.on_head('--fmt STR', String, 'xyxy : header is like x1, y1, x2, y2, x3, y3...',
+                             'xyy  : header is like x, y1, y2, y2, y3...') do |v|
+            options[:fmt] = v
+          end
+          sub_parser_add_ylim
+          sub_parser_add_xlim
+
+        when :scatter, :s
+          sub_parser_add_canvas
+          sub_parser_add_grid
+          sub_parser.on_head('--fmt STR', String, 'xyxy : header is like x1, y1, x2, y2, x3, y3...',
+                             'xyy  : header is like x, y1, y2, y2, y3...') do |v|
+            options[:fmt] = v
+          end
+          sub_parser_add_ylim
+          sub_parser_add_xlim
+
+        when :density, :d
+          sub_parser_add_canvas
+          sub_parser_add_grid
+          sub_parser.on('--fmt STR', String, 'xyxy : header is like x1, y1, x2, y2, x3, y3...',
+                        'xyy  : header is like x, y1, y2, y2, y3...') do |v|
+            options[:fmt] = v
+          end
+          sub_parser_add_ylim
+          sub_parser_add_xlim
+
+        when :boxplot, :box
+          sub_parser_add_xlim
+
+        when :colors, :color, :colours, :colour
+          sub_parser.on_head('-n', '--names', 'show color names only', TrueClass) do |v|
+            options[:color_names] = v
+          end
+
+        else
+          error_message = "uplot: unrecognized command '#{command}'"
+          if YouPlot.run_as_executable?
+            warn error_message
             exit 1
+          else
+            raise Error, error_message
           end
         end
       end
 
       def parse_options(argv = ARGV)
         begin
-          main_parser.order!(argv)
+          create_main_parser.order!(argv)
         rescue OptionParser::ParseError => e
           warn "uplot: #{e.message}"
-          exit 1
+          exit 1 if YouPlot.run_as_executable?
         end
 
         @command = argv.shift&.to_sym
 
         begin
-          sub_parser.parse!(argv)
+          create_sub_parser&.parse!(argv)
         rescue OptionParser::ParseError => e
           warn "uplot: #{e.message}"
-          exit 1
+          exit 1 if YouPlot.run_as_executable?
         end
       end
     end