vedeu 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 395f38280fc3c3c2c08cd35934211d1bf5f2f088
-  data.tar.gz: 56e22bfd0a48a8afed5d95577db5d556207f394e
+  metadata.gz: 8d097569d9ae161024a467480aee254bf3ea16db
+  data.tar.gz: a1f6e430f3a22d102ede5020716dc16a932126ce
 SHA512:
-  metadata.gz: 358f6eb1e2c13a9e3c6ff57db89165c9799a5b5df066251cf1437443897d210435f08abed2f4a582d7d15b66cef4d0bd0bbfa4c382e1ccb4f631c23afe2542ee
-  data.tar.gz: 34dcb6740bdae17988a112977b1b795fb455a926e474e53e41be69b2d30f11396b02333648afe7508a400da5257257a64b2ee963ef79b1f077f1a6297c5be12f
+  metadata.gz: ae5f70b23729b9eb744efac5ed4fcc8182ad9c4738b29b914cfb892a4d15ef83fcb5d04960955f3e8c01979990bf043aa229df1b6e89522260a1e82ccab23645
+  data.tar.gz: af4164804508dd1dc6cc58c2faf5f2e6248de9d31b62bab1d7fb6c70c0f8fbff09848071a08598280fadfcdc471d58550f45ed051fa6f859dd8da7e2da2b8bf2

data/LICENSE.txt

@@ -1,4 +1,6 @@
 Copyright (c) 2014 Gavin Laking
