vedeu 0.6.37 → 0.6.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fba735c3e10acba05e8b802dd3db76f2ebb06e0
-  data.tar.gz: 47bdfcbf57f2e69102f8a3fa489a4b88799a300f
+  metadata.gz: a3b9204a33456f344d0f99492f9b00b544036b23
+  data.tar.gz: 80f15efc5738f5fcaacd6065e53235f61e5e5b0e
 SHA512:
-  metadata.gz: 828bab91908c976e8e19936576afee8b24ea4fed9ca4748d384bb547ed19edfafaf9f6e4dedd07eb1101f652875eb8ea164ac84621bae1307c7b5b42eaafe3e3
-  data.tar.gz: 4ed3df4d46e4983c3fa205bfbc586530b26096ce2ef561cc6509fa3d8b9dc82ec83f59e5c0195b95e48bb1a37c61e9a7c9c0172043f179833c69ea53edd1fb98
+  metadata.gz: bd3541b906d8894c766f680ce02d5e49f9ad323302a8476ac2105a75aac5413c8956de137acb26a725be1a6e9bfee7b4493d16cc6398ec5bb280308c4d79881f
+  data.tar.gz: 11373347106344fd1617785d3367920f18d5ef6cd404e9f778833b812180fa1945013efa9ef557688e2cb399e89244885883c4f0e41447d10408a3ecf6d095d2

data/docs/events/system.md

@@ -41,14 +41,31 @@ action(s), like render the first screen, interface or make a sound.
     Vedeu.trigger(:_initialize_)
 
 ### `:\_keypress\_`
-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. Vedeu recognises most key presses and
-some 'extended' keypress (eg. Ctrl+J), a list of supported keypresses
-can be found here: {Vedeu::Input::Capture}.
+When the name is given:
 
-    Vedeu.trigger(:_keypress_, key)
+- The given key is passed to the named keymap. If the keymap is
+  registered, and the key has an associated action assigned, then
+  the action will be called/triggered.
+- If the keymap is not registered, the key will be passed to the
+  global keymap to be actioned, or ignored if the global keymap does
+  not have an action assigned for the key pressed.
+
+When the name is not given:
+
+- The given key is passed to the named keymap associated with the
+  interface/view currently in focus. If the key has an associated
+  action assigned, then the action will be called or triggered,
+  otherwise, the key is (as above) passed to the global keymap to be
+  processed.
+
+It is also to be noted, that a `:key` event will be triggered
+irrespective of the conditions above, you can bind to this event
+separately to 'do things'.
+
+A list of supported keypresses can be found here:
+{Vedeu::Input::Capture}.
+
+    Vedeu.trigger(:_keypress_, key, optional_name)
 
 ### `:\_log\_`
 When triggered with a message will cause Vedeu to log the message if
@@ -59,10 +76,9 @@ Note: 'message' is a String.
     Vedeu.trigger(:_log_, message)
 
 ### `:\_mode_switch\_`
-When triggered (by default, after the user presses `escape`), Vedeu
-switches between modes of the terminal. The idea here being
-that the raw mode is for single keypress actions, whilst fake and
-cooked modes allow the user to enter more elaborate commands- such as
-commands with arguments.
+When triggered, Vedeu switches between modes of the terminal. The idea
+here being that the raw mode is for single keypress actions, whilst
+fake and cooked modes allow the user to enter more elaborate commands-
+such as commands with arguments.
 
     Vedeu.trigger(:_mode_switch_)

