drawille 0.2.1 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWEzYWU1YjkwZTI1ODNiYjI1NzI4ZmZhZDRhZmE0Yjc5YmNiMmEzYQ==
+    YTlkNzYwOGIzNmE2NjEyZGE0ZWVhZjUzNGU2NmQwNjA0NDkwYTRjMA==
   data.tar.gz: !binary |-
-    YjNiYWIzN2U3OWJiNmY4OTYzMjFjMmQ4YzdlMzkwNjYwZWQwN2Q5OA==
+    YzYxODM4YjM2ZTQ1NjZlM2IxMDhlYjIwMGVlNDM3NmQ3YzQ0NWYxNg==
 SHA512:
   metadata.gz: !binary |-
-    MGY4YWRiMzRmNjc2YjUzMTUzNmM4MzYyNTdiOTdhOTYyMzM2MjhlZDlkMzc5
-    NjIzZDEyMzVjYjVmNjkwN2RhNjQ5NTRiMjJkMzUwZTBmZWFmYzg0N2FlYTA4
-    ZjhjZmYzYjVlZGM2YmNiYjdkZjljN2JkZjAyN2NkMmVhMmMzMGI=
+    OGJlODI1MzQwZWQxYTI5NDhhYzI2MGNhNDRiNThkZGMyNjczMDY0N2FkZGY1
+    MjE4MTZjZDFlYjE4MGZkYTI3MDhiYWZlNjI4MTZlNGM4OWI0ZGJlNzQ0ZGRh
+    NmI3YmU0MDNjZTVmZWVmMTNiNjc5Nzc5NGIwMWU5NTcxZDRhMmI=
   data.tar.gz: !binary |-
-    YTNjMjM1ZjExY2Y1ODQ3NDVmNDRlZDBlNDMzMGVjNjdiZTUzMGQ2YWU3ZmE0
-    NDFiMGNkYzdkOWRhZThlN2JmN2MxNjhhYjIyNjA4MjFmMTZmZTMzM2M1MTU5
-    YWVhN2ExZTI5Yjc5NzhmYzhlYmViZjQxMjIwYzk0MGM0ZTJkNjU=
+    NDM2YzY4NjEwMjM5NjliYjc2MjI2ZDY0YmI0OTI2MGQ0ZTI1NzRjZGUyZDQ0
+    NTM4YjZiMzEyOTg3NjBlNjBkZmQ4YzZjMmU1NDNlODMxMjc1Zjg2OGVmYTQz
+    ZWQ0MTA0MzAwOTNlZjQ5MTNhYTE1ZGVkMWJhMDg1ZDQ4NGI1MWI=

data/README.md

@@ -1,5 +1,6 @@
-RUBY-DRAWILLE
+Drawille for Ruby
 ========
