vedeu 0.1.15 → 0.1.16

data/lib/vedeu/models/style.rb

@@ -0,0 +1,29 @@
+module Vedeu
+  class Style
+
+    attr_reader :values
+
+    # @param values [String|Array]
+    # @return [Style]
+    def initialize(values)
+      @values = values
+    end
+
+    # @return [String]
+    def to_s
+      escape_sequences
+    end
+
+    private
+
+    def escape_sequences
+      @_sequences ||= if values.nil? || values.empty?
+        ''
+
+      else
+        Array(values).flatten.map { |value| Esc.string(value) }.join
+
+      end
+    end
+  end
+end

data/lib/vedeu/support/buffer.rb

@@ -1,41 +1,56 @@
 module Vedeu
   class Buffer
-    attr_reader :clear, :current, :group, :name, :_next
 
-    def initialize(vars)
-      @vars    = vars
-      @name    = vars.fetch(:name)
-      @clear   = vars.fetch(:clear)
-      @current = vars.fetch(:current)
-      @group   = vars.fetch(:group)
-      @_next   = vars.fetch(:next)
+    attr_reader :back, :front, :interface
+
+    # @param attributes [Hash]
+    # @return [Buffer]
+    def initialize(attributes = {})
+      @attributes = attributes
+
+      @back       = attributes.fetch(:back)
+      @front      = attributes.fetch(:front)
+      @interface  = attributes.fetch(:interface)
     end
 
-    def enqueue(sequence)
-      merge({ next: sequence })
+    # @param view [Interface]
+    # @return [Buffer]
+    def enqueue(view)
+      merge({ back: view })
     end
 
+    # @return [Buffer]
     def refresh
-      sequence = if !_next.empty?
-        merge({ current: _next, next: '' }).current
-
-      elsif current.empty?
-        clear
+      return merge({ front: back, back: nil }).render if content_available?
+      return clear                                    if no_content_available?
+      return render
+    end
 
-      else
-        current
+    def render
+      Terminal.output(front.to_s)
 
-      end
+      self
+    end
 
-      Terminal.output(sequence)
+    def clear
+      Terminal.output(interface.clear)
 
       self
     end
 
     private
 
-    def merge(vars)
-      Buffer.new(@vars.merge(vars))
+    def merge(new_attributes)
+      Buffer.new(@attributes.merge(new_attributes))
     end
+
+    def content_available?
+      !!(back)
+    end
+
+    def no_content_available?
+      front.nil?
+    end
+
   end
 end

data/lib/vedeu/support/buffers.rb

@@ -0,0 +1,88 @@
+module Vedeu
+  module Buffers
+
+    extend self
+
+    # @param attributes [Hash]
+    # @return [Hash]
+    def create(attributes)
+      store_attributes(attributes)
+
+      groups.add(attributes[:group], attributes[:name], attributes[:delay])
+
+      store_interface(Interface.new(attributes))
+    end
+
+    # @return [Hash]
+    def reset
+      @_storage = {}
+      @_buffers = {}
+      groups.reset
+    end
+
+    # @param name [String]
+    # @return [Hash]
+    def retrieve_attributes(name)
+      storage.fetch(name) { fail EntityNotFound, 'Interface was not found.' }
+    end
+
+    # @param name [String]
+    # @return [Buffer]
+    def retrieve_interface(name)
+      buffers.fetch(name) { fail EntityNotFound, 'Interface was not found.' }
+    end
+
+    # @param attributes [Hash]
+    # @return [Hash]
+    def store_attributes(attributes)
+      storage.store(attributes[:name], attributes)
+    end
+
+    # @param interface [Interface]
+    # @return [Buffer]
+    def store_interface(interface)
+      update(interface.name,
+        Buffer.new(interface: interface, back: nil, front: nil))
+    end
+
+    # @param name [String]
+    # @param view [Interface]
+    # @return []
+    def enqueue(name, view)
+      update(name, retrieve_interface(name).enqueue(view))
+    end
+
+    # @return [Array]
+    def refresh_all
+      buffers.keys.map { |name| refresh(name) }
+    end
+
+    # @return [Array]
+    def refresh_group(group_name)
+      groups.find(group_name).map { |name| refresh(name) }
+    end
+
+    def refresh(name)
+      update(name, retrieve_interface(name).refresh)
+    end
+
+    private
+
+    def update(name, buffer)
+      buffers.store(name, buffer)
+    end
+
+    def groups
+      @_groups ||= Groups.new
+    end
+
+    def buffers
+      @_buffers ||= {}
+    end
+
+    def storage
+      @_storage ||= {}
+    end
+
+  end
+end

