drawille 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDIyMDkxN2Y3YmYxYWEzMDMwZDBlNGQ5MDE1MzAyZTM5MWNlZDZjMA==
+    Yjk3ZmI2NzE4YzNjYzM0ZWEyYjJjNDU2OWY0NDhmY2VjNzRlMGVlNQ==
   data.tar.gz: !binary |-
-    Y2VmODE0YmRhMzZmNzI1NGZmOTAwNmUxODEzNDM0MTQwNDcwY2NiMQ==
+    NDVmZWMzYzY1MjA5YWE1ZjlkZWY1YzM1ODhiMzljMWI4NzhiNWQzOA==
 SHA512:
   metadata.gz: !binary |-
-    ZGYxYTk4OTQyZWIzYzRlMzBmNjhhMjdjZDc1OTdlMzZmN2IzYTNkNzE5NTI5
-    MGUwMjc1NjU1OGY2ZGEzNWFlNGEzNzliY2U2NjY3MmI0MDNjNWFkZGRlODg5
-    YzZlOTlhMzRkODZmZjY1M2VjODY1MmMzMzQ3ZTNjZDRhMDE1NWM=
+    MjJkZTdjM2I1MTZlYTZlYWI1ZTM5Zjk0Zjc1YTkzZmExODEwZTUyZWU5N2Jm
+    MjYxYTAyNmFlOWY3YTVmMTIyN2NlMDFlNzhiMjEyODczZjEyOTRmY2JjYjI5
+    M2YxOWZkYmNjNmM3MmRlMjU3MDAwMTJkNWY4ZTdiZWJlY2I1NzM=
   data.tar.gz: !binary |-
-    MjJhOGU4MjJkMGQ1NmMyMDkzNDViYjY1Mjc0MjlhZDc3ODk1YWVkZWIzYmNl
-    YWViOTc3ODZmYWIzMWZmNDliY2EwM2UzODE2YjY4MzgxMWM0ZjE1Yzk0N2Rl
-    MDdmYjhkY2RmYjg0ZGFkMjY1MTJkOGQxYzNjM2MzMzk1YjlhY2Q=
+    MDg3NjU4OTNmOTdkNzdlNmU4ODY5ODQwNWE1OTYyZWEzNzE4NTkzZmRmNTIy
+    NGFiODE4OTkxN2YyZTNmMjc0MjdkZDdiNDY3ZWYxMTc3MzhjMzFlN2YyYjc1
+    OWEwZWM5ZTg0MTM5ZTgwMDA3ODcyMDJjOGJkYWFmYzNkZWQ2Yjg=

data/README.md

@@ -1,7 +1,7 @@
 RUBY-DRAWILLE
 ========
 
-Drawing in terminal with Unicode [Braille][] characters. Implementation based on [drawille][] by @asciimoo.
+Draw in your terminal with Unicode [Braille][] characters. Implementation based on [drawille][] by @asciimoo.
 
 [Braille]: http://en.wikipedia.org/wiki/Braille
 [Drawille]: https://github.com/asciimoo/drawille
@@ -23,6 +23,8 @@ 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:
+
 ```ruby
 c = Drawille::Canvas.new
 
@@ -33,10 +35,116 @@ end
 puts c.frame
 ```
 
-## Contributing
+![Sinus](docs/images/sinus.gif)
+
+This implementation also includes a Turtle graphics API for all your beloved fractals. See this simple example:
+
+```ruby
+require 'drawille'
+
+canvas = Drawille::Canvas.new
+
+frame = canvas.paint do
+  move 300, 300
+  down
+
+  36.times do
+    right 10
+    36.times do
+      right 10
+      forward 8
+    end
+  end
+
+end.frame
+
+puts frame
+```
+
+![MN-gon](docs/images/mn-gon.gif)
+
+### Turtle-API
+
+```ruby
+  canvas = Drawille::Canvas.new
+  canvas.paint do
+    # Move your brush with the following commands
+  end
+``` 
+
+``forward 10`` or ``fw 10``
+
+Moves your brush in the current direction (default is 0 which points to the right). Please note that your brush has to be set down to actually draw. 
+
+``back 10`` or ``bk 10``
+
+Moves your brush in the opposite direction. Please note that your brush has to be set down to actually draw. 
+
+``right 90`` or ``rt 90``
+
+Turn the direction of the brush by 90 degrees to the right.
+
+``left 90`` or ``lt 90``
+
+Turn the direction of the brush by 90 degrees to the left.
+
+``up`` or ``pu``
+
+Sets the brush up which means all following operations will have no effect on the canvas itself.
+
+``down`` or ``pd``
+
+Sets the drush down which means that moving the brush will draw a stroke.
+
+``move 100, 100`` or ``mv 100, 100``
+
+Moves the brush to the position ``x=100`` and ``y=100``.
+
+``line from: [30, 20], to: [100, 100]``
+
+A line between the two given points will be drawn. The movement to the starting point will be with an ``up`` brush, but the former state of the brush will be restored after this line.
+
+### ``Drawille::Canvas`` API
+
+``#set(x, y)`` / ``#[x, y] = true``
+
+Sets the state of the given position to ``true``, i.e. the ``#frame`` method will render a point at ``[x,y]``.
+
+``#unset(x, y)`` / ``#[x, y] = false``
+
+Sets the state of the given position to ``false``, i.e. the ``#frame`` method will _not_ render a point at ``[x,y]``.
+
+``#toggle(x, y)``
+
+Toggles the state of the given position.
+
+``#clear``
+
+No point will be rendered by the ``#frame`` method.
+
+``#frame``
+
+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.
+
+## License
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/examples/mn-gon.rb

