vedeu 0.6.7 → 0.6.8

data/lib/vedeu/input/mapper.rb

@@ -1,127 +1,131 @@
 module Vedeu
 
-  # Maps keys to keymaps.
-  #
-  class Mapper
+  module Input
 
-    # 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.
+    # Maps keys to keymaps.
     #
-    # @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
-
-    # Returns a new instance of Vedeu::Mapper.
-    #
-    # @param key [NilClass|String|Symbol]
-    # @param name [NilClass|String]
-    # @param repository [NilClass|Vedeu::Repository]
-    # @return [Vedeu::Mapper]
-    def initialize(key = nil, name = nil, repository = nil)
-      @key        = key
-      @name       = name
-      @repository = repository || Vedeu.keymaps
-    end
-
-    # Returns a boolean indicating that the key is registered to the current
-    # keymap, or the global keymap.
-    #
-    # @return [Boolean]
-    def keypress
-      return false unless key
-
-      Vedeu.log(type: :input, message: "Key detected: #{key.inspect}")
-
-      return true if key_defined? && keymap.use(key)
-
-      return true if global_key? && keymap('_global_').use(key)
-
-      false
-    end
-
-    # Returns a boolean indicating that the key is not registered to the current
-    # keymap, or the global keymap.
-    #
-    # @return [Boolean]
-    def valid?
-      return false if !key || key_defined? || global_key?
-
-      true
-    end
-
-    protected
-
-    # @!attribute [r] key
-    # @return [String|Symbol]
-    attr_reader :key
-
-    # @!attribute [r] repository
-    # @return [Vedeu::Repository]
-    attr_reader :repository
-
-    private
-
-    # Is the key a global key?
-    #
-    # @return [Boolean]
-    def global_key?
-      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]
-    # @return [Vedeu::Keymap]
-    def keymap(named = name)
-      repository.find(named)
-    end
-
-    # Does the keymaps repository have the named keymap already registered?
-    #
-    # @param named [NilClass|String]
-    # @return [Boolean]
-    def keymap?(named = name)
-      repository.registered?(named)
-    end
-
-    # With a name, we check the keymap with that name, otherwise we use the
-    # name of the interface currently in focus.
-    #
-    # @return [String|NilClass]
-    def name
-      @name || Vedeu.focus
-    end
-    alias_method :interface, :name
-
-  end # Mapper
+    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
+
+      # Returns a new instance of Vedeu::Input::Mapper.
+      #
+      # @param key [NilClass|String|Symbol]
+      # @param name [NilClass|String]
+      # @param repository [NilClass|Vedeu::Repository]
+      # @return [Vedeu::Input::Mapper]
+      def initialize(key = nil, name = nil, repository = nil)
+        @key        = key
+        @name       = name
+        @repository = repository || Vedeu.keymaps
+      end
+
+      # Returns a boolean indicating that the key is registered to the current
+      # keymap, or the global keymap.
+      #
+      # @return [Boolean]
+      def keypress
+        return false unless key
+
+        Vedeu.log(type: :input, message: "Key detected: #{key.inspect}")
+
+        return true if key_defined? && keymap.use(key)
+
+        return true if global_key? && keymap('_global_').use(key)
+
+        false
+      end
+
+      # Returns a boolean indicating that the key is not registered to
+      # the current keymap, or the global keymap.
+      #
+      # @return [Boolean]
+      def valid?
+        return false if !key || key_defined? || global_key?
+
+        true
+      end
+
+      protected
+
+      # @!attribute [r] key
+      # @return [String|Symbol]
+      attr_reader :key
+
+      # @!attribute [r] repository
+      # @return [Vedeu::Repository]
+      attr_reader :repository
+
+      private
+
+      # Is the key a global key?
+      #
+      # @return [Boolean]
+      def global_key?
+        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]
+      # @return [Vedeu::Input::Keymap]
+      def keymap(named = name)
+        repository.find(named)
+      end
+
+      # Does the keymaps repository have the named keymap already registered?
+      #
+      # @param named [NilClass|String]
+      # @return [Boolean]
+      def keymap?(named = name)
+        repository.registered?(named)
+      end
+
+      # With a name, we check the keymap with that name, otherwise we use the
+      # name of the interface currently in focus.
+      #
+      # @return [String|NilClass]
+      def name
+        @name || Vedeu.focus
+      end
+      alias_method :interface, :name
+
+    end # Mapper
+
+  end # Input
 
 end # Vedeu