data/examples/dsl_editor.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'vedeu'
+
+class EditorApp
+
+  Vedeu.bind(:_initialize_) { Vedeu.trigger(:_refresh_) }
+
+  Vedeu.configure do
+    log './tmp/editor.log'
+    renderers Vedeu::Renderers::File.new(filename: './tmp/editor.out')
+    fake!
+  end
+
+  Vedeu.interface :editor_view do
+    border do
+      title 'Editor'
+    end
+    editable!
+    geometry do
+      align(:top, :left, 40, 8)
+    end
+  end
+
+  Vedeu.interface :help_view do
+    geometry do
+      height use(:editor_view).height
+      width  use(:editor_view).width
+      x      use(:editor_view).left
+      y      use(:editor_view).south
+    end
+  end
+
+  # When pressing Return/Enter in the editor view, the :_command_
+  # event will be triggered with any typed content you have provided.
+  #
+  # Bind to this event to retrieve the content entered, and then
+  # process yourself in whatever way appropriate.
+  #
+  #     Vedeu.bind(:_command_) do |data|
+  #        # ... do something with 'data'
+  #     end
+  #
+  Vedeu.keymap :editor_view do
+    key(:enter) { Vedeu.trigger(:_editor_execute_, :editor_view) }
+  end
+
+  Vedeu.keymap '_global_' do
+    key('q') { Vedeu.exit }
+  end
+
+  Vedeu.render do
+    view(:editor_view) do
+    end
+  end
+
+  Vedeu.render do
+    view(:help_view) do
+      lines do
+        line 'Type into the editor dialog above,'
+        line 'and press Return. This will trigger the'
+        line ':_command_ event with the contents of '
+        line 'the view.'
+
+        # @todo Not implemented yet:
+        #
+        # text 'Type into the editor dialog above, and press Return. This will ' \
+        #      'trigger the :_command_ event with the contents of the view.',
+        #      name: :help_view, mode: :wrap
+      end
+    end
+  end
+
+  def self.start(argv = ARGV)
+    Vedeu::Launcher.execute!(argv)
+  end
+
+end # EditorApp
+
+EditorApp.start

data/examples/dsl_hello_worlds.rb

@@ -18,9 +18,11 @@ class HelloWorldsApp
     Vedeu.trigger(:_refresh_)
   }
 
-  Vedeu.configure do
-    # Empty configure block is needed.
-  end
+  # Add specific configuration for the client application.
+  #
+  # Vedeu.configure do
+  #   log './tmp/hello_worlds.log'
+  # end
 
   Vedeu.interface :hello do
     # Define all of the interface in one place.
@@ -29,23 +31,23 @@ class HelloWorldsApp
     geometry do
       align(:middle, :centre, 24, 5)
     end
-    # (You usually specify the views outside the interface block).
-    Vedeu.views do
-      view :hello do
-        lines do
-          line { centre 'Hello Worlds!', width: 24 }
-          line
-          line { centre "Press 'q' to exit,",     width: 24 }
-          line { centre " 'w' to switch worlds.", width: 24 }
-        end
-      end
-    end
     keymap do
       key('q') { Vedeu.exit }
       key('w') { HelloWorldsApp.render_world }
     end
   end
 
+  Vedeu.renders do
+    view :hello do
+      lines do
+        line { centre 'Hello Worlds!', width: 24 }
+        line
+        line { centre "Press 'q' to exit,",     width: 24 }
+        line { centre " 'w' to switch worlds.", width: 24 }
+      end
+    end
+  end
+
   def self.start(argv = ARGV)
     Vedeu::Launcher.execute!(argv)
   end

data/lib/vedeu/editor/document.rb

@@ -27,6 +27,14 @@ module Vedeu
       # @return [String|Symbol]
       attr_accessor :name
 
+      # Store an instance of this class with its repository.
+      #
+      # @param (see #initialize)
+      # @return (see #initialize)
+      def self.store(attributes = {})
+        new(attributes).store
+      end
+
       # Returns a new instance of Vedeu::Editor::Document.
       #
       # @param attributes [Hash]

data/lib/vedeu/error.rb

@@ -45,8 +45,9 @@ module Vedeu
 
     end # InvalidSyntax
 
-    # Raised when a name is not provided for a model when attempting
-    # to store it in a repository.
+    # Raised when value required by Vedeu to proceed is not given.
+    # For example, when a name is not provided for a model when
+    # attempting to store it in a repository.
     #
     class MissingRequired < StandardError
 

data/lib/vedeu/input/capture.rb

@@ -24,9 +24,21 @@ module Vedeu
         @reader = reader
       end
 
-      # Triggers either a ':_command_' event with the command when the
-      # reader is in cooked mode, or when in raw mode, the keypress
-      # event with the key(s) pressed.
+      # Triggers various events dependent on the terminal mode.
+      #
+      # - When in raw mode, the :_keypress_ event is triggered with
+      #   the key(s) pressed.
+      # - When in fake mode, the keypress will be checked against the
+      #   keymap relating to the interface/view currently in focus.
+      #   - If registered, the :_keypress_ event is triggered with the
+      #     key(s) pressed.
+      #   - If the keypress is not registered, we check whether the
+      #     interface in focus is editable, if so, the :_editor_
+      #     event is triggered.
+      #   - Otherwise, the :key event is triggered for the client
+      #     application to handle.
+      # - When in cooked mode, the :_command_ event is triggered with
+      #   the input given.
       #
       # @return [Array|String|Symbol]
       def read
