warp-dir 1.1.3 → 1.1.4

data/spec/support/cli_expectations.rb

@@ -1,118 +0,0 @@
-require 'rspec/expectations'
-require 'warp/dir/app/cli'
-require 'rspec/expectations'
-
-module Warp
-  module Dir
-    module CLIHelper
-
-      def run_command!(arguments)
-        argv = arguments.is_a?(Array) ? arguments : arguments.split(' ')
-        cli  = Warp::Dir::App::CLI.new(argv)
-        cli.run
-      end
-
-      def validate!(arguments, yield_before_validation: false)
-        argv = arguments.is_a?(Array) ? arguments : arguments.split(' ')
-        cli  = Warp::Dir::App::CLI.new(argv)
-        if yield_before_validation
-          yield(cli) if block_given?
-        end
-        cli.validate
-        unless yield_before_validation
-          yield(cli) if block_given?
-        end
-        cli.run
-      end
-
-      def output_matches(output, expected)
-        if expected.is_a?(Regexp)
-          expected.match(output)
-        elsif expected.is_a?(String)
-          output.include?(expected)
-        else
-          nil
-        end
-      end
-    end
-  end
-end
-
-RSpec::Matchers.define :output do |*expectations|
-  include Warp::Dir::CLIHelper
-  match do |actual|
-    @response = nil
-    @command = "wd #{actual.is_a?(Array) ? actual.join(' ') : actual}"
-    expectations.all? do |expected|
-      @response = run_command!(actual)
-      @response.messages.any? { |m| output_matches(m, expected) }
-    end
-  end
-  failure_message do |actual|
-    "#{@command} was supposed to produce something matching or containing:\nexpected: '#{expected}',\n  actual: #{@response.messages}"
-  end
-  match_when_negated do |actual|
-    @response = nil
-    @command = "wd #{actual.is_a?(Array) ? actual.join(' ') : actual}"
-    expectations.none? do |expected|
-      @response = run_command!(actual)
-      @response.messages.any? { |m| output_matches(m, expected) }
-    end
-  end
-  failure_message_when_negated do |actual|
-    "expected #{actual} not to contain #{expected}, got #{@response}"
-  end
-end
-
-RSpec::Matchers.define :validate do |expected|
-  include Warp::Dir::CLIHelper
-  match do |actual|
-    if expected == true || expected == false
-      yield_before_validation = expected
-    end
-    expected = block_arg
-    if expected.is_a?(Proc)
-      begin
-        @response = validate!(actual, yield_before_validation: yield_before_validation) do |cli|
-          expected.call(cli)
-        end
-      rescue Exception => e
-        STDERR.puts(e.inspect)
-        STDERR.puts(e.backtrace.join("\n"))
-        raise
-      end
-    else
-      raise TypeError.new('Expected must be a block')
-    end
-  end
-  failure_message do |actual|
-    "expected #{actual} to validate that the block evaluates to true"
-  end
-
-end
-
-RSpec::Matchers.define :exit_with do |expected|
-  include Warp::Dir::CLIHelper
-
-  match do |actual|
-    response = run_command!(actual)
-    response.code == expected
-  end
-  match_when_negated do |actual|
-    response = run_command!(actual)
-    response.code != expected
-  end
-end
-
-# RSpec::Matchers.define :eval_to_true_after_validate do |expected|
-#   match do |actual|
-#     expected_type = expected.is_a?(Symbol) ?
-#       Warp::Dir::App::Response::RETURN_TYPE[expected_type] :
-#       expected
-#     response = run_and_yield(expected)
-#     response.type == expected_type
-#   end
-#   failure_message_for_should_not do |actual|
-#     "expected #{expected} to produce return type #{}"
-#   end
-# end

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

