list-tool 1.0.0

data/lib/list_tool/data.rb

@@ -0,0 +1,75 @@
+module ListTool
+
+  class Data
+    include Enumerable
+    
+    attr_reader :lists, :default_list
+
+    def initialize(hash = {})
+      raise ArgumentError, 'argument is not a hash' unless hash.respond_to?(:to_hash)
+
+      hash['lists'] ||= []
+      raise ArgumentError, 'incorrect data given' unless hash['lists'].respond_to?(:to_ary)
+
+      @lists = []
+      hash['lists'].each { |list_data| add_list(list_data) }
+
+      set_default_list(hash['default']) if hash['default']
+    end
+
+    def each
+      @lists.each { |list| yield(list) }
+    end
+
+    def add_list(data)
+      list = List.new(data)
+      @lists << list
+      list
+    end
+
+    def delete_list(index)
+      list = @lists.delete_at(index)
+      @default_list = nil if @default_list == list
+      list
+    end
+
+    def clear_list(index)
+      return nil if @lists[index] == nil
+      @lists[index].clear!
+    end
+
+    def rename_list(index, name)
+      return nil if @lists[index] == nil
+      @lists[index].rename(name)
+    end
+
+    def set_default_list(index)
+      raise ArgumentError, 'argument is not an integer' unless index.respond_to?(:to_int)
+      return nil if @lists[index] == nil
+      @default_list = @lists[index]
+    end
+
+    def move_list(index, direction)
+      case direction
+      when :up
+        return unless (1...@lists.length).include?(index)
+        @lists[index], @lists[index-1] = @lists[index-1], @lists[index]
+      when :down
+        return unless (0...(@lists.length-1)).include?(index)
+        @lists[index], @lists[index+1] = @lists[index+1], @lists[index]
+      end
+    end
+
+    def to_json
+      json = "{"
+      json += "\"default\":#{@lists.index(@default_list)}," if @default_list
+      json += "\"lists\":["
+      @lists.each do |list|
+        json += list.to_json
+        json += ',' unless list == @lists.last
+      end
+      json += ']}'
+    end
+      
+  end
+end

data/lib/list_tool/file_manager.rb

@@ -0,0 +1,27 @@
+module ListTool
+
+  class FileManager
+
+    def self.load filename
+      File.read(filename)
+    rescue Errno::EACCES
+      raise FileAccessError, "can't read file '#{filename}': access denied"
+    rescue Errno::ENOENT
+      raise FileNotFoundError, "can't read file '#{filename}': file not found"
+    rescue
+      raise IOError, "can't read file '#{filename}': unknown error"
+    end
+
+    def self.save filename, data
+      File.open(filename, 'w') { |f| f << data.to_json }
+    rescue Errno::EACCES
+      raise FileAccessError, "can't open file '#{filename}': access denied"
+    rescue Errno::ENOENT
+      raise FileNotFoundError, "can't open file '#{filename}': file not found"
+    rescue
+      raise IOError, "can't open file '#{filename}': unknown error"
+    end
+
+  end
+
+end

data/lib/list_tool/item.rb

@@ -0,0 +1,23 @@
+module ListTool
+
+  class Item
+    attr_accessor :text
+
+    def initialize arg
+      if arg.is_a?(String)
+        @text = arg
+      elsif arg.is_a?(Hash)
+        raise(ArgumentError, "item text not found in given hash") unless arg['text'].is_a?(String)
+        @text = arg["text"]
+      else
+        raise(ArgumentError, "argument expected to be Hash or String, #{arg.class} given")
+      end
+    end
+
+    def to_json
+      "{\"text\":\"#{@text}\"}"
+    end
+
+  end
+
+end

data/lib/list_tool/json_parser.rb

@@ -0,0 +1,11 @@
+module ListTool
+
+  class JsonParser
+
+    def self.parse json
+      JSON.parse(json)
+    end
+
+  end
+
+end

data/lib/list_tool/list.rb

