list-tool 1.0.0

data/spec/list_tool/app/commands_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../../spec_helper.rb'
+
+describe ListTool::App::Commands do
+  subject { ListTool::App::Commands }
+
+  it 'stores command list' do
+    commands = ListTool::App.constants.map {|c| ListTool::App.const_get(c)} - [ListTool::App::Commands, ListTool::App::Printer, ListTool::App::Runner]
+    expect(subject::COMMANDS).to eq commands
+  end
+
+  describe '.process' do
+    let(:lister)  {ListTool::Lister.new}
+    let(:printer) { ListTool::App::Printer }
+
+    context 'success' do
+
+      it 'gets command from argv' do
+        expect(argv = []).to receive(:shift).with(no_args)
+        allow(subject::COMMANDS).to receive(:each)
+        subject.process(argv, lister)
+      end
+
+      context 'no command given' do
+        it 'uses "h" command' do
+          expect(argv = []).to receive(:<<).with('h')
+          allow(subject::COMMANDS).to receive(:each)
+          subject.process(argv, lister)
+        end
+      end
+
+      it "passes command commands' .match? method" do
+        ListTool::App::Commands::COMMANDS.each do |cmd|
+          expect(cmd).to receive(:match?).with('some_command')
+        end
+        subject.process(['some_command'], lister)
+      end
+
+      it "executes matched command" do
+        expect(ListTool::App::ShowListsCommand).to receive(:parse)
+        expect(ListTool::App::ShowListsCommand).to receive(:execute)
+        subject.process(['sl'], lister)
+      end
+
+      it "don't execute unmatched commands" do
+        ListTool::App::Commands::COMMANDS.each do |cmd|
+          expect(cmd).not_to receive(:parse) unless cmd == ListTool::App::AddListCommand
+          expect(cmd).not_to receive(:execute) unless cmd == ListTool::App::AddListCommand
+        end
+        allow(ListTool::App::AddListCommand).to receive(:prase)
+        allow(ListTool::App::AddListCommand).to receive(:execute)
+
+        subject.process(['al', 'list_name'], lister)
+      end
+
+    end
+
+    context 'failure' do
+
+      context 'when first argument is not an array' do
+        it 'raises ArgumentError' do
+          expect{ subject.process 'not_an_array', lister, printer }.to raise_error(ArgumentError)
+        end
+      end
+
+    end
+
+  end
+
+
+  describe '.help' do
+    it 'returns a string' do
+      expect(subject.help).to be_a String
+    end
+
+    it 'gets help messages from all commands' do
+      ListTool::App::Commands::COMMANDS.each { |cmd| expect(cmd).to receive(:help).and_return("") }
+      subject.help
+    end
+  end
+end

data/spec/list_tool/app/printer_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../spec_helper.rb'
+
+describe ListTool::App::Printer do
+  subject { ListTool::App::Printer }
+
+  describe '.error' do
+    it 'prints error message' do
+      expect(subject).to receive(:puts).with( "#{"ERROR".red}: some error\n" )
+      subject.error(StandardError.new('some error'))
+    end
+  end
+
+
+  describe '.print_items' do
+    it 'prints list of items with indexes (starting with 1)' do
+      expect(subject).to receive(:puts).with( "Printing #{'testlist'.green}:\n   1. item1\n   2. item2\n" )
+      subject.print_items( {name: 'testlist', items: ['item1', 'item2']} )
+    end
+  end
+
+
+  describe '.print_lists' do
+    it 'prints list of lists with indexes (starting with 1)' do
+      expect(subject).to receive(:puts).with( "Printing lists:\n   1. list1 (1)\n   2. list2 (2)\n" )
+      subject.print_lists( {'list1' => 1, 'list2' => 2} )
+    end
+  end
+
+
+  describe '.print_usage' do
+    it 'gets help messages from commands' do
+      allow( subject ).to receive(:puts)
+      ListTool::App::Commands::COMMANDS.each do |cmd|
+        expect(cmd).to receive(:help).and_return("")
+      end
+      subject.print_usage
+    end
+
+    it 'prints usage info' do
+      allow( ListTool::App::Commands::COMMANDS ).to receive(:each)
+      expect( subject ).to receive(:puts)
+      subject.print_usage
+    end
+  end
+
+
+  describe '.print_version' do
+    it 'prints version of program' do
+      expect( subject ).to receive(:puts).with("clt version #{ListTool::VERSION}")
+      subject.print_version
+    end
+  end
+
+end

