vedeu 0.0.10 → 0.0.11

data/lib/vedeu/{process → repository}/dummy_command.rb

@@ -1,7 +1,7 @@
 module Vedeu
   class DummyCommand
-    def self.dispatch
-      'Dummy'
+    def self.dispatch(value = :dummy)
+      value
     end
   end
 end

data/lib/vedeu/repository/dummy_interface.rb

@@ -0,0 +1,4 @@
+module Vedeu
+  class DummyInterface
+  end
+end

data/lib/vedeu/repository/interface.rb

@@ -0,0 +1,52 @@
+module Vedeu
+  class Interface
+    attr_accessor :id, :active, :attributes, :result, :name, :geometry
+
+    class << self
+      def create(attributes = {})
+        new(attributes).create
+      end
+    end
+
+    def initialize(attributes = {})
+      @attributes = attributes || {}
+      @name       = attributes[:name]
+      @active     = false
+      @geometry   = Geometry.new(attributes[:geometry])
+    end
+
+    def create
+      InterfaceRepository.create(self)
+
+      InterfaceRepository.activate(self.name)
+
+      self
+    end
+
+    def origin(index = 0)
+      Position.set(geometry.vy(index), geometry.vx)
+    end
+
+    def initial_state
+      # raise NotImplementedError, 'Subclasses implement this method.'
+    end
+
+    def input
+      raise Collapse if evaluate == :stop
+    end
+
+    def output
+      Compositor.arrange(@result, self) unless @result.nil? || @result.empty?
+    end
+
+    private
+
+    def evaluate
+      @result = Input.evaluate(read)
+    end
+
+    def read
+      Terminal.input
+    end
+  end
+end

data/lib/vedeu/repository/interface_repository.rb

@@ -0,0 +1,49 @@
+module Vedeu
+  class InterfaceRepository
+    extend Repository
+
+    class << self
+      def activate(name)
+        deactivate
+
+        all.map do |interface|
+          interface.active = true if interface.name == name
+        end
+      end
+
+      def deactivate
+        all.map { |interface| interface.active = false }
+      end
+
+      def activated
+        query(klass, :active, true)
+      end
+
+      def find_by_name(value)
+        query(klass, :name, value)
+      end
+
+      def initial_state
+        all.map { |interface| interface.initial_state }
+      end
+
+      def update; end
+
+      def input
+        all.map do |interface|
+          interface.origin
+
+          interface.input
+        end
+      end
+
+      def output
+        all.map { |interface| interface.output }
+      end
+
+      def klass
+        Interface
+      end
+    end
+  end
+end

data/lib/vedeu/repository/repository.rb

@@ -0,0 +1,35 @@
+module Vedeu
+  module Repository
+    def adaptor
+      @adaptor ||= Storage.new
+    end
+
+    def adaptor=(adaptor)
+      @adaptor = adaptor
+    end
+
+    def find(id)
+      adaptor.find(self.klass, id)
+    end
+
+    def all
+      adaptor.all(self.klass)
+    end
+
+    def query(klass, attribute, value)
+      adaptor.query(klass, attribute, value)
+    end
+
+    def create(model)
+      adaptor.create(model)
+    end
+
+    def delete(model)
+      adaptor.delete(model)
+    end
+
+    def reset
+      adaptor.reset(self.klass)
+    end
+  end
+end

data/lib/vedeu/repository/storage.rb

@@ -0,0 +1,46 @@
+module Vedeu
+  class Storage
+    def initialize
+      @counter = 0
+      @map = {}
+    end
+
+    def create(record)
+      @counter = @counter + 1
+      record.id ||= @counter
+      map_for(record)[record.id] = record
+    end
+
+    def delete(record)
+      map_for(record).delete(record.id)
+    end
+
+    def reset(klass)
+      all(klass).map { |record| delete(record) }
+    end
+
+    def find(klass, id)
+      map_for_class(klass).fetch(id)
+    end
+
+    def all(klass)
+      map_for_class(klass).values
+    end
+
+    def query(klass, attribute, value)
+      map_for_class(klass).select do |id, result|
+        return result if result.send(attribute) == value
+      end
+    end
+
+    private
+
+    def map_for_class(klass)
+      @map[klass.to_s.to_sym] ||= {}
+    end
+
+    def map_for(record)
+      map_for_class(record.class)
+    end
+  end
+end

data/lib/vedeu/support/terminal.rb

@@ -26,9 +26,8 @@ module Vedeu
       end
 
       def close
-        clear_screen
         show_cursor
-        output(Position.reset)
+        output(Position.set(height - 1, 1))
       end
 
       def cooked(instance, &block)
@@ -73,7 +72,7 @@ module Vedeu
     end
 
     def initialize(options = {}, &block)
-      @options = options
+      @options = options || {}
 
       yield self if block_given?
     end
@@ -109,15 +108,15 @@ module Vedeu
     end
 
     def cursor
-      options.fetch(:cursor, :show)
+      options.fetch(:cursor)
     end
 
     def mode
-      options.fetch(:mode, :cooked)
+      options.fetch(:mode)
     end
 
     def clear_screen?
-      options.fetch(:clear, true)
+      return options.fetch(:clear)
     end
 
     def noop

data/lib/vedeu/version.rb

@@ -1,3 +1,3 @@
 module Vedeu
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/test/lib/vedeu/application_test.rb

@@ -13,7 +13,7 @@ module Vedeu
 
       before do
         Terminal.stubs(:open).yields(self)