data/lib/vedeu/input/translator.rb

@@ -0,0 +1,159 @@
+module Vedeu
+
+  module Input
+
+    # Translates escape sequences provided by the terminal into
+    # symbols which Vedeu can use for various behaviours.
+    #
+    class Translator
+
+      # @param code [String]
+      # @return [Symbol]
+      def self.translate(code)
+        new(code).translate
+      end
+
+      # Returns a new instance of Vedeu::Input::Translator.
+      #
+      # @param code [String]
+      # @return [Vedeu::Input::Translator]
+      def initialize(code)
+        @code = code
+      end
+
+      # @return [Symbol]
+      def translate
+        symbols.fetch(code, code)
+      end
+
+      protected
+
+      # @!attribute [r] code
+      # @return [String]
+      attr_reader :code
+
+      private
+
+      # @return [Hash<String => Symbol>]
+      def symbols
+        @symbols ||= f_keys.merge!(ctrl_letters).merge!(specials)
+      end
+
+      # @return [Hash<String => Symbol>]
+      def ctrl_letters
+        {
+          "\u0001"  => :ctrl_a,
+          "\u0002"  => :ctrl_b,
+          "\u0003"  => :ctrl_c,
+          "\u2404"  => :ctrl_c,
+          "\u0004"  => :ctrl_d,
+          "\u2403"  => :ctrl_d,
+          "\u0005"  => :ctrl_e,
+          "\u0006"  => :ctrl_f,
+          "\u0007"  => :ctrl_g,
+          "\u0008"  => :ctrl_h,
+          # "\u0009"  => :ctrl_i, # duplicates tab
+          "\u0010"  => :ctrl_j, # produces "\n"
+          "\u0011"  => :ctrl_k,
+          "\u0012"  => :ctrl_l,
+          "\u0013"  => :ctrl_m,
+          "\u0014"  => :ctrl_n,
+          "\u0015"  => :ctrl_o,
+          "\u0016"  => :ctrl_p,
+          "\u0017"  => :ctrl_q,
+          "\u0018"  => :ctrl_r,
+          "\u2412"  => :ctrl_r,
+          "\u0019"  => :ctrl_s,
+          # "\u0020"  => :ctrl_t, # duplicates spacebar
+          "\u0021"  => :ctrl_u,
+          "\u0022"  => :ctrl_v,
+          "\u0023"  => :ctrl_w,
+          "\u0024"  => :ctrl_x,
+          "\u0025"  => :ctrl_y,
+          "\u0026"  => :ctrl_z,
+        }
+      end
+
+      # @return [Hash<String => Symbol>]
+      def f_keys
+        {
+          "\eOP"      => :f1,
+          "\eOQ"      => :f2,
+          "\eOR"      => :f3,
+          "\eOS"      => :f4,
+
+          "\e[15~"    => :f5,
+          "\e[15;2~"  => :shift_f5,
+          "\e[15;5~"  => :ctrl_f5,
+
+          "\e[17~"    => :f6,
+          "\e[17;2~"  => :shift_f6,
+          "\e[17;5~"  => :ctrl_f6,
+
+          "\e[18~"    => :f7,
+          "\e[18;2~"  => :shift_f7,
+          "\e[18;5~"  => :ctrl_f7,
+
+          "\e[19~"    => :f8,
+          "\e[19;2~"  => :shift_f8,
+          "\e[19;5~"  => :ctrl_f8,
+
+          "\e[20~"    => :f9,
+          "\e[20;2~"  => :shift_f9,
+          "\e[20;5~"  => :ctrl_f9,
+
+          "\e[21~"    => :f10,
+          "\e[21;2~"  => :shift_f10,
+          "\e[21;5~"  => :ctrl_f10,
+
+          "\e[23~"    => :f11,
+          "\e[23;2~"  => :shift_f11,
+          "\e[23;5~"  => :ctrl_f11,
+
+          "\e[24~"    => :f12,
+          "\e[24;2~"  => :shift_f12,
+          "\e[24;5~"  => :ctrl_f12,
+        }
+      end
+
+      # @return [Hash<String => Symbol>]
+      def specials
+        {
+          "\u007F"  => :backspace,
+          "\u2408"  => :backspace,
+          "\u23CE"  => :carriage_return,
+          "\e[3~"   => :delete,
+          "\u232B"  => :delete,
+          "\e[B"    => :down,
+          "\u2193"  => :down,
+          "\e[F"    => :end,
+          "\r"      => :enter,
+          "\n"      => :enter,
+          "\e"      => :escape,
+          "\u238B"  => :escape,
+          "\e[H"    => :home,
+          "\eOH"    => :home,
+          "\e[2~"   => :insert,
+          "\e[D"    => :left,
+          "\u2190"  => :left,
+          "\u240A"  => :line_feed,
+          "\e[5~"   => :page_up,
+          "\e[6~"   => :page_down,
+          "\e[1;2R" => :pause_break,
+          "\e[1;2P" => :print_screen,
+          "\e[C"    => :right,
+          "\u2192"  => :right,
+          "\e[1;2Q" => :scroll_lock,
+          "\e[Z"    => :shift_tab,
+          "\t"      => :tab,
+          "\u21B9"  => :tab,
+          "\e[A"    => :up,
+          "\u2191"  => :up,
+        }
+      end
+
+    end # Translator
+
+  end # Input
+
+end # Vedeu