@@ -0,0 +1,88 @@
+module ListTool
+
+  class List
+    include Enumerable
+
+    attr_reader :name, :items
+
+    def initialize(arg=nil)
+      if arg.respond_to?(:to_str)
+        @name = arg
+        @items = []
+      elsif arg.is_a?(Hash)
+        prepare_data(arg)
+
+        @name = arg['name']
+
+        @items = []
+        arg['items'].each do |item|
+          add_item(item)
+        end
+      else
+        raise(ArgumentError, "argument expected to be Hash or String, #{arg.class} given")
+      end
+    end
+
+    def clear!
+      @items = []
+    end
+
+    def rename str
+      raise ArgumentError, 'string expected' unless str.is_a?(String)
+      old_name = @name
+      @name = str
+      old_name
+    end
+
+    def to_json
+      json = "{\"name\":\"#{@name}\",\"items\":["
+      @items.each do |item|
+        json += item.to_json
+        json += ',' unless item == @items.last
+      end
+      json += ']}'
+    end
+
+    def each
+      @items.each { |item| yield(item) }
+    end
+
+    def add_item text
+      @items << Item.new(text)
+    end
+
+    def delete_item num
+      @items.delete_at(num)
+    end
+
+    def change_item index, new_text
+      raise ArgumentError, 'index is not an integer' unless index.respond_to?(:to_int)
+      raise ArgumentError, 'new text is not a string' unless new_text.respond_to?(:to_str)
+      return nil if @items[index].nil?
+      @items[index].text = new_text
+    end
+
+    def move_item num, direction
+      case direction
+      when :up
+        return unless (1...@items.length).include?(num)
+        @items[num], @items[num-1] = @items[num-1], @items[num]
+      when :down
+        return unless (0...(@items.length-1)).include?(num)
+        @items[num], @items[num+1] = @items[num+1], @items[num]
+      end
+    end    
+
+  private
+
+    def prepare_data data
+      data['items'] ||= []
+      data['name'] ||= 'Anonimous list'
+
+      data['name'].respond_to?(:to_str) || raise(ArgumentError, 'name is not a string')      
+      data['items'].is_a?(Array) || raise(ArgumentError, '"items" is not an array')
+    end
+
+  end
+
+end

data/lib/list_tool/lister.rb

@@ -0,0 +1,81 @@
+module ListTool
+  class Lister
+
+    def initialize
+      @data = Data.new
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.__id__.to_s(16)}>"
+    end
+
+    def self.from_hash(hash)
+      lister = Lister.new
+      lister.instance_variable_set(:@data, Data.new(hash))
+      lister
+    end
+
+    def self.from_json(json)
+      data = JsonParser.parse(json)
+      from_hash(data)
+    end
+
+    def load(filename)
+      json = FileManager.load(filename)
+      @data = Data.new( JsonParser.parse(json) )
+      self
+    end
+
+    def save(filename)
+      FileManager.save(filename, @data)
+    end
+
+    def lists
+      out = {}
+      @data.each do |list|
+        out[list.name] = list.items.count
+      end
+      out
+    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
+
+      out = {name: list.name, items: []}
+      list.items.each do |item|
+        out[:items] << item.text
+      end
+      out
+    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
+      else
+        super
+      end
+
+      result = object.send(name, *args, &block)
+      return nil if result.nil?
+      self
+    rescue NoMethodError => e
+      raise NoMethodError, "undefined method '#{name.to_s}' for #{self.inspect}"
+    end
+
+  end
+end

data/lib/list_tool/version.rb

@@ -0,0 +1,3 @@
+module ListTool
+  VERSION = "1.0.0"
+end

data/lib/list_tool.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+require_relative "./list_tool/version"
+require_relative "./list_tool/lister"
+require_relative "./list_tool/item"
+require_relative "./list_tool/list"
+require_relative "./list_tool/data"
+require_relative "./list_tool/json_parser"
+require_relative "./list_tool/file_manager"
+require_relative "./list_tool/app.rb"
+
+module ListTool
+  class FileAccessError < StandardError; end
+  class FileNotFoundError < StandardError; end
+  class NoDefaultListError < StandardError; end
+  class ListNotFoundError < StandardError; end;
+  class ItemNotFoundError < StandardError; end;
+  class UnknownCommandError < StandardError; end;
+end

