vedeu 0.6.7 → 0.6.8

data/lib/vedeu/models/views/html_char.rb

@@ -0,0 +1,165 @@
+module Vedeu
+
+  module Views
+
+    # Represents a {Vedeu::Views::Char} as a HTML tag with value. By
+    # default, a table cell is used.
+    #
+    class HTMLChar
+
+      include Vedeu::Common
+
+      # @param char [Vedeu::Views::Char]
+      # @param options [Hash<Symbol => String>]
+      # @option options start_tag [String]
+      # @option options end_tag [String]
+      # @return [String]
+      def self.render(char, options = {})
+        new(char, options).render
+      end
+
+      # Returns a new instance of Vedeu::Views::HTMLChar.
+      #
+      # @param char [Vedeu::Views::Char]
+      # @param options [Hash<Symbol => String>]
+      # @option options start_tag [String]
+      # @option options end_tag [String]
+      # @return [Vedeu::Views::HTMLChar]
+      def initialize(char, options = {})
+        @char    = char
+        @options = options
+      end
+
+      # @return [String]
+      def render
+        "#{start_tag}#{tag_style}>#{tag_value}#{end_tag}"
+      end
+
+      protected
+
+      # @!attribute [r] char
+      # @return [Vedeu::Views::Char]
+      attr_reader :char
+
+      private
+
+      # @return [String]
+      def tag_style
+        return '' unless border || present?(value)
+
+        out = " style='"
+        out << tag_style_background unless char.background.empty?
+        out << tag_style_foreground unless char.foreground.empty?
+        out << "'"
+      end
+
+      # @return [String]
+      def tag_style_background
+        "border:1px #{char.background.to_html} solid;" \
+          "background:#{char.background.to_html};"
+      end
+
+      # @return [String]
+      def tag_style_foreground
+        "color:#{char.foreground.to_html};#{border_style}"
+      end
+
+      # @return [String]
+      def tag_value
+        return '&nbsp;' if border || !present?(value)
+
+        value
+      end
+
+      # @return [String]
+      def border_style
+        case border
+        when :top_horizontal    then css('top')
+        when :left_vertical     then css('left')
+        when :right_vertical    then css('right')
+        when :bottom_horizontal then css('bottom')
+        when :top_left     then "#{css('top')}#{css('left')}"
+        when :top_right    then "#{css('top')}#{css('right')}"
+        when :bottom_left  then "#{css('bottom')}#{css('left')}"
+        when :bottom_right then "#{css('bottom')}#{css('right')}"
+        else
+          ''
+        end
+      end
+
+      # @return [String]
+      def css(direction = '')
+        "border-#{direction}:1px #{char.foreground.to_html} solid;"
+      end
+
+      # # @return [String]
+      # def fg
+      #   @fg ||= colour(char, 'foreground', '#222')
+      # end
+
+      # # @return [String]
+      # def bg
+      #   @bg ||= colour(char, 'background', '#000')
+      # end
+
+      # @param char [Vedeu::Views::Char]
+      # @param type [String] 'background' or 'foreground'
+      # @param default [String] A default colour (CSS style; e.g. '#b2adf2')
+      # @return [String]
+      # def colour(char, type, default)
+      #   parent_type         = char.send(:parent).send(type).send(:to_html)
+      #   #parent_type         = ('parent_' + type).to_sym
+      #   type_to_html        = char.send(type).send(:to_html)
+      #   #parent_type_to_html = char.send(parent_type).send(:to_html)
+
+      #   if present?(type_to_html)
+      #     type_to_html
+
+      #   elsif char.parent
+      #     parent_type
+      #     #char.parent.send(type).send(:to_html)
+
+      #   else
+      #     default
+
+      #   end
+      # end
+
+      # @return [Symbol|NilClass]
+      def border
+        char.border
+      end
+
+      # @return [String]
+      def value
+        char.value
+      end
+
+      # @return [String]
+      def start_tag
+        options[:start_tag]
+      end
+
+      # @return [String]
+      def end_tag
+        options[:end_tag]
+      end
+
+      # @return [Hash<Symbol => String>]
+      def options
+        defaults.merge!(@options)
+      end
+
+      # @return [Hash<Symbol => String>]
+      def defaults
+        {
+          start_tag: '<td',
+          end_tag:   '</td>',
+        }
+      end
+
+    end # HTMLChar
+
+  end # Views
+
+end # Vedeu