data/spec/list_tool/app/runner_spec.rb

@@ -0,0 +1,166 @@
+require_relative '../../spec_helper.rb'
+
+describe ListTool::App::Runner do
+  subject { ListTool::App::Runner.new }
+
+  describe '#initialize' do
+    it 'stores data directory path' do
+      expect( subject.instance_variable_get(:@datadir) ). to eq File.join(Dir.home, '.clt/')
+    end
+
+    it 'stores data file name' do
+      expect( subject.instance_variable_get(:@datafile) ). to eq 'data.json'
+    end
+
+    it 'stores lister' do
+      expect( subject.instance_variable_get(:@lister) ).to be_a ListTool::Lister
+    end
+  end
+
+
+  describe '#load_data' do
+    it 'loads data to lister' do
+      file = subject.send(:datafile_fullname)
+      expect( subject.instance_variable_get(:@lister) ).to receive(:load).with(file)
+      subject.send(:load_data)
+    end
+  end
+
+
+  describe '#ensure_data_dir' do
+    let (:dir) { subject.instance_variable_get(:@datadir) }
+
+    context "when data dir doesn't exist" do
+      context 'success' do
+        it 'creates data dir' do
+          allow(Dir).to receive(:exist?).with(dir).and_return(false)
+          expect(Dir).to receive(:mkdir).with(dir)
+          subject.send(:ensure_data_dir)
+        end
+      end
+
+      context 'failure' do
+        it 'raises SystemCallError' do
+          allow(Dir).to receive(:mkdir).and_raise( SystemCallError.new('some msg') )
+          allow(Dir).to receive(:exist?).with(dir).and_return(false)
+          expect{ subject.send(:ensure_data_dir) }.to raise_error(SystemCallError)
+        end
+      end
+    end
+
+    context 'when data dir exists' do
+      it 'does nothing' do
+        allow(Dir).to receive(:exist?).and_return(true)
+        expect(Dir).not_to receive(:mkdir)
+        subject.send(:ensure_data_dir)
+      end
+    end
+
+  end
+
+
+  describe '#ensure_data_file' do
+    let(:file) { subject.send(:datafile_fullname) }
+
+    context "when data file doesn't exist" do
+
+      context 'success' do
+        it 'creates data file with initial(empty) data' do
+          allow(File).to receive(:exist?).with(file).and_return(false)
+          fake_datafile = double('file')
+          expect(File).to receive(:open).with(file, 'w').and_yield(fake_datafile)
+          expect(fake_datafile).to receive(:<<).with( '{"lists":[]}' )
+
+          subject.send(:ensure_data_file)
+        end
+      end
+
+      context 'failure' do
+        it 'raises SystemCallError' do
+          allow(File).to receive(:open).and_raise( SystemCallError.new('some msg') )
+          allow(File).to receive(:exist?).with(file).and_return(false)
+          expect{ subject.send(:ensure_data_file) }.to raise_error(SystemCallError)
+        end
+      end
+    end
+
+  end
+
+
+  describe '#ensure_data' do
+    it 'calls "ensure_data_dir"' do
+      expect(subject).to receive(:ensure_data_dir)
+      allow(subject).to receive(:ensure_data_file)
+      subject.send(:ensure_data)
+    end
+
+    it 'calls "ensure_data_file"' do
+      allow(subject).to receive(:ensure_data_dir)
+      expect(subject).to receive(:ensure_data_file)
+      subject.send(:ensure_data)
+    end
+  end
+
+
+  describe '#datafile_fullname' do
+    it 'returns full datafile name' do
+      file = File.join(subject.instance_variable_get(:@datadir),subject.instance_variable_get(:@datafile))
+      expect(subject.send(:datafile_fullname)).to eq file
+    end
+  end
+
+
+  describe '#run' do
+    let (:lister) { subject.instance_variable_get(:@lister) }
+
+    context 'success' do
+      it 'ensures presence of data' do
+        expect( subject ).to receive(:ensure_data)
+        allow( subject ).to receive(:load_data)
+        allow( ListTool::App::Commands ).to receive(:process)
+        allow( lister ).to receive(:save)
+
+        subject.run ['argv']
+      end
+
+      it 'loads data' do
+        allow( subject ).to receive(:ensure_data)
+        expect( subject ).to receive(:load_data)
+        allow( ListTool::App::Commands ).to receive(:process)
+        allow( lister ).to receive(:save)
+
+        subject.run []
+      end
+
+      it 'starts command processing' do
+        allow( subject ).to receive(:ensure_data)
+        allow( subject ).to receive(:load_data)
+        expect( ListTool::App::Commands ).to receive(:process).with(['argv'], lister)
+        allow( lister ).to receive(:save)
+
+        subject.run ['argv']
+      end
+
+      it 'saves data' do
+        allow( subject ).to receive(:ensure_data)
+        allow( subject ).to receive(:load_data)
+        allow( ListTool::App::Commands ).to receive(:process)
+        expect( lister ).to receive(:save)
+
+        subject.run ['argv']
+      end
+    end
+
+    context 'failure' do
+      context 'when any of inner method calls ended with exception' do
+        it 'passes this exception to Printer.error' do
+          allow( subject ).to receive(:ensure_data).and_raise(error = StandardError)
+          expect( ListTool::App::Printer ).to receive(:error).with(error)
+
+          subject.run ['argv']
+        end
+      end
+    end
+  end
+
+end