data/list_tool.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'list_tool/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "list-tool"
+  spec.version       = ListTool::VERSION
+  spec.date          = '2014-06-08'
+  spec.authors       = ["Dmitrii Krasnov"]
+  spec.email         = ["vizvamitra@gmail.com"]
+  spec.summary       = "list-tool-#{ListTool::VERSION}"
+  spec.description   = "A tool to manage lists of strings (like todos) in your app or terminal"
+  spec.homepage      = "http://github.com/vizvamitra/list-tool"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  # spec.add_runtime_dependency "json", '~> 1.8'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard", "~> 2.6"
+  spec.add_development_dependency "guard-rspec", "~> 4.2"
+  spec.add_development_dependency "rb-readline", "~> 0.5"
+end

data/spec/fixtures/data.json

@@ -0,0 +1,18 @@
+{ "default":0,
+  "lists":[
+  {
+    "name":"Todolist",
+    "items":[
+      {
+        "text": "item1"
+      },
+      {
+        "text": "item2"
+      }
+    ]
+  },
+  {
+    "name":"Wishlist",
+    "items":[]
+  }
+]}

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

@@ -0,0 +1,108 @@
+require_relative '../../../spec_helper.rb'
+
+describe ListTool::App::AddItemCommand do
+  subject { ListTool::App::AddItemCommand }
+
+  describe '.match?' do
+    it 'returns true if "a" or "add-item" given' do
+      expect( subject.match? "a" ).to be_truthy
+      expect( subject.match? "add-item" ).to be_truthy
+    end
+
+    it 'returns false otherwise' do
+      expect( subject.match? "some-arg" ).to be_falsey
+    end
+  end
+
+
+  describe '.parse' do
+
+    it 'shifts 2 args from ARGV' do
+      argv = ['text', '1']
+      expect( argv ).to receive(:shift).with(2).and_return(['text', '1'])
+      subject.parse argv
+    end
+
+    context 'success' do
+
+      context 'when list number not given' do
+        it 'returns {text: "item text"}' do
+          argv = ['item_text']
+          expect( subject.parse argv ).to eq( {text: 'item_text'} )
+        end
+      end
+
+      context 'when list number given' do
+        it 'returns {text: "item text", list: list_num}' do
+          argv = ['item_text', "2"]
+          expect( subject.parse argv ).to eq( {text: 'item_text', list: 1} )
+        end
+      end
+
+    end
+
+    context 'failure' do
+
+      context 'when item text not given' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse([]) }.to raise_error( ArgumentError )
+        end
+      end
+
+      context 'when list number is not an integer' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(['text', 'not_an_int']) }.to raise_error( ArgumentError )
+        end
+      end
+
+      context 'when list number is less than 1' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(['text', '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.add_item with given options' do
+        expect(lister).to receive(:add_item).with('item text').and_return("not_nil")
+        subject.execute({text: 'item text'}, lister)
+      end
+    end
+
+    context 'failure' do
+
+      context 'when list not found' do
+        it 'raises ListNotFoundError' do
+          expect{ subject.execute({text: 'item text', list: 2}, lister) }.to raise_error(ListTool::ListNotFoundError )
+        end
+      end
+
+      context 'when list not specified and no default list set' do
+        it 'raises NoDefaultListError' do
+          expect{ subject.execute({text: 'item text'}, lister) }.to raise_error(ListTool::NoDefaultListError )
+        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/add_list_command_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../../../spec_helper.rb'
+
+describe ListTool::App::AddListCommand do
+  subject { ListTool::App::AddListCommand }
+
+  describe '.match?' do
+    it 'returns true if "al" or "add-list" given' do
+      expect( subject.match? "al" ).to be_truthy
+      expect( subject.match? "add-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 = ['name']
+      expect( argv ).to receive(:shift).with(no_args).and_return('name')
+      subject.parse argv
+    end
+
+    context 'success' do
+      it 'returns {name: "name"}' do
+        expect( subject.parse(['name']) ).to eq( {name: 'name'} )
+      end
+    end
+
+    context 'failure' do
+
+      context 'when new name not given' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse[] }.to raise_error(ArgumentError)
+        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
+
+
+  describe '.execute' do
+    let (:lister)  { double('lister')  }
+
+    context 'success' do
+      it 'calls lister.add_list with given name' do
+        expect(lister).to receive(:add_list).with('list name').and_return("not_nil")
+        subject.execute({name: 'list name'}, lister)
+      end
+    end
+
+    context 'list creation failed' do
+      it 'raises RuntimeError' do
+        allow(lister).to receive(:add_list).and_return(nil)
+        expect{ subject.execute({name: 'some name'}, lister) }.to raise_error(RuntimeError)
+      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/delete_item_command_spec.rb

@@ -0,0 +1,116 @@
+require_relative '../../../spec_helper.rb'
+
+describe ListTool::App::DeleteItemCommand do
+  subject { ListTool::App::DeleteItemCommand }
+
+  describe '.match?' do
+    it 'returns true if "d" or "del-item" given' do
+      expect( subject.match? "d" ).to be_truthy
+      expect( subject.match? "del-item" ).to be_truthy
+    end
+
+    it 'returns false otherwise' do
+      expect( subject.match? "some-arg" ).to be_falsey
+    end
+  end
+
+
+  describe '.parse' do
+
+    it 'shifts 2 args from ARGV' do
+      argv = ['2', '1']
+      expect( argv ).to receive(:shift).with(2).and_return(['2', '1'])
+      subject.parse argv
+    end
+
+    context 'success' do
+
+      context 'when list number not given' do
+        it 'returns {item: item_num}' do
+          argv = ["2"]
+          expect( subject.parse argv ).to eq( {item: 1} )
+        end
+      end
+
+      context 'when list number given' do
+        it 'returns {text: "item text", list: list_num}' do
+          argv = ["2", "1"]
+          expect( subject.parse argv ).to eq( {item: 1, list: 0} )
+        end
+      end
+
+    end
+
+    context 'failure' do
+
+      context 'when item number not given' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse([]) }.to raise_error( ArgumentError )
+        end
+      end
+
+      context 'when list number is not an integer' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(['2', 'not_an_int']) }.to raise_error( ArgumentError )
+        end
+      end
+
+      context 'when list number is less than 1' do
+        it 'raises ArgumentError' do
+          expect{ subject.parse(['2', '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
+      context 'when list number is given' do
+        it 'calls lister.delete_item with item_num, {list: list_num}' do
+          expect(lister).to receive(:delete_item).with(2, {list: 2}).and_return("not_nill")
+          subject.execute({item: 2, list: 2}, lister)
+        end
+      end
+
+      context 'when list number is not given' do
+        it 'calls lister.delete_item with no args' do
+          expect(lister).to receive(:delete_item).with(2).and_return("not_nill")
+          subject.execute({item: 2}, lister)
+        end
+      end
+    end
+
+    context 'failure' do
+      context 'when list not found' do
+        it 'raises ListNotFoundError' do
+          expect{ subject.execute({item: 2, list: 2}, lister) }.to raise_error(ListTool::ListNotFoundError )
+        end
+      end
+
+      context 'when list not specified and no default list set' do
+        it 'raises NoDefaultListError' do
+          expect{ subject.execute({item: 2}, lister) }.to raise_error(ListTool::NoDefaultListError )
+        end
+      end
+    end
+
+  end
+
+
+  describe '.help' do
+    it 'returns help message' do
+      expect( subject.help ).to be_a String
+    end
+  end
+
+end