-        Interfaces.stubs(:initial_state)
+        InterfaceRepository.stubs(:initial_state)
         EventLoop.stubs(:main_sequence)
         Terminal.stubs(:close)
       end

data/test/lib/vedeu/output/compositor_test.rb

@@ -5,21 +5,11 @@ module Vedeu
     let(:described_class)    { Compositor }
     let(:described_instance) { described_class.new(output) }
     let(:output)             { [[]] }
-    let(:stream)             {}
-    let(:interface)          {
-      Vedeu::Interface.new({
-        geometry: {
-          y: 2,
-          x: 2,
-          width: 20,
-          height: 10
-        }
-      })
-    }
+    let(:stream)             { [] }
+    let(:interface)          { 'dummy' }
 
     before do
-      Interfaces.defined
-      Terminal.stubs(:output)
+      @interface = Interface.create({ name: 'dummy' })
       Renderer.stubs(:write).returns(stream)
     end
 
@@ -34,6 +24,18 @@ module Vedeu
         it { subject.must_be_instance_of(NilClass) }
       end
 
+      context 'when an array (single interface)' do
+        let(:output) { [[]] }
+
+        it { subject.must_be_instance_of(Array) }
+      end
+
+      context 'when a hash (multiple interfaces)' do
+        let(:output) { { test_interface: [] } }
+
+        it { subject.must_be_instance_of(Array) }
+      end
+
       context 'when unstyled' do
         context 'and a single line' do
           let(:output) { [['Some text...']] }

data/test/lib/vedeu/output/directive_test.rb

@@ -29,7 +29,7 @@ module Vedeu
       context 'when the position is set' do
         let(:position) { [4, 5] }
 
-        it { subject.must_equal("\e[5;6H") }
+        it { subject.must_equal("\e[4;5H") }
       end
 
       context 'when the colour is not set' do

data/test/lib/vedeu/output/position_test.rb

@@ -24,7 +24,7 @@ module Vedeu
         let(:x) { 19 }
 
         it 'returns a position escape sequence' do
-          subject.must_equal("\e[13;20H")
+          subject.must_equal("\e[12;19H")
         end
       end
     end

data/test/lib/vedeu/process/event_loop_test.rb

@@ -7,9 +7,8 @@ module Vedeu
     let(:subject)         { described_class.new }
 
     before do
-      Interfaces.stubs(:defined).returns(defined)
-      defined.stubs(:input).returns("stop")
-      defined.stubs(:output).returns(NilClass)
+      InterfaceRepository.stubs(:input).returns("stop")
+      InterfaceRepository.stubs(:output).returns(NilClass)
     end
 
     it { subject.must_be_instance_of(EventLoop) }

data/test/lib/vedeu/process/input_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Input do
+    let(:described_class) { Input }
+    let(:input)           { "" }
+    let(:args)            { [] }
+
+    before do
+      CommandRepository.stubs(:find_by_input)
+    end
+
+    describe '.evaluate' do
+      let(:subject) { described_class.evaluate(input, args) }
+
+      it { subject.must_be_instance_of(NilClass) }
+    end
+  end
+end

data/test/lib/vedeu/repository/command_repository_test.rb

@@ -0,0 +1,55 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe CommandRepository do
+    let(:described_class) { CommandRepository }
+    let(:input)           { }
+
+    before do
+      Command.create({ name:    'apple',
+                       klass:   DummyCommand,
+                       options: { keypress: 'a', keyword: 'apple' } })
+      Command.create({ name:    'banana',
+                       klass:   DummyCommand,
+                       options: { keypress: 'b', keyword: 'banana' } })
+    end
+
+    after do
+      CommandRepository.reset
+    end
+
+    describe '.find_by_input' do
+      let(:subject) { described_class.find_by_input(input) }
+
+      context 'when the command was found by keypress' do
+        let(:input) { 'b' }
+
+        it { subject.must_be_instance_of(Command) }
+
+        it { subject.name.must_equal('banana') }
+
+        it { subject.name.wont_equal('apple') }
+
+        it { subject.keypress.must_equal('b') }
+      end
+
+      context 'when the command was found by keyword' do
+        let(:input) { 'apple' }
+
+        it { subject.must_be_instance_of(Command) }
+
+        it { subject.keypress.must_equal('a') }
+
+        it { subject.keypress.wont_equal('b') }
+
+        it { subject.name.wont_equal('banana') }
+      end
+    end
+
+    describe '.klass' do
+      let(:subject) { described_class.klass }
+
+      it { subject.must_equal(Command) }
+    end
+  end
+end

data/test/lib/vedeu/repository/command_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  class DummyCommand
+    def self.dispatch; end
+  end
+
+  describe Command do
+    let(:described_class)    { Command }
+    let(:described_instance) { described_class.new(attributes) }
+    let(:attributes)         { { name: :test_command } }
+
+    it { described_instance.must_be_instance_of(Command) }
+
+    describe '#create' do
+      let(:subject) { described_class.create(attributes) }
+
+      it { subject.must_be_instance_of(Command) }
+    end
+
+    describe '#execute' do
+      let(:subject) { described_class.execute(args) }
+
+      it { skip }
+    end
+
+    describe '#executable' do
+      let(:subject) { described_instance.executable }
+
+      it { skip }
+    end
+
+    describe '#execute' do
+      let(:subject) { described_instance.execute }
+
+      it { skip }
+    end
+  end
+end