aruba 0.14.9 → 1.0.0

data/spec/event_bus/name_resolver_spec.rb

@@ -1,68 +0,0 @@
-require 'aruba/event_bus/name_resolver'
-
-describe Aruba::EventBus::NameResolver do
-  subject(:resolver) { described_class.new(default_name_space) }
-  let(:default_name_space) { 'Events' }
-  let(:resolved_name) { resolver.transform(original_name) }
-
-  before :each do
-    stub_const('Events::MyEvent', Class.new)
-    stub_const('Events::MyEvent', Class.new)
-  end
-
-  describe '#transform' do
-    context 'when name is string' do
-      context 'when simple' do
-        let(:original_name) { 'Events::MyEvent' }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-
-      context 'when prefixed' do
-        let(:original_name) { '::Events::MyEvent' }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-    end
-
-    context 'when name is class' do
-      context 'when simple' do
-        let(:original_name) { Events::MyEvent }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-
-      context 'when prefixed' do
-        let(:original_name) { ::Events::MyEvent }
-        it { expect(resolved_name).to eq Events::MyEvent }
-      end
-    end
-
-    context 'when name is symbol' do
-      let(:original_name) { :my_event }
-      it { expect(resolved_name).to eq Events::MyEvent }
-    end
-
-    context 'when namespace ...' do
-      before :each do
-        stub_const('MyLib::Events::MyEvent', Class.new)
-      end
-
-      context 'when is string' do
-        let!(:default_name_space) { 'MyLib::Events' }
-        let!(:original_name) { :my_event }
-
-        it { expect(resolved_name).to eq MyLib::Events::MyEvent }
-      end
-
-      context 'when is module' do
-        let!(:default_name_space) { MyLib::Events }
-        let!(:original_name) { :my_event }
-
-        it { expect(resolved_name).to eq MyLib::Events::MyEvent }
-      end
-    end
-
-    context 'when invalid' do
-      let(:original_name) { 1 }
-      it { expect { resolved_name }.to raise_error Aruba::EventNameResolveError, /Transforming "1"/ }
-    end
-  end
-end

data/spec/event_bus_spec.rb

