rubytext 0.0.54 → 0.0.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfca6da2edf0b5606c68ff215ad0b4cfa94eed796e9174f30db8e4a452e2f46e
-  data.tar.gz: 742f9c6bff9adaf73632a539125c6b724d7281869b4d497617e27acacaa4ad49
+  metadata.gz: 5e76b63a284c3e46a82ebdbffe93539688f3e05e5ba07c3bcd1b3134a8e4e3f6
+  data.tar.gz: ec46b8c22012c818b4d920758e7dee6e07fdc10aa791a987293cadb011f8e3a0
 SHA512:
-  metadata.gz: f4569c3d19ade57d06e46d37f30830a3e9ae5642f0217bb4213cd5d2188ab9e572ef5a515807d5884c516a70c5e0abd648fb29808c5039ecdd43ac168346d898
-  data.tar.gz: 612624e6134a8342d584d09ea0c79f34671cfabbd21431276965f4977de50dd0561135d6dd08831abbd21fdc09ce13a64dd0d30b8b272d0737ed628d3bc8767b
+  metadata.gz: ffe47e4511c9a9156fb6c0e93853b3bfa83f9c8b48c76db46f42eabb8f849227aa25a0c682231948eca23f0150602f6122db7d7a37914d1a1378b05d8d386529
+  data.tar.gz: 38bd6f8a6757d99f292dcd2731d0bd57d3275047aca5aadf5977c47b30b9f771912f648847594933c23a637b99c8175630191b1f9423177459a85908ca1c5da7

data/README.md

@@ -43,7 +43,7 @@ directory and the `showme.rb` script.
 
 A simple window:
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(6, 25, 2, 34, 
                       # 6 rows, 25 cols; upper left at 2,4
                       fg: Blue, bg: White) # foreground, background
@@ -53,7 +53,7 @@ win.puts "This is a window..."
 
 How `output` works. This name may change.
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(9, 36, 2, 6, fg: White, bg: Red) 
 
 win.output do
@@ -65,7 +65,7 @@ end
 
 Windows are bordered by default.
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(9, 35, 3, 7, border: false, fg: Black, bg: Green)
 
 win.puts "A window doesn't have to"
@@ -74,7 +74,7 @@ win.puts "have a border."
 
 Using `puts` will wrap around the window automagically.
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(8, 39, 4, 9, fg: Black, bg: Blue)
 
 win.puts "If your text is longer than " +
@@ -86,7 +86,7 @@ win.puts "Scrolling is not yet supported."
 
 Scrolling is not yet implemented.
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(10, 70, 2, 14, fg: Yellow, bg: Black)
 
 win.output do
@@ -103,7 +103,7 @@ end
 
 You can use `print` and `p` as well as `puts`.
 ```ruby
-require 'rubytext`
+require 'rubytext'
 win = RubyText.window(10, 60, 2, 14, fg: Blue, bg: Black)
 
 win.output do
