vedeu 0.0.10 → 0.0.11

data/lib/vedeu/interface/dummy_interface.rb

@@ -1,14 +0,0 @@
-module Vedeu
-  class DummyInterface < Interface
-    def initial_state
-    end
-
-    def input
-      super
-    end
-
-    def output
-      super
-    end
-  end
-end

data/lib/vedeu/interface/interface.rb

@@ -1,57 +0,0 @@
-module Vedeu
-  class NotImplementedError < StandardError; end
-
-  class Interface
-    def initialize(options = {})
-      @options = options
-      @output  = []
-    end
-
-    def initial_state
-      raise NotImplementedError, 'Subclasses implement this method.'
-    end
-
-    def input
-      raise Collapse if evaluate == :stop
-    end
-
-    def output
-      write
-    end
-
-    def geometry
-      @geometry ||= Geometry.new(options[:geometry])
-    end
-
-    private
-
-    attr_reader :options
-
-    def evaluate
-      @output = Commands.execute(read)
-    end
-
-    def read
-      Terminal.input
-    end
-
-    def write
-      Compositor.arrange(@output, self)
-    end
-
-    def options
-      defaults.merge!(@options)
-    end
-
-    def defaults
-      {
-        geometry: {
-                    y:      1,
-                    x:      1,
-                    width:  :auto,
-                    height: :auto
-                  }
-      }
-    end
-  end
-end

data/lib/vedeu/interface/interfaces.rb

@@ -1,66 +0,0 @@
-module Vedeu
-  class UndefinedInterface < StandardError; end
-
-  module Interfaces
-    extend self
-    attr_accessor :interfaces
-
-    def define(&block)
-      if block_given?
-        yield self
-      else
-        self
-      end
-    end
-
-    def defined
-      interfaces.empty? ? default : self
-    end
-
-    def list
-      interfaces.inspect
-    end
-
-    def add(name, options = {}, klass = DummyInterface)
-      interfaces[name] = klass.new(options) if valid?(klass)
-      self
-    end
-
-    def reset
-      @interfaces = {}
-    end
-
-    def find(name)
-      interfaces[name] || nil
-    end
-
-    def initial_state
-      interfaces.values.map { |io| io.initial_state }
-    end
-
-    def input
-      interfaces.values.map { |io| io.input }
-    end
-
-    def output
-      interfaces.values.map { |io| io.output }
-    end
-
-    private
-
-    def valid?(klass)
-      raise UndefinedInterface unless Object.const_defined?(klass.to_s)
-      true
-    end
-
-    def default
-      add(:dummy)
-
-      self
-    end
-
-    def interfaces
-      @interfaces ||= {}
-    end
-  end
-end

data/lib/vedeu/process/command.rb

@@ -1,51 +0,0 @@
-module Vedeu
-  class InvalidCommand < StandardError; end
-
-  class Command
-    class << self
-      def define(name, klass, args = [], options = {})
-        new(name, klass, args, options).define
-      end
-    end
-
-    def initialize(name, klass, args = [], options = {})
-      @name, @klass, @args, @options = name, klass, args, options
-    end
-
-    def define
-      { name => executable } if valid?
-    end
-
-    private
-
-    attr_reader :name, :klass, :args, :options
-
-    def executable
-      Proc.new { klass.dispatch(*args) }
-    end
-
-    def valid?
-      empty_name? || empty_klass? || klass_defined? || dispatch_defined? || true
-    end
-
-    def empty_name?
-      raise InvalidCommand, "Command name is missing." if name.to_s.empty?
-    end
-
-    def empty_klass?
-      raise InvalidCommand, "Command class is missing." if klass.to_s.empty?
-    end
-
-    def klass_defined?
-      unless Object.const_defined?(klass.to_s)
-        raise InvalidCommand, "Command class is not defined."
-      end
-    end
-
-    def dispatch_defined?
-      unless klass.singleton_methods(false).include?(:dispatch)
-        raise InvalidCommand, "Command dispatch method is not defined."
-      end
-    end
-  end
-end

data/lib/vedeu/process/commands.rb

@@ -1,35 +0,0 @@
-module Vedeu
-  module Commands
-    extend self
-
-    def define(&block)
-      if block_given?
-        yield self
-      else
-        self
-      end
-    end
-
-    def execute(command = "")
-      commands.fetch(command).call if exists?(command)
-    end
-
-    def list
-      commands.inspect
-    end
-
-    def add(name, klass, args = [], options = {})
-      commands.merge!(Command.define(name, klass, args, options))
-    end
-
-    private
-
-    def exists?(command)
-      commands.fetch(command, false)
-    end
-
-    def commands
-      @commands ||= { "exit" => Proc.new { Exit.dispatch } }
-    end
-  end
-end

data/test/lib/vedeu/interface/dummy_test.rb

@@ -1,22 +0,0 @@
-require_relative '../../../test_helper'
-
-module Vedeu
-  describe DummyInterface do
-    let(:described_class)    { DummyInterface }
-    let(:described_instance) { described_class.new }
-
-    describe '#initial_state' do
-      let(:subject) { described_instance.initial_state }
-
-      it { subject.must_be_instance_of(NilClass) }
-    end
-
-    describe '#input' do
-      let(:subject) { described_instance.input }
-    end
-
-    describe '#output' do
-      let(:subject) { described_instance.output }
-    end
-  end
-end