data/lib/vedeu/output/renderers/html.rb

@@ -2,8 +2,8 @@ module Vedeu
 
   module Renderers
 
-    # Renders a {Vedeu::VirtualBuffer} or {Vedeu::Output} as a HTML snippet;
-    # a table by default.
+    # Renders a {Vedeu::VirtualBuffer} or {Vedeu::Output} as a HTML
+    # snippet; a table by default.
     #
     class HTML < Vedeu::Renderers::File
 
@@ -29,7 +29,7 @@ module Vedeu
 
       # @return [String]
       def html_body
-        return '' if content.is_a?(Vedeu::Escape)
+        return '' if content.is_a?(Vedeu::Models::Escape)
 
         out = ''
 
@@ -68,7 +68,8 @@ module Vedeu
         options[:template]
       end
 
-      # Combines the options provided at instantiation with the default values.
+      # Combines the options provided at instantiation with the
+      # default values.
       #
       # @return [Hash<Symbol => void>]
       def options

data/lib/vedeu/repositories/model.rb

@@ -115,6 +115,8 @@ module Vedeu
         'Vedeu::Buffers::DSL'
       elsif demodulize(self.class.name) == 'Geometry'
         'Vedeu::Geometry::DSL'
+      elsif demodulize(self.class.name) == 'Menu'
+        'Vedeu::Menus::DSL'
       else
         'Vedeu::DSL::' + demodulize(self.class.name)
       end

data/lib/vedeu/runtime/application.rb

@@ -1,132 +1,139 @@
 module Vedeu
 
-  # Orchestrates the running of the main application loop.
-  #
-  class Application
+  module Runtime
 
-    class << self
-
-      # @param (see #initialize)
-      def start(configuration)
-        new(configuration).start
-      end
-
-      # @param (see #initialize)
-      def restart(configuration)
-        new(configuration).start
+    # Orchestrates the running of the main application loop.
+    #
+    class Application
+
+      class << self
+
+        # @param (see #initialize)
+        def start(configuration)
+          new(configuration).start
+        end
+
+        # @param (see #initialize)
+        def restart(configuration)
+          new(configuration).start
+        end
+
+        # Stops the application! - The `:_cleanup_` event is
+        # triggered, which in turn triggers the client event
+        # `:cleanup`; the client application may treat this event as
+        # Vedeu signalling that it is about to terminate. Client
+        # applications are encouraged to use this event to close any
+        # open buffers, save files, empty trash, etc.
+        #
+        # @example
+        #   Vedeu.exit
+        #
+        # @return [void]
+        def stop
+          Vedeu.trigger(:_cleanup_)
+
+          Vedeu::Runtime::MainLoop.stop!
+        end
+        alias_method :exit, :stop
+
+      end # Eigenclass
+
+      # :nocov:
+
+      # Returns a new instance of Vedeu::Runtime::Application.
+      #
+      # @param configuration [Vedeu::Configuration]
+      # @return [Vedeu::Runtime::Application]
+      def initialize(configuration)
+        @configuration = configuration
       end
 
-      # Stops the application!
-      # - The `:_cleanup_` event is triggered, which in turn triggers the client
-      #   event `:cleanup`; the client application may treat this event as Vedeu
-      #   signalling that it is about to terminate. Client applications are
-      #   encouraged to use this event to close any open buffers, save files,
-      #   empty trash, etc.
+      # Starts the application!
       #