data/spec/list_tool/app/string_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../../spec_helper.rb'
+
+describe String do
+
+  describe '#colorize' do
+    it 'colorizes string using given code' do
+      expect('test'.colorize(31)).to eq "\x1B[31mtest\x1B[0m"
+    end
+  end
+
+  describe '#red' do
+    it 'calls #colorize with 31' do
+      expect(string = 'test').to receive(:colorize).with(31)
+      string.red
+    end
+  end
+
+  describe '#green' do
+    it 'calls #colorize with 32' do
+      expect(string = 'test').to receive(:colorize).with(32)
+      string.green
+    end
+  end
+
+  describe '#blue' do
+    it 'calls #colorize with 34' do
+      expect(string = 'test').to receive(:colorize).with(34)
+      string.blue
+    end
+  end
+
+end

data/spec/list_tool/data_spec.rb

@@ -0,0 +1,257 @@
+require_relative '../spec_helper.rb'
+
+describe Data do 
+  let (:data) { ListTool::Data.new(Factory.data) }
+
+  describe '#initialize' do
+
+    context 'success' do
+      context 'from initial data' do
+        it "stores objects of List class" do
+          expect(data.lists[0]).to be_an_instance_of(ListTool::List)
+        end
+
+        it 'stores 2 lists' do
+          expect(data.lists.length).to eq 2
+        end
+
+        it 'stores default list' do
+          expect(data.default_list.name).to eq 'Todolist'
+        end
+      end
+
+      context 'no arguments' do
+        it 'creates new Data instance with empty array of lists' do
+          expect(ListTool::Data.new().lists).to be_empty
+        end
+      end
+
+    end
+
+    context 'failure' do
+      context 'argument is not a hash' do
+        it 'raises ArgumentError' do
+          expect{ListTool::Data.new('not_a_hash')}.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'no "lists" key in given hash' do
+        it 'creates new Data instance with empty lists array' do
+          expect(ListTool::Data.new({}).lists).to be_empty
+        end
+      end
+
+      context '"lists" is not an array' do
+        it 'raises ArgumentError' do
+          expect{ListTool::Data.new("lists" => 'not_an_array')}.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+  end
+
+
+  describe '#add_list' do
+
+    context 'hash given' do
+      it 'adds new list to data' do
+        data.add_list(Factory.list)
+        expect(data.lists.length).to eq 3
+      end
+    end
+
+    context 'string given' do
+      it 'adds blank list with given name' do
+        data.add_list('Testlist')
+        expect(data.lists.last.name).to eq 'Testlist'
+      end
+    end
+
+    it 'returns list object' do
+      expect(data.add_list(Factory.list)).to be_an_instance_of(ListTool::List)
+    end
+
+  end
+
+
+  describe '#delete_list' do
+
+    context 'success' do
+      it 'removes list with given number' do
+        data.delete_list(1)
+        expect(data.lists.length).to eq 1
+      end
+
+      it 'returns deleted list' do
+        list = data.lists[1]
+        expect(data.delete_list(1)).to eq list
+      end
+
+      context 'default list is being deleted' do
+        it 'clears default list' do
+          data.delete_list(0)
+          expect(data.default_list).to be_nil
+        end
+      end
+    end
+
+    context 'no list with given index' do
+      it 'returns nil' do
+        expect(data.delete_list(2)).to be_nil
+      end
+    end
+     
+  end
+
+
+  describe '#rename_list' do
+
+    context 'success' do
+      it 'renames list with given index and returns old name' do
+        expect( data.lists[1] ).to receive(:rename).with('Testlist').and_return('Wishlist')
+        data.rename_list(1, 'Testlist')
+      end
+
+      it 'returns not nil' do
+        expect( data.rename_list(1, 'Testlist') ).not_to be_nil
+      end
+    end
+
+    context 'no list with given index' do
+      it 'returns nil' do
+        expect(data.rename_list(2, 'new_name')).to be_nil
+      end
+    end
+
+  end
+
+
+  describe '#set_default_list' do
+
+    context 'success' do
+      it 'replaces default list' do
+        data.set_default_list(1)
+        expect(data.default_list).to eq data.lists[1]
+      end
+
+      it 'returns new defaut list' do
+        expect(data.set_default_list(1)).to eq data.lists[1]
+      end
+    end
+
+    context 'failure' do
+
+      context 'argument is not an integer' do
+        it 'raises ArgumentError' do
+          expect{data.set_default_list('bad_int')}.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'no list with given index' do
+        it 'returns nil' do
+          expect(data.set_default_list(2)).to be_nil
+        end
+
+        it 'does not affect on default list' do
+          data.set_default_list(2)
+          expect(data.default_list).to eq data.lists[0]
+        end
+      end
+
+    end
+
+  end
+
+
+  describe '#clear_list' do
+
+    context 'success' do
+      it 'clears list with given index' do
+        data.clear_list(0)
+        expect( data.lists[0].items ).to be_empty
+      end
+
+      it 'returns true' do
+        expect( data.clear_list(0) ).to be_truthy
+      end
+    end
+
+    context 'failure' do
+
+      context 'no list with given index' do
+        it 'returns nil' do
+          expect( data.clear_list(2) ).to be_nil
+        end
+      end
+
+    end
+  end
+
+
+  describe '#move_list' do
+
+    context 'success' do
+      it 'moves list up' do
+        data.move_list(1, :up)
+        expect(data.lists[0].name).to eq 'Wishlist'
+      end
+
+      it 'moves list down' do
+        data.move_list(0, :down)
+        expect(data.lists[1].name).to eq 'Todolist'
+      end
+
+      it 'returns not nil' do
+        expect( data.move_list(1, :up) ).not_to be_nil
+      end
+    end
+
+    context 'failure' do
+
+      context 'too high index' do
+        it 'does nothing when moving up' do
+          lists = data.lists.dup
+          data.move_list(2, :up)
+          expect(data.lists).to eq lists
+        end
+
+        it 'does nothing when moving down' do
+          lists = data.lists.dup
+          data.move_list(2, :down)
+          expect(data.lists).to eq lists
+        end
+      end
+
+      context 'too low index' do
+        it 'does nothing when moving up' do
+          lists = data.lists.dup
+          data.move_list(0, :up)
+          expect(data.lists).to eq lists
+        end
+
+        it 'does nothing when moving down' do
+          lists = data.lists.dup
+          data.move_list(-1, :down)
+          expect(data.lists).to eq lists
+        end
+      end
+
+    end
+
+  end
+
+
+  describe '#to_json' do
+    it 'returns correct json' do
+      expect(data.to_json).to eq Factory.json
+    end
+
+    context 'default list not set' do
+      it 'returns json without "default_list" field' do
+        data = ListTool::Data.new(Factory.blank_data)
+        expect(data.to_json).to eq '{"lists":[]}'
+      end
+    end
+  end
+
+end

