list-tool 1.0.3 → 1.0.5

data/lib/list_tool/app/commands/use_command.rb

@@ -1,31 +1,31 @@
 module ListTool
   module App
 
-    class UseCommand
+    class UseCommand < Command
+      class << self
 
-      def self.match? arg
-        ['u', 'use'].include? arg
-      end
+        def match? arg
+          ['u', 'use'].include? arg
+        end
 
-      def self.parse argv
-        raise ArgumentError, "expected argument to be an array, #{argv.class} given" unless argv.is_a? Array
-        list = argv.shift
-        raise ArgumentError, "list number not specified" if list.nil?
+        def parse argv
+          fail_if_not_an_array(argv)
+          
+          list = argv.shift
 
-        list = Integer( list ) - 1 rescue raise(ArgumentError, 'list number must be an integer')
-        raise ArgumentError, "list number can't be less than 1" if list < 0
+          { list: parse_list_number!(list) }
+        end
 
-        {list: list}
-      end
+        def execute options, lister
+          raise(ListNotFoundError, 'no list with given number') if lister.set_default_list( options[:list] ).nil?
+        end
 
-      def self.execute options, lister
-        raise(ListNotFoundError, 'no list with given number') if lister.set_default_list( options[:list] ).nil?
-      end
+        def help
+          "  u,  use LIST\t\t\tSet default list"
+        end
 
-      def self.help
-        "  u,  use LIST\t\t\tSet default list"
       end
-
     end
+
   end
 end

data/lib/list_tool/app/commands/version_command.rb

@@ -1,24 +1,27 @@
 module ListTool
   module App
 
-    class VersionCommand
+    class VersionCommand < Command
+      class << self
 
-      def self.match? arg
-        ['v', '-v', 'version', '--version'].include? arg
-      end
+        def match? arg
+          ['v', '-v', 'version', '--version'].include? arg
+        end
 
-      def self.parse argv
-        {}
-      end
+        def parse argv
+          {}
+        end
 
-      def self.execute options, lister
-        Printer.print_version
-      end
+        def execute options, lister
+          Printer.print_version
+        end
 
-      def self.help
-        " -v,  --version\t\t\tPrint version"
-      end
+        def help
+          " -v,  --version\t\t\tPrint version"
+        end
 
+      end
     end
+
   end
 end

data/lib/list_tool/app/commands.rb

@@ -1,3 +1,4 @@
+require_relative './commands/command.rb'
 require_relative './commands/add_item_command.rb'
 require_relative './commands/replace_item_command.rb'
 require_relative './commands/delete_item_command.rb'
@@ -5,6 +6,7 @@ require_relative './commands/show_items_command.rb'
 require_relative './commands/add_list_command.rb'
 require_relative './commands/rename_list_command.rb'
 require_relative './commands/delete_list_command.rb'
+require_relative './commands/clear_list_command.rb'
 require_relative './commands/show_lists_command.rb'
 require_relative './commands/use_command.rb'
 require_relative './commands/help_command.rb'
@@ -16,7 +18,7 @@ module ListTool
 
     class Commands
 
-      COMMANDS = ListTool::App.constants.map {|const| ListTool::App.const_get(const)} - [self, Printer, Runner, Colorizer]
+      COMMANDS = ListTool::App.constants.map {|const| ListTool::App.const_get(const)} - [self, Printer, Runner, Colorizer, Command]
 
       class << self
         def process argv, lister

data/lib/list_tool/list.rb

@@ -23,6 +23,10 @@ module ListTool
       end
     end
 
+    def inspect
+      "#<#{self.class}:0x#{self.__id__.to_s(16)}, name: #{name}, items: [#{items.map(&:text).join(', ')}]>"
+    end
+
     def clear!
       @items = []
     end
@@ -45,6 +49,7 @@ module ListTool
 
     def add_item text
       @items << Item.new(text)
+      @items[-1]
     end
 
     def delete_item num

data/lib/list_tool/lister.rb

@@ -37,38 +37,50 @@ module ListTool
     end
 
     def list(index=nil)
-      list = if index
-              return nil if @data.lists[index].nil?
-              @data.lists[index]
-            else
-              raise NoDefaultListError, "default list not set" if @data.default_list.nil?
-              @data.default_list
-            end
+      list = get_list(index)
+      return nil if list.nil?
 
       { name: list.name, items: list.items.map{|item| item.text} }
     end
 