-      # @example
-      #   Vedeu.exit
+      # - A new terminal screen is opened (or rather the current
+      #   terminal is requested into either :raw or :cooked mode).
+      # - The cursor visibility is then set dependent on this mode.
+      #   In :raw mode, the cursor is hidden.
+      # - The `:_initialize_` event is triggered. The client
+      #   application is may treat this event as Vedeu signalling that
+      #   it is now ready.
+      # - We enter into the main sequence where the application will
+      #   either run once or continuous, interactively or standalone.
       #
-      # @return [void]
-      def stop
-        Vedeu.trigger(:_cleanup_)
-
-        Vedeu::MainLoop.stop!
-      end
-      alias_method :exit, :stop
-
-    end # Eigenclass
-
-    # :nocov:
-
-    # Returns a new instance of Vedeu::Application.
-    #
-    # @param configuration [Vedeu::Configuration]
-    # @return [Vedeu::Application]
-    def initialize(configuration)
-      @configuration = configuration
-    end
-
-    # Starts the application!
-    # - A new terminal screen is opened (or rather the current terminal is
-    #   requested into either :raw or :cooked mode).
-    # - The cursor visibility is then set dependent on this mode. In :raw mode,
-    #   the cursor is hidden.
-    # - The `:_initialize_` event is triggered. The client application is
-    #   may treat this event as Vedeu signalling that it is now ready.
-    # - We enter into the main sequence where the application will either run
-    #   once or continuous, interactively or standalone.
-    #
-    # @return [Array] The last output sent to the terminal.
-    def start
-      Vedeu.trigger(:_drb_start_)
+      # @return [Array] The last output sent to the terminal.
+      def start
+        Vedeu.trigger(:_drb_start_)
 
-      Vedeu::Terminal.open do
-        Vedeu::Terminal.set_cursor_mode
+        Vedeu::Terminal.open do
+          Vedeu::Terminal.set_cursor_mode
 
-        Vedeu.trigger(:_initialize_)
+          Vedeu.trigger(:_initialize_)
 
-        runner { main_sequence }
+          runner { main_sequence }
+        end
       end
-    end
 
-    protected
+      protected
 
-    # @!attribute [r] configuration
-    # @return [Vedeu::Configuration]
-    attr_reader :configuration
+      # @!attribute [r] configuration
+      # @return [Vedeu::Configuration]
+      attr_reader :configuration
 
-    private
+      private
 
-    # Runs the application loop either once, or forever (exceptions and signals
-    # permitting).
-    #
-    # @return [void]
-    def runner
-      if configuration.once?
-        yield
+      # Runs the application loop either once, or forever (exceptions
+      # and signals permitting).
+      #
+      # @return [void]
+      def runner
+        if configuration.once?
+          yield
 
-      else
-        run_many { yield }
+        else
+          run_many { yield }
 
+        end
       end
-    end
-
-    # For an interactive application we capture input, (usually from the user),
-    # and continue the main loop. If the client application does not require
-    # user input then Vedeu triggers the `:_standalone_` event for each run of
-    # the main loop. The client application is expected to respond to this event
-    # and 'do something useful'. When the client application has finished, it
-    # should trigger the `:_exit_` event.
-    #
-    # @return [void]
-    def main_sequence
-      if configuration.interactive?
-        Vedeu::Input.capture(Terminal)
 
-      else
-        Vedeu.trigger(:_standalone_)
+      # For an interactive application we capture input, (usually from
+      # the user), and continue the main loop. If the client
+      # application does not require user input then Vedeu triggers
+      # the `:_standalone_` event for each run of the main loop. The
+      # client application is expected to respond to this event and
+      # 'do something useful'. When the client application has
+      # finished, it should trigger the `:_exit_` event.
+      #
+      # @return [void]
+      def main_sequence
+        if configuration.interactive?
+          Vedeu::Input::Input.capture(Terminal)
+
+        else
+          Vedeu.trigger(:_standalone_)
 