@@ -0,0 +1,19 @@
+require 'drawille'
+
+c = Drawille::Canvas.new
+
+frame = c.paint do
+  move 300, 300
+  down
+
+  36.times do
+    right 10
+    36.times do
+      right 10
+      forward 8
+    end
+  end
+
+end.frame
+
+puts frame

data/lib/drawille.rb

@@ -1,89 +1,5 @@
 # -*- encoding: utf-8 -*-
 require "drawille/version"
 
-module Drawille
-
-  class Canvas
-
-    attr_reader :chars
-
-    PIXEL_MAP = [[0x01, 0x08], 
-                 [0x02, 0x10], 
-                 [0x04, 0x20], 
-                 [0x40, 0x80]]
-
-    BRAILLE_CHAR_OFFSET = 0x2800
-
-    def initialize 
-      clear
-    end
-
-    def clear
-      @chars = Hash.new { |h,v| h[v] = Hash.new(0) }
-    end
-
-    def set x, y
-      x, y, px, py = convert x, y
-      @chars[py][px] |= PIXEL_MAP[y % 4][x % 2]
-    end
-
-    def unset x, y
-      x, y, px, py = convert x, y
-      @chars[py][px] &= ~PIXEL_MAP[y % 4][x % 2]
-    end
-
-    def get x, y
-      x, y, px, py = convert x, y
-      @chars[py][px] & PIXEL_MAP[y % 4][x % 2] != 0
-    end
-
-    def []= x, y, bool
-      bool ? set(x, y) : unset(x, y)
-    end
-
-    alias_method :[], :get
-
-    def toggle x, y
-      x, y, px, py = convert x, y
-      @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
-
-      (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
-      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
+require "drawille/canvas"
+require "drawille/brush"

data/lib/drawille/brush.rb

@@ -0,0 +1,91 @@
+# -*- encoding: utf-8 -*-
+
+module Drawille
+
+  class Brush
+
+    attr_accessor :canvas
+
+    def initialize canvas
+      @canvas = canvas
+      @state  = {
+        x:        0, 
+        y:        0,
+        up:       true,
+        rotation: 0
+      }
+    end
+
+    def down
+      @state[:up] = false
+    end
+
+    def up
+      @state[:up] = true
+    end
+
+    def forward length
+      theta = ((@state[:rotation]) / 180.0 * Math::PI)
+      x     = @state[:x] + length * Math::cos(theta)
+      y     = @state[:y] + length * Math::sin(theta)
+
+      move x, y
+    end
+
+    def back length
+      forward -length
+    end
+
+    def right angle
+      @state[:rotation] += angle
+    end
+
+    def left angle
+      @state[:rotation] -= angle
+    end
+
+    def move x, y
+      unless @state[:up]
+        x1 = @state[:x].round
+        y1 = @state[:y].round
+        x2 = x
+        y2 = y
+
+        xdiff = [x1, x2].max - [x1, x2].min
+        ydiff = [y1, y2].max - [y1, y2].min
+
+        xdir = x1 <= x2 ? 1 : -1
+        ydir = y1 <= y2 ? 1 : -1
+
+        r = [xdiff, ydiff].max
+
+        (0..r).each do |i|
+          x, y = x1, y1
+          y += (i.to_f*ydiff)/r*ydir if ydiff > 0
+          x += (i.to_f*xdiff)/r*xdir if xdiff > 0
+          @canvas.set(x, y)
+        end
+      end
+      @state[:x], @state[:y] = x, y
+    end
+
+    def line coordinates={}
+      last_state = @state[:up]
+
+      up
+      move *coordinates[:from]
+      down
+      move *coordinates[:to]
+
+      @state[:up] = last_state
+    end
+
+    alias_method :fd, :forward
+    alias_method :bk, :back
+    alias_method :rt, :right
+    alias_method :lt, :left
+    alias_method :pu, :up
+    alias_method :pd, :down
+    alias_method :mv, :move
+  end
+end

data/lib/drawille/canvas.rb

@@ -0,0 +1,91 @@
+# -*- encoding: utf-8 -*-
+
+module Drawille
+
+  class Canvas
+
+    attr_reader :chars
+
+    PIXEL_MAP = [[0x01, 0x08], 
+      [0x02, 0x10], 
+      [0x04, 0x20], 
+      [0x40, 0x80]]
+
+    BRAILLE_CHAR_OFFSET = 0x2800
+
+    def initialize 
+      clear
+    end
+
+    def paint &block
+      Brush.new(self).instance_eval(&block)
+      self
+    end
+
+    def clear
+      @chars = Hash.new { |h,v| h[v] = Hash.new(0) }
+    end
+
+    def set x, y
+      x, y, px, py = convert x, y
+      @chars[py][px] |= PIXEL_MAP[y % 4][x % 2]
+    end
+
+    def unset x, y
+      x, y, px, py = convert x, y
+      @chars[py][px] &= ~PIXEL_MAP[y % 4][x % 2]
+    end
+
+    def get x, y
+      x, y, px, py = convert x, y
+      @chars[py][px] & PIXEL_MAP[y % 4][x % 2] != 0
+    end
+
+    def []= x, y, bool
+      bool ? set(x, y) : unset(x, y)
+    end
+
+    alias_method :[], :get
+
+    def toggle x, y
+      x, y, px, py = convert x, y
+      @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
+
+      (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
+      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/version.rb

@@ -1,3 +1,3 @@
 module Drawille
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: drawille
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Marcin Skirzynski
@@ -35,8 +35,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/images/mn-gon.gif
+- docs/images/sinus.gif
 - drawille.gemspec
+- examples/mn-gon.rb
 - lib/drawille.rb
+- lib/drawille/brush.rb
+- lib/drawille/canvas.rb
 - lib/drawille/version.rb
 - spec/drawille_spec.rb
 - spec/sinus.dat