@@ -1,239 +0,0 @@
-require 'spec_helper'
-require 'support/cli_expectations'
-require 'warp/dir'
-require 'warp/dir/config'
-require 'warp/dir/app/cli'
-require 'pp'
-require 'fileutils'
-
-RSpec.describe Warp::Dir::App::CLI do
-  include_context :fixture_file
-  include_context :initialized_store
-
-  let(:config_args) { ['--config', config.warprc] }
-  let(:warprc) { config_args.join(' ') }
-
-  describe 'when parsing argument list' do
-    let(:cli) { Warp::Dir::App::CLI.new(argv) }
-    before do
-      cli.config = config
-    end
-
-    describe 'with suffix flags' do
-      subject { cli.send(:extract_suffix_flags, argv) }
-      describe 'and with at leats two arguments' do
-        let(:argv) { 'command argument --flag1 --flag2 -- --suffix1 --suffix2 suffix-argument'.split(' ')}
-        it 'extracts them well' do
-          should eql(%w(--suffix1 --suffix2 suffix-argument))
-        end
-      end
-    end
-
-    describe 'with only one argument' do
-      let(:result) { cli.send(:shift_non_flag_commands) }
-
-      describe "that's a list command" do
-        let(:argv) { %w(list --verbose) }
-
-        it 'should assign the command' do
-          expect(cli.argv).to eql(%w(list --verbose))
-          expect(result[:command]).to eql(:list)
-          expect(cli.argv).to eql(['--verbose'])
-        end
-      end
-
-      describe "that's a warp point" do
-        let(:argv) { %w(awesome-point) }
-
-        it 'should default to the :warp command' do
-          expect(result[:command]).to eql(:warp)
-          expect(result[:point]).to eql(:'awesome-point')
-          expect(cli.argv).to be_empty
-        end
-      end
-    end
-
-    describe 'with two command args' do
-      let(:argv) { %w(add mypoint) }
-      let(:result) { cli.send(:shift_non_flag_commands) }
-
-      it 'should interpret as a command and a point' do
-        expect(result[:command]).to eql(:add)
-        expect(result[:point]).to eql(:mypoint)
-        expect(cli.argv).to be_empty
-      end
-    end
-  end
-
-  describe 'when parsing flags' do
-    describe 'and found --help' do
-      let(:argv) { ['--help', *config_args] }
-      it 'should print the help message' do
-        expect(argv).to output(/<point>/, /Usage:/)
-        expect(argv).not_to output(/^cd /)
-      end
-      it 'should exit with zero status' do
-        expect(argv).to exit_with(0)
-      end
-    end
-
-    describe 'and a flag is no found' do
-      let(:argv) { [ '--boo mee --moo', *config_args ] }
-      it 'should report invalid option' do
-        expect(argv).to output( /unknown option/)
-      end
-    end
-
-    describe 'when an exception error occurs' do
-      let(:argv) { [ %w(boo dkk --debug), *config_args ].flatten }
-      context 'and --debug is given' do
-        it 'should print backtrace' do
-          expect(argv.join(' ')).to eql('boo dkk --debug --config /tmp/warprc')
-          expect(STDERR).to receive(:puts).twice
-          expect(argv).to validate(false) { |cli|
-            expect(cli.config.debug).to be_truthy
-          }
-        end
-      end
-    end
-  end
-
-  describe 'when running command' do
-    describe 'without a parameter' do
-      describe 'such as list' do
-        let(:argv) { ['list', *config_args] }
-
-        it 'should return listing of all points' do
-          expect("list #{warprc}").to output %r{log  ->  /var/log}
-          expect("list #{warprc}").to output %r{tmp  ->  /tmp}
-        end
-
-        it 'should exit with zero status' do
-          expect("list #{warprc}").to exit_with(0)
-        end
-      end
-    end
-
-    describe 'with a point arg, such as ' do
-      let(:wp_name) { store.last.name }
-      let(:wp_path) { store.last.path }
-      let(:warp_args) { "#{wp_name} #{warprc}" }
-
-      describe 'warp <point>' do
-        it "should return response with a 'cd' to a warp point" do
-          warp_point = wp_name
-          expect(warp_args).to validate { |cli|
-            expect(cli.config.point).to eql(warp_point)
-            expect(cli.config.command).to eql(:warp)
-            expect(cli.store[warp_point]).to eql(Warp::Dir::Point.new(wp_name, wp_path))
-          }
-          expect(warp_args).to output("cd #{wp_path}")
-        end
-
-        describe 'when using --command' do
-          let(:warp_args) { "--command warp -p #{wp_name} #{warprc}"}
-          it "should return response with a 'cd' to a warp point" do
-            warp_point = wp_name
-            expect(warp_args).to validate { |cli|
-              expect(cli.config.point).to eql(warp_point.to_s)
-              expect(cli.config.command).to eql(:warp)
-              expect(cli.store[warp_point]).to eql(Warp::Dir::Point.new(wp_name, wp_path))
-            }
-            expect(warp_args).to output("cd #{wp_path}")
-          end
-
-        end
-      end
-
-      describe 'remove <point>' do
-        let(:warp_args) { "remove #{wp_name} #{warprc}" }
-
-        it 'should show that point is removed ' do
-          expect(warp_args).to output(/has been removed/)
-        end
-        it 'should change warp point count ' do
-          expect(store.size).to eq(2)
-          expect {
-            expect(warp_args).to validate { |cli|
-              expect(cli.config.point).to eql(point.name)
-              expect(cli.config.command).to eql(:remove)
-            }
-            store.restore!
-          }.to change(store, :size).by(-1)
-          expect(store.size).to eq(1)
-        end
-      end
-
-      describe 'add <point>' do
-        context 'when point exists' do
-          context 'without --force flag' do
-            let(:warp_args) { "add #{wp_name} #{warprc}" }
-
-            it 'should show error without' do
-              expect(warp_args).to output(/already exists/)
-              expect(warp_args).to exit_with(1)
-            end
-          end
-          context 'with --force' do
-            let(:warp_args) { "add #{wp_name} #{warprc} --force" }
-            it 'should overwrite existing point' do
-
-              expect(Warp::Dir.pwd).to_not eql(wp_path)
-
-              existing_point = store[wp_name]
-              expect(existing_point).to be_kind_of(Warp::Dir::Point)
-              expect(existing_point.path).to eql(wp_path)
-
-              expect {
-                response = expect(warp_args).to validate { |cli|
-                  expect(cli.config.point).to eql(point.name)
-                  expect(cli.config.command).to eql(:add)
-                  expect(cli.store[point.name]).to_not be_nil
-                }
-                expect(response.type).to eql(Warp::Dir::App::Response::INFO), response.message
-                store.restore!
-                updated_point = store[wp_name]
-                expect(updated_point.relative_path).to eql(Warp::Dir::pwd)
-              }.to_not change(store, :size)
-
-            end
-          end
-        end
-      end
-
-      describe 'ls <point>' do
-        context 'no flags' do
-          let(:warp_args) { "ls #{wp_name} #{warprc}" }
-          it 'should default to -al' do
-            expect(warp_args).to output(%r{total \d+\n}, %r{ warprc\n})
-          end
-        end
-        context '-- -l' do
-          let(:warp_args) { "ls #{wp_name} #{warprc} -- -l" }
-          it 'should extract flags' do
-            expect(warp_args).to validate { |cli|
-              expect(cli.flags).to eql(['-l'])
-            }
-          end
-          it 'should ls folder in long format' do
-            expect(warp_args).to output(%r{total \d+\n}, %r{ warprc\n})
-          end
-        end
-        context '-- -1' do
-          let(:warp_args) { "ls #{wp_name} #{warprc} -- -1" }
-          it 'should not list directory in long format' do
-            expect(warp_args).not_to output(%r{total \d+\n}, %r{ warprc\n})
-          end
-        end
-        context '-- -elf' do
-          let(:warp_args) { "ls #{wp_name} #{warprc} -- -alF" }
-          [%r{total \d+\n}, %r{ warprc\n}].each do |reg|
-            it "should list directory and match #{reg}" do
-              expect(warp_args).to output(reg)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

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