@@ -34,8 +46,20 @@ module Vedeu
           Vedeu.trigger(:_keypress_, keypress)
 
         elsif reader.fake_mode?
-          Vedeu.trigger(:_editor_, keypress)
+          name      = Vedeu.focus
+          interface = Vedeu.interfaces.by_name(name)
+          key       = keypress
+
+          if Vedeu::Input::Mapper.registered?(key, name)
+            Vedeu.trigger(:_keypress_, key, name)
+
+          elsif interface.editable?
+            Vedeu.trigger(:_editor_, key)
+
+          else
+            Vedeu.trigger(:key, key)
 
+          end
         else
           Vedeu.trigger(:_command_, command)
 

data/lib/vedeu/input/mapper.rb

@@ -6,34 +6,51 @@ module Vedeu
     #
     class Mapper
 
-      # Takes a key as a keypress and sends it to registered keymaps.
-      # If found, the associated action is fired, otherwise, we move
-      # to the next keymap or return false.
-      #
-      # @example
-      #   Vedeu.keypress(key_name, keymap_name)
-      #
-      # @param (see #initialize)
-      # @return [Boolean]
-      def self.keypress(key = nil, name = nil)
-        Vedeu.trigger(:key, key)
-
-        return false unless key
-
-        new(key, name).keypress
-      end
-
-      # Checks a key is valid; i.e. not already registered to a
-      # keymap. When the key is registered, then the key is invalid
-      # and cannot be used again.
-      #
-      # @param (see #initialize)
-      # @return [Boolean]
-      def self.valid?(key = nil, name = nil)
-        return false unless key
-
-        new(key, name).valid?
-      end
+      class << self
+
+        include Vedeu::Common
+
+        # Takes a key as a keypress and sends it to registered
+        # keymaps. If found, the associated action is fired,
+        # otherwise, we move to the next keymap or return false.
+        #
+        # @example
+        #   Vedeu.keypress(key_name, keymap_name)
+        #
+        # @param (see #initialize)
+        # @return [Boolean]
+        def keypress(key = nil, name = nil)
+          Vedeu.trigger(:key, key)
+
+          return false unless key
+
+          new(key, name).keypress
+        end
+
+        def registered?(key = nil, name = nil)
+          fail Vedeu::Error::MissingRequired,
+               'Cannot check whether a key is registered to a keymap without ' \
+               'the key.' if absent?(key)
+          fail Vedeu::Error::MissingRequired,
+               'Cannot check whether a key is registered to a keymap without ' \
+               'the keymap name.' if absent?(name)
+
+          new(key, name).registered?
+        end
+
+        # Checks a key is valid; i.e. not already registered to a
+        # keymap. When the key is registered, then the key is invalid
+        # and cannot be used again.
+        #
+        # @param (see #initialize)
+        # @return [Boolean]
+        def valid?(key = nil, name = nil)
+          return false unless key
+
+          new(key, name).valid?
+        end
+
+      end # Eigenclass
 
       # Returns a new instance of Vedeu::Input::Mapper.
       #
@@ -63,6 +80,15 @@ module Vedeu
         false
       end
 
+      # Is the key defined in the named keymap?
+      #
+      # @param named [NilClass|String]
+      # @return [Boolean]
+      def key_defined?(named = name)
+        keymap?(named) && keymap(named).key_defined?(key)
+      end
+      alias_method :registered?, :key_defined?
+
       # Returns a boolean indicating that the key is not registered to
       # the current keymap, or the global keymap.
       #
@@ -92,14 +118,6 @@ module Vedeu
         key_defined?('_global_')
       end
 
-      # Is the key defined in the named keymap?
-      #
-      # @param named [NilClass|String]
-      # @return [Boolean]
-      def key_defined?(named = name)
-        keymap?(named) && keymap(named).key_defined?(key)
-      end
-
       # Fetch the named keymap from the repository.
       #
       # @param named [NilClass|String]
@@ -137,7 +155,7 @@ module Vedeu
   # :nocov:
 
   # See {file:docs/events/system.md#\_keypress_}
