vedeu 0.2.12 → 0.3.0

data/lib/vedeu/repositories/cursors.rb

@@ -1,64 +0,0 @@
-module Vedeu
-
-  # Repository for storing, retrieving and manipulating the cursor position and
-  # visibility for an interface.
-  #
-  # @api private
-  module Cursors
-
-    include Repository
-    extend self
-
-    # Add or update the cursor coordinates.
-    #
-    # @param attributes [Hash]
-    # @return [Offset]
-    def add(attributes)
-      validate_attributes!(attributes)
-
-      Vedeu.log("#{action(__callee__)} positional (#{model}): " \
-                "'#{attributes[:name]}'")
-
-      model.new(attributes).store
-    end
-    alias_method :update, :add
-
-    # Make the cursor of this interface invisible.
-    #
-    # @return [Cursor]
-    def hide
-      find_or_create(Focus.current).hide
-    end
-
-    # Make the cursor of this interface visible.
-    #
-    # @return [Cursor]
-    def show
-      find_or_create(Focus.current).show
-    end
-
-    private
-
-    # @return [Class] The model class for this repository.
-    def model
-      Vedeu::Cursor
-    end
-
-    # Returns an empty collection ready for the storing of cursors by name with
-    # current attributes.
-    #
-    # @example
-    #   { 'holmium' => {
-    #                    name:     'holmium',
-    #                    state:    :show,
-    #                    x:        1,
-    #                    y:        1 } }
-    #
-    # @return [Hash]
-    def in_memory
-      {}
-    end
-
-  end # Cursors
-
-end # Vedeu

data/lib/vedeu/repositories/events.rb

@@ -1,147 +0,0 @@
-module Vedeu
-
-  # Provides a mechanism for storing and retrieving events by name. A single
-  # name can contain many events. Also, an event can trigger other events.
-  #
-  # @todo I really don't like the 'hashiness' of this. (GL 2014-10-29)
-  #
-  # @api private
-  module Events
-
-    include Repository
-    extend self
-
-    # @see Vedeu::API#unevent
-    alias_method :unevent, :remove
-
-    # 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.
-    #
-    # @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 add(name, options = {}, &block)
-      Vedeu.log("Registering event: '#{name}'")
-
-      events(name) << model.new(name, options, block)
-    end
-    alias_method :event, :add
-
-    # @see Vedeu::API#trigger
-    def use(name, *args)
-      results = events(name).map { |event| event.trigger(*args) }
-
-      return results.first if results.one?
-
-      results
-    end
-    alias_method :trigger, :use
-
-    private
-
-    # @return [Class] The model class for this repository.
-    def model
-      Vedeu::Event
-    end
-
-    def events(name)
-      storage[name][:events]
-    end
-
-    # Returns an empty collection ready for the storing of events by name with
-    # associated event instance.
-    #
-    # @return [Hash]
-    def in_memory
-      Hash.new { |hash, key| hash[key] = { events: [] } }
-    end
-
-    # System events needed by Vedeu to run.
-    event(:_clear_)                   { Vedeu::Terminal.clear_screen }
-    event(:_exit_)                    { Vedeu::Application.stop      }
-    event(:_initialize_)              { Vedeu.trigger(:_refresh_)    }
-    event(:_keypress_)                { |key| Vedeu.keypress(key)    }
-    event(:_log_)                     { |msg| Vedeu.log(msg)         }
-    event(:_mode_switch_)             { fail ModeSwitch              }
-    event(:_resize_, { delay: 0.25 }) { Vedeu.resize                 }
-
-    # System events which when called will update the cursor visibility
-    # accordingly for the interface in focus.
-    # From: Cursors (top)
-    event(:_cursor_hide_) { Vedeu::Cursors.hide }
-    event(:_cursor_show_) { Vedeu::Cursors.show }
-
-    # System events which when called will change which interface is currently
-    # focussed. When the interface is brought into focus, its cursor position
-    # and visibility is restored.
-    # From: Focus (top)
-    event(:_focus_by_name_) { |name| Vedeu::Focus.by_name(name) }
-    event(:_focus_next_)    {        Vedeu::Focus.next_item }
-    event(:_focus_prev_)    {        Vedeu::Focus.prev_item }
-
-    # System events which when called will move in the direction specified;
-    # these will update the cursor position or content offset (scrolling)
-    # according to the interface in focus.
-    # From: Offsets (bottom)
-    event(:_cursor_down_)  { Vedeu::Offsets.down  }
-    event(:_cursor_left_)  { Vedeu::Offsets.left  }
-    event(:_cursor_right_) { Vedeu::Offsets.right }
-    event(:_cursor_up_)    { Vedeu::Offsets.up    }
-
-    # System events which when called with the appropriate menu name will
-    # update the menu accordingly.
-    # From: Menus (top)
-    event(:_menu_bottom_)   { |name| Vedeu::Menus.use(name).bottom_item   }
-    event(:_menu_current_)  { |name| Vedeu::Menus.use(name).current_item  }
-    event(:_menu_deselect_) { |name| Vedeu::Menus.use(name).deselect_item }
-    event(:_menu_items_)    { |name| Vedeu::Menus.use(name).items         }
-    event(:_menu_next_)     { |name| Vedeu::Menus.use(name).next_item     }
-    event(:_menu_prev_)     { |name| Vedeu::Menus.use(name).prev_item     }
-    event(:_menu_selected_) { |name| Vedeu::Menus.use(name).selected_item }
-    event(:_menu_select_)   { |name| Vedeu::Menus.use(name).select_item   }
-    event(:_menu_top_)      { |name| Vedeu::Menus.use(name).top_item      }
-    event(:_menu_view_)     { |name| Vedeu::Menus.use(name).view          }
-
-    # System event to refresh all registered interfaces.
-    event(:_refresh_) { Vedeu::Refresh.all }
-
-  end # Events
-
-end # Vedeu