+Copyright (c) 2013 Steve Klabnik - Monologger
+                   (https://github.com/steveklabnik/mono_logger)
 
 MIT License
 

data/README.md

@@ -1,5 +1,6 @@
 [![Code Climate](https://codeclimate.com/github/gavinlaking/vedeu.png)](https://codeclimate.com/github/gavinlaking/vedeu)
 [![Build Status](https://travis-ci.org/gavinlaking/vedeu.svg?branch=master)](https://travis-ci.org/gavinlaking/vedeu)
+[![Inline docs](http://inch-ci.org/github/gavinlaking/vedeu.svg?branch=master)](http://inch-ci.org/github/gavinlaking/vedeu)
 
 # Vedeu
 
@@ -26,7 +27,7 @@ And then execute:
 
 ## Example
 
-Have a look at: https://github.com/gavinlaking/playa
+Have a look at: [Playa](https://github.com/gavinlaking/playa). Please browse the source of Playa and Vedeu to get a feel for how it all works. The [RubyDoc](http://rubydoc.info/github/gavinlaking/vedeu/master/frames) may also help!
 
 
 ## Usage
@@ -35,81 +36,79 @@ Expect proper documentation soon!
 
 ### Getting Started
 
-    require 'vedeu'
-
-    class MyApp
-      include Vedeu
-
-      interface 'main' do
-        ...
-      end
-
-      event :some_event do
-        # ...
-      end
-
-      event :other_event do |hash_args, array_args, args|
-        # ...
-      end
-
-      event :key do |key|
-        case key
-        when 'a' then puts "Apple"
-        when 'b' then puts "Banana"
-        # ...
-        when :f1 then trigger(:some_event)
-        when :f2 then
-          trigger(:other_event, { args: here }, [:or, :here], :etc)
-        end
-      end
-    end
+The basic mechanics of a Vedeu app are outlined below:
+
+```ruby
+require 'vedeu'
+
+class MyApp
+  include Vedeu
 
+  interface 'main' do
+    ...
+  end
 
-### Building Views
+  event :some_event do
+    # ...
+  end
+
+  event :other_event do |hash_args, array_args, args|
+    # ...
+  end
+
+  event :key do |key|
+    case key
+    when 'a' then puts "Apple"
+    when 'b' then puts "Banana"
+    # ...
+    when :f1 then trigger(:some_event)
+    when :f2 then
+      trigger(:other_event, { args: here }, [:or, :here], :etc)
+    end
+  end
+end
+```
+
+### Building Interfaces & Views
 
 Views with Vedeu are made up of simple building blocks. These blocks can be arranged in a multitude of ways which I hope is more than sufficient for your design needs.
 
-- Interfaces (`Interface`) are made up of lines. (`Line`)
-- Lines are made up of zero, one or multiple streams. (`Stream`)
+- A view (`Composition`) is made up of one or more interfaces.
+- An interface is an area on the screen where you can take input or direct output. You will define it's colour and style, its dimensions, including position and give it a name. You can then direct the output of a command, or event, to this interface and Vedeu will ensure the content is placed there.
+- Interfaces (`Interface`) are made up of lines (`Line`), their length being the width of the interface and their number being the height of the interface.
+- An interface with `width: 12, height: 5` will have five lines, each made of 12 characters- providing 60 cells. Colours and styles are handled by terminal escape sequences and therefore do not consume a cell.
+- Lines are made up of zero, one or multiple streams (`Stream`) which are basically subsets of the line.
 - An interface, line or stream can have a colour (`colour`) attribute.
 - An interface, line or stream can have a style (`style`) attribute.
 - Interfaces have a position (`y`, `x`) on the screen, and a size. (`width`, `height`)
-- Interfaces can be placed relative to each other based on their attributes. (`top`, `right`, `bottom`, `left`)
+- Interfaces can be placed relative to each other based on their attributes.
+    - An interface has a `top`, `right`, `bottom`, `left`.
+    - An interface also has a `north` and `west` (`top` and `left` minus 1 respectively).
+    - An interface also has a `south` and `east` (`bottom` and `right` plus 1 respectively).
 - Colours are defined in CSS-style values, i.e. `#ff0000` would be red.
 - Styles are named. See the table below for supported styles.
 
 
-### Some Terms
-
-To understand how Vedeu works, you need to familiarise yourself with some terms.
-
-  - Interface: This is an area on the screen where you can take input or direct output. You will define it's colour and style, its dimensions, including position and give it a name. You can then direct the output of a command to this interface and Vedeu will ensure the content is placed there.
-
-  - Line: An interface is composed of many lines. Their length being the width of the interface and their number being the height of the interface.
-
-  An interface with `width: 12, height: 5` will have five lines, each made of 12 characters.
-
-  - Stream: A stream is a subset of a line. Having streams basically allow us to apply styles and colours to part of a line; their not necessary, but provide you with greater flexibility for your output.
-
-
 ### On Defining Interfaces
 
-    interface 'main' do
-      y      1
-      x      1
-      width  10 # see notes below
-      height 10
-      colour foreground: '#ffffff', background: '#000000'
-      cursor false
-    end
+```ruby
+interface 'main' do
+  y      1
+  x      1
+  width  10 # see notes below
+  height 10
+  colour foreground: '#ffffff', background: '#000000'
+  cursor false
+end
+```
 
 Referring to the above example, interfaces have a name, and various default attributes.
 
 - `y`          sets the starting row point. (See Geometry)
 - `x`          sets the starting column point.
 
-- `width`      sets character width of the interface
-- `height`     sets character height of the interface
+- `width`      sets the character width of the interface
+- `height`     sets the character height of the interface
 
 Note: not setting a width or height will set the values to the terminal's reported width and height.
 
@@ -120,18 +119,22 @@ Note: not setting a width or height will set the values to the terminal's report
 
 ### On Defining Events
 
-    event :event_name do |arg1, arg2|
-    end
+```ruby
+event :event_name do |arg1, arg2|
+end
+```
 
 One can define events which perform work or trigger other events. Vedeu has built-in events which are namespaced with underscores:
 
 - `:_initialize_` Special event which Vedeu triggers when it is ready to enter the main loop. Client applications can listen for this event and perform some action(s), like render the first screen, interface or make a sound.
 
+- `:_cleanup_` This event is fired by Vedeu when `:_exit_` is triggered. You can hook into this to perform a special action before the application terminates. Saving the user's work, session or preferences might be popular here.
+
 - `:_clear_` Clears the whole terminal space.
 
-- `:_exit_` when triggered, Vedeu will attempt to exit.
+- `:_exit_` when triggered, Vedeu will trigger a `:_cleanup_` event which you can define (to save files, etc) and attempt to exit.
 
-- `:_keypress_` triggering this event will cause the triggering of the `key` event; which you should define to 'do things'. If the `escape` key is pressed, then `key` is triggered with the argument `:escape`, also an internal event `_mode_switch_` is triggered.
+- `:_keypress_` triggering this event will cause the triggering of the `:key` event; which you should define to 'do things'. If the `escape` key is pressed, then `key` is triggered with the argument `:escape`, also an internal event `_mode_switch_` is triggered.
 
 - `:_mode_switch_` when triggered (after the user presses `escape`), Vedeu switches from a "raw mode" terminal to a "cooked mode" terminal. The idea here being that the raw mode is for single keypress actions, whilst cooked mode allows the user to enter more elaborate commands- such as commands with arguments.
 
@@ -141,59 +144,74 @@ One can define events which perform work or trigger other events. Vedeu has buil
 
 - `:_refresh_(interface_name)_` will refresh the interface with this name. E.g. `_refresh_widget_` will refresh the interface `widget`.
 
-Note: Overriding or adding additional events to the Vedeu event namespace may cause unpredictable results.
+Note: Overriding or adding additional events to the Vedeu event namespace may cause unpredictable results. It is recommended to only to hook into events like :_cleanup_, :_initialize_ and :key if you need to do something respective to those events.
 
 
 ### Geometry
 
-Geometry for Vedeu, as the same for ANSI terminals, is set top-left, which is point 1, 1. Interfaces have internal geometry which is handled automatically. Unless you are doing something special, you will probably only set it on a per-interface basis.
+Geometry for Vedeu, as the same for ANSI terminals, is set top-left, which is cell/point 1, 1. Interfaces themselves have internal geometry which is handled automatically. Unless you are doing something special, you will probably only set it on a per-interface basis.
 
 
 ### Colours
 
-Vedeu uses HTML/CSS style notation (i.e. '#aadd00'), they can be used at the stream level, the line level or for the whole interface.
+Vedeu uses HTML/CSS style notation (i.e. '#aadd00'), they can be used at the stream level, the line level or for the whole interface. Terminals generally support either 8, 16 or 256 colours, with few supporting full 24-bit colour. Vedeu attempts to detect the colour depth using the `$TERM` environment variable.
+
+To set your `$TERM` variable to allow 256 colour support:
 
-    "colour": { "foreground": "#ff0000", "background": "#ffffff" }
+```bash
+echo "export TERM=xterm-256color" >> ~/.bashrc
+```
+
+or, if you wish not to tamper with `$TERM`:
+
+```bash
+echo "export VEDEUTERM=xterm-256color" >> ~/.bashrc
+```
+
+If you know your terminal supports full 24-bit colour, set the `$VEDEUTERM` environment variable:
+
+```bash
+echo "export VEDEUTERM=xterm-truecolor" >> ~/.bashrc
+```
 
 
 ### Styles
 
-Vedeu has a range of symbol styles which are compatible with most terminals which are ANSI compatible.
-
-    "style": []
-
-Like colours, they can be defined in either interfaces, for specific lines or within streams. Styles are applied as encountered.
-
-| Style name    | Escape Sequence               |
-|---------------|-------------------------------|
-| bg_reset      | `\e[48;2;49m`                 |
-| blink         | `\e[5m`                       |
-| blink_off     | `\e[25m`                      |
-| bold          | `\e[1m`                       |
-| bold_off      | `\e[21m`                      |
-| clear         | `\e[2J`                       |
-| clear_line    | `\e[38;2;39m\e[48;2;49m\e[2K` |
-| colour_reset  | `\e[38;2;39m\e[48;2;49m`      |
-| fg_reset      | `\e[38;2;39m`                 |
-| hide_cursor   | `\e[?25l`                     |
-| negative      | `\e[7m`                       |
-| positive      | `\e[27m`                      |
-| reset         | `\e[0m`                       |
-| normal        | `\e[24m\e[21m\e[27m`          |
-| dim           | `\e[2m`                       |
-| show_cursor   | `\e[?25h`                     |
-| underline     | `\e[4m`                       |
-| underline_off | `\e[24m`                      |
-
-
-## Contributing
-
-1. Fork it ( http://github.com/gavinlaking/vedeu/fork )
+Vedeu has a range of symbol styles which are compatible with most terminals which are ANSI compatible. Like colours, they can be defined in either interfaces, for specific lines or within streams. Styles are applied as encountered.
+
+
+## Development / Contributing
+
+* Documentation hosted at [RubyDoc](http://rubydoc.info/github/gavinlaking/vedeu/master/frames).
+* Source hosted at [GitHub](https://github.com/gavinlaking/vedeu).
+
+Pull requests are very welcome! Please try to follow these simple rules if applicable:
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well tested.
+* Update the [Yard](http://yardoc.org/) documentation.
+* Update the [README](https://github.com/gavinlaking/vedeu/blob/master/README.md).
+* Please **do not change** the version number.
+
+
+### General contribution help
+
+1. Fork it ([https://github.com/gavinlaking/vedeu/fork](https://github.com/gavinlaking/vedeu/fork))
 2. Clone it
 3. `bundle`
-4. `rake` or `bundle exec guard`
+4. `rake` (runs all tests and coverage report) or `bundle exec guard`
 5. Create your feature branch (`git checkout -b my-new-feature`)
-6. Write some tests, write some code, have some fun
+6. Write some tests, write some code, have some fun!
 7. Commit your changes (`git commit -am 'Add some feature'`)
 8. Push to the branch (`git push origin my-new-feature`)
-9. Create a new pull request
+9. Create a new pull request.
+
+
+## Author & Contributors
+
+[Gavin Laking](https://github.com/gavinlaking) ([@gavinlaking](http://twitter.com/gavinlaking))
+
+
+### Contributors
+
+[https://github.com/gavinlaking/vedeu/graphs/contributors](https://github.com/gavinlaking/vedeu/graphs/contributors)

data/lib/vedeu.rb

@@ -1,5 +1,11 @@
 module Vedeu
 
+  EntityNotFound = Class.new(StandardError)
+  GroupNotFound  = Class.new(StandardError)
+  ModeSwitch     = Class.new(StandardError)
+  NotImplemented = Class.new(StandardError)
+  OutOfRange     = Class.new(StandardError)
+
   def self.included(receiver)
     receiver.send(:include, API)
     receiver.extend(API)
@@ -13,38 +19,45 @@ require 'io/console'
 require 'logger'
 require 'optparse'
 
-require 'vedeu/models/attributes/attributes'
+require 'vedeu/configuration'
+
+require 'vedeu/models/attributes/coercions'
 require 'vedeu/models/attributes/colour_translator'
+require 'vedeu/models/attributes/background'
+require 'vedeu/models/attributes/foreground'
+require 'vedeu/models/attributes/presentation'
 require 'vedeu/models/composition'
 require 'vedeu/support/terminal'
 require 'vedeu/models/geometry'
 require 'vedeu/models/colour'
+require 'vedeu/models/style'
 require 'vedeu/models/interface'
 require 'vedeu/models/line'
-require 'vedeu/models/store'
 require 'vedeu/models/stream'
 
 require 'vedeu/api/api'
 require 'vedeu/api/composition'
-require 'vedeu/api/events'
-require 'vedeu/api/grid'
 require 'vedeu/api/helpers'
 require 'vedeu/api/interface'
 require 'vedeu/api/line'
-require 'vedeu/api/log'
 require 'vedeu/api/stream'
 
 require 'vedeu/application'
-require 'vedeu/configuration'
 require 'vedeu/launcher'
 
-require 'vedeu/output/buffers'
-require 'vedeu/output/clear'
-require 'vedeu/output/render'
-require 'vedeu/output/view'
-
+require 'vedeu/support/focus'
+require 'vedeu/support/groups'
+require 'vedeu/support/buffers'
+require 'vedeu/support/clear'
+require 'vedeu/support/render'
+require 'vedeu/support/view'
 require 'vedeu/support/buffer'
 require 'vedeu/support/position'
 require 'vedeu/support/esc'
+require 'vedeu/support/event'
+require 'vedeu/support/events'
+require 'vedeu/support/grid'
 require 'vedeu/support/input'
+require 'vedeu/support/log'
 require 'vedeu/support/menu'
+require 'vedeu/support/trace'

data/lib/vedeu/api/api.rb

@@ -1,94 +1,235 @@
 module Vedeu
   module API
-    # @param name  [Symbol] The name of the event which will be triggered later
-    # @param delay [Fixnum|Float] Limits the execution of the triggered event to
-    #   the delay in seconds, effectively throttling the event. A delay of 1.0
-    #   will mean that even if the event is triggered multiple times a second
-    #   it will only execute once for that second. Triggers inside the delay are
-    #   discarded.
+
+    # Register an event by name with optional delay (throttling) which when
+    # triggered will execute the code contained within the passed block.
+    #
+    # @param name  [Symbol] The name of the event which will be triggered later.
+    # @param [Hash] opts The options to register the event with.
+    # @option opts :delay [Fixnum|Float] Limits the execution of the
+    #   triggered event to only execute when first triggered, with subsequent
+    #   triggering being ignored until the delay has expired.
+    # @option opts :debounce [Fixnum|Float] Limits the execution of the
+    #   triggered event to only execute once the debounce has expired.
+    #   Subsequent triggers before debounce expiry are ignored.
     # @param block [Proc] The event to be executed when triggered. This block
     #   could be a method call, or the triggering of another event, or sequence
     #   of either/both.
-    def event(name, delay = 0, &block)
-      Vedeu.events.event(name, delay, &block)
+    #
+    # @example
+    #   Vedeu.event :my_event do |some, args|
+    #     ... some code here ...
+    #
+    #     Vedeu.trigger(:my_other_event)
+    #   end
+    #
+    #   T = Triggered, X = Executed, I = Ignored.
+    #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6...
+    #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T
+    #   .X...I...I...I...I...X...I...I...I...I...X...I...I...I...I...I...I...I
+    #
+    #   Vedeu.event(:my_delayed_event, { delay: 0.5 })
+    #     ... some code here ...
+    #   end
+    #
+    #   T = Triggered, X = Executed, I = Ignored.
+    #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6...
+    #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T
+    #   .I...I...I...I...I...I...I...X...I...I...I...I...I...I...X...I...I...I
+    #
+    #   Vedeu.event(:my_debounced_event, { debounce: 0.7 })
+    #     ... some code here ...
+    #   end
+    #
+    # @return [Hash]
+    def event(name, opts = {}, &block)
+      Vedeu.events.event(name, opts = {}, &block)
     end
 
-    # @api private
-    def events
-      @events ||= API::Events.new do
-        event(:_log_)         { |msg| Vedeu.log(msg)      }
-        event(:_exit_)        { fail StopIteration        }
-        event(:_mode_switch_) { fail ModeSwitch           }
-        event(:_clear_)       { Terminal.clear_screen     }
-        event(:_refresh_)     { Buffers.refresh_all       }
-        event(:_keypress_)    { |key| Vedeu.keypress(key) }
-      end
+    # Unregister an event by name.
+    #
+    # @param name [Symbol]
+    # @return [Hash]
+    def unevent(name)
+      Vedeu.events.unevent(name)
     end
 
+    # def focus(name)
+    #   Focus.by_name(name)
+    # end
+
+    # Find out how many lines the current terminal is able to display.
+    #
+    # @example
+    #   Vedeu.height
+    #
     # @return [Fixnum] The total height of the current terminal.
     def height
       Terminal.height
     end
 
+    # Register an interface by name which will display output from a event or
+    # command. This provides the means for you to define your application's
+    # views without their content.
+    #
     # @param name  [String] The name of the interface. Used to reference the
     #   interface throughout your application's execution lifetime.
     # @param block [Proc] A set of attributes which define the features of the
     #   interface. TODO: More help.
+    #
+    # @example
+    #   Vedeu.interface 'my_interface' do
+    #      ... some interface attributes like width and height ...
+    #   end
+    #
+    # @return [TrueClass]
     def interface(name, &block)
       API::Interface.define({ name: name }, &block)
     end
 
-    # @param key [String] A simulated keypress. Escape sequences are also
-    #   supported.
+    # Simulate keypresses in your application. TODO: More help.
+    #
+    # @param key [String|Symbol] A simulated keypress. Escape sequences are also
+    #   supported. Special keys like the F-keys are named as symbols; i.e. `:f4`
+    #
+    # @example
+    #   TODO
+    #
+    # @return []
     def keypress(key)
-      trigger(:key, key)
-      trigger(:_log_, "Key: #{key}")
-      trigger(:_mode_switch_) if key == :escape
+      Vedeu.events.trigger(:key, key)
+      Vedeu.events.trigger(:_log_, "Key: #{key}")
+      Vedeu.events.trigger(:_mode_switch_) if key == :escape
     end
 
+    # Write a message to the Vedeu log file located at `$HOME/.vedeu/vedeu.log`
+    #
     # @param message [String] The message you wish to emit to the log
     #   file, useful for debugging.
+    #
+    # @example
+    #   Vedeu.log('A useful debugging message: Error!')
+    #
+    # @return [TrueClass]
     def log(message)
-      API::Log.logger.debug(message)
+      Vedeu::Log.logger.debug(message)
     end
 
+    # Trigger a registered or system event by name with arguments.
+    #
     # @param name [Symbol] The name of the event you wish to trigger.
     #   The event does not have to exist.
     # @param args [Array] Any arguments the event needs to execute correctly.
+    #
+    # @example
+    #   Vedeu.trigger(:my_event, :oxidize, 'nitrogen')
+    #
+    # @return [Array]
     def trigger(name, *args)
       Vedeu.events.trigger(name, *args)
     end
 
+    # Use attributes of another interface whilst defining one. TODO: More help.
+    #
     # @param name [String] The name of the interface you wish to use. Typically
-    #   used when defining interfaces to share geometry. TODO: Example required.
+    #   used when defining interfaces to share geometry.
+    #
+    # @example
+    #   Vedeu.interface 'main_screen' do
+    #     ... some attributes ...
+    #     width use('my_interface').width
+    #     x     use('my_interface').east(1)
+    #   end
+    #
+    # @return [Vedeu::Interface]
     def use(name)
-      Vedeu::Interface.new(Vedeu::Store.query(name))
+      Vedeu::Interface.new(Vedeu::Buffers.retrieve_attributes(name))
     end
 
+    # Define a view (content) for an interface. TODO: More help.
+    #
     # @param name [String] The name of the interface you are targetting for this
     #   view.
     # @param block [Proc] The directives you wish to send to this interface.
-    #   TODO: Example required.
+    #
+    # @example
+    #   view 'my_interface' do
+    #     ... some view attributes ...
+    #   end
+    #
+    # @return [Hash]
     def view(name, &block)
-      {
-        interfaces: [
-          API::Interface.build({ name: name }, &block)
-        ]
-      }
+      API::Composition.build { view(name, &block) }
     end
 
+    # Instruct Vedeu to treat contents of block as a single composition.
+    # TODO: More help.
+    #
     # @param block [Proc] Instructs Vedeu to treat all of the 'view' directives
     #   therein as one instruction. Useful for redrawing multiple interfaces at
-    #   once. TODO: Example required.
+    #   once.
+    #
+    # @example
+    #   views do
+    #     view 'my_interface' do
+    #       ... some attributes ...
+    #     end
+    #     view 'my_other_interface' do
+    #       ... some other attributes ...
+    #     end
+    #   end
+    #
+    #   composition do
+    #     view 'my_interface' do
+    #       ...
+    #   ...
+    #
+    # @return [Hash]
     def views(&block)
       API::Composition.build(&block)
     end
+    alias_method :composition, :views
 
+    # Find out how many columns the current terminal is able to display.
+    #
+    # @example
+    #   Vedeu.width
+    #
     # @return [Fixnum] The total width of the current terminal.
     def width
       Terminal.width
     end
+
+    # @api private
+    def events
+      @events ||= Vedeu::Events.new do
+        event(:_log_)                     { |msg| Vedeu.log(msg)      }
+        event(:_exit_)                    { Vedeu.shutdown            }
+        event(:_mode_switch_)             { fail ModeSwitch           }
+        event(:_clear_)                   { Terminal.clear_screen     }
+        event(:_refresh_)                 { Buffers.refresh_all       }
+        event(:_resize_, { delay: 0.25 }) { Vedeu.resize              }
+        event(:_keypress_)                { |key| Vedeu.keypress(key) }
+      end
+    end
+
+    # @api private
+    def resize
+      trigger(:_clear_)
+
+      trigger(:_refresh_)
+    end
+
+    # @api private
+    def shutdown
+      trigger(:_cleanup_)
+
+      fail StopIteration
+    end
+
   end
 
   extend API
+
+  trap('SIGWINCH') { Vedeu.trigger(:_resize_) }
 end