data/lib/vedeu/{output → support}/clear.rb

@@ -1,16 +1,22 @@
 module Vedeu
   class Clear
+
+    # @param interface [Interface]
+    # @return [String]
     def self.call(interface)
       new(interface).clear
     end
 
+    # @param interface [Interface]
+    # @return [Clear]
     def initialize(interface)
       @interface = interface
     end
 
+    # @return [String]
     def clear
       rows.inject([colours]) do |line, index|
-        line << interface.origin(index) { ' ' * interface.width }
+        line << interface.origin(index) { ' ' * interface.viewport_width }
       end.join
     end
 
@@ -23,7 +29,8 @@ module Vedeu
     end
 
     def rows
-      interface.height.times
+      interface.viewport_height.times
     end
+
   end
 end

data/lib/vedeu/support/esc.rb

@@ -1,18 +1,25 @@
 module Vedeu
   module Esc
+
     extend self
 
+    # @param y [Fixnum]
+    # @param x [Fixnum]
+    # @param block [Proc]
+    # @return [String]
     def set_position(y = 1, x = 1, &block)
       Position.new(y, x).to_s(&block)
     end
 
+    # @param value [String]
+    # @return [String]
     def string(value = '')
       case value
       when 'bg_reset'      then "\e[48;2;49m"
       when 'blink'         then "\e[5m"
       when 'blink_off'     then "\e[25m"
       when 'bold'          then "\e[1m"
-      when 'bold_off'      then "\e[21m"
+      when 'bold_off'      then "\e[22m"
       when 'clear'         then "\e[38;2;39m\e[48;2;49m\e[2J"
       when 'clear_line'    then "\e[38;2;39m\e[48;2;49m\e[2K"
       when 'colour_reset'  then "\e[38;2;39m\e[48;2;49m"
@@ -23,7 +30,7 @@ module Vedeu
       when 'negative'      then "\e[7m"
       when 'positive'      then "\e[27m"
       when 'reset'         then "\e[0m"
-      when 'normal'        then "\e[24m\e[21m\e[27m"
+      when 'normal'        then "\e[24m\e[22m\e[27m"
       when 'dim'           then "\e[2m"
       when 'show_cursor'   then "\e[?25h"
       when 'underline'     then "\e[4m"
@@ -32,5 +39,12 @@ module Vedeu
         ''
       end
     end
+
+    # private
+
+    # def method_missing(method, *args, &block)
+    #   self.send(:string, method, &block)
+    # end
+
   end
 end

data/lib/vedeu/support/event.rb