data/lib/vedeu/repositories/groups.rb

@@ -1,47 +0,0 @@
-module Vedeu
-
-  # Repository for storing and retrieving interfaces by their group name.
-  #
-  # @api private
-  module Groups
-
-    include Repository
-    extend self
-
-    # Add an interface name to a group, creating the group if it doesn't already
-    # exist, and rejecting the interface if it is already known.
-    #
-    # @param attributes [Hash]
-    # @return [Boolean]
-    def add(attributes)
-      validate_attributes!(attributes)
-
-      return false unless defined_value?(attributes[:group])
-
-      storage[attributes[:group]] << attributes[:name]
-
-      register_event(attributes)
-
-      true
-    end
-
-    private
-
-    # @see Vedeu::Refresh.register_event
-    # @param attributes [Hash]
-    # @return [Boolean]
-    def register_event(attributes)
-      group_name = attributes[:group]
-      delay      = attributes[:delay] || 0.0
-
-      Vedeu::Refresh.register_event(:by_group, group_name, delay)
-    end
-
-    # @return [Hash]
-    def in_memory
-      Hash.new { |hash, key| hash[key] = Set.new }
-    end
-
-  end # Groups
-
-end # Vedeu

data/lib/vedeu/repositories/interfaces.rb

@@ -1,78 +0,0 @@
-module Vedeu
-
-  # Repository for storing and retrieving defined interfaces.
-  #
-  # @api private
-  module Interfaces
-
-    include Repository
-    extend self
-
-    # Stores the interface attributes defined by the API.
-    #
-    # @param attributes [Hash]
-    # @return [Hash|FalseClass]
-    def add(attributes)
-      validate_attributes!(attributes)
-
-      Vedeu.log("Registering interface: '#{attributes[:name]}'")
-
-      storage.store(attributes[:name], attributes)
-
-      register_event(attributes)
-
-      true
-    end
-
-    # Create an instance of Interface from the stored attributes.
-    #
-    # @param name [String]
-    # @return [Interface]
-    def build(name)
-      model.new(find(name))
-    end
-
-    # Reset the interfaces repository; removing all registered interfaces.
-    # This will delete the interfaces themselves, and the client application
-    # will need to either redefine interfaces before using them, or restart.
-    #
-    # Note: It also resets repositories which depend on interfaces being
-    # registered.
-    #
-    # @return [Hash]
-    def reset
-      @_storage = in_memory
-
-      Vedeu::Buffers.reset
-      Vedeu::Cursors.reset
-      Vedeu::Focus.reset
-      Vedeu::Groups.reset
-
-      @_storage
-    end
-
-    private
-
-    # @return [Class] The model class for this repository.
-    def model
-      Vedeu::Interface
-    end
-
-    # @see Vedeu::Refresh.register_event
-    # @param attributes [Hash]
-    # @return [Boolean]
-    def register_event(attributes)
-      name  = attributes[:name]
-      delay = attributes[:delay] || 0.0
-
-      Vedeu::Refresh.register_event(:by_name, name, delay)
-    end
-
-    # @return [Hash]
-    def in_memory
-      {}
-    end
-
-  end # Interfaces
-
-end # Vedeu

data/lib/vedeu/repositories/keymaps.rb