data/spec/list_tool/file_manager_spec.rb

@@ -0,0 +1,84 @@
+require_relative '../spec_helper.rb'
+
+describe ListTool::FileManager do
+  let(:fm){ListTool::FileManager}
+
+  describe '.load' do
+
+    context 'success' do
+      it 'loads json from specified file' do
+        allow(File).to receive(:read).and_return('{"test":0}')
+        expect(fm.load('some_file')).to eq '{"test":0}'
+      end
+    end
+
+    context 'failure' do
+
+      context 'access denied to specified file' do
+        it 'raises FileAccessError' do
+          allow(File).to receive(:read).and_raise(Errno::EACCES)
+          expect{ fm.load('some_file') }.to raise_error(ListTool::FileAccessError)
+        end
+      end
+
+      context "file doesn't exist" do
+        it 'raises NoFileError' do
+          allow(File).to receive(:read).and_raise(Errno::ENOENT)
+          expect{ fm.load('some_file') }.to raise_error(ListTool::FileNotFoundError)
+        end
+      end
+
+      context 'unknown error' do
+        it 'raises IOError' do
+          allow(File).to receive(:read).and_raise(StandardError)
+          expect{ fm.load('some_file') }.to raise_error(IOError)
+        end
+      end
+
+    end
+
+  end
+
+
+  describe '.save' do
+    let(:filename){ "some_file" }
+    let(:data){ ListTool::Data.new }
+
+    context 'success' do
+      it 'saves given data to specified file' do
+        file = double('File')
+        allow(File).to receive(:open).with(filename, 'w').and_yield(file)
+        expect(file).to receive(:<<).with('{"lists":[]}')
+
+        ListTool::FileManager.save(filename, data)
+      end
+    end
+
+    context 'failure' do
+      
+      context 'access denied to specified file' do
+        it 'raises FileAccessError' do
+          allow(File).to receive(:open).with(filename, 'w').and_raise(Errno::EACCES)
+          expect{ fm.save('some_file', data) }.to raise_error(ListTool::FileAccessError)
+        end
+      end
+
+      context "file doesn't exist" do
+        it 'raises NoFileError' do
+          allow(File).to receive(:open).with(filename, 'w').and_raise(Errno::ENOENT)
+          expect{ fm.save('some_file', data) }.to raise_error(ListTool::FileNotFoundError)
+        end
+      end
+
+      context 'unknown error' do
+        it 'raises IOError' do
+          allow(File).to receive(:open).with(filename, 'w').and_raise(StandardError)
+          expect{ fm.save('some_file', data) }.to raise_error(IOError)
+        end
+      end
+
+    end
+
+  end
+
+end