unicode_plot 0.0.4 → 0.0.5

data/lib/unicode_plot/styled_printer.rb

@@ -58,7 +58,7 @@ module UnicodePlot
     COLOR_DECODE = COLOR_ENCODE.map {|k, v| [v, k] }.to_h.freeze
 
     def print_styled(out, *args, bold: false, color: :normal)
-      return out.print(*args) unless color?(out)
+      return out.print(*args) unless out.color?
 
       str = StringIO.open {|sio| sio.print(*args); sio.close; sio.string }
       color = :nothing if bold && color == :bold
@@ -83,9 +83,5 @@ module UnicodePlot
       color = COLOR_DECODE[color]
       print_styled(out, *args, color: color)
     end
-
-    def color?(out)
-      out&.tty? || false
-    end
   end
 end

data/lib/unicode_plot/version.rb

@@ -1,5 +1,5 @@
 module UnicodePlot
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 
   module Version
     numbers, TAG = VERSION.split("-", 2)

data/test/helper/with_term.rb

@@ -2,22 +2,28 @@ require 'stringio'
 
 module Helper
   module WithTerm
-    def with_term(tty=true)
+    def with_sio(tty: true)
       sio = StringIO.new
       def sio.tty?; true; end if tty
 
-      orig_stdout, $stdout = $stdout, sio
-      orig_env = ENV.to_h.dup
-      ENV['TERM'] = 'xterm-256color'
-
-      result = yield
+      result = yield(sio)
       sio.close
 
       [result, sio.string]
-    ensure
-      $stdout.close
-      $stdout = orig_stdout
-      ENV.replace(orig_env) if orig_env
+    end
+
+    def with_term(tty=true)
+      with_sio(tty: tty) do |sio|
+        begin
+          orig_stdout, $stdout = $stdout, sio
+          orig_env = ENV.to_h.dup
+          ENV['TERM'] = 'xterm-256color'
+          yield
+        ensure
+          $stdout = orig_stdout
+          ENV.replace(orig_env) if orig_env
+        end
+      end
     end
   end
 end

data/test/test-barplot.rb

@@ -12,6 +12,14 @@ class BarplotTest < Test::Unit::TestCase
       end
     end
 
+    sub_test_case("with invalid arguments") do
+      test("unknown border type") do
+        assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+          UnicodePlot.barplot(data: {bar: 23, foo: 37}, border: :invalid_border_name)
+        end
+      end
+    end
+
     test("colored") do
       data = { bar: 23, foo: 37 }
       plot = UnicodePlot.barplot(data: data)

data/test/test-boxplot.rb

@@ -3,6 +3,14 @@ class BoxplotTest < Test::Unit::TestCase
   include Helper::WithTerm
 
   sub_test_case("UnicodePlot.boxplot") do
+    sub_test_case("with invalid arguments") do
+      test("unknown border type") do
+        assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+          UnicodePlot.boxplot([1, 2, 3, 4, 5], border: :invalid_border_name)
+        end
+      end
+    end
+
     sub_test_case("print to tty") do
       test("without name") do
         plot = UnicodePlot.boxplot([1, 2, 3, 4, 5])

data/test/test-canvas.rb

@@ -6,7 +6,8 @@ module CanvasTestCases
     ascii: UnicodePlot::AsciiCanvas,
     braille: UnicodePlot::BrailleCanvas,
     density: UnicodePlot::DensityCanvas,
-    dot: UnicodePlot::DotCanvas
+    dot: UnicodePlot::DotCanvas,
+    block: UnicodePlot::BlockCanvas
   }.freeze
 
   def self.included(mod)
@@ -54,11 +55,11 @@ module CanvasTestCases
 
       test("empty") do
         if self.class::CANVAS_NAME == :braille