@@ -1,158 +0,0 @@
-require 'aruba/event_bus'
-
-module Events
-  class TestEvent; end
-  class AnotherTestEvent; end
-  module MalformedTestEvent; end
-end
-
-class MyHandler
-  def call(*); end
-end
-
-class MyMalformedHandler; end
-
-describe Aruba::EventBus do
-  subject(:bus) { described_class.new(name_resolver) }
-
-  let(:name_resolver) { instance_double('Events::NameResolver') }
-
-  let!(:event_klass) { Events::TestEvent }
-  let!(:event_name) { event_klass }
-  let!(:event_instance) { Events::TestEvent.new }
-
-  let!(:another_event_klass) { Events::AnotherTestEvent }
-  let!(:another_event_name) { another_event_klass }
-  let!(:another_event_instance) { Events::AnotherTestEvent.new }
-
-  describe '#notify' do
-    before(:each) do
-      allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-    end
-
-    context 'when subscriber to event, the block is called and get\'s an instance of the event passed as payload' do
-      before :each do
-        bus.register(event_klass) do |event|
-          @received_payload = event
-        end
-
-        bus.notify event_instance
-      end
-
-      it { expect(@received_payload).to eq(event_instance) }
-    end
-
-    context 'when not subscriber to event' do
-      before :each do
-        @received_payload = false
-        bus.register(event_klass) { @received_payload = true }
-        bus.notify another_event_instance
-      end
-
-      it { expect(@received_payload).to eq(false) }
-    end
-
-    context 'when event is not an instance of event class' do
-      let!(:event_name) { :test_event }
-      let(:received_payload) { [] }
-
-      before :each do
-        bus.register(event_name, proc {})
-      end
-
-      it { expect { bus.notify event_klass }.to raise_error Aruba::NoEventError }
-    end
-  end
-
-  describe '#register' do
-    before(:each) do
-      allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-    end
-
-    context 'when valid subscriber' do
-      context 'when multiple instances are given' do
-        let(:received_events) { [] }
-
-        before :each do
-          bus.register(Events::TestEvent) do |event|
-            received_events << event
-          end
-          bus.register(Events::TestEvent) do |event|
-            received_events << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_events.length).to eq 2 }
-        it { expect(received_events).to all eq event_instance }
-      end
-
-      context 'when is string' do
-        let!(:event_name) { event_klass.to_s }
-        let(:received_payload) { [] }
-
-        before :each do
-          bus.register(event_klass.to_s) do |event|
-            received_payload << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_payload).to include event_instance }
-      end
-
-      context 'when is symbol and event is defined in the default namespace given to NameResolver.new' do
-        let!(:event_name) { :test_event }
-        let(:received_payload) { [] }
-
-        before :each do
-          bus.register(event_name) do |event|
-            received_payload << event
-          end
-
-          bus.notify event_instance
-        end
-
-        it { expect(received_payload).to include event_instance }
-      end
-    end
-
-    context 'when valid custom handler' do
-      context 'when single event class' do
-        before(:each) do
-          allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-        end
-
-        before :each do
-          bus.register(event_klass, MyHandler.new)
-        end
-
-        it { expect { bus.notify event_instance }.not_to raise_error }
-      end
-
-      context 'when list of event classes' do
-        before(:each) do
-          allow(name_resolver).to receive(:transform).with(event_name).and_return(event_klass)
-          allow(name_resolver).to receive(:transform).with(another_event_name).and_return(another_event_klass)
-        end
-
-        before :each do
-          bus.register([event_klass, another_event_klass], MyHandler.new)
-        end
-
-        it { expect { bus.notify event_instance }.not_to raise_error }
-        it { expect { bus.notify another_event_instance }.not_to raise_error }
-      end
-    end
-
-    context 'when malformed custom handler' do
-      it { expect { bus.register(event_klass, MyMalformedHandler.new) }.to raise_error ArgumentError }
-    end
-
-    context 'when no handler is given' do
-      it { expect { bus.register(event_klass) }.to raise_error ArgumentError }
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-$LOAD_PATH << ::File.expand_path('../../lib', __FILE__)
-
-require 'simplecov'
-SimpleCov.command_name 'rspec'
-SimpleCov.start
-
-# Pull in all of the gems including those in the `test` group
-require 'bundler'
-Bundler.require
-
-# Loading support files
-if RUBY_VERSION < '1.9'
-  Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-  Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
-else
-  Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
-  Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
-end

data/spec/support/configs/aruba.rb

@@ -1,5 +0,0 @@
-require 'aruba/rspec'
-
-Aruba.configure do |config|
-  config.activate_announcer_on_command_failure = [:stderr, :stdout, :command]
-end

data/spec/support/configs/pry.rb

@@ -1,3 +0,0 @@
-# Otherwise pry doesn't find it's RC file
-# if ENV['HOME'] is mocked
-ENV['PRYRC'] = File.expand_path('~/.pryrc')

data/spec/support/configs/rspec.rb

@@ -1,15 +0,0 @@
-require 'rspec/core'
-require 'aruba/api'
-
-RSpec.configure do |config|
-  config.filter_run :focus => true
-
-  config.run_all_when_everything_filtered = true
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.include Aruba::Api
-  config.before(:each) { setup_aruba }
-end

data/spec/support/helpers/reporting.rb

@@ -1,44 +0,0 @@
-module SpecHelpers
-  module Reporting
-    # Captures the given stream and returns it:
-    #
-    #   stream = capture(:stdout) { puts 'notice' }
-    #   stream # => "notice\n"
-    #
-    #   stream = capture(:stderr) { warn 'error' }
-    #   stream # => "error\n"
-    #
-    # even for subprocesses:
-    #
-    #   stream = capture(:stdout) { system('echo notice') }
-    #   stream # => "notice\n"
-    #
-    #   stream = capture(:stderr) { system('echo error 1>&2') }
-    #   stream # => "error\n"
-    def capture(stream)
-      stream = stream.to_s
-      captured_stream = Tempfile.new(stream)
-
-      # rubocop:disable Lint/Eval
-      stream_io = eval("$#{stream}")
-      # rubocop:enable Lint/Eval
-
-      origin_stream = stream_io.dup
-      stream_io.reopen(captured_stream)
-
-      yield
-
-      stream_io.rewind
-      return captured_stream.read
-    ensure
-      captured_stream.close
-      captured_stream.unlink
-      stream_io.reopen(origin_stream)
-    end
-    alias silence capture
-  end
-end
-
-RSpec.configure do |config|
-  config.include SpecHelpers::Reporting
-end

