v0.2.6

* Use only comma separators
* A hyphen is indistinguishable from a minus sign
* Colon separators aren't as common as commas

Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in uplot.gemspec

README.md

@@ -26,27 +26,7 @@ ruby -r numo/narray -e "puts Numo::DFloat.new(1000).rand_norm.to_a" \
   | uplot hist --nbins 15
 ```
 
-```
-                ┌                                        ┐ 
-   [-4.5, -4.0) ┤ 1                                        
-   [-4.0, -3.5) ┤ 0                                        
-   [-3.5, -3.0) ┤ 1                                        
-   [-3.0, -2.5) ┤▇▇ 9                                      
-   [-2.5, -2.0) ┤▇▇▇ 15                                    
-   [-2.0, -1.5) ┤▇▇▇▇▇▇▇▇▇ 50                              
-   [-1.5, -1.0) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 97                     
-   [-1.0, -0.5) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 154          
-   [-0.5,  0.0) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 193   
-   [ 0.0,  0.5) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 165        
-   [ 0.5,  1.0) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 152          
-   [ 1.0,  1.5) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 86                       
-   [ 1.5,  2.0) ┤▇▇▇▇▇▇▇▇▇ 51                              
-   [ 2.0,  2.5) ┤▇▇▇▇ 21                                   
-   [ 2.5,  3.0) ┤▇ 3                                       
-   [ 3.0,  3.5) ┤ 2                                        
-                └                                        ┘ 
-                                Frequency
-```
+<img src="https://i.imgur.com/wpsoGJq.png" width="75%" height="75%"></img>
 
 **scatter**
 

Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 

exe/uplot

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'uplot'
 

lib/uplot.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'unicode_plot'
 require 'uplot/version'
 require 'uplot/preprocessing'

lib/uplot/command.rb

@@ -1,275 +1,82 @@
-require 'optparse'
+# frozen_string_literal: true
+
 require_relative 'preprocessing'
+require_relative 'command/parser'
 
 module Uplot
   Data = Struct.new(:headers, :series)
 
   class Command
-    Params = Struct.new(
-      # Sort me!
-      :title,
-      :width,
-      :height,
-      :border,
-      :margin,
-      :padding,
-      :color,
-      :xlabel,
-      :ylabel,
-      :labels,
-      :symbol,
-      :xscale,
-      :nbins,
-      :closed,
-      :canvas,
-      :xlim,
-      :ylim,
-      :grid,
-      :name
-    ) do
-      def to_hc
-        to_h.compact
-      end
-    end
-
-    attr_accessor :params, :plot_type
-    attr_reader :raw_inputs, :data, :fmt
+    attr_accessor :params
+    attr_reader :raw_inputs, :data, :fmt, :parser
 
     def initialize
       @params = Params.new
 
-      @plot_type = nil
-      @headers   = nil
-      @delimiter = "\t"
-      @transpose = false
-      @output    = false
-      @count     = false
-      @fmt       = 'xyy'
-
       @raw_inputs = []
-      @debug      = false
-    end
 
-    def create_parser
-      OptionParser.new do |opt|
-        opt.program_name = 'uplot'
-        opt.version = Uplot::VERSION
-        opt.on('-o', '--output', TrueClass) do |v|
-          @output = v
-        end
-           .on('-d', '--delimiter VAL', String) do |v|
-          @delimiter = v
-        end
-           .on('-H', '--headers', TrueClass) do |v|
-          @headers = v
-        end
-           .on('-T', '--transpose', TrueClass) do |v|
-          @transpose = v
-        end
-           .on('-t', '--title VAL', String) do |v|
-          params.title = v
-        end
-           .on('-w', '--width VAL', Numeric) do |v|
-          params.width = v
-        end
-           .on('-h', '--height VAL', Numeric) do |v|
-          params.height = v
-        end
-           .on('-b', '--border VAL', Numeric) do |v|
-          params.border = v
-        end
-           .on('-m', '--margin VAL', Numeric) do |v|
-          params.margin = v
-        end
-           .on('-p', '--padding VAL', Numeric) do |v|
-          params.padding = v
-        end
-           .on('-c', '--color VAL', String) do |v|
-          params.color = v.to_sym
-        end
-           .on('-x', '--xlabel VAL', String) do |v|
-          params.xlabel = v
-        end
-           .on('-y', '--ylabel VAL', String) do |v|
-          params.ylabel = v
-        end
-           .on('-l', '--labels', TrueClass) do |v|
-          params.labels = v
-        end
-           .on('--fmt VAL', String) do |v|
-          @fmt = v
-        end
-           .on('--debug', TrueClass) do |v|
-          @debug = v
-        end
-      end
-    end
-
-    def parse_options(argv = ARGV)
-      main_parser = create_parser
-      parsers = Hash.new { |h, k| h[k] = create_parser }
-
-      parsers[:barplot] = \
-        parsers[:bar]
-        .on('--symbol VAL', String) do |v|
-          params.symbol = v
-        end
-        .on('--xscale VAL', String) do |v|
-          params.xscale = v
-        end
-        .on('--count', TrueClass) do |v|
-          @count = v
-        end
-
-      parsers[:count] = \
-        parsers[:c] # barplot -c
-        .on('--symbol VAL', String) do |v|
-          params.symbol = v
-        end
-
-      parsers[:histogram] = \
-        parsers[:hist]
-        .on('-n', '--nbins VAL', Numeric) do |v|
-          params.nbins = v
-        end
-        .on('--closed VAL', String) do |v|
-          params.closed = v
-        end
-        .on('--symbol VAL', String) do |v|
-          params.symbol = v
-        end
-
-      parsers[:lineplot] = \
-        parsers[:line]
-        .on('--canvas VAL', String) do |v|
-          params.canvas = v
-        end
-        .on('--xlim VAL', String) do |v|
-          params.xlim = get_lim(v)
-        end
-        .on('--ylim VAL', String) do |v|
-          params.ylim = get_lim(v)
-        end
-
-      parsers[:lineplots] = \
-        parsers[:lines]
-        .on('--canvas VAL', String) do |v|
-          params.canvas = v
-        end
-        .on('--xlim VAL', String) do |v|
-          params.xlim = get_lim(v)
-        end
-        .on('--ylim VAL', String) do |v|
-          params.ylim = get_lim(v)
-        end
-
-      parsers[:scatter] = \
-        parsers[:s]
-        .on('--canvas VAL', String) do |v|
-          params.canvas = v
-        end
-        .on('--xlim VAL', String) do |v|
-          params.xlim = get_lim(v)
-        end
-        .on('--ylim VAL', String) do |v|
-          params.ylim = get_lim(v)
-        end
-
-      parsers[:density] = \
-        parsers[:d]
-        .on('--grid', TrueClass) do |v|
-          params.grid = v
-        end
-        .on('--xlim VAL', String) do |v|
-          params.xlim = get_lim(v)
-        end
-        .on('--ylim VAL', String) do |v|
-          params.ylim = get_lim(v)
-        end
-
-      parsers[:boxplot] = \
-        parsers[:box]
-        .on('--xlim VAL', String) do |v|
-          params.xlim = get_lim(v)
-        end
-
-      # Preventing the generation of new sub-commands
-      parsers.default = nil
-
-      # Usage and help messages
-      main_parser.banner = \
-        <<~MSG
-          Program: uplot (Tools for plotting on the terminal)
-          Version: #{Uplot::VERSION} (using unicode_plot #{UnicodePlot::VERSION})
-
-          Usage:   uplot <command> [options]
-
-          Command: #{parsers.keys.join(' ')}
-
-          Options:
-        MSG
-
-      begin
-        main_parser.order!(argv)
-      rescue OptionParser::ParseError => e
-        warn "uplot: #{e.message}"
-        exit 1
-      end
-
-      @plot_type = argv.shift&.to_sym
-
-      unless parsers.has_key?(plot_type)
-        if plot_type.nil?
-          warn main_parser.help
-        else
-          warn "uplot: unrecognized command '#{plot_type}'"
-        end
-        exit 1
-      end
-      parser = parsers[plot_type]
-
-      begin
-        parser.parse!(argv) unless argv.empty?
-      rescue OptionParser::ParseError => e
-        warn "uplot: #{e.message}"
-        exit 1
-      end
-    end
-
-    def get_lim(str)
-      str.split(/-|:|\.\./)[0..1].map(&:to_f)
+      @parser = Parser.new
     end
 
     def run
-      parse_options
+      parser.parse_options
+      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
+        Plot.colors
+        exit
+      end
+
       # Sometimes the input file does not end with a newline code.
-      while input = Kernel.gets(nil)
+      while (input = Kernel.gets(nil))
         input.freeze
         @raw_inputs << input
-        @data = Preprocessing.input(input, @delimiter, @headers, @transpose)
+        @data = Preprocessing.input(input, delimiter, headers, transpose)
         pp @data if @debug
-        case plot_type
-        when :bar, :barplot
-          Plot.barplot(data, params, @count)
-        when :count, :c
-          Plot.barplot(data, params, count = true)
-        when :hist, :histogram
-          Plot.histogram(data, params)
-        when :line, :lineplot
-          Plot.line(data, params)
-        when :lines, :lineplots
-          Plot.lines(data, params, fmt)
-        when :scatter, :s
-          Plot.scatter(data, params, fmt)
-        when :density, :d
-          Plot.density(data, params, fmt)
-        when :box, :boxplot
-          Plot.boxplot(data, params)
-        else
-          raise "unrecognized plot_type: #{plot_type}"
-        end.render($stderr)
+        plot = case command
+               when :bar, :barplot
+                 Plot.barplot(data, params)
+               when :count, :c
+                 Plot.barplot(data, params, count: true)
+               when :hist, :histogram
+                 Plot.histogram(data, params)
+               when :line, :lineplot
+                 Plot.line(data, params)
+               when :lines, :lineplots
+                 Plot.lines(data, params, fmt)
+               when :scatter, :s
+                 Plot.scatter(data, params, fmt)
+               when :density, :d
+                 Plot.density(data, params, fmt)
+               when :box, :boxplot
+                 Plot.boxplot(data, params)
+               else
+                 raise "unrecognized plot_type: #{command}"
+               end
 
-        print input if @output
+        if output.is_a?(IO)
+          plot.render(output)
+        else
+          File.open(output, 'w') do |f|
+            plot.render(f)
+          end
+        end
+
+        if pass.is_a?(IO)
+          print input
+        elsif pass
+          File.open(pass, 'w') do |f|
+            f.print(input)
+          end
+        end
       end
     end
   end

lib/uplot/command/params.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Uplot
+  class Command
+    # UnicodePlot parameters.
+    # * Normally in a Ruby program, you might use hash for the parameter object.
+    # * Here, I use Struct for 2 safety reason.
+    # * The keys are static in Struct.
+    # * Struct does not conflict with keyword arguments. Hash dose.
+    Params = Struct.new(
+      # Sort me!
+      :title,
+      :width,
+      :height,
+      :border,
+      :margin,
+      :padding,
+      :color,
+      :xlabel,
+      :ylabel,
+      :labels,
+      :symbol,
+      :xscale,
+      :nbins,
+      :closed,
+      :canvas,
+      :xlim,
+      :ylim,
+      :grid,
+      :name
+    ) do
+      def to_hc
+        to_h.compact
+      end
+    end
+  end
+end

lib/uplot/command/parser.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative 'params'
+
+module Uplot
+  class Command
+    class Parser
+      attr_reader :command, :params,
+                  :delimiter, :transpose, :headers, :pass, :output, :fmt, :debug
+
+      def initialize
+        @command = nil
+        @params = Params.new
+
+        @delimiter  = "\t"
+        @transpose  = false
+        @headers    = nil
+        @pass       = false
+        @output     = $stderr
+        @fmt        = 'xyy'
+        @debug      = false
+      end
+
+      def create_default_parser
+        OptionParser.new do |opt|
+          opt.program_name = 'uplot'
+          opt.version = Uplot::VERSION
+          opt.on('-O', '--pass [VAL]', 'file to output standard input data to [stdout]',
+                 'for inserting uplot in the middle of Unix pipes') do |v|
+            @pass = v || $stdout
+          end
+          opt.on('-o', '--output VAL', 'file to output results to [stderr]') do |v|
+            @output = v
+          end
+          opt.on('-d', '--delimiter VAL', String, 'use DELIM instead of TAB for field delimiter') do |v|
+            @delimiter = v
+          end
+          opt.on('-H', '--headers', TrueClass, 'specify that the input has header row') do |v|
+            @headers = v
+          end
+          opt.on('-T', '--transpose', TrueClass) do |v|
+            @transpose = v
+          end
+          opt.on('-t', '--title VAL', 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|
+            params.xlabel = v
+          end
+          opt.on('-y', '--ylabel VAL', 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|
+            params.width = v
+          end
+          opt.on('-h', '--height VAL', 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|
+            params.border = v.to_sym
+          end
+          opt.on('-m', '--margin VAL', 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|
+            params.padding = v
+          end
+          opt.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|
+            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
+          end
+          opt.on('--debug', TrueClass) do |v|
+            @debug = v
+          end
+          yield opt if block_given?
+        end
+      end
+
+      def main_parser
+        @main_parser ||= create_default_parser do |main_parser|
+          # Usage and help messages
+          main_parser.banner = \
+            <<~MSG
+              Program: uplot (Tools for plotting on the terminal)
+              Version: #{Uplot::VERSION} (using UnicodePlot #{UnicodePlot::VERSION})
+              Author:  kojix2 <2xijok@gmail.com>
+              Source:  https://github.com/kojix2/uplot
+
+              Usage:   uplot <command> [options]
+
+              Command: barplot    bar
+                       histogram  hist
+                       lineplot   line
+                       scatter    s
+                       density    d
+                       boxplot    box
+                       colors
+
+              Options:
+            MSG
+        end
+      end
+
+      def sub_parser
+        @sub_parser ||= create_default_parser do |parser|
+          parser.banner = <<~MSG
+            Usage: uplot #{command} [options]
+
+            Options:
+          MSG
+
+          case command
+          when nil
+            warn main_parser.help
+            exit 1
+
+          when :barplot, :bar
+            parser.on('--symbol VAL', String, 'character to be used to plot the bars') do |v|
+              params.symbol = v
+            end
+            parser.on('--xscale VAL', String,  'axis scaling') do |v|
+              params.xscale = v
+            end
+
+          when :count, :c
+            parser.on('--symbol VAL', String, 'character to be used to plot the bars') do |v|
+              params.symbol = v
+            end
+
+          when :histogram, :hist
+            parser.on('-n', '--nbins VAL', Numeric, 'approximate number of bins') do |v|
+              params.nbins = v
+            end
+            parser.on('--closed VAL', String) do |v|
+              params.closed = v
+            end
+            parser.on('--symbol VAL', String, 'character to be used to plot the bars') do |v|
+              params.symbol = v
+            end
+
+          when :lineplot, :line
+            parser.on('--canvas VAL', String, 'type of canvas') do |v|
+              params.canvas = v
+            end
+            parser.on('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
+              params.xlim = v.take(2)
+            end
+            parser.on('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
+              params.ylim = v.take(2)
+            end
+
+          when :lineplots, :lines
+            parser.on('--canvas VAL', String) do |v|
+              params.canvas = v
+            end
+            parser.on('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
+              params.xlim = v.take(2)
+            end
+            parser.on('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
+              params.ylim = v.take(2)
+            end
+
+          when :scatter, :s
+            parser.on('--canvas VAL', String) do |v|
+              params.canvas = v
+            end
+            parser.on('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
+              params.xlim = v.take(2)
+            end
+            parser.on('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
+              params.ylim = v.take(2)
+            end
+
+          when :density, :d
+            parser.on('--grid', TrueClass) do |v|
+              params.grid = v
+            end
+            parser.on('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
+              params.xlim = v.take(2)
+            end
+            parser.on('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
+              params.ylim = v.take(2)
+            end
+
+          when :boxplot, :box
+            parser.on('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
+              params.xlim = v.take(2)
+            end
+
+          when :colors
+            parser.on('-n', '--names', TrueClass) do |v|
+              @color_names = v
+            end
+
+          else
+            warn "uplot: unrecognized command '#{command}'"
+            exit 1
+          end
+        end
+      end
+
+      def parse_options(argv = ARGV)
+        begin
+          main_parser.order!(argv)
+        rescue OptionParser::ParseError => e
+          warn "uplot: #{e.message}"
+          exit 1
+        end
+
+        @command = argv.shift&.to_sym
+
+        begin
+          sub_parser.parse!(argv)
+        rescue OptionParser::ParseError => e
+          warn "uplot: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

lib/uplot/plot.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'unicode_plot'
 
 module Uplot
@@ -5,7 +7,7 @@ module Uplot
   module Plot
     module_function
 
-    def barplot(data, params, count = false)
+    def barplot(data, params, count: false)
       headers = data.headers
       series = data.series
       if count
@@ -51,7 +53,7 @@ module Uplot
       (method1.to_s + '!').to_sym
     end
 
-    def xyy_plot(data, method1, params)
+    def plot_xyy(data, method1, params)
       headers = data.headers
       series = data.series
       method2 = get_method2(method1)
@@ -68,7 +70,7 @@ module Uplot
       plot
     end
 
-    def xyxy_plot(data, method1, params)
+    def plot_xyxy(data, method1, params)
       headers = data.headers
       series = data.series
       method2 = get_method2(method1)
@@ -85,34 +87,30 @@ module Uplot
       plot
     end
 
-    def lines(data, params, fmt = 'xyy')
-      check_series_size(data, fmt)
+    def plot_fmt(data, fmt, method1, params)
       case fmt
       when 'xyy'
-        xyy_plot(data, :lineplot, params)
+        plot_xyy(data, method1, params)
       when 'xyxy'
-        xyxy_plot(data, :lineplot, params)
+        plot_xyxy(data, method1, params)
+      else
+        raise "Unknown format: #{fmt}"
       end
     end
 
+    def lines(data, params, fmt = 'xyy')
+      check_series_size(data, fmt)
+      plot_fmt(data, fmt, :lineplot, params)
+    end
+
     def scatter(data, params, fmt = 'xyy')
       check_series_size(data, fmt)
-      case fmt
-      when 'xyy'
-        xyy_plot(data, :scatterplot, params)
-      when 'xyxy'
-        xyxy_plot(data, :scatterplot, params)
-      end
+      plot_fmt(data, fmt, :scatterplot, params)
     end
 
     def density(data, params, fmt = 'xyy')
       check_series_size(data, fmt)
-      case fmt
-      when 'xyy'
-        xyy_plot(data, :densityplot, params)
-      when 'xyxy'
-        xyxy_plot(data, :densityplot, params)
-      end
+      plot_fmt(data, fmt, :densityplot, params)
     end
 
     def boxplot(data, params)
@@ -123,6 +121,18 @@ module Uplot
       UnicodePlot.boxplot(headers, series, **params.to_hc)
     end
 
+    def colors
+      UnicodePlot::StyledPrinter::TEXT_COLORS.each do |k, v|
+        print v
+        print k
+        print "\t"
+        print '  ●'
+        print "\033[0m"
+        print "\t"
+      end
+      puts
+    end
+
     def check_series_size(data, fmt)
       series = data.series
       if series.size == 1

lib/uplot/preprocessing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'csv'
 
 module Uplot
@@ -5,13 +7,32 @@ module Uplot
     module_function
 
     def input(input, delimiter, headers, transpose)
-      arr = read_csv(input, delimiter)
+      arr = parse_as_csv(input, delimiter)
       headers = get_headers(arr, headers, transpose)
       series = get_series(arr, headers, transpose)
-      Data.new(headers, series)
+      if headers.nil?
+        Data.new(headers, series)
+      else
+        if headers.include?(nil)
+          warn "\e[35mHeaders contains nil in it.\e[0m"
+        elsif headers.include? ''
+          warn "\e[35mHeaders contains \"\" in it.\e[0m"
+        end
+        h_size = headers.size
+        s_size = series.size
+        if h_size == s_size
+          Data.new(headers, series)
+        elsif h_size > s_size
+          warn "\e[35mThe number of headers is greater than the number of series.\e[0m"
+          exit 1
+        elsif h_size < s_size
+          warn "\e[35mThe number of headers is less than the number of series.\e[0m"
+          exit 1
+        end
+      end
     end
 
-    def read_csv(input, delimiter)
+    def parse_as_csv(input, delimiter)
       CSV.parse(input, col_sep: delimiter)
          .delete_if do |i|
            i == [] or i.all? nil

lib/uplot/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Uplot
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.2.6'
 end

test/test_helper.rb

@@ -1,4 +1,8 @@
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
 require 'uplot'
 
 require 'test/unit'

test/uplot/command_test.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper.rb'
+
+class UplotCommandTest < Test::Unit::TestCase
+end

test/uplot/plot_test.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper.rb'
+
+class UplotPlotTest < Test::Unit::TestCase
+end

test/uplot/preprocessing_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper.rb'
+
+class UplotPreprocessingTest < Test::Unit::TestCase
+  def setup
+    @m = Uplot::Preprocessing
+  end
+
+  test :transpose2 do
+    n = nil
+
+    assert_equal([[1, 2, 3],
+                  [4, 5, 6],
+                  [7, 8, 9]], @m.transpose2([[1, 4, 7],
+                                             [2, 5, 8],
+                                             [3, 6, 9]]))
+    assert_equal([[1, 2, 3],
+                  [4, 5, n],
+                  [6, n, n]], @m.transpose2([[1, 4, 6],
+                                             [2, 5],
+                                             [3]]))
+    assert_equal([[1, 2, 3],
+                  [n, 4, 5],
+                  [n, n, 6]], @m.transpose2([[1],
+                                             [2, 4],
+                                             [3, 5, 6]]))
+  end
+
+  test :get_headers do
+    assert_equal([1, 4, 7], @m.get_headers([[1, 2, 3],
+                                            [4, 5, 6],
+                                            [7, 8, 9]], true, true))
+
+    assert_equal([1, 2, 3], @m.get_headers([[1, 4, 6],
+                                            [2, 5],
+                                            [3]], true, true))
+
+    assert_equal([1, 2, 3], @m.get_headers([[1],
+                                            [2, 4],
+                                            [3, 5, 6]], true, true))
+
+    assert_equal([1, 2, 3], @m.get_headers([[1, 2, 3],
+                                            [4, 5, 6],
+                                            [7, 8, 9]], true, false))
+
+    assert_equal([1, 4, 6], @m.get_headers([[1, 4, 6],
+                                            [2, 5],
+                                            [3]], true, false))
+
+    assert_equal([1], @m.get_headers([[1],
+                                      [2, 4],
+                                      [3, 5, 6]], true, false))
+
+    assert_equal(nil, @m.get_headers([[1, 2, 3],
+                                      [4, 5, 6],
+                                      [7, 8, 9]], false, true))
+
+    assert_equal(nil, @m.get_headers([[1, 2, 3],
+                                      [4, 5, 6],
+                                      [7, 8, 9]], false, false))
+  end
+
+  test :get_series do
+    n = nil
+
+    assert_equal([[2, 3], [5, 6], [8, 9]], @m.get_series([[1, 2, 3],
+                                                          [4, 5, 6],
+                                                          [7, 8, 9]], true, true))
+
+    assert_equal([[4, 6], [5], []], @m.get_series([[1, 4, 6],
+                                                   [2, 5],
+                                                   [3]], true, true))
+
+    assert_equal([[], [4], [5, 6]], @m.get_series([[1],
+                                                   [2, 4],
+                                                   [3, 5, 6]], true, true))
+
+    assert_equal([[4, 7], [5, 8], [6, 9]], @m.get_series([[1, 2, 3],
+                                                          [4, 5, 6],
+                                                          [7, 8, 9]], true, false))
+
+    assert_equal([[2, 3], [5, nil]], @m.get_series([[1, 4, 6],
+                                                    [2, 5],
+                                                    [3]], true, false))
+
+    assert_equal([[2, 3], [4, 5], [nil, 6]], @m.get_series([[1],
+                                                            [2, 4],
+                                                            [3, 5, 6]], true, false))
+
+    assert_equal([[1, 2, 3],
+                  [4, 5, 6],
+                  [7, 8, 9]], @m.get_series([[1, 2, 3],
+                                             [4, 5, 6],
+                                             [7, 8, 9]], false, true))
+
+    assert_equal([[1, 4, 6],
+                  [2, 5],
+                  [3]], @m.get_series([[1, 4, 6],
+                                       [2, 5],
+                                       [3]], false, true))
+
+    assert_equal([[1],
+                  [2, 4],
+                  [3, 5, 6]], @m.get_series([[1],
+                                             [2, 4],
+                                             [3, 5, 6]], false, true))
+
+    assert_equal([[1, 4, 7],
+                  [2, 5, 8],
+                  [3, 6, 9]], @m.get_series([[1, 2, 3],
+                                             [4, 5, 6],
+                                             [7, 8, 9]], false, false))
+
+    assert_equal([[1, 2, 3],
+                  [4, 5, n],
+                  [6, n, n]], @m.get_series([[1, 4, 6],
+                                             [2, 5],
+                                             [3]], false, false))
+
+    assert_equal([[1, 2, 3],
+                  [n, 4, 5],
+                  [n, n, 6]], @m.get_series([[1],
+                                             [2, 4],
+                                             [3, 5, 6]], false, false))
+  end
+
+  test :count do
+    assert_equal([%i[a b c], [3, 2, 1]], @m.count(%i[a a a b b c]))
+    assert_equal([%i[c b a], [3, 2, 1]], @m.count(%i[a b b c c c]))
+  end
+end

test/uplot_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class UplotTest < Test::Unit::TestCase

uplot.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/uplot/version'
 
 Gem::Specification.new do |spec|
@@ -13,7 +15,7 @@ Gem::Specification.new do |spec|
   MSG
   spec.homepage      = 'https://github.com/kojix2/uplot'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
 
   spec.files         = Dir['*.{md,txt}', '{lib,exe}/**/*']
   spec.bindir        = 'exe'
@@ -24,5 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'test-unit'
 end