warp-dir 1.1.0

data/spec/warp/dir/app/response_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'warp/dir/app/response'
+
+RSpec.describe Warp::Dir::App::Response do
+  let(:response_class) { ::Warp::Dir::App::Response }
+  let(:response_instance) { response_class.new }
+  let(:stream) { double }
+
+  before do
+    expect(Warp::Dir).to receive(:eval_context?).at_most(100).times.and_return(true)
+  end
+  after do
+    response_instance.messages.clear
+    response_instance.instance_variable_set(:@type, nil)
+  end
+
+  describe 'class and type' do
+    it 'should be able to create response_instance' do
+      expect(response_instance).to be_kind_of(response_class)
+    end
+
+    it 'should have constants of correct type' do
+      expect(Warp::Dir::App::Response::INFO).to be_kind_of(Warp::Dir::App::Response::Type)
+    end
+  end
+
+  describe 'accessors' do
+    it 'should allow setting type, code and messages' do
+      response_instance.type(Warp::Dir::App::Response::INFO)
+      response_instance.message('Hi')
+      response_instance.code(200)
+      expect(response_instance.type).to eql(Warp::Dir::App::Response::INFO)
+      expect(response_instance.message).to eql('Hi')
+      expect(response_instance.code).to eql(200)
+    end
+  end
+
+  describe '#configure' do
+    describe 'given a response_instance object' do
+      before do
+        response_instance.instance_variable_set(:@type, nil)
+        response_instance.configure do
+          type Warp::Dir::App::Response::INFO
+          message 'Hello'
+          message 'World'
+          code 255
+        end
+      end
+
+      describe '#messages' do
+        it 'should concatenate when merged' do
+          expect(response_instance.messages).to eql(%w(Hello World))
+          expect(response_instance.message).to eql('HelloWorld')
+        end
+      end
+      describe '#type' do
+        it 'be equal to the lookup result' do
+          expect(response_instance.type).to eql(Warp::Dir::App::Response::RETURN_TYPE[:success])
+          expect(response_instance.type).to eql(Warp::Dir::App::Response::INFO)
+        end
+      end
+      describe '#code' do
+        it 'should be as it was configured' do
+          expect(response_instance.code).to eql(255)
+        end
+      end
+    end
+  end
+
+
+  describe '#exit' do
+    let(:exit_code) { 199 }
+    let(:fake_type) { Warp::Dir::App::Response::Type.new(exit_code, stream) }
+    before do
+      Warp::Dir::App::Response.enable_exit!
+    end
+    after do
+      Warp::Dir::App::Response.disable_exit!
+    end
+
+    describe 'without specifying type' do
+      it 'should throw an exception' do
+        expect { response_instance.exit! }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'when type is user output' do
+      before do
+        response_instance.type(fake_type)
+      end
+
+      it 'should properly format messages for eval' do
+        expect(stream).to receive(:printf).with(%Q{printf -- 'Hello\\n';}).once
+        expect(stream).to receive(:printf).with(%Q{printf -- 'World\\n';}).once
+        response_instance.configure do
+          message 'Hello'
+          message 'World'
+        end
+        response_instance.print
+      end
+      it 'should properly exit via Kernel' do
+        expect(Kernel).to receive(:exit).with(exit_code).once
+        response_instance.configure do
+          code 199
+        end
+        response_instance.exit!
+      end
+    end
+
+    describe 'when type is shell' do
+      before do
+        @stream                                = Warp::Dir::App::Response::SHELL.stream
+        Warp::Dir::App::Response::SHELL.stream = stream
+      end
+      after do
+        Warp::Dir::App::Response::SHELL.stream = @stream
+      end
+
+      it 'should return proper exit code for shell commands' do
+        response_instance.type(Warp::Dir::App::Response::SHELL)
+        response_instance.configure do
+          message 'ls -al'
+          code 1231 # this should be ignored
+        end
+        expect(stream).to receive(:printf).with('ls -al;').once
+        expect(Kernel).to receive(:exit).with(2).once
+        response_instance.print.exit!
+      end
+    end
+  end
+end