data/spec/support/matchers/option.rb

@@ -1,35 +0,0 @@
-RSpec::Matchers.define :be_valid_option do |_|
-  match do |actual|
-    subject.option?(actual)
-  end
-
-  failure_message do |actual|
-    format("expected that \"%s\" is a valid option", actual)
-  end
-
-  failure_message_when_negated do |actual|
-    format("expected that \"%s\" is not a valid option", actual)
-  end
-end
-
-RSpec::Matchers.define :have_option_value do |expected|
-  match do |actual|
-    @old_actual = actual
-    @actual     = if RUBY_VERSION < '1.9'
-                    subject.send(actual.to_sym)
-                  else
-                    subject.public_send(actual.to_sym)
-                  end
-    values_match? expected, @actual
-  end
-
-  diffable
-
-  failure_message do |_actual|
-    format(%(expected that option "%s" has value "%s"), @old_actual, expected)
-  end
-
-  failure_message_when_negated do |_actual|
-    format(%(expected that option "%s" does not have value "%s"), @old_actual, expected)
-  end
-end

data/spec/support/shared_contexts/aruba.rb

@@ -1,49 +0,0 @@
-require 'fileutils'
-require 'securerandom'
-
-RSpec.shared_context 'uses aruba API' do
-  def random_string(options = {})
-    options[:prefix].to_s + SecureRandom.hex + options[:suffix].to_s
-  end
-
-  def create_test_files(files, data = 'a')
-    Array(files).each do |s|
-      next if s.to_s[0] == '%'
-      local_path = expand_path(s)
-
-      FileUtils.mkdir_p File.dirname(local_path)
-      File.open(local_path, 'w') { |f| f << data }
-    end
-  end
-
-  before(:each) do
-    klass = Class.new do
-      include Aruba::Api
-
-      def set_tag(tag_name, value)
-        self.instance_variable_set "@#{tag_name}", value
-      end
-    end
-
-    @aruba = klass.new
-
-    @file_name = "test.txt"
-    @file_size = 256
-    @file_path = @aruba.expand_path(@file_name)
-    @aruba.setup_aruba
-
-    raise "We must work with relative paths, everything else is dangerous" if ?/ == @aruba.aruba.current_directory[0]
-  end
-end
-
-RSpec.shared_context 'needs to expand paths' do
-  def expand_path(*args)
-    @aruba.expand_path(*args)
-  end
-end
-
-RSpec.shared_context 'needs to run with environment' do
-  def with_environment(*args, &block)
-    @aruba.with_environment(*args, &block)
-  end
-end

data/spec/support/shared_examples/configuration.rb