-          _, output = with_term { @canvas.show($stdout) }
+          _, output = with_term { @canvas.show(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/empty_braille_show.txt").read,
                        output)
         else
-          _, output = with_term { @canvas.show($stdout) }
+          _, output = with_term { @canvas.show(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/empty_show.txt").read,
                        output)
         end
@@ -80,31 +81,31 @@ module CanvasTestCases
         end
 
         test("print_row") do
-          _, output = with_term { @canvas.print_row($stdout, 2) }
+          _, output = with_term { @canvas.print_row(UnicodePlot::IOContext.new($stdout), 2) }
           assert_equal(fixture_path("canvas/#{self.class::CANVAS_NAME}_printrow.txt").read,
                        output)
         end
 
         test("print") do
-          _, output = with_term { @canvas.print($stdout) }
+          _, output = with_term { @canvas.print(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/#{self.class::CANVAS_NAME}_print.txt").read,
                        output)
         end
 
         test("print_nocolor") do
-          _, output = with_term(false) { @canvas.print($stdout) }
+          _, output = with_term(false) { @canvas.print(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/#{self.class::CANVAS_NAME}_print_nocolor.txt").read,
                        output)
         end
 
         test("sow") do
-          _, output = with_term { @canvas.show($stdout) }
+          _, output = with_term { @canvas.show(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/#{self.class::CANVAS_NAME}_show.txt").read,
                        output)
         end
 
         test("show_nocolor") do
-          _, output = with_term(false) { @canvas.show($stdout) }
+          _, output = with_term(false) { @canvas.show(UnicodePlot::IOContext.new($stdout)) }
           assert_equal(fixture_path("canvas/#{self.class::CANVAS_NAME}_show_nocolor.txt").read,
                        output)
         end
@@ -136,3 +137,9 @@ class DotCanvasTest < Test::Unit::TestCase
 
   include CanvasTestCases
 end
+
+class BlockCanvasTest < Test::Unit::TestCase
+  CANVAS_NAME = :block
+
+  include CanvasTestCases
+end

data/test/test-densityplot.rb

@@ -10,6 +10,14 @@ class DensityplotTest < Test::Unit::TestCase
     assert_equal(1000, @dy.length)
   end
 
+  sub_test_case("with invalid arguments") do
+    test("unknown border type") do
+      assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+        UnicodePlot.densityplot(@dx, @dy, border: :invalid_border_name)
+      end
+    end
+  end
+
   test("default") do
     plot = UnicodePlot.densityplot(@dx, @dy)
     dx2 = @dx.map {|x| x + 2 }

data/test/test-histogram.rb

@@ -7,6 +7,14 @@ class HistogramTest < Test::Unit::TestCase
       @x = fixture_path("randn.txt").read.lines.map(&:to_f)
     end
 
+    sub_test_case("with invalid arguments") do
+      test("unknown border type") do
+        assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+          UnicodePlot.histogram(@x, border: :invalid_border_name)
+        end
+      end
+    end
+
     test("default") do
       plot = UnicodePlot.histogram(@x)
       _, output = with_term { plot.render($stdout) }

data/test/test-lineplot.rb

@@ -23,6 +23,14 @@ class LineplotTest < Test::Unit::TestCase
       assert_raise(ArgumentError) { UnicodePlot.lineplot(1..3, 1..2) }
     end
 
+    sub_test_case("with invalid arguments") do
+      test("unknown border type") do
+        assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+          UnicodePlot.lineplot(@x, @y, border: :invalid_border_name)
+        end
+      end
+    end
+
     sub_test_case("with numeric array") do
       test("default") do
         plot = UnicodePlot.lineplot(@x, @y)
@@ -192,8 +200,84 @@ class LineplotTest < Test::Unit::TestCase
                    output)
     end
 
+    test("fixed line y-interpolation bug (issue 32)") do
+      ys = [261, 272, 277, 283, 289, 294, 298, 305, 309, 314, 319, 320, 322, 323, 324]
+      xs = ys.size.times.to_a
+      plot = UnicodePlot.lineplot(xs, ys, height: 26, ylim: [0, 700])
+      _, output = with_term { plot.render($stdout, newline: false) }
+      assert_equal(fixture_path("lineplot/issue32_fix.txt").read,
+                   output)
+    end
+
     # TODO: functions
 
-    # TODO: stairs
+    sub_test_case("stairs") do
+      def setup
+        @sx = [1, 2, 4, 7, 8]
+        @sy = [1, 3, 4, 2, 7]
+      end
+
+      test("pre") do
+        plot = UnicodePlot.stairs(@sx, @sy, style: :pre)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_pre.txt").read, output)
+      end
+
+      test("post") do
+        # inferred post
+        plot = UnicodePlot.stairs(@sx, @sy)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_post.txt").read, output)
+        # explicit post
+        plot = UnicodePlot.stairs(@sx, @sy, style: :post)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_post.txt").read, output)
+      end
+
+      test("with parameters") do
+        plot = UnicodePlot.stairs(@sx, @sy, title: "Foo", color: :red, xlabel: "x", name: "1")
+        sx2 = @sx.map { |val| val - 0.2 }
+        sy2 = @sy.map { |val| val + 1.5 }
+        plot2 = UnicodePlot.stairs!(plot, sx2, sy2, name: "2")
+        assert_equal(plot.class, plot2.class)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_parameters.txt").read, output)
+
+        # add a 3rd staircase and check again
+        plot3 = UnicodePlot.stairs!(plot, @sx, @sy, name: "3", style: :pre)
+        assert_equal(plot.class, plot3.class)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_parameters2.txt").read, output)
+
+        # check with color disabled
+        output = StringIO.open do |sio|
+          plot.render(sio)
+          sio.close
+          sio.string
+        end
+        assert_equal("\n", output[-1])
+        assert_equal(fixture_path("lineplot/stairs_parameters2_nocolor.txt").read,
+                     output.chomp)
+      end
+
+      test("special weird case") do
+        plot = UnicodePlot.stairs(@sx, [1, 3, 4, 2, 7000])
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/stairs_edgecase.txt").read, output)
+      end
+
+      test("annotations") do
+        plot = UnicodePlot.stairs(@sx, @sy, width: 10, padding: 3)
+        plot.annotate!(:tl, "Hello")
+        plot.annotate!(:t, "how are")
+        plot.annotate!(:tr, "you?")
+        plot.annotate!(:bl, "Hello")
+        plot.annotate!(:b, "how are")
+        plot.annotate!(:br, "you?")
+        UnicodePlot.lineplot!(plot, 1, 0.5)
+        _, output = with_term { plot.render($stdout, newline: false) }
+        assert_equal(fixture_path("lineplot/squeeze_annotations.txt").read, output)
+      end
+    end
   end
 end

data/test/test-plot.rb

@@ -1,6 +1,8 @@
 require 'stringio'
 
 class TestPlot < Test::Unit::TestCase
+  include Helper::WithTerm
+
   sub_test_case("#render") do
     test("render to $stdout when no arguments") do
       sio = StringIO.new
@@ -16,5 +18,19 @@ class TestPlot < Test::Unit::TestCase
         $stdout = save_stdout
       end
     end
+
+    test("color: true") do
+      _, tty_output   = with_sio(tty: true)  {|sio| UnicodePlot.barplot(data: {a: 23, b: 37}).render(sio) }
+      _, notty_output = with_sio(tty: false) {|sio| UnicodePlot.barplot(data: {a: 23, b: 37}).render(sio, color: true) }
+
+      assert_equal(tty_output, notty_output)
+    end
+
+    test("color: false") do
+      _, tty_output   = with_sio(tty: true)  {|sio| UnicodePlot.barplot(data: {a: 23, b: 37}).render(sio, color: false) }
+      _, notty_output = with_sio(tty: false) {|sio| UnicodePlot.barplot(data: {a: 23, b: 37}).render(sio) }
+
+      assert_equal(tty_output, notty_output)
+    end
   end
 end

data/test/test-scatterplot.rb

@@ -22,6 +22,14 @@ class ScatterplotTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case("with invalid arguments") do
+    test("unknown border type") do
+      assert_raise(ArgumentError.new("unknown border type: invalid_border_name")) do
+        UnicodePlot.scatterplot(@x, @y, border: :invalid_border_name)
+      end
+    end
+  end
+
   test("default") do
     plot = UnicodePlot.scatterplot(@x, @y)
     _, output = with_term { plot.render($stdout, newline: false) }

data/test/test-stemplot.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+class HistogramTest < Test::Unit::TestCase
+  include Helper::Fixture
+  include Helper::WithTerm
+
+  sub_test_case("UnicodePlot.stemplot") do
+    def setup
+      @randoms = fixture_path("randn.txt").read.lines.take(50).map(&:to_f)
+      
+      @int80a = [40, 53, 33, 8, 30, 78, 68, 63, 80, 75, 73, 75, 61, 24, 84, 84, 51, 31, 94, 63, 72, 9, 80, 1, 84, 1, 13, 55, 46, 41, 99, 100, 39, 41, 10, 70, 67, 21, 50, 41, 49, 24, 32, 42, 32, 37, 44, 10, 48, 64, 41, 46, 94, 15, 15, 5, 6, 97, 48, 14, 2, 92, 10, 2, 91, 89, 20, 98, 19, 66, 43, 95, 90, 34, 71, 42, 31, 92, 95, 30]
+      
+      @int80b = [23, 24, 70, 61, 26, 57, 28, 18, 69, 53, 92, 11, 33, 38, 85, 58, 38, 27, 14, 62, 57, 38, 91, 11, 66, 23, 63, 28, 98, 9, 53, 26, 1, 93, 96, 49, 8, 89, 19, 18, 68, 51, 4, 57, 79, 90, 72, 99, 41, 57, 100, 94, 5, 13, 24, 76, 5, 60, 26, 41, 89, 99, 22, 81, 41, 48, 65, 67, 38, 53, 96, 85, 75, 89, 35, 75, 88, 50, 14, 33]
+      
+      @int300 = [-30, -7, 37, -42, -15, 8, 62, 22, -3, -32, -35, -48, -29, 8, -75, 27, 84, 81, -21, 9, 23, 86, -30, 29, 47, 89, -3, 38, 22, 31, 49, 84, -5, -28, -26, -66, 68, 59, -92, -3, -23, 100, -73, 19, -37, 89, -21, 23, 71, 14, -98, 49, -3, -1, -8, 67, -55, -30, -55, 93, 69, -20, -79, -91, -23, -46, 84, -49, -12, 35, -74, -2, -84, -34, -28, 98, -70, -72, 71, 86, 24, 64, -99, -76, -37, 54, 53, 72, -31, -53, 85, 10, -17, -8, -35, -16, -3, 26, 68, -92, 20, -70, 87, -78, 95, -88, -85, -7, 67, -47, -46, 0, -24, -48, 53, -53, -26, 79, -51, -40, -95, -37, 44, 77, -66, 85, 14, 5, -25, -85, -54, -17, -94, -52, -75, -79, 79, -53, -16, -27, -43, -94, -66, -56, -47, -56, -21, 7, 73, -19, 87, -64, -46, -81, 19, -13, -44, -87, -22, 18, 54, -9, 84, 50, 85, 62, 8, 99, -94, -65, 59, 93, 84, 16, 82, -16, 77, 55, -63, -13, -34, -77, 55, 87, -99, -82, 9, 73, 75, -94, -6, 9, 89, 27, 70, 56, -38, -67, -46, 59, 91, -26, 30, -81, -6, -29, -66, 25, 17, -25, -9, -90, 20, -71, 1, -47, -76, 39, -29, -19, -45, 91, -92, -6, -59, 34, 51, -61, -41, -90, 77, 83, -83, -25, -29, -64, 16, -91, -14, 7, -71, -57, -71, 76, -9, -43, -89, 86, 56, 56, 27, 3, -5, 13, -99, 13, -97, -68, 94, -15, 6, -8, -28, -52, 38, -96, -54, 13, -36, 78, -24, 32, 96, -57, -56, -27, -79, -73, -18, 44, -48, -65, -4, 80, -69, -26, -38, 66, 62, 65, -83, -100, -37, 1, -99, 75, 33, 19, 0, -70]
+      
+      @words_1 = %w[apple junk ant age bee bar baz dog egg a]
+      @words_2 = %w[ape flan can cat juice elf gnome child fruit]
+      
+    end
+
+    test("range input") do
+      _, output = with_term { UnicodePlot.stemplot(-100..100) }
+      assert_equal(fixture_path("stemplot/range.txt").read, output)
+    end
+
+    test("positive integers") do
+      _, output = with_term { UnicodePlot.stemplot(@int80a) }
+      assert_equal(fixture_path("stemplot/pos_ints.txt").read, output)
+    end
+    
+    test("with happy divider") do
+      _, output = with_term { UnicodePlot.stemplot(@int80a, divider:  "😄") }
+      assert_equal(fixture_path("stemplot/ints_divider.txt").read, output)
+    end
+
+    test("positive and negative integers") do
+      _, output = with_term { UnicodePlot.stemplot(@int300) }
+      assert_equal(fixture_path("stemplot/posneg_ints.txt").read, output)
+    end
+
+    test("floats") do
+      x10 = @randoms.map {|a| a * 10 }
+      #p x10.sort
+      #UnicodePlot.stemplot(x10)
+      _, output = with_term { UnicodePlot.stemplot(x10) }
+      assert_equal(fixture_path("stemplot/float.txt").read, output)
+    end
+
+    
+    test("floats, scale=1") do
+      floats = (-8..8).to_a.map { |a| a / 2.0 }
+      _, output = with_term { UnicodePlot.stemplot(floats, scale: 1) }
+      assert_equal(fixture_path("stemplot/float_scale1.txt").read, output)
+    end
+
+
+    test("back-to-back stemplot with integers") do
+      _, output = with_term { UnicodePlot.stemplot(@int80a, @int80b) }
+      assert_equal(fixture_path("stemplot/b2b_integers.txt").read, output)
+    end
+
+    test("stemplot with strings") do
+      _, output = with_term { UnicodePlot.stemplot(@words_1) }
+      assert_equal(fixture_path("stemplot/strings.txt").read, output)
+    end
+
+    test("back-to-back stemplot with strings") do
+      _, output = with_term { UnicodePlot.stemplot(@words_1, @words_2) }
+      assert_equal(fixture_path("stemplot/b2b_strings.txt").read, output)
+    end
+
+    test("stemplot with strings, two-char scale") do
+      _, output = with_term {  UnicodePlot.stemplot(@words_1, scale: 100, trim: true) }
+      assert_equal(fixture_path("stemplot/strings_2c.txt").read, output)
+    end
+
+    test("stemplot with strings, two-char scale, string_padchar") do
+      _, output = with_term {  UnicodePlot.stemplot(@words_1, string_padchar: '?') }
+      assert_equal(fixture_path("stemplot/strings_pad.txt").read, output)
+    end
+
+    test("string stemplot cannot take scale less than 10") do
+      assert_raise(ArgumentError) do
+        UnicodePlot.stemplot(@words_1, scale: 9)
+      end
+    end
+
+    test("cannot mix string/number in back to back stemplot") do
+      assert_raise(ArgumentError) do
+        UnicodePlot.stemplot(@words_1, @int80a)
+      end
+    end
+
+  end
+end

data/test/test-utils.rb

@@ -0,0 +1,13 @@
+class UnicodePlotTest < Test::Unit::TestCase
+  test("UnicodePlot.canvas_types") do
+    available_canvas_types = [:ascii, :block, :braille, :density, :dot]
+    assert_equal(available_canvas_types.sort,
+                 UnicodePlot.canvas_types.sort)
+  end
+
+  test("UnicodePlot.border_types") do
+    available_border_types = [:solid, :corners, :barplot]
+    assert_equal(available_border_types.sort,
+                 UnicodePlot.border_types.sort)
+  end
+end