-  Vedeu.bind(:_keypress_) { |key| Vedeu.keypress(key) }
+  Vedeu.bind(:_keypress_) { |key, name| Vedeu.keypress(key, name) }
 
   # See {file:docs/events/drb.md#\_drb_input_}
   Vedeu.bind(:_drb_input_) do |data, type|

data/lib/vedeu/interfaces/dsl.rb

@@ -39,13 +39,18 @@ module Vedeu
           fail Vedeu::Error::MissingRequired,
                'name not given'.freeze unless present?(name)
 
+          attributes = { client: client(&block), name: name }
+
+          interface = Vedeu::Interfaces::Interface
+                      .build(attributes, &block)
+                      .store
+
           add_buffers!(name)
           add_cursor!(name)
+          add_editor!(name) if interface.editable?
           add_focusable!(name)
 
-          attributes = { client: client(&block), name: name }
-
-          Vedeu::Interfaces::Interface.build(attributes, &block).store
+          interface
         end
 
         private
@@ -70,6 +75,13 @@ module Vedeu
           Vedeu::Cursors::Cursor.store(name: name)
         end
 
+        # Registers a new document with the interface.
+        #
+        # @param name [String|Symbol]
+        def add_editor!(name)
+          Vedeu::Editor::Document.store(name: name)
+        end
+
         # Registers interface name in focus list unless already
         # registered.
         #
@@ -92,8 +104,7 @@ module Vedeu
       # Set the cursor visibility on an interface.
       #
       # @param value [Boolean] Any value other than nil or false will
-      #   evaluate
-      #   to true.
+      #   evaluate to true.
       #
       # @example
       #   Vedeu.interface :my_interface do
@@ -151,6 +162,51 @@ module Vedeu
         model.delay = value
       end
 
+      # Set whether the interface is editable.
+      #
+      # @note
+      #   When an interface is made editable, then the cursor
+      #   visibility will be set to visible.
+      #
+      # @param value [Boolean] Any value other than nil or false will
+      #   evaluate to true.
+      #
+      # @example
+      #   Vedeu.interface :my_interface do
+      #     editable true # => The interface/view can be edited.
+      #
+      #     # or...
+      #
+      #     editable! # => Convenience method for above.
+      #
+      #     # ...
+      #   end
+      #
+      #   Vedeu.interface :my_interface do
+      #     editable false # => The interface/view cannot be edited.
+      #
+      #     # or...
+      #
+      #     editable # => as above
+      #     # ...
+      #   end
+      #
+      # @return [Boolean]
+      def editable(value = true)
+        boolean = value ? true : false
+
+        cursor(true) if boolean
+
+        model.editable = boolean
+      end
+
+      # Set the interface to be editable.
+      #
+      # @return [Boolean]
+      def editable!
+        editable(true)
+      end
+
       # Specify this interface as being in focus when the application
       # starts.
       #

data/lib/vedeu/interfaces/interface.rb

@@ -23,6 +23,11 @@ module Vedeu
       # @return [Fixnum|Float]
       attr_accessor :delay
 
+      # @!attribute [rw] editable
+      # @return [Boolean]
+      attr_accessor :editable
+      alias_method :editable?, :editable
+
       # @!attribute [rw] group
       # @return [Symbol|String]
       attr_accessor :group
@@ -111,6 +116,7 @@ module Vedeu
           colour:     Vedeu::Colours::Colour.coerce(background: :default,
                                                     foreground: :default),
           delay:      0.0,
+          editable:   false,
           group:      '',
           name:       '',
           parent:     nil,

data/lib/vedeu/null/generic.rb

@@ -34,6 +34,7 @@ module Vedeu
       alias_method :unmaximise, :falsy
       alias_method :visible, :falsy
       alias_method :visible?, :falsy
+      alias_method :editable?, :falsy
 
       # @return [NilClass]
       def null(*)

data/lib/vedeu/output/text.rb

@@ -26,6 +26,7 @@ module Vedeu
       # @option options foreground [String]
       # @option options model
       #   [Vedeu::Views::View|Vedeu::Views::Line|Vedeu::Views::Stream]
+      # @option options mode (see Vedeu::Output::Wordwrap#mode)
       # @option options pad [String]
       # @option options width [Integer]
       # @return [Vedeu::Output::Text]
@@ -55,7 +56,13 @@ module Vedeu
       #
       # @return [void]
       def add