data/spec/warp/dir/command_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe Warp::Dir::Command do
+  include_context :initialized_store
+  installed_commands = Warp::Dir::Command.installed_commands.dup.freeze
+
+  let(:command) { Warp::Dir::Command }
+  let(:commander) { Warp::Dir::Commander.instance }
+
+  describe 'when we remove inherited hierarchy' do
+    before do
+      commander.commands.clear
+    end
+    after do
+      commander.commands.merge(installed_commands.dup)
+    end
+
+    it 'should start with a blank list' do
+      expect(commander.commands).to be_empty
+    end
+
+    it 'should add a subclass command to the list of installed Command' do
+      class Warp::Dir::Command::MyCommand < Warp::Dir::Command; def run; end; end
+      expect(commander.installed_commands).to eql([:mycommand])
+      expect(commander.find :mycommand).to eql(Warp::Dir::Command::MyCommand)
+    end
+
+    it 'should be possible to lookup the command by alias' do
+      class Warp::Dir::Command::CommandWithAlias < Warp::Dir::Command
+        aliases :with_alias, :without_alias
+        def run;
+        end;
+      end
+
+      expect(commander.installed_commands).to eql([:commandwithalias])
+      expect(commander.find :commandwithalias).to eql(Warp::Dir::Command::CommandWithAlias)
+      expect(commander.find :with_alias).to eql(Warp::Dir::Command::CommandWithAlias)
+      expect(commander.find :without_alias).to eql(Warp::Dir::Command::CommandWithAlias)
+
+      expect { commander.find :boo }.to raise_error Warp::Dir::Errors::InvalidCommand
+    end
+
+
+    describe '#validate!' do
+      it 'should raise exception when subclass command does not have a #run method ' do
+        class Warp::Dir::Command::Random < Warp::Dir::Command;
+        end
+        expect(commander.commands).to include(Warp::Dir::Command::Random)
+        expect { commander.send(:validate!) }.to raise_error(Warp::Dir::Errors::InvalidCommand)
+      end
+
+      it 'should not quietly remove any abstract classes ' do
+        class Warp::Dir::Command::Random < Warp::Dir::Command
+          def abstract_class?;
+            true;
+          end
+        end
+        expect(commander.commands).to eql(Set.new)
+      end
+    end
+  end
+end

data/spec/warp/dir/commands/add_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'warp/dir/store'
+
+RSpec.describe Warp::Dir::Command::Add do
+  include_context :fake_serializer
+
+  let(:store) { double }
+  let(:command_class) { Warp::Dir::Command::Add }
+  let(:commander) { Warp::Dir::Commander.instance }
+
+  let(:wp_path) { ENV['HOME'] + '/workspace/tinker-mania' }
+  let(:wp_name) { 'harro' }
+  let(:point) { Warp::Dir::Point.new(wp_name, wp_path) }
+
+  let(:add_command) { command_class.new(store, wp_name, wp_path) }
+
+  before do
+    expect(store).to receive(:config).and_return(config).at_least(:once)
+  end
+
+  it 'should have the commander defined' do
+    expect(add_command.store).to_not be_nil
+  end
+
+  describe '#help' do
+    it 'should define a help message' do
+      expect(add_command.command_name).to eql(:add)
+      expect(add_command.description).to match(%r(Adds the current directory)i)
+      expect(add_command.help).to match /add/
+      expect(add_command.help).to match /Adds the current directory/
+    end
+  end
+
+  describe '#run' do
+    it 'should call #save! on store after adding new wp' do
+      expect(store).to receive(:insert).with(point_name: wp_name, point_path: wp_path, overwrite: false).and_return(point)
+      add_command.run
+    end
+  end
+end

data/spec/warp/dir/commands/install_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'support/cli_expectations'
+require 'warp/dir/formatter'
+
+RSpec.describe Warp::Dir::Command::Install do
+
+  let(:commander) { Warp::Dir.commander }
+  let(:install) { Warp::Dir::Command::Install.new(store) }
+
+  describe '#run' do
+    include_context :fixture_file
+    include_context :initialized_store
+
+    context 'when shell files do not exist' do
+      it 'should return :error type response' do
+        expect('install --dotfile ~/.do_not_exist').to output(/not found/)
+      end
+    end
+  end
+end

data/spec/warp/dir/commands/list_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'warp/dir/formatter'
+
+RSpec.describe Warp::Dir::Command::List do
+
+  let(:commander) { Warp::Dir.commander }
+  let(:list) { Warp::Dir::Command::List }
+
+  describe '#help' do
+    it 'should define a help message' do
+      expect(list.help).to match /list/
+      expect(list.help).to match /Print all stored warp points/
+    end
+  end
+
+  describe '#run' do
+    include_context :fake_serializer
+    include_context :initialized_store
+
+    let(:formatter) { Warp::Dir::Formatter.new(store) }
+    let(:output) { formatter.format_store(:ascii) }
+    before do
+      store.add(point: point)
+    end
+
+    it 'should return formatted warp points from the store' do
+      expect(output).to eql(%Q{harro  ->  ~/workspace/tinker-mania})
+    end
+
+    it 'should return response and print the listing' do
+      response = list.new(store).run
+      expect(response.messages.first).to eql(output.blue.bold)
+      expect(STDOUT).to receive(:printf).at_least(1).times
+      response.print
+    end
+  end
+end