@@ -1,116 +0,0 @@
-RSpec.shared_examples 'a basic configuration' do
-  subject(:config) do
-    Class.new(described_class) do
-      option_accessor :use_test, :contract => { Contracts::Bool => Contracts::Bool }, :default => false
-    end.new
-  end
-
-  it { expect(config).not_to be_nil }
-
-  describe '.option_reader' do
-    let(:config_klass) { Class.new(described_class) }
-
-    subject(:config) { config_klass.new }
-
-    before :each do
-      config_klass.option_reader :new_opt, :contract => { Contracts::Num => Contracts::Num }, :default => 1
-    end
-
-    context 'when value is read' do
-      it { expect(config.new_opt).to eq 1 }
-    end
-
-    context 'when one tries to write a value' do
-      it { expect{ config.new_opt = 1}.to raise_error NoMethodError }
-    end
-
-    context 'when block is defined' do
-      before :each do
-        config_klass.option_reader :new_opt2, :contract => { Contracts::Num => Contracts::Num } do |c|
-          c.new_opt.value + 1
-        end
-      end
-
-      it { expect(config.new_opt2).to eq 2 }
-    end
-
-    context 'when block and default value is defined' do
-      it do
-        expect do
-          config_klass.option_accessor :new_opt2, :contract => { Contracts::Num => Contracts::Num }, :default => 2 do |c|
-            c.new_opt.value + 1
-          end
-        end.to raise_error ArgumentError, 'Either use block or default value'
-      end
-    end
-  end
-
-  describe '.option_accessor' do
-    let(:config_klass) { Class.new(described_class) }
-
-    subject(:config) { config_klass.new }
-
-    before :each do
-      config_klass.option_accessor :new_opt, :contract => { Contracts::Num => Contracts::Num }, :default => 1
-    end
-
-    context 'when default is used' do
-      it { expect(config.new_opt).to eq 1 }
-    end
-
-    context 'when is modified' do
-      before(:each) { config.new_opt = 2 }
-
-      it { expect(config.new_opt).to eq 2 }
-    end
-
-    context 'when block is defined' do
-      before :each do
-        config_klass.option_accessor :new_opt2, :contract => { Contracts::Num => Contracts::Num } do |c|
-          c.new_opt.value + 1
-        end
-      end
-
-      it { expect(config.new_opt2).to eq 2 }
-    end
-
-    context 'when block and default value is defined' do
-      it do
-        expect do
-          config_klass.option_accessor :new_opt2, :contract => { Contracts::Num => Contracts::Num }, :default => 2 do |c|
-            c.new_opt1 + 1
-          end
-        end.to raise_error ArgumentError, 'Either use block or default value'
-      end
-    end
-  end
-
-  describe 'option?' do
-    let(:name) { :use_test }
-
-    context 'when valid option' do
-      it { expect(name).to be_valid_option }
-    end
-
-    context 'when invalid_option' do
-      let(:name) { :blub }
-      it { expect(name).not_to be_valid_option }
-    end
-  end
-
-  describe 'set_if_option' do
-    let(:name) { :use_test }
-    let(:value) { true }
-
-    context 'when valid option' do
-      before(:each) { config.set_if_option(name, value) }
-      it { expect(name).to have_option_value true }
-    end
-
-    context 'when invalid_option' do
-      let(:name) { :blub }
-
-      it { expect { config.set_if_option(name, value) }.not_to raise_error }
-    end
-  end
-end

data/spec/support/shared_examples/directory.rb

@@ -1,7 +0,0 @@
-shared_examples 'an existing directory' do
-  it { Array(path).each { |p| expect(File).to be_directory(p) } }
-end
-
-shared_examples 'a non-existing directory' do
-  it { Array(path).each { |p| expect(File).not_to be_exist(p) } }
-end

data/spec/support/shared_examples/file.rb

@@ -1,7 +0,0 @@
-shared_examples 'an existing file' do
-  it { Array(path).each { |p| expect(File).to be_file(p) } }
-end
-
-shared_examples 'a non-existing file' do
-  it { Array(path).each { |p| expect(File).not_to be_exist(p) } }
-end

data/templates/css/console.css

@@ -1,24 +0,0 @@
-.console {
-  background-color: #000000;
-  color: #ffffff;
-}
-
-.console .xterm_ef1 { /* red */
-  color: #ff0000;
-}
-
-.console .xterm_ef2 { /* green */ 
-  color: #00ff00;
-}
-
-.console .xterm_ef3 { /* yellow */ 
-  color: #ffff00;
-}
-
-.console .xterm_ef6 { /* cyan */ 
-  color: #00ffff;
-}
-
-.console .xterm_ef8 { /* gray */ 
-  color: #888888;
-}

data/templates/css/filesystem.css

@@ -1,42 +0,0 @@
-.filesystem ul {
-  background: #FFFFFF;
-  margin: 0;
-  padding: 0;
-}
-
-.filesystem li {
-  list-style-type: none;
-  padding-left: 20px;
-  margin-bottom: 4px;
-}
-
-.filesystem li .highlight {
-  display: block;
-  border: 1px solid #CCCCCC;
-  margin-top: 4px;
-}
-
-.filesystem li .highlight pre, pre.console {
-  margin: 2px;
-  padding: 2px;
-}
-
-.filesystem li.file {
-  cursor: pointer;
-}
-
-.filesystem li.folder {
-  background: url('../images/folder.png') no-repeat;
-}
-
-.filesystem li.feature {
-  background: url('../images/page_white_gherkin.png') no-repeat;
-}
-
-.filesystem li.rb {
-  background: url('../images/page_white_ruby.png') no-repeat;
-}
-
-.filesystem li.unknown {
-  background: url('../images/page_white.png') no-repeat;
-}