@@ -119,5 +119,277 @@ win.output do
 end
 ```
 
+You can still use `puts` (etc.) with files, but watch for `STDOUT` and `STDERR`.
+```ruby
+require 'rubytext'
+win = RubyText.window(10, 50, 0, 5, fg: Yellow, bg: Blue)
+
+win.output do
+  puts "Of course, #puts and #print are unaffected \nfor other receivers."
+
+  out = File.new("/tmp/junk", "w")
+  out.puts "Nothing to see here."
+  sleep 2
+
+  print "\nHowever, if you print to STDOUT or STDERR \nwithout redirection, "
+  STDOUT.print "you will have some "
+  STDERR.print "unexpected/undefined results "
+  puts " in more ways than one."
+end
+
+```
+
+Use `[]=` to stuff single characters into a window (like an array).
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 50, 0, 5, fg: Yellow, bg: Blue)
+
+win.puts "We can use the []= method (0-based)"
+win.puts "to address individual window locations"
+win.puts "and place characters there.\n "
+
+sleep 2
+win[4,22] = "X"; win.refresh
+
+sleep 2
+win[8,20] = "y"; win.refresh
+
+sleep 2
+win[6,38] = "Z"; win.refresh
+```
+
+Likewise use `[]` to retrieve characters from a window.
+```ruby
+require 'rubytext'
+win = RubyText.window(12, 60, 2, 5, fg: Yellow, bg: Blue)
+
+win.puts "ABCDE    Method [] can retrieve characters "
+win.puts "FGHIJ    from a window."
+win.puts "KLMNO\nPQRST\nUVWZYZ"
+win.puts
+
+sleep 2
+win.puts "(2,2) => '#{win[2,2]}'    (0,4)  => '#{win[0,4]}'"
+win.puts "(6,7) => '#{win[6,7]}'    (0,15) => '#{win[0,15]}'"
+```
+
+You can write to `STDSCR` or to a subwindow.
+```ruby
+require 'rubytext'
+win = RubyText.window(6, 30, 2, 5, fg: Yellow, bg: Blue)
+
+win.puts "You can write to a window..."
+
+sleep 2
+9.times { STDSCR.puts }
+STDSCR.puts "...or you can write to STDSCR (standard screen)"
+
+sleep 1
+puts "STDSCR is the default receiver."
+
+sleep 2
+STDSCR.go 5, 0
+puts "Nothing stops you from overwriting a window."
+
+```
+
+You can retrieve cursor position and window size.
+```ruby
+require 'rubytext'
+win = RubyText.window(12, 65, 1, 5, fg: Yellow, bg: Blue)
+
+win.output do
+  puts "You can detect the size and cursor position of any window."
+  puts "\nSTDSCR is #{STDSCR.rows} rows by #{STDSCR.cols} columns"
+  puts "win is     #{win.rows} rows by #{win.cols} columns"
+  puts "\nSlightly Heisenbergian report of cursor position:"
+  puts "  STDSCR.rc = #{STDSCR.rc.inspect}\n  win.rc    = #{win.rc.inspect}"
+  puts "\nFor fun, I'll print \"ABC\" to STDSCR..."
+  sleep 2
+  STDSCR.print "ABC"
+end
+```
+
+Move the cursor with `go` (and use a block to jump/return).
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 65, 0, 15, fg: Blue, bg: Black)
+
+win.puts "The #go method will move the cursor to a specific location."
+win.go 2, 5
+win.puts "x  <-- The x is at 2,5"
+
+win.puts "\nWith a block, it will execute the block and then"
+win.puts "return to its previous location."
+
+win.print "\n   ABC..."
+sleep 2
+win.go(8, 20) { win.print "XYZ" }
+sleep 2
+win.print "DEF"
+```
+
+Use `rcprint` to print at specific coordinates.
+```ruby
+require 'rubytext'
+win = RubyText.window(13, 65, 0, 6, fg: Blue, bg: White)
+
+win.puts "The #rcprint method will print at the specified"
+win.puts "row/column, like go(r,c) followed by a print,"
+win.puts "except that it does NOT move the cursor."
+
+win.rcprint 4,8,  "Simplify,"
+win.rcprint 6,12, "simplify,"
+win.rcprint 8,16, "simplify!"
+
+win.rcprint 10,0, "Later there will be other ways to do this kind of thing."
+```
+
+Window navigation: `home`, `up`, `down`, `left`, `right`
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 65, 0, 6, fg: Blue, bg: White)
+
+win.go 2,0
+win.puts "   Method #home will home the cursor..."
+win.puts "   and #putch will put a character at the current location."
+sleep 2
+win.home; win.putch "H"; sleep 2
+win.rcprint 4,3, "We can also move up/down/left/right..."; sleep 2
+
+win.go 7, 29;            win.putch("+"); sleep 1
+win.go 7, 29; win.up;    win.putch("U"); sleep 1
+win.go 7, 29; win.down;  win.putch("D"); sleep 1
+win.go 7, 29; win.left;  win.putch("L"); sleep 1
+win.go 7, 29; win.right; win.putch("R"); sleep 1
+```
+
+More navigation: `up`, `down`, `left`, `right` with a parameter.
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 65, 1, 6, fg: Blue, bg: White)
+
+win.puts "Methods up/down/left/right can also take an integer..."
+
+win.go 4, 29;               win.putch("+"); sleep 1
+win.go 4, 29; win.up(2);    win.putch("2"); sleep 1
+win.go 4, 29; win.down(3);  win.putch("3"); sleep 1
+win.go 4, 29; win.left(4);  win.putch("4"); sleep 1
+win.go 4, 29; win.right(5); win.putch("5"); sleep 1
+```
+
+Still more navigation: `up!`, `down!`, `left!`, `right!`
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 65, 1, 6, fg: Blue, bg: White)
+
+win.go 2,0
+win.puts "We also have: up!, down!, left!, and right! which can" 
+win.puts "Take us to the edges of the window."
+
+win.go 5, 21;             win.putch("+"); sleep 1
+win.go 5, 21; win.up!;    win.putch("U"); sleep 1
+win.go 5, 21; win.down!;  win.putch("D"); sleep 1
+win.go 5, 21; win.left!;  win.putch("L"); sleep 1
+win.go 5, 21; win.right!; win.putch("R"); sleep 1
+```
+
+And finally, `top` and `bottom`.
+```ruby
+require 'rubytext'
+win = RubyText.window(11, 65, 1, 6, fg: Blue, bg: White)
+
+win.go 2,0
+win.puts "#top and #bottom are the same as #up! and #down!"
+
+win.go 5, 21;             win.putch("+"); sleep 1
+win.go 5, 21; win.top;    win.putch("T"); sleep 1
+win.go 5, 21; win.bottom; win.putch("B"); sleep 1
+```
+
+Somewhat useless, but there is a `center` method.
+```ruby
+require 'rubytext'
+win = RubyText.window(15, 65, 1, 6, fg: Green, bg: Blue)
+
+win.puts "#center will print text centered on the current row"
+win.puts "and do an implicit CRLF at the end.\n "
+
+stuff = ["I","can","never","imagine","good sets","of real words",
+         "which can somehow", "produce tree shapes", "|", "|"]
+
+stuff.each {|str| win.center(str) }
+
+```
+
+Changing colors during printing. This syntax will change.
+```ruby
+require 'rubytext'
+win = RubyText.window(12, 65, 0, 6, fg: Green, bg: Blue)
+
+win.puts "This is EXPERIMENTAL."
+win.puts "Use a color symbol to change text color temporarily:\n "
+
+win.puts "This is", :yellow, " another color", :white, " and yet another."
+win.puts "And this is normal again.\n "
+
+win.puts "This does mean that you can't print a symbol that is"
+win.puts "also a color name... you'd need a workaround.\n "
+
+sym = :red
+win.puts "The symbol is ", sym.inspect, " which works", sym, " just fine."
+```
+
+A simple menu (incomplete, still experimental).
+```ruby
+require 'rubytext'
+puts "This very crude menu is also EXPERIMENTAL."
+puts "At the moment, it only works inside STDSCR!\n"
+puts "It knows up, down, Enter, and Escape.\n "
+puts "Press any key to display the menu..."
+getch
+
+days = %w[Monday Tuesday Wednesday Thursday Friday]
+num, day = RubyText.menu(c: 30, items: days)
+
+puts
+if day.nil?
+  puts "You picked nothing!"
+else
+  puts "You picked item #{num} which is #{day.inspect}"
+end
+```
+
+DESC
+```ruby
+require 'rubytext'
+```
+
+A marquee or ticker example. This uses threads and is kind of cool.
+```ruby
+require 'rubytext'
+msg = <<~EOS
+ A "ticker" example that actually uses threads. Maybe Curses is not as slow as 
+ you thought? PRESS ANY KEY TO EXIT...
+EOS
+
+w, h = STDSCR.cols, STDSCR.rows - 1
+threads = []
+
+r = RubyText
+t1 = -> { r.ticker(text: msg, row: h-8, col: 20, width: w-40, delay: 0.02, fg: Red, bg: Black) }
+t2 = -> { r.ticker(text: msg, row: h-6, col: 15, width: w-30, delay: 0.04) }
+t3 = -> { r.ticker(text: msg, row: h-4, col: 10, width: w-20, delay: 0.06, fg: Black, bg: Green) }
+t4 = -> { r.ticker(text: msg, row: h-2, col:  5, width: w-10, delay: 0.08, bg: Black) }
+t5 = -> { r.ticker(text: msg) }  # All defaults -- goes at bottom
+
+threads << Thread.new { t1.call } << Thread.new { t2.call } << Thread.new { t3.call } << 
+           Thread.new { t4.call } << Thread.new { t5.call }
+
+threads << Thread.new { getch; exit }   # quitter thread...
+threads.each {|t| t.join } 
+```
+
+
 *More later...*
 

data/lib/version.rb

@@ -1,6 +1,6 @@
 
 module RubyText
-  VERSION = "0.0.54"
+  VERSION = "0.0.55"
 
   Path  = File.expand_path(File.join(File.dirname(__FILE__)))
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubytext
 version: !ruby/object:Gem::Version
-  version: 0.0.54
+  version: 0.0.55
 platform: ruby
 authors:
 - Hal Fulton