data/spec/warp/dir/config_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe Warp::Dir::Config do
+  let(:c1) { Warp::Dir::Config.new(blah: 'blah blah') }
+
+  it 'should have a default folder' do
+    expect(c1.warprc).to eql(ENV['HOME'] + '/.warprc')
+  end
+
+  it 'should automatically create accessors' do
+    expect(c1.blah).to eql('blah blah')
+  end
+
+  it 'should add new parameter to the params array' do
+    expect(c1.variables).to eql([:warprc, :shell, :force, :debug, :blah])
+  end
+
+  it 'should be able to create a attr_writer also' do
+    c1.blah = 'another blah'
+    expect(c1.blah).to eql('another blah')
+  end
+
+  it 'should be possible to add a new value after instance was created' do
+    c1.new_field = 'really new here'
+    expect(c1.new_field?).to be_truthy
+    expect(c1.new_field).to eql('really new here')
+  end
+
+  describe 'when another instance of the config is created' do
+    let(:c2) { Warp::Dir::Config.new(poo: 'boo') }
+
+    it 'should only have one parameter for this class' do
+      expect(c1.respond_to?(:poo)).to be_falsey
+      expect(c2.respond_to?(:poo)).to be_truthy
+
+      expect(c1.respond_to?(:blah)).to be_truthy
+      expect(c2.respond_to?(:blah)).to be_falsey
+    end
+
+    it 'should add new parameter to the params array' do
+      expect(c2.variables).to eql([:warprc, :shell, :force, :debug, :poo])
+    end
+
+  end
+end

data/spec/warp/dir/errors_spec.rb

@@ -0,0 +1,16 @@
+require 'warp/dir'
+require 'spec_helper'
+
+RSpec.describe Warp::Dir::Errors do
+  include_context :fake_serializer
+  include_context :initialized_store
+
+  it 'should properly throw point already exists error' do
+    expect(store.class).to eql(Warp::Dir::Store)
+    expect(point.class).to eql(Warp::Dir::Point)
+
+    store.add(point: point.dup)
+    point.full_path = '~/booomania'
+    expect { store.add(point: point) }.to raise_error(Warp::Dir::Errors::PointAlreadyExists)
+  end
+end

data/spec/warp/dir/formatter_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'warp/dir/formatter'
+
+RSpec.describe Warp::Dir::Formatter do
+  include_context :initialized_store
+
+  let(:path_absolute) { ENV['HOME'] + '/workspace' }
+  let(:path_relative) { '~/workspace' }
+  let(:p1) { Warp::Dir::Point.new('p', ENV['HOME'] + '/workspace') }
+  let(:p2) { Warp::Dir::Point.new('n', ENV['HOME'] + '/workspace/new-project') }
+
+  describe 'with empty store' do
+    before do
+      store.add(p1)
+      store.add(p2)
+    end
+
+
+    # it '#map,#each' do
+    #   expect(collection.map(&:formatted)).to eql([
+    #                                                'p  ->  ~/workspace',
+    #                                                'n  ->  ~/workspace/new-project'
+    #                                              ])
+    #   paths = []
+    #   collection.each { |p| paths << p.relative_path }
+    #   expect(paths).to eql(%w(~/workspace ~/workspace/new-project))
+    # end
+    # it '#:[]' do
+    #   expect(collection[1]).to eql(p2)
+    # end
+    # it '#formatted' do
+    #   expect(collection.formatted).to eql("n  ->  ~/workspace/new-project\np  ->  ~/workspace")
+    # end
+    # it '#formatted sorted' do
+    #   expect(collection.formatted(:ascii, :path)).to eql("p  ->  ~/workspace\nn  ->  ~/workspace/new-project")
+    # end
+  end
+end

data/spec/warp/dir/point_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'warp/dir'
+
+RSpec.describe Warp::Dir::Point do
+  include_context :fake_serializer
+  include_context :initialized_store
+
+  let(:path_absolute) { ENV['HOME'] + '/workspace' }
+  let(:path_relative) { '~/workspace' }
+  let(:p1) { Warp::Dir::Point.new('p', ENV['HOME'] + '/workspace') }
+  let(:p2) { Warp::Dir::Point.new('n', ENV['HOME'] + '/workspace/new-project') }
+
+  describe 'with two distinct but identical objects' do
+    let(:p2) { Warp::Dir::Point.new('p', ENV['HOME'] + '/workspace') }
+    it 'correctly defines #eql?' do
+      expect(p1).to eql(p2)
+    end
+    it 'correctly defines #hash' do
+      expect(p1.hash).to eql(p2.hash)
+    end
+    it '#file.path' do
+      expect(file.path.length > 0).to be_truthy
+    end
+  end
+
+  describe 'instance methods' do
+    it '#to_s' do
+      expect(p1.to_s).to eql('p  ->  ~/workspace')
+    end
+    it '#inspect' do
+      expect(p1.inspect).to match(%r{name: '#{p1.name}', path: '#{p1.relative_path}'})
+    end
+  end
+
+end