+[![Gem Version](https://badge.fury.io/rb/drawille.svg)](http://badge.fury.io/rb/drawille)
 
 Draw in your terminal with Unicode [Braille][] characters. Implementation based on [drawille][] by @asciimoo.
 
@@ -23,7 +24,7 @@ Or install it yourself as:
 
 ## Usage
 
-Drawille can be used like the Python implementation due to the similar API. Here is on of its examples:
+Drawille can be used like the Python implementation due to the similar API. Here is one of its examples:
 
 ```ruby
 require 'drawille'
@@ -68,7 +69,7 @@ puts canvas.frame
 
 ![Stencil](docs/images/stencil.gif)
 
-This implementation also includes a Turtle graphics API for all your beloved fractals. See this simple example:
+This implementation also includes a [Turtle graphics](http://en.wikipedia.org/wiki/Turtle_graphics) API for all your beloved fractals:
 
 ```ruby
 require 'drawille'
@@ -157,6 +158,40 @@ No point will be rendered by the ``#frame`` method.
 
 Returns newline-delimited string of the given canvas state. Braille characters are used to represent points. Please note that a single character contains 2 x 4 pixels.
 
+### Flip-book
+
+```ruby
+c = Drawille::Canvas.new
+f = Drawille::FlipBook.new
+
+c.paint do
+  move 200, 100
+  down
+
+  36.times do
+    right 10
+    36.times do
+      right 10
+      forward 8
+    end
+    f.snapshot canvas
+  end
+
+end
+
+f.play repeat: true, fps: 6
+``` 
+
+With the flip-book it is possible to create and play animations. Just draw on the canvas as usual and create a snapshot for every frame you want to be included in the animation.
+
+``FlipBook#snapshot canvas``
+
+Saves a snapshot of the current state of the canvas.
+
+``FlipBook#snapshot#play``
+
+Will render the animation on the terminal. The method also takes an option hash with the options ``:repeat`` ``:fps``.
+
 ## License
 
 MIT License

data/drawille.gemspec

@@ -17,5 +17,6 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_dependency 'curses'
   gem.add_development_dependency 'rspec'
 end

data/lib/drawille.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 require "drawille/version"
 
+require 'drawille/frameable'
 require "drawille/canvas"
 require "drawille/brush"
+require "drawille/flipbook"

data/lib/drawille/brush.rb

@@ -26,8 +26,8 @@ module Drawille
 
     def forward length
       theta = ((@state[:rotation]) / 180.0 * Math::PI)
-      x     = @state[:x] + length * Math::cos(theta)
-      y     = @state[:y] + length * Math::sin(theta)
+      x     = (@state[:x] + length * Math::cos(theta)).round
+      y     = (@state[:y] + length * Math::sin(theta)).round
 
       move x, y
     end

data/lib/drawille/canvas.rb

@@ -1,20 +1,14 @@
 # -*- encoding: utf-8 -*-
-
 module Drawille
 
   class Canvas
+    include Frameable
 
     attr_reader :chars
 
-    PIXEL_MAP = [[0x01, 0x08], 
-      [0x02, 0x10], 
-      [0x04, 0x20], 
-      [0x40, 0x80]]
-
-    BRAILLE_CHAR_OFFSET = 0x2800
-
     def initialize 
       clear
+      @snapshots = [{}]
     end
 
     def paint &block
@@ -52,41 +46,10 @@ module Drawille
       @chars[py][px] & PIXEL_MAP[y % 4][x % 2] == 0 ? set(x, y) : unset(x, y) 
     end
 
-    def row y, options={}
-      row   = @chars[y]
-      min   = options[:min_x] || row.keys.min
-      max   = options[:max_x] || row.keys.max
-      return "" if min.nil? || max.nil?
-      (min..max).reduce("") { |memo, i| memo << to_braille(row[i] || 0) }
-    end
-
-    def rows options={}
-      min   = options[:min_y] || @chars.keys.min
-      max   = options[:max_y] || @chars.keys.max
-      return [] if min.nil? || max.nil?
-      options[:min_x] ||= @chars.reduce([]) { |m,x| m << x.last.keys }.flatten.min
-      options[:max_x] ||= @chars.reduce([]) { |m,x| m << x.last.keys }.flatten.max
-      (min..max).map { |i| row i, options }
-    end
-
-    def frame options={}
-      rows(options).join("\n")
-    end
-
-    def char x, y
-      to_braille @chars[y][x]
-    end
-
-    private
-
     def convert x, y
       x = x.round
       y = y.round
       [x, y, (x / 2).floor, (y / 4).floor]
     end
-
-    def to_braille x
-      [BRAILLE_CHAR_OFFSET + x].pack("U*")
-    end
   end
 end

data/lib/drawille/flipbook.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+require 'curses'
+
+module Drawille
+
+  class FlipBook
+    include Frameable
+
+    def initialize
+      clear
+    end
+
+    def clear
+      @snapshots = []
+      @chars     = {}
+    end
+
+    def snapshot canvas
+      @snapshots << canvas.frame
+      @chars     =  canvas.chars
+    end
+
+    def each_frame options={}
+      return enum_for(:each_frame) unless block_given?
+      @snapshots.each do |frame|
+        yield frame
+      end
+    end
+
+    def play options={}
+      options = {
+        repeat: false, fps: 6,
+        min_x: 0, min_y: 0
+      }.merge(options)
+
+      Curses::init_screen
+      begin
+        Curses::crmode
+        Curses::curs_set 0
+        repeat options do
+          each_frame options do |frame|
+            Curses::setpos(0, 0)
+            Curses::addstr(frame)
+            Curses::refresh
+            sleep(1.0/options[:fps])
+          end
+        end
+      ensure
+        Curses::close_screen
+      end
+    end
+
+    def repeat options
+      options[:repeat] ? loop { yield; clear_screen options } : yield
+    end
+
+    private
+
+    def clear_screen options
+      Curses::clear
+      Curses::refresh
+    end
+  end
+end

data/lib/drawille/frameable.rb

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+
+module Drawille
+
+  module Frameable
+
+    PIXEL_MAP = [[0x01, 0x08], 
+      [0x02, 0x10], 
+      [0x04, 0x20], 
+      [0x40, 0x80]]
+
+    BRAILLE_CHAR_OFFSET = 0x2800
+
+    def row y, options={}
+      chars = options[:chars] || @chars
+      row   = chars[y]
+      min   = options[:min_x]
+      max   = options[:max_x]
+      return "" if min.nil? || max.nil?
+      (min..max).reduce("") { |memo, i| memo << to_braille(row.nil? ? 0 : row[i] || 0) }
+    end
+
+    def rows options={}
+      chars = options[:chars] || @chars
+      min   = options[:min_y] || [chars.keys.min, 0].min
+      max   = options[:max_y] ||  chars.keys.max
+      return [] if min.nil? || max.nil?
+      options[:min_x] ||= [chars.reduce([]) { |m,x| m << x.last.keys }.flatten.min, 0].min
+      options[:max_x] ||=  chars.reduce([]) { |m,x| m << x.last.keys }.flatten.max
+      (min..max).map { |i| row i, options }
+    end
+
+    def frame options={}
+      rows(options).join("\n")
+    end
+
+    def char x, y
+      to_braille @chars[y][x]
+    end
+
+    def to_braille x
+      [BRAILLE_CHAR_OFFSET + x].pack("U*")
+    end
+  end
+end

data/lib/drawille/version.rb

@@ -1,3 +1,3 @@
 module Drawille
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/drawille_spec.rb

@@ -1,8 +1,10 @@
 # -*- encoding: utf-8 -*-
 require 'spec_helper'
 
-describe Drawille do
-  subject { Drawille::Canvas.new }
+include Drawille
+
+describe Canvas do
+  subject(:canvas) { Canvas.new }
 
   describe '#set' do
     it 'sets pixel in the first char in the first row' do
@@ -20,76 +22,76 @@ describe Drawille do
 
   describe "#unset" do
     it 'sets and unsets a pixel' do
-      subject.set(0, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE[0]
-      subject.unset(0, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE.last
+      canvas.set(0, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE[0]
+      canvas.unset(0, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
     end
 
     it 'sets four pixel but only unsets one' do
-      subject.set(0, 0)
-      subject.set(0, 1)
-      subject.set(1, 0)
-      subject.set(1, 1)
-      expect(subject.char(0, 0)).to eq BRAILLE[3]
-      subject.unset(1, 1)
-      expect(subject.char(0, 0)).to eq BRAILLE[2]
+      canvas.set(0, 0)
+      canvas.set(0, 1)
+      canvas.set(1, 0)
+      canvas.set(1, 1)
+      expect(canvas.char(0, 0)).to eq BRAILLE[3]
+      canvas.unset(1, 1)
+      expect(canvas.char(0, 0)).to eq BRAILLE[2]
     end
   end
 
   describe "#get" do
     it 'returns the state of a pixel' do
-      subject.set(1, 1)
-      expect(subject.get(0, 0)).to eq false
-      expect(subject.get(1, 1)).to eq true
+      canvas.set(1, 1)
+      expect(canvas.get(0, 0)).to eq false
+      expect(canvas.get(1, 1)).to eq true
     end
   end
 
   describe "#toggle" do
     it 'toggles a pixel' do
-      subject.toggle(0, 0)
-      subject.toggle(1, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE[1]
-      subject.toggle(1, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE[0]
-      subject.toggle(0, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE.last
+      canvas.toggle(0, 0)
+      canvas.toggle(1, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE[1]
+      canvas.toggle(1, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE[0]
+      canvas.toggle(0, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
     end
   end
 
   describe "#clear" do
     it 'clears the canvas' do
-      subject.set(0, 0)
-      subject.set(2, 0)
-      expect(subject.char(0, 0)).to eq BRAILLE[0]
-      expect(subject.char(1, 0)).to eq BRAILLE[0]
-      subject.clear
-      expect(subject.char(0, 0)).to eq BRAILLE.last
-      expect(subject.char(1, 0)).to eq BRAILLE.last
+      canvas.set(0, 0)
+      canvas.set(2, 0)
+      expect(canvas.char(0, 0)).to eq BRAILLE[0]
+      expect(canvas.char(1, 0)).to eq BRAILLE[0]
+      canvas.clear
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
+      expect(canvas.char(1, 0)).to eq BRAILLE.last
     end
   end
 
   describe '#[]' do
     it 'works with alternate syntax' do
-      subject[0, 0] = true
-      expect(subject.char(0, 0)).to eq BRAILLE[0]
-      expect(subject[0, 0]).to eq true
-      expect(subject[1, 0]).to eq false
-      subject[0, 0] = false
-      expect(subject.char(0, 0)).to eq BRAILLE.last
-      expect(subject[0, 0]).to eq false
+      canvas[0, 0] = true
+      expect(canvas.char(0, 0)).to eq BRAILLE[0]
+      expect(canvas[0, 0]).to eq true
+      expect(canvas[1, 0]).to eq false
+      canvas[0, 0] = false
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
+      expect(canvas[0, 0]).to eq false
     end
   end
 
   describe "#rows" do
     it 'has over 9 columns and 3 rows' do
-      subject.set(0,  1)
-      subject.set(4,  4)
-      subject.set(8,  5)
-      subject.set(16, 8)
+      canvas.set(0,  1)
+      canvas.set(4,  4)
+      canvas.set(8,  5)
+      canvas.set(16, 8)
 
-      expect(subject.rows.size).to eq 3
-      subject.rows.each do |row|
+      expect(canvas.rows.size).to eq 3
+      canvas.rows.each do |row|
         expect(row.length).to eq 9
       end
     end
@@ -98,19 +100,214 @@ describe Drawille do
   describe "#frame" do
     it 'prints a happy sinus' do
       (0..1800).step(10).each do |x| 
-          subject.set(x/10, 10 + Math.sin(x * Math::PI / 180) * 10) 
+          canvas.set(x/10, 10 + Math.sin(x * Math::PI / 180) * 10) 
       end
-      expect(subject.frame).to eq IO.read("spec/sinus.dat")
+      expect(canvas.frame).to eq IO.read("spec/sinus.dat")
     end
 
     it 'does not throw an exception on an empty canvas' do
-      subject.frame
+      canvas.frame
     end
 
     it 'is an empty frame for an empty canvas' do
-      expect(subject.rows.size).to eq 0
-      expect(subject.frame).to eq ""
+      expect(canvas.rows.size).to eq 0
+      expect(canvas.frame).to eq ""
+    end
+  end
+end
+
+describe Brush do
+  subject(:canvas) { Canvas.new }
+  subject(:brush)  { Brush.new(canvas) }
+
+  describe "#up" do
+    it 'is up by default' do
+      brush.forward 40
+      expect(canvas.rows.size).to eq 0
+    end
+
+    it 'does not draw anymore after putting brush up' do
+      brush.down
+      brush.forward 1
+      brush.up
+      brush.forward 2
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE[1]
+    end
+  end
+
+  describe "#down" do
+    it "draws if brush is put down" do
+      brush.down
+      brush.forward 1
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE[1]
+    end
+  end
+
+  describe "#forward" do
+    it 'moves to the right without changing the direction' do
+      brush.down
+      brush.forward 3
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size).to eq 2
+      expect(canvas.char(0, 0)).to eq BRAILLE[1]
+      expect(canvas.char(1, 0)).to eq BRAILLE[1]
+    end
+  end
+
+  describe "#back" do
+    it 'moves backward without drawing' do
+      brush.forward 10
+      brush.back 10
+      expect(canvas.rows.size).to eq 0
+    end
+
+    it 'moves backward with drawing' do
+      brush.forward 9
+      brush.down
+      brush.back 9
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size). to eq 5
+      5.times do |i|
+        expect(canvas.char(i, 0)).to eq BRAILLE[1]
+      end
+    end
+  end
+
+  describe "#right" do
+    it 'changes the direction' do
+      brush.down
+      brush.forward 1
+      brush.right 90
+      brush.forward 3
+      brush.right 90
+      brush.forward 1
+      brush.right 90
+      brush.forward 3
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE[-2]
+    end
+  end
+
+  describe "#left" do
+    it 'changes the direction' do
+      brush.move 0, 3
+      brush.down
+      brush.down
+      brush.forward 1
+      brush.left 90
+      brush.forward 3
+      brush.left 90
+      brush.forward 1
+      brush.left 90
+      brush.forward 3
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.rows[0].size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE[-2]
+    end
+  end
+
+  describe "#move" do
+    it 'moves and does not draw a line' do
+      brush.move 200, 200
+      expect(canvas.rows.size).to eq 0
+    end
+
+    it 'moves and does draw a line' do
+      brush.down
+      brush.move 99, 0
+      brush.up
+      brush.move 99, 4
+      brush.down
+      brush.move  0, 4
+      expect(canvas.rows.size).to eq 2
+      expect(canvas.rows[0].size).to eq 50
+      50.times do |i|
+        expect(canvas.char(i, 0)).to eq BRAILLE[1]
+        expect(canvas.char(i, 1)).to eq BRAILLE[1]
+      end
+    end
+  end
+
+  describe "#line" do
+    it 'should draw a line regardless of the brush state' do
+      brush.line from: [2, 0], to: [5, 0]
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
+      expect(canvas.char(1, 0)).to eq BRAILLE[1]
+      expect(canvas.char(2, 0)).to eq BRAILLE[1]
+    end
+
+    it 'should not draw with the move to the beginning of the line' do
+      brush.down
+      brush.line from: [2, 0], to: [5, 0]
+      expect(canvas.rows.size).to eq 1
+      expect(canvas.char(0, 0)).to eq BRAILLE.last
+      expect(canvas.char(1, 0)).to eq BRAILLE[1]
+      expect(canvas.char(2, 0)).to eq BRAILLE[1]
     end
   end
 end
 
+describe FlipBook do
+  subject(:canvas)   { Canvas.new }
+  subject(:flipbook) { FlipBook.new }
+
+  describe "#each_frame" do
+    it 'yields four frames' do
+      canvas.set(0, 0)
+      flipbook.snapshot canvas
+      canvas.set(1, 0)
+      flipbook.snapshot canvas
+      canvas.set(0, 1)
+      flipbook.snapshot canvas
+      canvas.set(1, 1)
+      flipbook.snapshot canvas
+
+      i = 0
+      flipbook.each_frame do |frame|
+        expect(frame).to eq BRAILLE[i]
+        i += 1
+      end
+    end
+
+    it 'yields multiline frames' do
+      canvas.set(0, 0)
+      flipbook.snapshot canvas
+      canvas.set(0, 4)
+      flipbook.snapshot canvas
+
+      expect(flipbook.rows.size).to eq 2
+      expect(flipbook.char(0, 0)).to eq BRAILLE[0]
+      expect(flipbook.char(0, 1)).to eq BRAILLE[0]
+    end
+
+    it 'yields the same frame twice' do
+      canvas.set(0, 0)
+      flipbook.snapshot canvas
+      canvas.set(1, 0)
+      flipbook.snapshot canvas
+      2.times do
+        i = 0
+        flipbook.each_frame do |frame|
+          expect(frame).to eq BRAILLE[i]
+          i += 1
+        end
+      end
+    end
+
+    it 'returns an enumerator without a block given' do
+      canvas.set(0, 0)
+      flipbook.snapshot canvas
+      canvas.set(1, 0)
+      flipbook.snapshot canvas
+      flipbook.each_frame.with_index do |frame, i|
+        expect(frame).to eq BRAILLE[i]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -7,8 +7,8 @@ def set_and_check_char px_range, py_range, cx, cy
   i = 0
   py_range.each do |y|
     px_range.each do |x|
-      subject.set(x, y)
-      expect(subject.char(cx, cy)).to eq BRAILLE[i]
+      canvas.set(x, y)
+      expect(canvas.char(cx, cy)).to eq BRAILLE[i]
       i += 1
     end
   end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: drawille
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Marcin Skirzynski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -46,6 +60,8 @@ files:
 - lib/drawille.rb
 - lib/drawille/brush.rb
 - lib/drawille/canvas.rb
+- lib/drawille/flipbook.rb
+- lib/drawille/frameable.rb
 - lib/drawille/version.rb
 - spec/drawille_spec.rb
 - spec/sinus.dat