+        end
       end
-    end
 
-    # Runs the application in a continuous loop. This loop is stopped when an
-    # uncaught exception occurs or when either the `:_mode_switch_` or `:_exit_`
-    # event is triggered.
-    #
-    # @return [void]
-    def run_many
-      Vedeu::MainLoop.start! { yield }
+      # Runs the application in a continuous loop. This loop is
+      # stopped when an uncaught exception occurs or when either the
+      # `:_mode_switch_` or `:_exit_` event is triggered.
+      #
+      # @return [void]
+      def run_many
+        Vedeu::Runtime::MainLoop.start! { yield }
+
+      rescue Vedeu::Error::ModeSwitch
+        Vedeu::Terminal.switch_mode!
 
-    rescue Vedeu::Error::ModeSwitch
-      Vedeu::Terminal.switch_mode!
+        Vedeu.trigger(:_drb_restart_)
 
-      Vedeu.trigger(:_drb_restart_)
+        Vedeu::Runtime::Application.restart(configuration)
+      end
 
-      Vedeu::Application.restart(configuration)
-    end
+      # :nocov:
 
-    # :nocov:
+    end # Application
 
-  end # Application
+  end # Runtime
 
 end # Vedeu

data/lib/vedeu/runtime/bootstrap.rb

@@ -1,123 +1,129 @@
 module Vedeu
 
-  # Provides the mechanism to start up a generated application.
-  #
-  # This class loads all necessary client application files and initializes
-  # Vedeu with this data, then starts the client application.
-  #
-  class Bootstrap
-
-    # @param argv [Array<String>]
-    # @return [void]
-    def self.start(argv = ARGV)
-      new(argv).start
-    end
-
-    # Returns a new instance of Vedeu::Bootstrap.
+  module Runtime
+
+    # Provides the mechanism to start up a generated application.
     #
-    # @param argv [Array<String>]
-    # @return [Vedeu::Bootstrap]
-    def initialize(argv)
-      @argv = argv
-    end
-
-    # Loads all of the client application files so that Vedeu has access to
-    # them, then launches the client application.
+    # This class loads all necessary client application files and initializes
+    # Vedeu with this data, then starts the client application.
     #
-    # @return [void]
-    def start
-      configure_log!
-      client_configuration!
-      client_application!
-      client_initialize!
+    class Bootstrap
+
+      # @param argv [Array<String>]
+      # @return [void]
+      def self.start(argv = ARGV)
+        new(argv).start
+      end
+
+      # Returns a new instance of Vedeu::Runtime::Bootstrap.
+      #
+      # @param argv [Array<String>]
+      # @return [Vedeu::Runtime::Bootstrap]
+      def initialize(argv)
+        @argv = argv
+      end
 
-      Vedeu::Launcher.execute!(argv)
-    end
+      # Loads all of the client application files so that Vedeu has access to
+      # them, then launches the client application.
+      #
+      # @return [void]
+      def start
+        configure_log!
+        client_configuration!
+        client_application!
+        client_initialize!
+
+        Vedeu::Launcher.execute!(argv)
+      end
 
-    protected
+      protected
 
-    # @!attribute [r] argv
-    # @return [Array<String>]
-    attr_reader :argv
+      # @!attribute [r] argv
+      # @return [Array<String>]
+      attr_reader :argv
 
-    private
+      private
 
-    # @return [String]
-    def base_path
-      Vedeu::Configuration.base_path
-    end
+      # @return [String]
+      def base_path
+        Vedeu::Configuration.base_path
+      end
 
