warp-dir 1.1.0

data/lib/warp/dir/serializer/base.rb

@@ -0,0 +1,43 @@
+module Warp
+  module Dir
+    module Serializer
+      class Base
+        attr_accessor :store
+
+        def initialize store
+          self.store = store
+        end
+
+        def config
+          self.store.config
+        end
+
+        def self.inherited subclass
+          Warp::Dir::SERIALIZERS[subclass.name] = subclass
+        end
+
+        #
+        # restore method should read the values from somewhere (i.e. database?)
+        # and perform the following operation:
+        #
+        # for each [ shortcut, path ] do
+        #   self.store.add(shortcut, path)
+        # end
+
+        def restore!
+          raise NotImplementedError.new('Abstract Method')
+        end
+
+        #
+        # save shortcuts to the persistence layer
+        #
+        # store.points.each_pair |shortcut, path| do
+        #   save(shortcut, path)
+        # end
+        def persist!
+          raise NotImplementedError.new('Abstract Method')
+        end
+      end
+    end
+  end
+end

data/lib/warp/dir/serializer/dotfile.rb

@@ -0,0 +1,36 @@
+require_relative '../errors'
+require_relative '../../dir'
+module Warp
+  module Dir
+    module Serializer
+      class Dotfile < Base
+
+        def restore!
+          File.open(Warp::Dir.absolute(config.warprc), "r") do |f|
+            f.each_line do |line|
+              line = line.chomp
+              next if line.blank?
+              name, path = line.split(/:/)
+              if name.nil? || path.nil?
+                raise Warp::Dir::Errors::StoreFormatError.new("File may be corrupt - #{config.warprc}:#{line}", line)
+              end
+              store.add point_name: name, point_path: path
+            end
+          end
+        end
+
+        def persist!
+          File.open(Warp::Dir.absolute(config.warprc), 'w') do |file|
+            buffer = ''
+            store.points.each do |point|
+              buffer << "#{point.name}:#{point.relative_path}\n"
+            end
+            file.write(buffer)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/warp/dir/store.rb

@@ -0,0 +1,129 @@
+require_relative 'point'
+require_relative 'errors'
+require_relative 'serializer'
+require 'forwardable'
+
+module Warp
+  module Dir
+
+    # We want to keep around only one store, so we follow the Singleton patter.
+    # Due to us wanting to pass parameters to the singleton class's #new method,
+    # using standard Singleton becomes more hassle than it's worth.
+    class Store
+      extend Forwardable
+
+      def_delegators :@points_collection, :size, :clear, :each, :map
+      def_delegators :@config, :warprc, :shell
+
+      attr_reader :config, :serializer, :points_collection
+
+      def initialize(config, serializer_class = Warp::Dir::Serializer.default)
+        @config            = config
+        serializer_class   ||= Warp::Dir::Serializer.default
+        @serializer        = serializer_class.new(self)
+        restore!
+      end
+
+      def restore!
+        @points_collection = Set.new
+        self.serializer.restore!
+      end
+
+      def [](name)
+        find_point(name)
+      end
+
+      def first
+        points_collection.to_a.sort.first
+      end
+
+      def last
+        points_collection.to_a.sort.last
+      end
+
+      def <<(value)
+        raise ArgumentError.new("#{value} is not a Point") unless value.is_a?(Point)
+        self.add(point: value)
+      end
+
+      def remove(point_name: nil)
+        point = point_name.is_a?(Warp::Dir::Point) ? point_name : self[point_name]
+        self.points_collection.delete(point) if point
+        save!
+      end
+
+      def points
+        points_collection.to_a
+      end
+
+      def find_point(name_or_point)
+        return if name_or_point.nil?
+        result = if name_or_point.is_a?(Warp::Dir::Point)
+                   self.find_point(name_or_point.name)
+                 else
+                   matching_set = self.points_collection.classify { |p| p.name.to_sym }[name_or_point.to_sym]
+                   (matching_set && !matching_set.empty?) ? matching_set.first : nil
+                 end
+        raise ::Warp::Dir::Errors::PointNotFound.new(name_or_point) unless result
+        result
+      end
+
+      def save!
+        serializer.persist!
+      end
+
+      # a version of add that save right after.
+      def insert(*args)
+        add(*args)
+        save!
+      end
+
+      # add to memory representation only
+      def add(point: nil,
+              point_name: nil,
+              point_path: nil,
+              overwrite: false)
+        unless point
+          if !(point_name && point_path)
+            raise ArgumentError.new('invalid arguments')
+          end
+          point = Warp::Dir::Point.new(point_name, point_path)
+        end
+
+        # Three use-cases here.
+        # if we found this WarpPoint by name, and it's path is different from the incoming...
+        existing = begin
+          self[point]
+        rescue Warp::Dir::Errors::PointNotFound
+          nil
+        end
+
+        if existing.eql?(point) # found, but it's identical
+          if config.debug
+            puts "Point being added #{point} is identical to existing #{existing}, ignore."
+          end
+          return
+        elsif existing # found, but it's different
+          if overwrite # replace it
+            if config.debug
+             puts "Point being added #{point} is replacing the existing #{existing}."
+            end
+            replace(point, existing)
+          else # reject it
+            if config.debug
+             puts "Point being added #{point} already exists, but no overwrite was set"
+            end
+            raise Warp::Dir::Errors::PointAlreadyExists.new(point)
+          end
+        else # no lookup found
+          self.points_collection << point # add it
+        end
+      end
+
+      def replace(point, existing_point)
+        remove(point_name: existing_point)
+        insert(point: point)
+      end
+    end
+  end
+end