data/lib/vedeu/internal_api.rb

@@ -1,8 +1,8 @@
 module Vedeu
 
-  # Vedeu's internal API methods provide convenient ways to access Vedeu's
-  # internals. They are not supposed to be used by client applications as they
-  # have limited value there.
+  # Vedeu's internal API methods provide convenient ways to access
+  # Vedeu's internals. They are not supposed to be used by client
+  # applications as they have limited value there.
   #
   module InternalAPI
 
@@ -46,14 +46,15 @@ module Vedeu
     # @return [Vedeu::Cursors::Repository]
     def_delegators Vedeu::Cursors::Repository, :cursors
 
-    # Allow debugging via the creation of stack traces courtesy of ruby-prof.
+    # Allow debugging via the creation of stack traces courtesy of
+    # ruby-prof.
     #
     # @example
     #   Vedeu.debug
     #
     # @!method debug
-    # @return [Vedeu::Debug]
-    def_delegators Vedeu::Debug, :debug
+    # @return [Vedeu::Logging::Debug]
+    def_delegators Vedeu::Logging::Debug, :debug
 
     # Manipulate the repository of documents.
     #
@@ -115,8 +116,8 @@ module Vedeu
     #   Vedeu.keymaps
     #
     # @!method keymaps
-    # @return [Vedeu::Keymaps]
-    def_delegators Vedeu::Keymaps, :keymaps
+    # @return [Vedeu::Input::Keymaps]
+    def_delegators Vedeu::Input::Keymaps, :keymaps
 
     # Manipulate the repository of menus.
     #
@@ -124,15 +125,15 @@ module Vedeu
     #   Vedeu.menus
     #
     # @!method menus
-    # @return [Vedeu::Menus]
-    def_delegators Vedeu::Menus, :menus
+    # @return [Vedeu::Menus::Repository]
+    def_delegators Vedeu::Menus::Repository, :menus
 
     # Manipulate the internal flags.
     #
     # @!method ready?
     # @!method ready!
     # @return [Boolean]
-    def_delegators Vedeu::Flags, :ready?, :ready!
+    def_delegators Vedeu::Runtime::Flags, :ready?, :ready!
 
     # @example
     #   Vedeu.renderer
@@ -144,8 +145,8 @@ module Vedeu
     #   @see Vedeu::Renderers#renderers
     def_delegators Vedeu::Renderers, :renderer, :renderers
 
-    # Instruct the terminal to resize. This will happen automatically as the
-    # terminal recieves SIGWINCH signals.
+    # Instruct the terminal to resize. This will happen automatically
+    # as the terminal recieves SIGWINCH signals.
     #
     # @example
     #   Vedeu.resize
@@ -162,8 +163,8 @@ module Vedeu
     #   end
     #
     # @!method timer
-    #   @see Vedeu::Timer.timer
-    def_delegators Vedeu::Timer, :timer
+    #   @see Vedeu::Logging::Timer.timer
+    def_delegators Vedeu::Logging::Timer, :timer
 
   end # InternalAPI
 

data/lib/vedeu/logging/all.rb