@@ -0,0 +1,104 @@
+module Vedeu
+  class Event
+
+    # @param closure [Proc]
+    # @param options [Hash]
+    # @return [Event]
+    def initialize(closure, options = {})
+      @closure      = closure
+      @options      = options
+      @deadline     = 0
+      @executed_at  = 0
+      @now          = 0
+    end
+
+    # @params args [Array]
+    # @return []
+    def trigger(*args)
+      return execute(*args) unless debouncing? || throttling?
+
+      return execute(*args) if debouncing? && set_executed > deadline
+
+      return execute(*args) if throttling? && elapsed_time > delay
+    end
+
+    private
+
+    attr_reader   :closure
+    attr_accessor :deadline, :executed_at, :now
+
+    def execute(*args)
+      reset_deadline
+
+      set_executed
+
+      reset_time
+
+      closure.call(*args)
+    end
+
+    def throttling?
+      set_time
+
+      options[:delay] > 0
+    end
+
+    def debouncing?
+      set_time
+
+      set_deadline unless has_deadline?
+
+      options[:debounce] > 0
+    end
+
+    def elapsed_time
+      now - @executed_at
+    end
+
+    def set_executed
+      @executed_at = now
+    end
+
+    def set_time
+      @now = Time.now.to_f
+    end
+
+    def reset_time
+      @now = 0
+    end
+
+    def has_deadline?
+      @deadline > 0
+    end
+
+    def reset_deadline
+      @deadline = 0
+    end
+
+    def set_deadline
+      @deadline = now + debounce
+
+      nil
+    end
+
+    def debounce
+      options[:debounce]
+    end
+
+    def delay
+      options[:delay]
+    end
+
+    def options
+      defaults.merge!(@options)
+    end
+
+    def defaults
+      {
+        delay:    0,
+        debounce: 0
+      }
+    end
+
+  end
+end

data/lib/vedeu/support/events.rb

@@ -0,0 +1,61 @@
+module Vedeu
+  class Events
+
+    # @param block [Proc]
+    # @return [Events]
+    def initialize(&block)
+      @handlers = Hash.new { |hash, key| hash[key] = { events: [] } }
+
+      instance_eval(&block) if block_given?
+    end
+
+    # @param object []
+    # @param block [Proc]
+    # @return []
+    def add(object, &block)
+      @self_before_instance_eval = eval('self', block.binding)
+
+      instance_eval(&block)
+    end
+
+    # @see Vedeu::API#event
+    def event(name, opts = {}, &block)
+      handlers[name][:events] << Event.new(block, opts)
+      handlers[name]
+    end
+
+    # Unregisters the event by name, effectively deleting the associated events
+    # bound with it also.
+    #
+    # @param name [Symbol]
+    # @return []
+    def unevent(name)
+      handlers.delete_if { |k, v| k == name }
+    end
+
+    # Returns a collection of the names of all the registered events.
+    #
+    # @return [Array]
+    def registered
+      handlers.keys
+    end
+
+    # @see Vedeu::API#trigger
+    def trigger(name, *args)
+      handlers[name][:events].each { |event| event.trigger(*args) }
+    end
+
+    def reset
+      @handlers = Hash.new { |hash, key| hash[key] = { events: [] } }
+    end
+
+    private
+
+    attr_reader :handlers
+
+    def method_missing(method, *args, &block)
+      @self_before_instance_eval.send(method, *args, &block)
+    end
+
+  end
+end

data/lib/vedeu/support/focus.rb

@@ -0,0 +1,69 @@
+module Vedeu
+  NoInterfacesDefined = Class.new(StandardError)
+  InterfaceNotFound   = Class.new(StandardError)
+
+  # Maintains which interface is current in focus.
+  class Focus
+
+    def initialize
+      register_events
+
+      self
+    end
+
+    def add(name)
+      if registered?(name)
+        storage
+
+      else
+        storage << name
+
+      end
+    end
+
+    def by_name(name)
+      fail InterfaceNotFound unless storage.include?(name)
+
+      storage.rotate!(storage.index(name))
+
+      current
+    end
+
+    def current
+      fail NoInterfacesDefined if storage.empty?
+
+      storage.first
+    end
+
+    def next_item
+      storage.rotate!
+
+      current
+    end
+
+    def prev_item
+      storage.rotate!(-1)
+
+      current
+    end
+
+    def register_events
+      Vedeu.event(:_focus_next_)    { next_item }
+      Vedeu.event(:_focus_prev_)    { prev_item }
+      Vedeu.event(:_focus_by_name_) { |name| by_name(name) }
+    end
+
+    private
+
+    def registered?(name)
+      return false if storage.empty?
+
+      storage.include?(name)
+    end
+
+    def storage
+      @storage ||= []
+    end
+
+  end
+end