-    # @note
-    #   config/configuration.rb is already loaded so don't load it twice
-    # @return [void]
-    def client_configuration!
-      Dir[File.join(base_path, 'config/**/*')].each do |path|
-        next if path =~ %r{config/configuration\.rb}
+      # @note
+      #   config/configuration.rb is already loaded so don't load it twice
+      # @return [void]
+      def client_configuration!
+        Dir[File.join(base_path, 'config/**/*')].each do |path|
+          next if path =~ %r{config/configuration\.rb}
 
-        load(path)
+          load(path)
+        end
       end
-    end
-
-    # @return [void]
-    def client_application!
-      [
-        'app/views/templates/**/*',
-        'app/views/interfaces/**/*',
-        'app/controllers/**/*',
-        'app/helpers/**/*',
-        'app/views/**/*',
-        'app/models/keymaps/**/*',
-      ].each { |path| load(File.join(base_path, path)) }
-    end
-
-    # @return [void]
-    def client_initialize!
-      if Vedeu::Configuration.root
-        Vedeu.trigger(:_goto_, *Vedeu::Configuration.root)
-
-      else
-        Vedeu.log_stderr(type: :debug, message: client_initialize_error)
 
+      # @return [void]
+      def client_application!
+        [
+          'app/views/templates/**/*',
+          'app/views/interfaces/**/*',
+          'app/controllers/**/*',
+          'app/helpers/**/*',
+          'app/views/**/*',
+          'app/models/keymaps/**/*',
+        ].each { |path| load(File.join(base_path, path)) }
       end
-    end
 
-    # Load each of the loadable files.
-    #
-    # @param path [String]
-    # @return [String]
-    def load(path)
-      loadables(path).each { |file| Kernel.load(file) }
+      # @return [void]
+      def client_initialize!
+        if Vedeu::Configuration.root
+          Vedeu.trigger(:_goto_, *Vedeu::Configuration.root)
 
-      path
-    end
+        else
+          Vedeu.log_stderr(type: :debug, message: client_initialize_error)
 
-    # Collect each of the files from the client application directories by path
-    # excluding '.' and '..' and only loading files with the '.rb' extension.
-    #
-    # @param path [String]
-    # @return [Array<String>]
-    def loadables(path)
-      Dir.glob(path).select do |file|
-        File.file?(file) && File.extname(file) == '.rb'
+        end
+      end
+
+      # Load each of the loadable files.
+      #
+      # @param path [String]
+      # @return [String]
+      def load(path)
+        loadables(path).each { |file| Kernel.load(file) }
+
+        path
+      end
+
+      # Collect each of the files from the client application
+      # directories by path excluding '.' and '..' and only loading
+      # files with the '.rb' extension.
+      #
+      # @param path [String]
+      # @return [Array<String>]
+      def loadables(path)
+        Dir.glob(path).select do |file|
+          File.file?(file) && File.extname(file) == '.rb'
+        end
+      end
+
+      # @return [void]
+      def configure_log!
+        Vedeu.configure do
+          log('/tmp/vedeu_bootstrap.log')
+        end unless Vedeu::Configuration.log?
+      end
+
+      # @return [String]
+      def client_initialize_error
+        "Please update the 'root' setting in " \
+        "'config/configuration.rb' to start Vedeu using this " \
+        "controller and action: (args are optional)\n\n" \
+        "Vedeu.configure do\n" \
+        "  root :some_controller, :show, *args\n" \
+        "end\n\n"
       end
-    end
-
-    # @return [void]
-    def configure_log!
-      Vedeu.configure do
-        log('/tmp/vedeu_bootstrap.log')
-      end unless Vedeu::Configuration.log?
-    end
-
-    # @return [String]
-    def client_initialize_error
-      "Please update the 'root' setting in 'config/configuration.rb' to "     \
-      "start Vedeu using this controller and action: (args are optional)\n\n" \
-      "Vedeu.configure do\n" \
-      "  root :some_controller, :show, *args\n" \
-      "end\n\n"
-    end
-
-  end # Bootstrap
+
+    end # Bootstrap
+
+  end # Runtime
 
 end # Vedeu