data/test/lib/vedeu/interface/interface_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../../test_helper'
-
-module Vedeu
-  describe Interface do
-    let(:described_class)    { Interface }
-    let(:described_instance) { described_class.new(options) }
-    let(:options)            { {} }
-
-    it { described_instance.must_be_instance_of(Interface) }
-
-    describe '#initial_state' do
-      let(:subject) { described_instance.initial_state }
-
-      it { proc { subject }.must_raise(NotImplementedError) }
-    end
-
-    describe '#input' do
-      let(:subject) { described_instance.input }
-
-      before do
-        Terminal.stubs(:input).returns('stop')
-        Commands.stubs(:execute)
-      end
-
-      it { subject.must_be_instance_of(NilClass) }
-    end
-
-    describe '#output' do
-      let(:subject) { described_instance.output }
-      let(:command) { mock }
-
-      before { Compositor.stubs(:arrange).returns([]) }
-
-      it 'sends the output of the command to the compositor' do
-        subject.must_be_instance_of(Array)
-      end
-    end
-
-    describe '#geometry' do
-      let(:subject) { described_instance.geometry }
-
-      it { subject.must_be_instance_of(Geometry) }
-    end
-  end
-end

data/test/lib/vedeu/interface/interfaces_test.rb

@@ -1,108 +0,0 @@
-require_relative '../../../test_helper'
-
-module Vedeu
-  describe Interfaces do
-    let(:described_class) { Interfaces }
-
-    describe '.define' do
-      let(:subject) { described_class.define }
-
-      it { subject.must_be_instance_of(Module) }
-
-      context 'when a block is given' do
-        let(:subject) { described_class.define { :some_block } }
-
-        it { subject.must_be_instance_of(Symbol) }
-      end
-    end
-
-    describe '.defined' do
-      let(:subject) { described_class.defined }
-
-      after { described_class.interfaces = {} }
-
-      context 'when interfaces are not defined' do
-        before { described_class.interfaces = {} }
-
-        it 'adds the default interface and returns all interfaces' do
-          subject.must_be_instance_of(Module)
-        end
-      end
-
-      context 'when interfaces are defined' do
-        before { described_class.interfaces = { mock: :interface } }
-
-        it { subject.must_be_instance_of(Module) }
-      end
-    end
-
-    describe '.list' do
-      let(:subject) { described_class.list }
-
-      it { subject.must_be_instance_of(String) }
-    end
-
-    describe '.add' do
-      let(:subject)   { described_class.add(interface, options, klass) }
-      let(:interface) {}
-      let(:klass)     { DummyInterface }
-      let(:options)   { {} }
-
-      it { subject.must_be_instance_of(Module) }
-
-      context 'when the interface class does not exist' do
-        before { Object.stubs(:const_defined?).returns(false) }
-
-        it { proc { subject }.must_raise(UndefinedInterface) }
-      end
-    end
-
-    describe '.reset' do
-      let(:subject) { described_class.reset }
-      let(:interface) { :dummy }
-
-      before { described_class.add(:dummy) }
-
-      it { subject.must_be_instance_of(Hash) }
-
-      it { subject.must_be_empty }
-    end
-
-    describe '.find' do
-      let(:subject)   { described_class.find(interface) }
-      let(:interface) { :dummy }
-
-      context 'when the interface exists' do
-        before { described_class.add(:dummy) }
-
-        it { subject.must_be_instance_of(DummyInterface) }
-      end
-
-      context 'when the interface does not exist' do
-        before { described_class.reset }
-
-        it { subject.must_be_instance_of(NilClass) }
-      end
-    end
-
-    describe '.initial_state' do
-      let(:subject) { described_class.initial_state }
-
-      it { subject.must_be_instance_of(Array) }
-    end
-
-    describe '.input' do
-      let(:subject) { described_class.input }
-
-      before { Terminal.stubs(:input).returns("some input") }
-
-      it { subject.must_be_instance_of(Array) }
-    end
-
-    describe '.output' do
-      let(:subject) { described_class.output }
-
-      it { subject.must_be_instance_of(Array) }
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require_relative '../../../test_helper'
-
-module Vedeu
-  describe Command do
-    let(:described_class)    { Command }
-    let(:described_instance) { described_class.new(cmd_name, cmd_klass, cmd_args, cmd_options) }
-    let(:cmd_name)           { "dummy" }
-    let(:cmd_klass)          { DummyCommand }
-    let(:cmd_args)           { [] }
-    let(:cmd_options)        { {} }
-
-    it { described_instance.must_be_instance_of(Command) }
-
-    describe '#define' do
-      subject do
-        described_class.define(cmd_name, cmd_klass, cmd_args, cmd_options)
-      end
-
-      it { subject.must_be_instance_of(Hash) }
-
-      it { subject.wont_be_empty }
-
-      context "when the command name is empty" do
-        let(:cmd_name) { "" }
-
-        it { proc { subject }.must_raise(InvalidCommand) }
-      end
-
-      context "when the command class is empty" do
-        let(:cmd_klass) { "" }
-
-        it { proc { subject }.must_raise(InvalidCommand) }
-      end
-
-      context "when the command class is not defined" do
-        before { Object.stubs(:const_defined?).returns(false) }
-
-        it { proc { subject }.must_raise(InvalidCommand) }
-      end
-
-      context "when the command class doesn't have a .dispatch method" do
-        before { cmd_klass.stubs(:singleton_methods).returns([]) }
-
-        it { proc { subject }.must_raise(InvalidCommand) }
-      end
-    end
-  end
-end