@@ -1,196 +0,0 @@
-module Vedeu
-
-  # Repository for storing, retrieving and using defined keymaps.
-  #
-  # @api private
-  module Keymaps
-
-    include Repository
-    extend self
-
-    # Stores the keymap attributes defined by the API.
-    #
-    # @param attributes [Hash]
-    # @option attributes :interfaces [Array] A list of the names of interfaces for which the
-    #   keys are active for.
-    # @option attributes :keys [Array] A collection of key/action pairs.
-    # @return [TrueClass|KeyInUse|FalseClass]
-    def add(attributes)
-      return false unless defined_value?(attributes[:keys])
-
-      if defined_value?(attributes[:interfaces])
-        attributes[:interfaces].map do |interface|
-          storage.store(interface, {}) unless registered?(interface)
-
-          register(attributes, interface)
-        end
-
-      else
-        register(attributes)
-
-      end
-
-      true
-    end
-
-    # Find a keymap by named interface. Return an empty collection when there =
-    # are no specific keys defined for the named interface.
-    #
-    # @param name [String]
-    # @return [Hash]
-    def find(name)
-      storage.fetch(name, {})
-    end
-
-    # Return a boolean indicating whether the key is registered as a global key.
-    #
-    # @param key [String|Symbol]
-    # @return [Boolean]
-    def global_key?(key)
-      global_keys.include?(key)
-    end
-
-    # Return the collection of global keys.
-    #
-    # @return [Array]
-    def global_keys
-      storage.fetch('_global_keymap_', {}).keys
-    end
-
-    # Return a boolean indicating whether the key is registered as an interface
-    # key. When an interface argument is provided, only that interface is
-    # checked.
-    #
-    # @param key [String|Symbol]
-    # @param interface [String]
-    # @return [Boolean]
-    def interface_key?(key, interface = '')
-      if defined_value?(interface)
-        find(interface).keys.include?(key)
-
-      else
-        interface_keys.include?(key)
-
-      end
-    end
-
-    # Return a collection of interface keys. When the optional 'name' parameter
-    # is provided, then only the keys associated with that interface are
-    # returned.
-    #
-    # @param interface [String]
-    # @return [Hash]
-    def interface_keys(interface = nil)
-      return find(interface).keys if interface
-
-      storage.reject do |k, _|
-        k == '_global_keymap_'
-      end.map { |_, v| v.keys }.flatten.uniq
-    end
-
-    # Return a boolean indicating whether the key is registered as a system key.
-    #
-    # @param key [String|Symbol]
-    # @return [Boolean]
-    def system_key?(key)
-      system_keys.include?(key)
-    end
-
-    # Return the collection of system keys.
-    #
-    # @return [Array]
-    def system_keys
-      Configuration.system_keys.invert.keys
-    end
-
-    # Handles the keypress in your application. Can also be used to simulate a
-    # keypress.
-    #
-    # 1) Log the keypress if debugging is enabled.
-    # 2) Trigger the client application's `:key` event (it may not exist).
-    # 3) Determine if the key pertains to the focussed interface and action it,
-    #    or check both global, then system keys to action it. Returns false if
-    #    nothing can deal with it.
-    #
-    # @param key [String|Symbol] The key which was pressed. Escape sequences
-    #   are also supported. Special keys like the F-keys are named as symbols;
-    #   i.e. `:f4`. A list of these translations can be found at {Vedeu::Input}.
-    #
-    # @example
-    #   Vedeu.keypress('s')
-    #
-    # @return [Array|FalseClass]
-    def use(key)
-      Vedeu.log("Key pressed: '#{key}'")
-
-      Vedeu.trigger(:key, key)
-
-      focussed_interface = Vedeu::Focus.current
-
-      if interface_key?(key, focussed_interface)
-        find(focussed_interface).fetch(key, noop).call(:noop_interface)
-
-      elsif global_key?(key)
-        find('_global_keymap_').fetch(key, noop).call(:noop_global)
-
-      elsif system_key?(key)
-        system_key(key)
-
-      else
-        false
-
-      end
-    end
-    alias_method :keypress, :use
-
-    private
-
-    # @return [Class] The model class for this repository.
-    def model
-      Vedeu::Keymap
-    end
-
-    # Triggers the system event defined for this key.
-    #
-    # @param key [String|Symbol]
-    # @return [Array] The result(s) of triggering the event.
-    def system_key(key)
-      action = Vedeu::Configuration.system_keys.key(key)
-      event  = ['_', action, '_'].join.to_sym
-
-      Vedeu.trigger(event)
-    end
-
-    # Registers the key.
-    #
-    # @param attributes [Hash]
-    # @param interface [String]
-    # @return [Array]
-    def register(attributes, interface = '_global_keymap_')
-      attributes[:keys].map do |keymap|
-        KeymapValidator.check(storage, keymap[:key], interface)
-
-        Vedeu.log("Registering key: '#{keymap[:key]}' with '#{interface}'")
-
-        storage[interface].merge!({ keymap[:key] => keymap[:action] })
-      end
-    end
-
-    # Returns a noop proc which when called returns the argument or :noop.
-    #
-    # @param value [Symbol]
-    # @return [Proc]
-    def noop(value = :noop)
-      proc { value }
-    end
-
-    # @return [Hash]
-    def in_memory
-      {
-        '_global_keymap_' => {}
-      }
-    end
-
-  end # Keymaps
-
-end # Vedeu