vedeu 0.1.18 → 0.1.19

data/bin/log

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
-
--> { its -> { a } }
-trap('INT') { exit! }
-
-require 'vedeu'
-
-loop do
-  Vedeu.log('-B<-------------------------------------------------------------------')
-
-  sleep 60
-end

data/lib/vedeu/support/buffer.rb

@@ -1,69 +0,0 @@
-module Vedeu
-  class Buffer
-
-    attr_reader :back, :front, :interface
-
-    # @param [Hash] attributes The buffer attributes.
-    # @option attributes :back [Hash] The next view to be rendered.
-    # @option attributes :front [Hash] The view which is currently on screen.
-    # @option attributes :interface [Hash] An attribute form of the interface from
-    #   which we can create a new front or back.
-    # @return [Buffer]
-    def initialize(attributes = {})
-      @attributes = attributes
-
-      @back       = attributes.fetch(:back)
-      @front      = attributes.fetch(:front)
-      @interface  = attributes.fetch(:interface)
-    end
-
-    # @param view [Interface]
-    # @return [Buffer]
-    def enqueue(view)
-      merge({ back: view })
-    end
-
-    # @return [Buffer]
-    def refresh
-      return merge({ front: back, back: nil }).render if content_available?
-      return clear                                    if no_content_available?
-      return render
-    end
-
-    # @return [Buffer]
-    def render
-      Terminal.output(front.to_s)
-
-      self
-    end
-
-    # @return [Buffer]
-    def clear
-      Terminal.output(interface.clear)
-
-      self
-    end
-
-    private
-
-    # @api private
-    # @param new_attributes [Hash]
-    # @return [Buffer]
-    def merge(new_attributes)
-      Buffer.new(@attributes.merge(new_attributes))
-    end
-
-    # @api private
-    # @return [TrueClass|FalseClass]
-    def content_available?
-      !!(back)
-    end
-
-    # @api private
-    # @return [TrueClass|FalseClass]
-    def no_content_available?
-      front.nil?
-    end
-
-  end
-end

data/lib/vedeu/support/buffers.rb

@@ -1,106 +0,0 @@
-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])
-
-      focus.add(attributes[:name])
-
-      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
-
-    # @param name [String]
-    # @return []
-    def refresh(name)
-      update(name, retrieve_interface(name).refresh)
-    end
-
-    private
-
-    # @api private
-    # @return []
-    def update(name, buffer)
-      buffers.store(name, buffer)
-    end
-
-    # @api private
-    # @return [Focus]
-    def focus
-      @_focus ||= Focus.new
-    end
-
-    # @api private
-    # @return [Groups]
-    def groups
-      @_groups ||= Groups.new
-    end
-
-    # @api private
-    # @return [Hash]
-    def buffers
-      @_buffers ||= {}
-    end
-
-    # @api private
-    # @return [Hash]
-    def storage
-      @_storage ||= {}
-    end
-
-  end
-end

data/lib/vedeu/support/focus.rb

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

data/lib/vedeu/support/groups.rb

@@ -1,61 +0,0 @@
-module Vedeu
-  class Groups
-
-    # @return [Groups]
-    def initialize; end
-
-    # @return [Set]
-    def all
-      @_storage
-    end
-
-    # @param name [String]
-    # @return [Set]
-    def find(name)
-      storage.fetch(name) do
-        fail GroupNotFound, 'Cannot find interface group with this name.'
-      end
-    end
-
-    # @param group [String]
-    # @param name [String]
-    # @param delay [Float]
-    # @return [Groups|FalseClass]
-    def add(group, name, delay = 0.0)
-      return false if group.empty?
-
-      storage[group] << name
-
-      register_group_refresh_event(group, delay)
-
-      self
-    end
-
-    # @return [Hash]
-    def reset
-      @_storage = in_memory
-    end
-
-    private
-
-    # @api private
-    # @return []
-    def register_group_refresh_event(group, delay = 0.0)
-      Vedeu.event("_refresh_group_#{group}_".to_sym, { delay: delay }) do
-        Buffers.refresh_group(group)
-      end
-    end
-
-    # @api private
-    # @return [Hash]
-    def storage
-      @_storage ||= in_memory
-    end
-
-    # @api private
-    # @return [Hash]
-    def in_memory
-      Hash.new { |hash, key| hash[key] = Set.new }
-    end
-  end
-end

data/lib/vedeu/support/input.rb