-        model.add(content)
+        if wrap?
+          model.add(wrapped)
+
+        else
+          model.add(content)
+
+        end
       end
 
       protected
@@ -123,6 +130,7 @@ module Vedeu
           anchor: :left,
           colour: nil,
           model:  nil,
+          mode:   :default,
           pad:    ' ',
           width:  nil,
         }
@@ -150,6 +158,12 @@ module Vedeu
         @model ||= options[:model] || Vedeu::Null::Generic.new
       end
 
+      # @see Vedeu::Output::Wordwrap#mode
+      # @return [Symbol]
+      def mode
+        options[:mode]
+      end
+
       # The character to use for padding the string.
       #
       # @return [String]
@@ -218,6 +232,21 @@ module Vedeu
         options[:width]
       end
 
+      # Return a boolean indicating whether the string should be
+      # wrapped.
+      #
+      # @return [Boolean]
+      def wrap?
+        options[:mode] == :wrap
+      end
+
+      # Return the content as wrapped lines.
+      #
+      # @return [Vedeu::Views::Lines]
+      def wrapped
+        Vedeu::Output::Wordwrap.for(string, options)
+      end
+
     end # Text
 
   end # Output

data/lib/vedeu/output/wordwrap.rb

@@ -6,6 +6,8 @@ module Vedeu
     #
     class Wordwrap
 
+      include Vedeu::Common
+
       # @see Vedeu::Output::Wordwrap#initialize
       def self.for(text, options = {})
         new(text, options).content
@@ -17,6 +19,7 @@ module Vedeu
       # @param options [Hash]
       # @option options ellipsis [String] See {#ellipsis}.
       # @option options mode [Symbol] See {#mode}.
+      # @option options name [String|Symbol] See {#name}.
       # @option options width [Fixnum] See {#width}.
       # @return [Vedeu::Output::Wordwrap]
       def initialize(text, options = {})
@@ -136,31 +139,58 @@ module Vedeu
 
       # Returns the word wrapping mode. One of :default, :prune or
       #   :wrap;
+      #
       #     :default = Renders the content as is.
       #     :prune   = Discards the remainder of the content line
       #                after width.
       #     :wrap    = Forces the content on to a new line after
       #                width.
+      #
       # @return [Symbol]
       def mode
         options[:mode]
       end
 
+      # Returns the value of the :name option. When given, and a
+      # geometry is registered with this name, the width of the
+      # geometry is used if the :width option was not given.
+      #
+      # @return [String|Symbol]
+      def name
+        options[:name]
+      end
+
+      # Returns a boolean indicating the :name option was given and
+      # a geometry is registered with that name.
+      #
+      # @return [Boolean]
+      def registered?
+        present?(name) && Vedeu.geometries.registered?(name)
+      end
+
       # Returns the width to prune or wrap to.
       #
+      # @raise [Vedeu::Error::MissingRequired]
       # @return [Fixnum]
       def width
-        options[:width]
+        return options[:width] if present?(options[:width])
+        return Vedeu.geometries.by_name(name).width if registered?
+
+        fail Vedeu::Error::MissingRequired,
+             'The text provided cannot be wrapped or pruned because a :width ' \
+             'option was not given, or a :name option was either not given ' \
+             'or there is no geometry registered with that name.'
       end
 
       # Returns the default options/attributes for this class.
       #
-      # @return [Hash<Symbol => Fixnum, String, Symbol>]
+      # @return [Hash<Symbol => NilClass, String, Symbol>]
       def defaults
         {
           ellipsis: '...',
           mode:     :default,
-          width:    70,
+          name:     nil,
+          width:    nil,
         }
       end
 

data/lib/vedeu/repositories/collection.rb

@@ -60,8 +60,14 @@ module Vedeu
       #
       # @param other [Vedeu::Repositories::Collection]
       # @return [Vedeu::Repositories::Collection]
-      def add(*other)
-        self.class.new(@collection += other, parent, name)
+      def add(other)
+        if other.is_a?(Vedeu::Repositories::Collection)
+          return self.class.coerce(other, parent, name) if empty?
+
+        else
+          self.class.new(@collection += Array(other), parent, name)
+
+        end
       end
       alias_method :<<, :add
 

data/lib/vedeu/version.rb

@@ -1,6 +1,6 @@
 module Vedeu
 
   # The current version of Vedeu.