data/spec/warp/dir/store_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'warp/dir'
+require 'warp/dir/config'
+require 'warp/dir/store'
+require 'tempfile'
+
+RSpec.describe Warp::Dir::Store do
+  include_context :fake_serializer
+  include_context :initialized_store
+
+  context 'when store responds to common methods on collections' do
+    let(:point_name) { 'moo' }
+    let(:point_path) { ENV['HOME'] + '/tmp/12398485' }
+    let(:store) { Warp::Dir::Store.new(config) }
+    let(:p1) { Warp::Dir::Point.new('p', ENV['HOME'] + '/workspace') }
+    let(:p2) { Warp::Dir::Point.new('n', ENV['HOME'] + '/workspace/new-project') }
+
+    it 'should be able to have an empty store' do
+      expect(store.points).to be_empty
+    end
+
+    it 'should respond to #size and return 0' do
+      expect(store.size).to eql(0)
+    end
+
+    it 'it should respond to #<< and add a new point' do
+      store.add(point: p1)
+      store.add(point: p2)
+      store << Warp::Dir::Point.new('123', '436')
+      expect(store.size).to eql(3)
+    end
+  end
+
+  context 'when the data storeis empty' do
+    let(:point_name) { 'moo' }
+    let(:point_path) { ENV['HOME'] + '/tmp/12398485' }
+    let(:store) { Warp::Dir::Store.new(config) }
+
+    it 'should be able to initialize the Store' do
+      expect(store.points).to be_empty
+    end
+
+    it 'should respond to #size and return 0' do
+      expect(store.size).to eql(0)
+    end
+
+    it 'it should respond to #<< and add a new point' do
+      expect(store.size).to eql(0)
+      store << Warp::Dir::Point.new('123', '436')
+      expect(store.size).to eql(1)
+    end
+
+    it 'should be able to add a new point to the Store' do
+      store.add(point_name: point_name, point_path: point_path)
+      corrected_path = Warp::Dir.absolute point_path
+      expect(store[point_name].path).to eql(corrected_path)
+    end
+
+    it 'should not be able to add a different point with the same name' do
+      store.add(point_name: point_name, point_path: point_path)
+      # double adding the same point is ok
+      expect { store.add(point_name: point_name, point_path: point_path) }.to_not raise_error
+      # adding another point pointing to the same name is not OK
+      expect { store.add(point_name: point_name, point_path: point_path + '98984') }.to raise_error(Warp::Dir::Errors::PointAlreadyExists)
+    end
+
+    it 'should be able to add multiple points to the Store' do
+      store.add(point_name: 'm1', point_path: '123')
+      store.add(point_name: 'm2', point_path: '456')
+      expect(store['m1'].path).to eql('123')
+      expect(store['m2'].path).to eql('456')
+    end
+  end
+
+  context 'data store contains some warp points already' do
+    let(:store) { Warp::Dir::Store.new(config) }
+    before do
+      store.add(point_name: 'm1', point_path: 'A1')
+      store.add(point_name: 'm2', point_path: 'A2')
+      store.save!
+    end
+
+    describe 'reading data' do
+      let(:new_store) { Warp::Dir::Store.new(config) }
+
+      it 'should restore correctly compared to last saved' do
+        expect(new_store['m1'].path).to eql('A1')
+        expect(new_store['m2'].path).to eql('A2')
+      end
+
+      it 'should not allow overwriting without a force flag' do
+        # adding another point pointing to the same name is not OK
+        expect { new_store.add(point_name: 'm1', point_path: '98984') }.to raise_error(Warp::Dir::Errors::PointAlreadyExists)
+      end
+
+      it 'should be able to find previously saved item' do
+        expect(new_store['m1']).to eql(Warp::Dir::Point.new('m1', 'A1'))
+      end
+
+      it 'should be able to handle when it doesnt find a given element' do
+        expect { new_store['ASDSADAS'] }.to raise_error(Warp::Dir::Errors::PointNotFound)
+      end
+    end
+  end
+end