-    def method_missing(name, *args, &block)
-      if name =~ /_list$/
-        object = @data
-      elsif name =~ /_item$/
-        object = if args[-1].is_a?(Hash) && args[-1].has_key?(:list)
-                  return nil if @data.lists[ args[-1][:list] ].nil?
-                  index = args.pop()[:list]
-                  @data.lists[index]
-                else
-                  raise NoDefaultListError, "default list not set" if @data.default_list.nil?
-                  @data.default_list
-                end
+    def default_list
+      if @data.default_list
+        list = @data.default_list
+        { name: list.name, items: list.items.map{|item| item.text} }
+      else
+        nil
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name =~ /_list$/
+        receiver = @data
+      elsif method_name =~ /_item$/
+        if args[-1].is_a?(Hash) && args[-1].has_key?(:list)
+          # then last argument is an options hash
+          options = args.pop
+          index = options[:list]
+        end
+        receiver = get_list(index)
+        receiver || raise(ListNotFoundError, "list with given index doesn't exist")
       else
         super
       end
 
-      result = object.send(name, *args, &block)
-      return nil if result.nil?
-      self
+      receiver.send(method_name, *args, &block)
     rescue NoMethodError => e
-      raise NoMethodError, "undefined method '#{name.to_s}' for #{self.inspect}"
+      raise NoMethodError, "undefined method '#{method_name.to_s}' for #{self.inspect}"
+    end
+
+    private
+
+    def get_list index=nil
+      if index
+        @data.lists[index]
+      else
+        raise NoDefaultListError, "default list not set" if @data.default_list.nil?
+        @data.default_list
+      end
     end
 
   end

data/lib/list_tool/lister_data.rb

@@ -17,6 +17,10 @@ module ListTool
       set_default_list(hash['default']) if hash['default']
     end
 
+    def inspect
+      "#<#{self.class}:0x#{self.__id__.to_s(16)}, lists: [#{lists.map(&:name).join(', ')}], default_list: #{default_list.name}>"
+    end
+
     def each
       @lists.each { |list| yield(list) }
     end

data/lib/list_tool/version.rb

@@ -1,3 +1,3 @@
 module ListTool
-  VERSION = "1.0.3"
+  VERSION = "1.0.5"
 end

data/spec/list_tool/app/commands/add_list_command_spec.rb

@@ -36,12 +36,6 @@ describe ListTool::App::AddListCommand do
         end
       end
 
-      context 'when first arg is not a string' do
-        it 'raises ArgumentError' do
-          expect{ subject.parse([1]) }.to raise_error(ArgumentError)
-        end
-      end
-
     end
 
   end

data/spec/list_tool/app/commands/clear_list_command_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../../../spec_helper.rb'
+
+describe ListTool::App::ClearListCommand do
+  subject { ListTool::App::ClearListCommand }
+
+  describe '.match?' do
+    it 'returns true if "cl" or "clear-list" given' do
+      expect( subject.match? "cl" ).to be_truthy
+      expect( subject.match? "clear-list" ).to be_truthy
+    end
+
+    it 'returns false otherwise' do
+      expect( subject.match? "some-arg" ).to be_falsey
+    end
+  end
+
+
+  describe '.parse' do
+    it 'shifts 1 arg from ARGV' do
+      argv = ['2']
+      expect( argv ).to receive(:shift).with(no_args).and_return('2')
+      subject.parse argv
+    end
+
+    context 'success' do
+      it 'returns {list: list_num}' do
+        expect( subject.parse(['2']) ).to eq( {list: 1} )
+      end
+    end
+
+    context 'failure' do
+
+      context 'when list number not given' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse[] }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'when list number is not a integer' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(["not_an_integer"]) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'when list number is less than 1' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(['0']) }.to raise_error( ArgumentError )
+        end
+      end
+
+      context 'when not an array given' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse "not_an_array" }.to raise_error( ArgumentError )
+        end
+      end
+
+    end
+
+  end
+
+
+  describe '.execute' do
+    let (:lister)  { ListTool::Lister.new }
+
+    context 'success' do
+      it 'calls lister.clear_list with given list number' do
+        expect(lister).to receive(:clear_list).with(2).and_return("not_nil")
+        subject.execute({list: 2}, lister)
+      end
+    end
+
+    context 'failure' do
+      context 'when list not found' do
+        it 'raises ListNotFoundError' do
+          expect{ subject.execute({list: -2}, lister) }.to raise_error(ListTool::ListNotFoundError )
+        end
+      end
+    end
+
+  end
+
+
+  describe '.help' do
+    it 'returns help message' do
+      expect( subject.help ).to be_a String
+    end
+  end
+
+end