@@ -0,0 +1,13 @@
+module Vedeu
+
+  module Logging
+
+  end # Logging
+
+end # Vedeu
+
+require 'vedeu/logging/lockless_log_device'
+require 'vedeu/logging/mono_logger'
+require 'vedeu/logging/log'
+require 'vedeu/logging/debug'
+require 'vedeu/logging/timer'

data/lib/vedeu/logging/debug.rb

@@ -0,0 +1,84 @@
+module Vedeu
+
+  module Logging
+
+    # Provides a stack trace of a running client application upon exit
+    # in a file for further analysis.
+    #
+    module Debug
+
+      extend self
+
+      # :nocov:
+      # Helps to debug a running application by providing a stack
+      # trace of its execution upon exiting.
+      #
+      # @param filename [String]
+      # @return [void]
+      # @yieldreturn [void] The section of the application to debug.
+      def self.debug(filename = 'profile.html')
+        return nil unless block_given?
+
+        require 'ruby-prof'
+
+        # RubyProf.measure_mode = RubyProf::WALL_TIME
+        # RubyProf.measure_mode = RubyProf::PROCESS_TIME
+        RubyProf.measure_mode = RubyProf::CPU_TIME
+        # RubyProf.measure_mode = RubyProf::ALLOCATIONS
+        # RubyProf.measure_mode = RubyProf::MEMORY
+        # RubyProf.measure_mode = RubyProf::GC_TIME
+        # RubyProf.measure_mode = RubyProf::GC_RUNS
+
+        RubyProf.start
+
+        work = yield
+
+        result = RubyProf.stop
+        result.eliminate_methods!([
+          /^Array/,
+          /^Hash/,
+          /^String/,
+          /^Fixnum/,
+        ])
+
+        File.open('/tmp/' + filename, 'w') do |file|
+          # - Creates a HTML visualization of the Ruby stack
+          RubyProf::CallStackPrinter.new(result).print(file)
+
+          # Used with QTCacheGrind to analyse performance.
+          # RubyProf::CallTreePrinter.new(result).print(file)
+
+          # Creates a flat report in text format
+          # RubyProf::FlatPrinter
+
+          # - same as above but more verbose
+          # RubyProf::FlatPrinterWithLineNumbers
+
+          # - Creates a call graph report in text format
+          # RubyProf::GraphPrinter
+
+          # - Creates a call graph report in HTML (separate files per
+          #   thread)
+          # RubyProf::GraphHtmlPrinter
+
+          # - Creates a call graph report in GraphViz's DOT format
+          #   which can be converted to an image
+          # RubyProf::DotPrinter
+
+          # - Creates a call tree report compatible with KCachegrind.
+          # RubyProf::CallTreePrinter
+
+          # - Uses the other printers to create several reports in one
+          #   profiling run
+          # RubyProf::MultiPrinter
+        end
+
+        work
+      end
+      # :nocov:
+
+    end # Debug
+
+  end # Logging
+
+end # Vedeu

data/lib/vedeu/logging/lockless_log_device.rb

@@ -0,0 +1,65 @@
+module Vedeu
+
+  module Logging
+
+    # Ensures we can always write to the log file by creating a
+    # lock-less log device.
+    #
+    class LocklessLogDevice < ::Logger::LogDevice
+
+      # Returns a new instance of Vedeu::Logging::LocklessLogDevice.
+      #
+      # @param log [void]
+      # @return [Vedeu::Logging::LocklessLogDevice]
+      def initialize(log = nil)
+        @dev      = nil
+        @filename = nil
+
+        if log.respond_to?(:write) && log.respond_to?(:close)
+          @dev = log
+
+        else
+          @dev      = open_logfile(log)
+          @dev.sync = true
+          @filename = log
+
+        end
+      end
+
+      # @param message [String]
+      # @return [void]
+      def write(message)
+        @dev.write(message)
+
+      rescue StandardError => exception
+        warn("log writing failed. #{exception}")
+      end
+
+      # @return [void]
+      def close
+        @dev.close
+      rescue
+        nil
+      end
+
+      private
+
+      # @param log [String]
+      # @return [void]
+      def open_logfile(log)
+        if FileTest.exist?(log)
+          open(log, (File::WRONLY | File::APPEND))
+
+        else
+          logdev = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+          logdev.sync = true
+          logdev
+
+        end
+      end
+
+    end # LocklessLogDevice
+
+  end # Logging
+
+end # Vedeu