warp-dir 1.1.3 → 1.1.4

data/spec/warp/dir/command_spec.rb

@@ -1,62 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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 #{warprc_args} --dotfile ~/.do_not_exist").to output(/not found/)
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'warp/dir'
-require 'warp/dir/config'
-require 'warp/dir/store'
-require 'tempfile'
-
-RSpec.describe Warp::Dir::Store do
-
-  describe 'with no existin warprc file' do
-    let(:config_path) { "/tmp/warprc#{srand()}" }
-    let(:config) { Warp::Dir::Config.new(warprc: config_path) }
-    let(:store) { Warp::Dir::Store.new(config) }
-
-    after do
-      File.unlink(config_path) if File.exists?(config_path)
-    end
-
-    it 'does not fail for find requests' do
-      expect(File.exist?(config.warprc)).to be_falsey, config.warprc
-      expect { store['mypoint'] }.to raise_error(Warp::Dir::Errors::PointNotFound)
-    end
-
-    it 'creates the file when adding points' do
-      expect(File.exist?(config.warprc)).to be_falsey, config.warprc
-      expect(store.size).to eql(0)
-      store.add(point_name: 'mypoint', point_path: '/tmp')
-      expect(File.exist?(config.warprc)).to be_falsey, config.warprc
-    end
-  end
-
-  describe 'with an exiting warprc file' 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
-end