@@ -1,67 +0,0 @@
-module Vedeu
-  class Input
-
-    # @return [String|Symbol]
-    def self.capture
-      new.capture
-    end
-
-    # @return [Input]
-    def initialize; end
-
-    # @return []
-    def capture
-      Vedeu.trigger(:_keypress_, keypress)
-    end
-
-    private
-
-    # @api private
-    # @return [String]
-    def input
-      @_input ||= Terminal.input
-    end
-
-    # @api private
-    # @return [String|Symbol]
-    def keypress
-      key        = input
-      translated = case key
-      when "\r"      then :enter
-      when "\t"      then :tab
-      when "\e"      then :escape
-      when "\e[A"    then :up
-      when "\e[B"    then :down
-      when "\e[C"    then :right
-      when "\e[D"    then :left
-      when "\e[5~"   then :page_up
-      when "\e[6~"   then :page_down
-      when "\e[H"    then :home
-      when "\e[3~"   then :delete
-      when "\e[F"    then :end
-      when "\e[Z"    then :shift_tab
-      when "\eOP"    then :f1
-      when "\eOQ"    then :f2
-      when "\eOR"    then :f3
-      when "\eOS"    then :f4
-      when "\e[15~"  then :f5
-      when "\e[17~"  then :f6
-      when "\e[18~"  then :f7
-      when "\e[19~"  then :f8
-      when "\e[20~"  then :f9
-      when "\e[21~"  then :f10
-      when "\e[23~"  then :f11
-      when "\e[24~"  then :f12
-      when "\e[1;2P" then :print_screen
-      when "\e[1;2Q" then :scroll_lock
-      when "\e[1;2R" then :pause_break
-      when "\u007F"  then :backspace
-      else
-        key
-      end
-
-      translated
-    end
-
-  end
-end

data/test/lib/vedeu/support/buffer_test.rb

@@ -1,83 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-  describe Buffer do
-    let(:vars) {
-      {
-        back: '',
-        front: '',
-        interface: mock('Interface'),
-      }
-    }
-
-    describe '#initialize' do
-      it 'returns a Buffer instance when all the vars are set' do
-        #vars = { name: 'interface', clear: '', current: '', group: '', next: '' }
-        Buffer.new(vars).must_be_instance_of(Buffer)
-      end
-
-      it 'raises an exception if a var is not set' do
-        vars = {}
-        proc { Buffer.new(vars) }.must_raise(KeyError)
-      end
-    end
-
-    describe '#enqueue' do
-      it 'creates a new Buffer instance with the sequence assigned to @_next' do
-        buffer     = Buffer.new(vars)
-        new_buffer = buffer.enqueue('some_sequence')
-
-        buffer.back.must_equal('')
-        new_buffer.wont_equal(buffer)
-        new_buffer.back.must_equal('some_sequence')
-      end
-    end
-
-    describe '#refresh' do
-      it 'renders the fresh content if available' do
-        interface = Interface.new
-        buffer    = Buffer.new({ back: interface, front: nil, interface: interface })
-        Terminal.stub(:output, '') do
-          buffer.refresh.must_be_instance_of(Buffer)
-          buffer.refresh.wont_equal(buffer)
-        end
-      end
-
-      it 'clears the interface if no content is available' do
-        interface = Interface.new
-        buffer    = Buffer.new({ back: nil, front: nil, interface: interface })
-        Terminal.stub(:output, '') do
-          buffer.refresh.must_equal(buffer)
-        end
-      end
-
-      it 'renders the previous/old content if nothing new has arrived' do
-        interface = Interface.new
-        buffer    = Buffer.new({ back: nil, front: interface, interface: interface })
-        Terminal.stub(:output, '') do
-          buffer.refresh.must_equal(buffer)
-        end
-      end
-    end
-
-    describe '#render' do
-      it 'renders the interface and returns the Buffer instance' do
-        interface = Interface.new
-        buffer = Buffer.new({ back: nil, front: nil, interface: interface })
-        Terminal.stub(:output, '') do
-          buffer.render.must_equal(buffer)
-        end
-      end
-    end
-
-    describe '#clear' do
-      it 'clears the interface and returns the Buffer instance' do
-        interface = Interface.new
-        buffer = Buffer.new({ back: nil, front: nil, interface: interface })
-        Terminal.stub(:output, '') do
-          buffer.clear.must_equal(buffer)
-        end
-      end
-    end
-  end
-end