data/lib/warp/dir/version.rb

@@ -0,0 +1,6 @@
+module Warp
+  module Dir
+    VERSION = '1.1.0'
+  end
+end
+

data/spec/fixtures/warprc

@@ -0,0 +1,2 @@
+tmp:/tmp
+log:/var/log

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+require 'codeclimate-test-reporter'
+require 'warp/dir'
+require 'rspec/core'
+
+CodeClimate::TestReporter.start
+
+module Warp
+  module Dir
+    module App
+      class Response
+        class << self
+          attr_accessor :exit_disabled
+
+          def enable_exit!
+            self.exit_disabled = false
+          end
+
+          def disable_exit!
+            self.exit_disabled = true
+          end
+
+          def exit_disabled?
+            self.exit_disabled
+          end
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before do
+    Warp::Dir::App::Response.disable_exit!
+  end
+end
+
+RSpec.shared_context :fake_serializer do
+  let(:file) { @file ||= ::Tempfile.new('warp-dir') }
+  let(:config) { Warp::Dir::Config.new(config: file.path) }
+  let(:serializer) {
+    @initialized_store ||= FakeSerializer ||= Class.new(Warp::Dir::Serializer::Base) do
+      def persist!;
+      end
+
+      def restore!;
+      end
+    end
+  }
+
+  after do
+    file.close
+    file.unlink
+  end
+end
+
+RSpec.shared_context :fixture_file do
+  let(:fixture_file) { 'spec/fixtures/warprc'}
+  let(:config_path) { '/tmp/warprc' }
+  let(:file) {
+    FileUtils.cp(fixture_file, config_path)
+    File.new(config_path)
+  }
+  let(:config) { Warp::Dir::Config.new(config: file.path) }
+end
+
+RSpec.shared_context :initialized_store do
+  let(:store) { Warp::Dir::Store.new(config) }
+  let(:wp_path) { ENV['HOME'] + '/workspace/tinker-mania' }
+  let(:wp_name) { 'harro' }
+  let(:point) { Warp::Dir::Point.new(wp_name, wp_path) }
+end

data/spec/support/cli_expectations.rb

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

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