data/spec/list_tool/app/commands/command_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../../../spec_helper.rb'
+
+describe ListTool::App::Command do
+  subject { ListTool::App::Command }
+
+  describe '::parse_number' do
+    context 'success' do
+      it "returns an integer" do
+        expect( subject.parse_number("2", "list") ).to eq 1
+      end
+    end
+
+    context 'failure' do
+
+      it 'injects given number name into error message' do
+        expect{ subject.parse_number("not_an_int", "smth") }.to raise_error(ArgumentError, /smth/)
+      end
+
+      context 'when list number is not a integer' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse_number("not_an_int", "item") }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'when list number is less than 1' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse_number("-1", "list") }.to raise_error( ArgumentError)
+        end
+      end
+    end
+  end
+
+
+  describe '::parse_item_number' do
+    it 'calls ::parse_number with given string and "item"' do
+      expect(subject).to receive(:parse_number).with("2", "item")
+      subject.parse_item_number("2")
+    end
+  end
+
+  describe '::parse_item_number!' do
+    it 'calls ::parse_item_number with given string' do
+      expect(subject).to receive(:parse_item_number).with("2")
+      subject.parse_item_number!("2")
+    end
+
+    it 'raises ArgumentError if number == nil' do
+      expect{ subject.parse_item_number!(nil) }.to raise_error(ArgumentError, /item number/)
+    end
+  end
+
+
+  describe '::parse_list_number' do
+    it 'calls ::parse_number with given string and "list"' do
+      expect(subject).to receive(:parse_number).with("2", "list")
+      subject.parse_list_number("2")
+    end
+  end
+
+  describe '::parse_list_number!' do
+    it 'calls ::parse_list_number with given string' do
+      expect(subject).to receive(:parse_list_number).with("2")
+      subject.parse_list_number!("2")
+    end
+
+    it 'raises ArgumentError if number == nil' do
+      expect{ subject.parse_list_number!(nil) }.to raise_error(ArgumentError, /list number/)
+    end
+  end
+
+
+  describe '::ensure_existence_of' do
+    it 'raises error if given argument is nil' do
+      expect{ subject.ensure_existence_of("value" => nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error if any of given hash values is nil' do
+      expect{ subject.ensure_existence_of("value1" => "not_nil", "value2" => nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'inserts key name to exception message' do
+      expect{ subject.ensure_existence_of("value1" => nil) }.to raise_error(ArgumentError, /value1/)
+    end
+  end
+
+
+  describe '::fail_if_not_an_array' do
+    context 'when argument is an array' do
+      it 'does nothing' do
+        expect{ subject.fail_if_not_an_array([]) }.not_to raise_error
+      end
+    end
+
+    context 'when argument is not an array' do
+      it 'raises ArgumentError' do
+        expect{ subject.fail_if_not_an_array("not_an_array") }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+end

data/spec/list_tool/app/commands_spec.rb

@@ -4,7 +4,7 @@ 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, ListTool::App::Colorizer]
+    commands = ListTool::App.constants.map {|c| ListTool::App.const_get(c)} - [ListTool::App::Commands, ListTool::App::Printer, ListTool::App::Runner, ListTool::App::Colorizer, ListTool::App::Command]
     expect(subject::COMMANDS).to eq commands
   end
 

data/spec/list_tool/list_spec.rb

@@ -67,6 +67,14 @@ describe ListTool::List do
   end
 
 
+  describe '#inspect' do
+    it "returns class name, object id, list name and array of item texts" do
+      str = "#<ListTool::List:0x#{list.__id__.to_s(16)}, name: Todolist, items: [item1, item2]>"
+      expect( list.inspect ).to eq str
+    end
+  end
+
+
   describe '#clear!' do
     it "clears items array" do
       list.clear!

data/spec/list_tool/lister_data_spec.rb

@@ -51,6 +51,14 @@ describe ListTool::ListerData do
   end
 
 
+  describe '#inspect' do
+    it "returns class name, object id, array of list names and default list name" do
+      str = "#<ListTool::ListerData:0x#{data.__id__.to_s(16)}, lists: [Todolist, Wishlist], default_list: Todolist>"
+      expect( data.inspect ).to eq str
+    end
+  end
+
+
   describe '#add_list' do
 
     context 'hash given' do

data/spec/list_tool/lister_spec.rb

@@ -72,35 +72,36 @@ describe ListTool::Lister do
 
   describe '#list' do
 
-    context 'success' do
-      context 'no options' do
-        it 'returns hash with list name and array of item texts' do
-          expect( lister.list(0) ).to eq( {name: 'Todolist', items: ['item1', 'item2']} )
-        end
+    context 'no options' do
+      it 'returns hash with list name and array of item texts' do
+        expect( lister.list(0) ).to eq( {name: 'Todolist', items: ['item1', 'item2']} )
       end
+    end
 
-      context 'list number not given' do
-        it 'returns contents of default list' do
-          expect( lister.list ).to eq( {name: 'Todolist', items: ['item1', 'item2']} )
-        end
+    context 'list number not given' do
+      it 'returns contents of default list' do
+        expect( lister.list ).to eq( {name: 'Todolist', items: ['item1', 'item2']} )
       end
     end
 
-    context 'failure' do
-      context 'no list with given index' do
-        it 'returns nil' do
-          expect( lister.list(2) ).to be_nil
-        end
-      end
+  end
 
-      context 'default list not set and list not given' do
-        it 'raises NoDefaultListError' do
-          lister = ListTool::Lister.new
-          expect{ lister.list }.to raise_error(ListTool::NoDefaultListError)
-        end
+
+  describe '#default_list' do
+    let(:data) { lister.instance_variable_get(:@data) }
+
+    context 'when default list is set' do
+      it 'returns hash with default ist name and array of item texts' do
+        expect( lister.default_list ).to eq( {name: 'Todolist', items: ['item1', 'item2']} )
       end
     end
 
+    context 'when default list is not set' do
+      it 'returns nil' do
+        allow( data ).to receive(:default_list).and_return(nil)
+        expect( lister.default_list ).to be_nil
+      end
+    end
   end
 
 
@@ -112,75 +113,88 @@ describe ListTool::Lister do
 
 
   describe '#method_missing' do
+    let(:data) { lister.instance_variable_get(:@data) }
 
-    context 'success' do
-
-      it 'returns self' do
-        expect( lister.add_item('text') ).to eq lister
-      end
-
-      context '_list method given' do
-        it 'deligates method call to @data' do
-          data = lister.instance_variable_get(:@data)
-          expect( data ).to receive(:add_list).with('new_list')
-          lister.add_list('new_list')
-        end
+    context 'method name ends with _list' do
+      it 'deligates method call to ListerData' do
+        expect(data).to receive(:add_list).with("name")
+        lister.add_list("name")
       end
+    end
 
-      context '_item method given' do
+    context 'when method name ends with _item' do
+      context 'and list index is not specified' do
 
-        context 'list number not specified' do
+        context 'if default list is set' do
           it 'deligates method call to default list' do
-            default_list = lister.instance_variable_get(:@data).default_list
-            expect( default_list ).to receive(:add_item).with('new_item')
+            list = data.default_list
+            expect(list).to receive(:add_item).with("text")
+            lister.add_item("text")
+          end
+        end
 
-            lister.add_item('new_item')
+        context 'if default list is not set' do
+          it 'raises NoDefaultListError' do
+            allow( data ).to receive(:default_list).and_return(nil)
+            expect{ lister.add_item }.to raise_error(ListTool::NoDefaultListError)
           end
         end
 
-        context 'list number specified' do
-          it 'deligates method call to specified list' do
-            list = lister.instance_variable_get(:@data).lists[0]
-            expect( list ).to receive(:add_item).with('new_item')
+      end
 
-            lister.add_item('new_item', list: 0)
+      context 'and list index is specified' do
+
+        context 'if list with given index exists' do
+          it 'deligates method call to list with given index' do
+            list = data.lists[1]
+            expect(list).to receive(:add_item).with("text")
+            lister.add_item("text", {list: 1})
+          end
+        end
+
+        context 'if there is no list with given index' do
+          it 'raises ListNotFoundError' do
+            expect{ lister.add_item("text", {list: 3}) }.to raise_error(ListTool::ListNotFoundError)
           end
         end
 
       end
+    end
 
+    context 'for any other methods' do
+      it 'raises NoMethodError' do
+        expect{ lister.unknown_method }.to raise_error(NoMethodError)
+      end
     end
 
-    context 'failure' do
+  end
 
-      context 'call to unknown method' do
-        it 'raises NoMethodError' do
-          message = "undefined method 'no_such_method' for #{lister.inspect}"
-          expect{lister.no_such_method}.to raise_error(NoMethodError, message)
-        end
-      end
 
-      context 'no list with specified number' do
-        it 'returns nil' do
-          expect( lister.add_item('new_item', list: 3) ).to be_nil
-        end
+  describe '#get_list' do
+    context 'when list index given' do
+      it 'returns corresponding list object' do
+        list = lister.instance_variable_get(:@data).instance_variable_get(:@lists)[0]
+        expect( lister.send(:get_list, 0) ).to eq list
       end
+    end
+
+    context 'when list index not given' do
 
-      context 'method returned nil' do
-        it 'returns nil' do
-          expect( lister.delete_item(3) ).to be_nil
+      context 'default list is set' do
+        it 'returns default list' do
+          list = lister.instance_variable_get(:@data).instance_variable_get(:@default_list)
+          expect( lister.send(:get_list) ).to eq list
         end
       end
 
-      context 'list number not specified and default list not set' do
+      context 'default list is not set' do
         it 'raises NoDefaultListError' do
-          lister = ListTool::Lister.new
-          expect{ lister.add_item('new item') }.to raise_error(ListTool::NoDefaultListError)
+          allow( lister.instance_variable_get(:@data) ).to receive(:default_list).and_return(nil)
+          expect{ lister.send(:get_list) }.to raise_error(ListTool::NoDefaultListError)
         end
       end
-
+      
     end
-
   end
 
 end