data/templates/css/pygments-autumn.css

@@ -1,59 +0,0 @@
-/* https://raw.github.com/richleland/pygments-css/master/autumn.css */
-.highlight .hll { background-color: #ffffcc }
-.highlight .c { color: #aaaaaa; font-style: italic } /* Comment */
-.highlight .err { color: #F00000; background-color: #F0A0A0 } /* Error */
-.highlight .k { color: #0000aa } /* Keyword */
-.highlight .cm { color: #aaaaaa; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #4c8317 } /* Comment.Preproc */
-.highlight .c1 { color: #aaaaaa; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #0000aa; font-style: italic } /* Comment.Special */
-.highlight .gd { color: #aa0000 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #aa0000 } /* Generic.Error */
-.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.highlight .gi { color: #00aa00 } /* Generic.Inserted */
-.highlight .go { color: #888888 } /* Generic.Output */
-.highlight .gp { color: #555555 } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #aa0000 } /* Generic.Traceback */
-.highlight .kc { color: #0000aa } /* Keyword.Constant */
-.highlight .kd { color: #0000aa } /* Keyword.Declaration */
-.highlight .kn { color: #0000aa } /* Keyword.Namespace */
-.highlight .kp { color: #0000aa } /* Keyword.Pseudo */
-.highlight .kr { color: #0000aa } /* Keyword.Reserved */
-.highlight .kt { color: #00aaaa } /* Keyword.Type */
-.highlight .m { color: #009999 } /* Literal.Number */
-.highlight .s { color: #aa5500 } /* Literal.String */
-.highlight .na { color: #1e90ff } /* Name.Attribute */
-.highlight .nb { color: #00aaaa } /* Name.Builtin */
-.highlight .nc { color: #00aa00; text-decoration: underline } /* Name.Class */
-.highlight .no { color: #aa0000 } /* Name.Constant */
-.highlight .nd { color: #888888 } /* Name.Decorator */
-.highlight .ni { color: #800000; font-weight: bold } /* Name.Entity */
-.highlight .nf { color: #00aa00 } /* Name.Function */
-.highlight .nn { color: #00aaaa; text-decoration: underline } /* Name.Namespace */
-.highlight .nt { color: #1e90ff; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #aa0000 } /* Name.Variable */
-.highlight .ow { color: #0000aa } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #009999 } /* Literal.Number.Float */
-.highlight .mh { color: #009999 } /* Literal.Number.Hex */
-.highlight .mi { color: #009999 } /* Literal.Number.Integer */
-.highlight .mo { color: #009999 } /* Literal.Number.Oct */
-.highlight .sb { color: #aa5500 } /* Literal.String.Backtick */
-.highlight .sc { color: #aa5500 } /* Literal.String.Char */
-.highlight .sd { color: #aa5500 } /* Literal.String.Doc */
-.highlight .s2 { color: #aa5500 } /* Literal.String.Double */
-.highlight .se { color: #aa5500 } /* Literal.String.Escape */
-.highlight .sh { color: #aa5500 } /* Literal.String.Heredoc */
-.highlight .si { color: #aa5500 } /* Literal.String.Interpol */
-.highlight .sx { color: #aa5500 } /* Literal.String.Other */
-.highlight .sr { color: #009999 } /* Literal.String.Regex */
-.highlight .s1 { color: #aa5500 } /* Literal.String.Single */
-.highlight .ss { color: #0000aa } /* Literal.String.Symbol */
-.highlight .bp { color: #00aaaa } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #aa0000 } /* Name.Variable.Class */
-.highlight .vg { color: #aa0000 } /* Name.Variable.Global */
-.highlight .vi { color: #aa0000 } /* Name.Variable.Instance */
-.highlight .il { color: #009999 } /* Literal.Number.Integer.Long */