-  VERSION = '0.6.37'.freeze
+  VERSION = '0.6.38'.freeze
 
 end

data/test/lib/vedeu/editor/document_test.rb

@@ -48,6 +48,22 @@ module Vedeu
         }
       end
 
+      describe '.store' do
+        before { Vedeu.documents.reset! }
+
+        subject { described.store(attributes) }
+
+        it { subject.must_be_instance_of(described) }
+
+        it 'registers the instance with the repository' do
+          Vedeu.documents.registered?(_name).must_equal(false)
+
+          subject
+
+          Vedeu.documents.registered?(_name).must_equal(true)
+        end
+      end
+
       describe 'accessors' do
         it {
           instance.must_respond_to(:attributes)

data/test/lib/vedeu/input/capture_test.rb

@@ -46,10 +46,60 @@ module Vedeu
 
           before { reader.stubs(:read).returns(keypress) }
 
-          it 'triggers an event with the keypress' do
-            Vedeu.expects(:trigger).with(:_editor_, keypress)
-            subject
+          context 'when an interface or view has been registered' do
+            let(:interface_name) { :fake_interface }
+            let(:interface)      {
+              Vedeu::Interfaces::Interface.new(name: interface_name, editable: editable)
+            }
+            let(:editable)       { false }
+            let(:registered)     { false }
+
+            before do
+              Vedeu.stubs(:focus).returns(interface_name)
+              Vedeu.interfaces.stubs(:by_name).with(interface_name).returns(interface)
+              Vedeu::Input::Mapper.expects(:registered?).with(keypress, interface_name).returns(registered)
+            end
+
+            context 'when the keypress is registered with the keymap' do
+              let(:registered) { true }
+
+              it 'triggers an event with the keypress' do
+                Vedeu.expects(:trigger).with(:_keypress_, keypress, interface_name)
+                subject
+              end
+            end
+
+            context 'when the keypress is not registered with the keymap' do
+              let(:registered) { false }
+
+              context 'when the interface or view is editable' do
+                let(:editable) { true }
+
+                it 'triggers an event with the keypress' do
+                  Vedeu.expects(:trigger).with(:_editor_, keypress)
+                  subject
+                end
+              end
+
+              context 'when the interface or view is not editable' do
+                let(:editable) { false }
+
+                it 'triggers an event with the keypress' do
+                  Vedeu.expects(:trigger).with(:key, keypress)
+                  subject
+                end
+              end
+            end
           end
+
+          # context 'when no interfaces or views have been registered' do
+          #   before {
+          #     Vedeu.focus.reset
+          #     Vedeu.interfaces.reset
+          #   }
+
+          #   it { proc { subject }.must_raise(Vedeu::Error::Fatal) }
+          # end
         end
 
         context 'when in raw mode' do

data/test/lib/vedeu/input/mapper_test.rb

@@ -13,9 +13,9 @@ module Vedeu
     describe Mapper do
 
       let(:described)  { Vedeu::Input::Mapper }
-      let(:instance)   { described.new(key, keymap, repository) }
+      let(:instance)   { described.new(key, _name, repository) }
       let(:key)        {}
-      let(:keymap)     {}
+      let(:_name)      {}
       let(:repository) {}
 
       before { Vedeu.keymaps.reset }
@@ -23,7 +23,7 @@ module Vedeu
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
         it { instance.instance_variable_get('@key').must_equal(key) }
-        it { instance.instance_variable_get('@name').must_equal(keymap) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
         it do
           instance.instance_variable_get('@repository').must_equal(Vedeu.keymaps)
         end
@@ -38,11 +38,11 @@ module Vedeu
       end
 
       describe '.keypress' do
-        let(:keymap) { 'test' }
+        let(:_name) { 'test' }
 
         before { Vedeu.stubs(:log) }
 
-        subject { described.keypress(key, keymap) }
+        subject { described.keypress(key, _name) }
 
         context 'when the key is not provided' do
           it { subject.must_equal(false) }
@@ -68,10 +68,43 @@ module Vedeu
         end
       end
 
+      describe '.registered?' do
+        subject { described.registered?(key, _name) }
+
+        context 'when the name was given' do
+          let(:_name) { :some_keymap }
+
+          context 'when the key was given' do
+            let(:key) { 'a' }
+
+            context 'when the key is defined for the keymap' do
+              # @todo Add more tests.
+              # it { skip }
+
+              # it { subject.must_equal(true) }
+            end
+
+            context 'when the key is not defined for the keymap' do
+              it { subject.must_equal(false) }
+            end
+          end
+
+          context 'when the key was not given' do
+            let(:key) {}
+
+            it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+          end
+        end
+
+        context 'when the name was not given' do
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        end
+      end
+
       describe '.valid?' do
-        let(:keymap) { 'test' }
+        let(:_name) { 'test' }
 
-        subject { described.valid?(key, keymap) }
+        subject { described.valid?(key, _name) }
 
         context 'when the key is not provided' do
           it { subject.must_equal(false) }

data/test/lib/vedeu/interfaces/dsl_test.rb

@@ -118,6 +118,34 @@ module Vedeu
         }
       end
 
+      describe '#editable' do
+        let(:_value) {}
+
+        subject { instance.editable(_value) }
+
+        context 'when the value is nil' do
+          it { subject.must_equal(false) }
+        end
+
+        context 'when the value is false' do
+          let(:_value) { false }
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'when the value is true' do
+          let(:_value) { true }
+
+          it { subject.must_equal(true) }
+        end
+      end
+
+      describe '#editable!' do
+        subject { instance.editable! }
+
+        it { subject.must_equal(true) }
+      end
+
       describe '#focus!' do
         subject { instance.focus! }
 

data/test/lib/vedeu/interfaces/interface_test.rb

@@ -10,20 +10,22 @@ module Vedeu
       let(:instance)   { described.new(attributes) }
       let(:attributes) {
         {
-          client:  client,
-          colour:  colour,
-          delay:   delay,
-          group:   group,
-          name:    _name,
-          parent:  parent,
-          style:   style,
-          visible: visible,
-          zindex:  zindex,
+          client:   client,
+          colour:   colour,
+          delay:    delay,
+          editable: editable,
+          group:    group,
+          name:     _name,
+          parent:   parent,
+          style:    style,
+          visible:  visible,
+          zindex:   zindex,
         }
       }
       let(:client)     {}
       let(:colour)     {}
       let(:delay)      { 0.0 }
+      let(:editable)   { false }
       let(:group)      { '' }
       let(:_name)      { 'hydrogen' }
       let(:parent)     {}
@@ -38,6 +40,7 @@ module Vedeu
         it { subject.must_be_instance_of(described) }
         it { subject.instance_variable_get('@client').must_equal(client) }
         it { subject.instance_variable_get('@delay').must_equal(delay) }
+        it { subject.instance_variable_get('@editable').must_equal(editable) }
         it { subject.instance_variable_get('@group').must_equal(group) }
         it { subject.instance_variable_get('@name').must_equal(_name) }
         it { subject.instance_variable_get('@parent').must_equal(parent) }
@@ -54,6 +57,9 @@ module Vedeu
           instance.must_respond_to(:client=)
           instance.must_respond_to(:delay)
           instance.must_respond_to(:delay=)
+          instance.must_respond_to(:editable)
+          instance.must_respond_to(:editable=)
+          instance.must_respond_to(:editable?)
           instance.must_respond_to(:group)
           instance.must_respond_to(:group=)
           instance.must_respond_to(:name)

data/test/lib/vedeu/null/generic_test.rb

@@ -43,11 +43,13 @@ module Vedeu
 
         it { subject.must_be_instance_of(FalseClass) }
 
+        it { instance.must_respond_to(:enabled?) }
         it { instance.must_respond_to(:maximise) }
         it { instance.must_respond_to(:maximised?) }
         it { instance.must_respond_to(:unmaximise) }
         it { instance.must_respond_to(:visible) }
         it { instance.must_respond_to(:visible?) }
+        it { instance.must_respond_to(:editable?) }
       end
 
       describe '#null' do

data/test/lib/vedeu/output/wordwrap_test.rb

@@ -9,15 +9,17 @@ module Vedeu
       let(:described) { Vedeu::Output::Wordwrap }
       let(:instance)  { described.new(text, options) }
       let(:text)      { '' }
+      let(:mode)      { :default }
+      let(:_name)     {}
+      let(:width)     { 30 }
       let(:options)   {
         {
           ellipsis: '...',
           mode:     mode,
+          name:     _name,
           width:    width,
         }
       }
-      let(:mode)      { :default }
-      let(:width)     { 30 }
 
       let(:text_line) {
         "Krypton (from Greek: κρυπτός kryptos 'the hidden one')."

data/test/lib/vedeu/repositories/collection_test.rb

@@ -51,16 +51,8 @@ module Vedeu
         subject { instance.add(:hydrogen) }
 
         it { instance.must_respond_to(:<<) }
-        it { subject.must_be_instance_of(Collection) }
+        it { subject.must_be_instance_of(Vedeu::Repositories::Collection) }
         it { subject.all.must_equal([:hydrogen]) }
-
-        context 'with multiple objects' do
-          subject { instance.add(:hydrogen, :helium) }
-
-          it 'adds all the objects to the collection' do
-            subject.all.must_equal([:hydrogen, :helium])
-          end
-        end
       end
 
       describe '#all' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vedeu
 version: !ruby/object:Gem::Version
-  version: 0.6.37
+  version: 0.6.38
 platform: ruby
 authors:
 - Gavin Laking
@@ -296,6 +296,7 @@ files:
 - docs/view.md
 - examples/dsl_alignment.rb
 - examples/dsl_demo_groups.rb
+- examples/dsl_editor.rb
 - examples/dsl_hello_worlds.rb
 - examples/dsl_horizontal_alignment.rb
 - examples/dsl_vertical_alignment.rb
@@ -659,7 +660,6 @@ files:
 - test/support/coverage.rb
 - test/support/examples/borders_app.rb
 - test/support/examples/drb_app.rb
-- test/support/examples/editor_app.rb
 - test/support/examples/focus_app.rb
 - test/support/examples/hello_world.rb
 - test/support/examples/material_colours_app.rb
@@ -863,7 +863,6 @@ test_files:
 - test/support/coverage.rb
 - test/support/examples/borders_app.rb
 - test/support/examples/drb_app.rb
-- test/support/examples/editor_app.rb
 - test/support/examples/focus_app.rb
 - test/support/examples/hello_world.rb
 - test/support/examples/material_colours_app.rb

data/test/support/examples/editor_app.rb

@@ -1,70 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'vedeu'
-
-# An example application to demonstrate colours, cursor and interface movement,
-# maximising/unmaximising of interfaces and toggling of cursors and interfaces.
-#
-# If you have cloned this repository from GitHub, you can run this example:
-#
-#     ./test/support/examples/material_colours_app.rb
-#
-class VedeuEditorApp
-
-  Vedeu.bind(:_initialize_) { Vedeu.trigger(:_refresh_) }
-
-  # Be aware that running an application with profiling enabled will affect
-  # performance.
-  Vedeu.configure do
-    debug!
-    fake!
-    log '/tmp/vedeu_editor_app.log'
-    # profile!
-    # renderers Vedeu::Renderers::File.new
-  end
-
-  Vedeu.interface 'main_interface' do
-    border 'main_interface' do
-      colour foreground: '#ffffff', background: :default
-      title 'Editor'
-      caption('Ctrl+C = Quit')
-    end
-    colour foreground: '#ffffff', background: :default
-    cursor!
-    geometry 'main_interface' do
-      x  columns(1)
-      xn columns(11)
-      y  rows(1)
-      yn rows(1) + 10
-    end
-    zindex 1
-  end
-
-  Vedeu.keymap('_global_') do
-    key(:up)    { Vedeu.trigger(:_cursor_up_)    }
-    key(:right) { Vedeu.trigger(:_cursor_right_) }
-    key(:down)  { Vedeu.trigger(:_cursor_down_)  }
-    key(:left)  { Vedeu.trigger(:_cursor_left_)  }
-
-    key('q')        { Vedeu.trigger(:_exit_) }
-    key(:escape)    { Vedeu.trigger(:_mode_switch_) }
-    key(:shift_tab) { Vedeu.trigger(:_focus_prev_) }
-    key(:tab)       { Vedeu.trigger(:_focus_next_) }
-  end
-
-  Vedeu.renders do
-    view 'main_interface' do
-      line { line '' }
-    end
-  end
-
-  Vedeu.focus_by_name 'main_interface'
-
-  def self.start(argv = ARGV)
-    Vedeu::Launcher.execute!(argv)
-  end
-
-end # VedeuEditorApp
-
-VedeuEditorApp.start(ARGV)