tudu 0.0.5 → 0.0.6

data/lib/tudu_dsl.rb

@@ -23,19 +23,19 @@ module Tudu
 
     # == initialize Dsl
     # === Params
-    #- _target_type: target notice type
-    def target_type(_target_type)
-      return if _target_type.nil?
-      return unless _target_type.instance_of?(String) || _target_type.instance_of?(Symbol)
-      _target_type = _target_type.to_sym if _target_type.instance_of? String
-      return unless TARGET_TYPES.include? _target_type
-      @_target_type = _target_type
+    #- target_type: target notice type
+    def target_type(target_type)
+      return if target_type.nil?
+      return unless [String, Symbol].include?(target_type.class)
+      target_type = target_type.to_sym if target_type.instance_of? String
+      return unless TARGET_TYPES.include? target_type
+      @_target_type = target_type
     end
 
-    def targets(_targets)
-      return if _targets.nil?
-      return unless _targets.instance_of? Array
-      @_targets = _targets
+    def targets(target_type)
+      return if target_type.nil?
+      return unless target_type.instance_of? Array
+      @_targets = target_type
     end
   end
 end

data/lib/tudu_file_keys.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Tudu
+  # = Tudu::TuduFileKeys
+  module TuduFileKeys
+    # == Tudufile key
+    TUDU_FILE_KEY = :tudufile
+    # == todo key
+    TUDU_TODO_KEY = :todo
+    # == doing key
+    TUDU_DOING_KEY = :doing
+    # == done key
+    TUDU_DONE_KEY = :done
+    # == file's key
+    TUDU_KEYS = [TUDU_FILE_KEY, TUDU_TODO_KEY, TUDU_DOING_KEY, TUDU_DONE_KEY]
+  end
+end

data/lib/tudu_paths.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'tudu_file_keys'
+
+module Tudu
+  # = Tudu::TuduPaths
+  module TuduPaths
+    # == Tudufile file name
+    TUDU_FILE = 'Tudufile'
+    # == Tudufile file name
+    TUDU_DIR = 'tudu'
+    # == todo file name
+    TUDU_TODOS_FILE = 'todos'
+    # == todo file path
+    TUDU_TODOS_FILE_PATH = "./#{TUDU_DIR}/#{TUDU_TODOS_FILE}"
+    # == doing file name
+    TUDU_DOINGS_FILE = 'doings'
+    # == doing file path
+    TUDU_DOINGS_FILE_PATH = "./#{TUDU_DIR}/#{TUDU_DOINGS_FILE}"
+    # == done file name
+    TUDU_DONES_FILE = 'dones'
+    # == done file path
+    TUDU_DONES_FILE_PATH = "./#{TUDU_DIR}/#{TUDU_DONES_FILE}"
+    # == file names
+    INIT_FILES = {
+      TuduFileKeys::TUDU_FILE_KEY => TUDU_FILE,
+      TuduFileKeys::TUDU_TODO_KEY => TUDU_TODOS_FILE,
+      TuduFileKeys::TUDU_DOING_KEY => TUDU_DOINGS_FILE,
+      TuduFileKeys::TUDU_DONE_KEY => TUDU_DONES_FILE
+    }
+    # == task file names
+    TASK_FILES = {
+      TuduFileKeys::TUDU_TODO_KEY => TUDU_TODOS_FILE,
+      TuduFileKeys::TUDU_DOING_KEY => TUDU_DOINGS_FILE,
+      TuduFileKeys::TUDU_DONE_KEY => TUDU_DONES_FILE
+    }
+  end
+end

data/lib/tudu_templates.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require 'tudu_file_keys'
+
+module Tudu
+  # = Tudu::Templates
+  module Templates
+    # == Tudufile file template
+    TUDU_FILE_TEMPLATE = <<-EOS
+# encoding: utf-8
+
+# !!!!!!! in tudu ver 0.0.1 this file not using !!!!!!!
+
+# if you want to use notification, set target type. default => :none
+# you can set :none, :mail
+# target_type :mail
+
+# if you want to use notification, set targets. default => []
+# if you choose target_type none, you must not set targets.
+# if you choose mail, you must set target email addresses.
+# targets ["target1@abcdefg", "target2@abcdefg"]
+    EOS
+
+    # == todo file template
+    TUDU_TODOS_FILE_TEMPLATE = ''
+    # == doing file template
+    TUDU_DOINGS_FILE_TEMPLATE = ''
+    # == done file template
+    TUDU_DONES_FILE_TEMPLATE = ''
+
+    # == template files
+    INIT_FILES_TEMPLATE = {
+      TuduFileKeys::TUDU_FILE_KEY => TUDU_FILE_TEMPLATE,
+      TuduFileKeys::TUDU_TODO_KEY => TUDU_TODOS_FILE_TEMPLATE,
+      TuduFileKeys::TUDU_DOING_KEY => TUDU_DOINGS_FILE_TEMPLATE,
+      TuduFileKeys::TUDU_DONE_KEY => TUDU_DONES_FILE_TEMPLATE
+    }
+  end
+end

data/spec/tasks_spec.rb

@@ -2,7 +2,9 @@
 require 'spec_helper'
 require 'tudu_core'
 require 'tasks'
+require 'task'
 
+# rubocop:disable LineLength, UnusedMethodArgument
 describe Tudu::Tasks do
 
   context :todo? do
@@ -12,15 +14,15 @@ describe Tudu::Tasks do
         case_title: 'todo task',
         name: 'task_name',
         type: 'todos',
-        expected: true,
+        expected: true
       },
       {
         case_no: 2,
         case_title: 'not todo task',
         name: 'task_name',
         type: 'doings',
-        expected: false,
-      },
+        expected: false
+      }
     ]
 
     cases.each do |c|
@@ -29,7 +31,7 @@ describe Tudu::Tasks do
           case_before c
 
           # -- given --
-          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+          tudu_task = Tudu::Task.new(c[:type], c[:name])
 
           # -- when --
           actual = tudu_task.todo?
@@ -58,15 +60,15 @@ describe Tudu::Tasks do
         case_title: 'doing task',
         name: 'task_name',
         type: 'doings',
-        expected: true,
+        expected: true
       },
       {
         case_no: 2,
         case_title: 'not doing task',
         name: 'task_name',
         type: 'todos',
-        expected: false,
-      },
+        expected: false
+      }
     ]
 
     cases.each do |c|
@@ -75,7 +77,7 @@ describe Tudu::Tasks do
           case_before c
 
           # -- given --
-          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+          tudu_task = Tudu::Task.new(c[:type], c[:name])
 
           # -- when --
           actual = tudu_task.doing?
@@ -105,15 +107,15 @@ describe Tudu::Tasks do
         case_title: 'done task',
         name: 'task_name',
         type: 'dones',
-        expected: true,
+        expected: true
       },
       {
         case_no: 2,
         case_title: 'not done task',
         name: 'task_name',
         type: 'doings',
-        expected: false,
-      },
+        expected: false
+      }
     ]
 
     cases.each do |c|
@@ -122,7 +124,7 @@ describe Tudu::Tasks do
           case_before c
 
           # -- given --
-          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+          tudu_task = Tudu::Task.new(c[:type], c[:name])
 
           # -- when --
           actual = tudu_task.done?
@@ -150,23 +152,23 @@ describe Tudu::Tasks do
         case_no: 1,
         case_title: 'get todos from file',
         type: 'todos',
-        texts: %w{task1 task2 task3},
-        expected: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
+        expected: %w(task1 task2 task3)
       },
       {
         case_no: 2,
         case_title: 'get doings from file',
         type: 'doings',
-        texts: %w{task1 task2 task3},
-        expected: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
+        expected: %w(task1 task2 task3)
       },
       {
         case_no: 3,
         case_title: 'get done from file',
         type: 'dones',
-        texts: %w{task1 task2 task3},
-        expected: %w{task1 task2 task3},
-      },
+        texts: %w(task1 task2 task3),
+        expected: %w(task1 task2 task3)
+      }
     ]
 
     cases.each do |c|
@@ -189,14 +191,14 @@ describe Tudu::Tasks do
 
       def case_before(c)
         # implement each case before
-        Dir.mkdir("./#{Tudu::Tasks::TUDU_DIR}")
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        Dir.mkdir("./#{Tudu::TuduPaths::TUDU_DIR}")
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -207,35 +209,35 @@ describe Tudu::Tasks do
         case_no: 1,
         case_title: 'get todos from file',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         expected: [
-          Tudu::Tasks.new('todos', 'task1'),
-          Tudu::Tasks.new('todos', 'task2'),
-          Tudu::Tasks.new('todos', 'task3'),
-          ],
+          Tudu::Task.new('todos', 'task1'),
+          Tudu::Task.new('todos', 'task2'),
+          Tudu::Task.new('todos', 'task3')
+          ]
       },
       {
         case_no: 2,
         case_title: 'get doings from file',
         type: 'doings',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         expected: [
-          Tudu::Tasks.new('doings', 'task1'),
-          Tudu::Tasks.new('doings', 'task2'),
-          Tudu::Tasks.new('doings', 'task3'),
-          ],
+          Tudu::Task.new('doings', 'task1'),
+          Tudu::Task.new('doings', 'task2'),
+          Tudu::Task.new('doings', 'task3')
+          ]
       },
       {
         case_no: 3,
         case_title: 'get done from file',
         type: 'dones',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         expected: [
-          Tudu::Tasks.new('dones', 'task1'),
-          Tudu::Tasks.new('dones', 'task2'),
-          Tudu::Tasks.new('dones', 'task3'),
-          ],
-      },
+          Tudu::Task.new('dones', 'task1'),
+          Tudu::Task.new('dones', 'task2'),
+          Tudu::Task.new('dones', 'task3')
+          ]
+      }
     ]
 
     cases.each do |c|
@@ -258,31 +260,31 @@ describe Tudu::Tasks do
 
       def case_before(c)
         # implement each case before
-        Dir.mkdir("./#{Tudu::Tasks::TUDU_DIR}")
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        Dir.mkdir("./#{Tudu::TuduPaths::TUDU_DIR}")
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
 
-  context :get_todos do
+  context :todos do
     cases = [
       {
         case_no: 1,
         case_title: 'get doings from file',
         type: 'doings',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         expected: [
-          Tudu::Tasks.new('doings', 'task1'),
-          Tudu::Tasks.new('doings', 'task2'),
-          Tudu::Tasks.new('doings', 'task3'),
-          ],
-      },
+          Tudu::Task.new('doings', 'task1'),
+          Tudu::Task.new('doings', 'task2'),
+          Tudu::Task.new('doings', 'task3')
+          ]
+      }
     ]
 
     cases.each do |c|
@@ -294,7 +296,7 @@ describe Tudu::Tasks do
           # nothing
 
           # -- when --
-          actual = Tudu::Tasks.get_doings
+          actual = Tudu::Tasks.doings
 
           # -- then --
           expect(actual).to eq(c[:expected])
@@ -305,31 +307,31 @@ describe Tudu::Tasks do
 
       def case_before(c)
         # implement each case before
-        Dir.mkdir("./#{Tudu::Tasks::TUDU_DIR}")
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        Dir.mkdir("./#{Tudu::TuduPaths::TUDU_DIR}")
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
 
-  context :get_dones do
+  context :dones do
     cases = [
       {
         case_no: 1,
         case_title: 'get done from file',
         type: 'dones',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         expected: [
-          Tudu::Tasks.new('dones', 'task1'),
-          Tudu::Tasks.new('dones', 'task2'),
-          Tudu::Tasks.new('dones', 'task3'),
-          ],
-      },
+          Tudu::Task.new('dones', 'task1'),
+          Tudu::Task.new('dones', 'task2'),
+          Tudu::Task.new('dones', 'task3')
+          ]
+      }
     ]
 
     cases.each do |c|
@@ -341,7 +343,7 @@ describe Tudu::Tasks do
           # nothing
 
           # -- when --
-          actual = Tudu::Tasks.get_dones
+          actual = Tudu::Tasks.dones
 
           # -- then --
           expect(actual).to eq(c[:expected])
@@ -352,14 +354,14 @@ describe Tudu::Tasks do
 
       def case_before(c)
         # implement each case before
-        Dir.mkdir("./#{Tudu::Tasks::TUDU_DIR}")
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        Dir.mkdir("./#{Tudu::TuduPaths::TUDU_DIR}")
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -370,34 +372,34 @@ describe Tudu::Tasks do
         case_no: 1,
         case_title: 'find todos from tasks',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         search_name: 'task1',
-        expected: Tudu::Tasks.new('todos', 'task1')
+        expected: Tudu::Task.new('todos', 'task1')
       },
       {
         case_no: 2,
         case_title: 'find doings from tasks',
         type: 'doings',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         search_name: 'task1',
-        expected: Tudu::Tasks.new('doings', 'task1')
+        expected: Tudu::Task.new('doings', 'task1')
       },
       {
         case_no: 3,
         case_title: 'find done from tasks',
         type: 'dones',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         search_name: 'task1',
-        expected: Tudu::Tasks.new('dones', 'task1')
+        expected: Tudu::Task.new('dones', 'task1')
       },
       {
         case_no: 4,
         case_title: 'not find',
         type: 'dones',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         search_name: 'task4',
         expected: nil
-      },
+      }
     ]
 
     cases.each do |c|
@@ -421,14 +423,14 @@ describe Tudu::Tasks do
       def case_before(c)
         # implement each case before
         Tudu::Core.new.init
-        Dir.mkdir(Tudu::Tasks::TUDU_DIR) unless File.exists?(Tudu::Tasks::TUDU_DIR)
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        Dir.mkdir(Tudu::TuduPaths::TUDU_DIR) unless File.exist?(Tudu::TuduPaths::TUDU_DIR)
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -439,87 +441,86 @@ describe Tudu::Tasks do
         case_no: 1,
         case_title: 'choose task',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: 'task1',
         expected: [
-          Tudu::Tasks.new('todos', 'task2'),
-          Tudu::Tasks.new('todos', 'task3'),
-          Tudu::Tasks.new('doings', 'task1'),
+          Tudu::Task.new('todos', 'task2'),
+          Tudu::Task.new('todos', 'task3'),
+          Tudu::Task.new('doings', 'task1')
         ]
       },
       {
         case_no: 2,
         case_title: 'aleady exists doing',
         type: 'doings',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: 'task1',
         expected: [
-          Tudu::Tasks.new('doings', 'task1'),
-          Tudu::Tasks.new('doings', 'task2'),
-          Tudu::Tasks.new('doings', 'task3'),
+          Tudu::Task.new('doings', 'task1'),
+          Tudu::Task.new('doings', 'task2'),
+          Tudu::Task.new('doings', 'task3')
         ]
       },
       {
         case_no: 3,
         case_title: 'not exists task',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: 'task4',
         expected: [
-          Tudu::Tasks.new('todos', 'task1'),
-          Tudu::Tasks.new('todos', 'task2'),
-          Tudu::Tasks.new('todos', 'task3'),
+          Tudu::Task.new('todos', 'task1'),
+          Tudu::Task.new('todos', 'task2'),
+          Tudu::Task.new('todos', 'task3')
         ]
       },
       {
         case_no: 4,
         case_title: 'task exists, but dones',
         type: 'dones',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: 'task1',
         expected: [
-          Tudu::Tasks.new('dones', 'task1'),
-          Tudu::Tasks.new('dones', 'task2'),
-          Tudu::Tasks.new('dones', 'task3'),
+          Tudu::Task.new('dones', 'task1'),
+          Tudu::Task.new('dones', 'task2'),
+          Tudu::Task.new('dones', 'task3')
         ]
       },
       {
         case_no: 5,
         case_title: 'task exists, empty args',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: '',
         expected: [
-          Tudu::Tasks.new('todos', 'task2'),
-          Tudu::Tasks.new('todos', 'task3'),
-          Tudu::Tasks.new('doings', 'task1'),
+          Tudu::Task.new('todos', 'task2'),
+          Tudu::Task.new('todos', 'task3'),
+          Tudu::Task.new('doings', 'task1')
         ]
       },
       {
         case_no: 6,
         case_title: 'task exists, nil args',
         type: 'todos',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: nil,
         expected: [
-          Tudu::Tasks.new('todos', 'task2'),
-          Tudu::Tasks.new('todos', 'task3'),
-          Tudu::Tasks.new('doings', 'task1'),
+          Tudu::Task.new('todos', 'task2'),
+          Tudu::Task.new('todos', 'task3'),
+          Tudu::Task.new('doings', 'task1')
         ]
       },
       {
         case_no: 7,
         case_title: 'todos not exists, empty args',
         type: 'doings',
-        texts: %w{task1 task2 task3},
+        texts: %w(task1 task2 task3),
         choose: nil,
         expected: [
-          Tudu::Tasks.new('doings', 'task1'),
-          Tudu::Tasks.new('doings', 'task2'),
-          Tudu::Tasks.new('doings', 'task3'),
+          Tudu::Task.new('doings', 'task1'),
+          Tudu::Task.new('doings', 'task2'),
+          Tudu::Task.new('doings', 'task3')
         ]
-      },
-
+      }
     ]
 
     cases.each do |c|
@@ -543,13 +544,13 @@ describe Tudu::Tasks do
       def case_before(c)
         # implement each case before
         Tudu::Core.new.init
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/#{c[:type]}", 'w') { |f|f.puts c[:texts].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -559,12 +560,12 @@ describe Tudu::Tasks do
       {
         case_no: 1,
         case_title: 'one doing to done, shift todo to doing',
-        task_names: %w{task1 task2 task3},
+        task_names: %w(task1 task2 task3),
         choose: 'task1',
         expected: [
-          Tudu::Tasks.new('todos', 'task3'),
-          Tudu::Tasks.new('doings', 'task2'),
-          Tudu::Tasks.new('dones', 'task1'),
+          Tudu::Task.new('todos', 'task3'),
+          Tudu::Task.new('doings', 'task2'),
+          Tudu::Task.new('dones', 'task1')
         ]
       },
       {
@@ -573,7 +574,7 @@ describe Tudu::Tasks do
         task_names: ['task1'],
         choose: 'task1',
         expected: [
-          Tudu::Tasks.new('dones', 'task1'),
+          Tudu::Task.new('dones', 'task1')
         ]
       },
       {
@@ -582,9 +583,9 @@ describe Tudu::Tasks do
         task_names: ['task1'],
         choose: '',
         expected: [
-          Tudu::Tasks.new('todos', 'task1'),
+          Tudu::Task.new('todos', 'task1')
         ]
-      },
+      }
     ]
 
     cases.each do |c|
@@ -613,8 +614,8 @@ describe Tudu::Tasks do
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -628,7 +629,7 @@ describe Tudu::Tasks do
         task_names2: nil,
         task_names3: nil,
         expected: [
-          Tudu::Tasks.new('todos', 'task_name')
+          Tudu::Task.new('todos', 'task_name')
         ]
       },
       {
@@ -646,9 +647,9 @@ describe Tudu::Tasks do
         task_names2: 'task_name2',
         task_names3: 'task_name3',
         expected: [
-          Tudu::Tasks.new('todos', 'task_name1'),
-          Tudu::Tasks.new('todos', 'task_name2'),
-          Tudu::Tasks.new('todos', 'task_name3')
+          Tudu::Task.new('todos', 'task_name1'),
+          Tudu::Task.new('todos', 'task_name2'),
+          Tudu::Task.new('todos', 'task_name3')
         ]
       },
       {
@@ -658,9 +659,9 @@ describe Tudu::Tasks do
         task_names2: 'task_name1',
         task_names3: nil,
         expected: [
-          Tudu::Tasks.new('todos', 'task_name1'),
+          Tudu::Task.new('todos', 'task_name1')
         ]
-      },
+      }
     ]
 
     cases.each do |c|
@@ -675,7 +676,7 @@ describe Tudu::Tasks do
           Tudu::Tasks.add c[:task_names1], c[:task_names2], c[:task_names3]
 
           # -- then --
-          actual = Tudu::Tasks.get_todos
+          actual = Tudu::Tasks.todos
           expect(actual).to eq(c[:expected])
         ensure
           case_after c
@@ -687,8 +688,8 @@ describe Tudu::Tasks do
       end
 
       def case_after(c)
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -700,22 +701,22 @@ describe Tudu::Tasks do
         case_title: 'single remove',
         add_tasks: ['task_name'],
         remove_tasks: ['task_name'],
-        expected_tasks: [],
+        expected_tasks: []
       },
       {
         case_no: 2,
         case_title: 'multi remove',
-        add_tasks: %w{task_name1 task_name2 task_name3},
-        remove_tasks: %w{task_name1 task_name2 task_name3},
-        expected_tasks: [],
+        add_tasks: %w(task_name1 task_name2 task_name3),
+        remove_tasks: %w(task_name1 task_name2 task_name3),
+        expected_tasks: []
       },
       {
         case_no: 3,
         case_title: 'not remove',
         add_tasks: ['task_name'],
         remove_tasks: ['invalid name'],
-        expected_tasks: [Tudu::Tasks.new('todos', 'task_name')],
-      },
+        expected_tasks: [Tudu::Task.new('todos', 'task_name')]
+      }
     ]
 
     cases.each do |c|
@@ -743,8 +744,8 @@ describe Tudu::Tasks do
       end
 
       def case_after(c)
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
@@ -755,13 +756,13 @@ describe Tudu::Tasks do
         case_no: 1,
         case_title: 'get todos from file',
         tasks: [
-          Tudu::Tasks.new('doings', 'task1_1'),
-          Tudu::Tasks.new('doings', 'task1_2'),
-          Tudu::Tasks.new('doings', 'task3'),
+          Tudu::Task.new('doings', 'task1_1'),
+          Tudu::Task.new('doings', 'task1_2'),
+          Tudu::Task.new('doings', 'task3')
           ],
         filter_word: 'task1_1',
-        expected: [Tudu::Tasks.new('doings', 'task1_1')],
-      },
+        expected: [Tudu::Task.new('doings', 'task1_1')]
+      }
     ]
 
     cases.each do |c|
@@ -797,27 +798,27 @@ describe Tudu::Tasks do
       {
         case_no: 1,
         case_title: 'display progress',
-        todos: %w{task5 task6},
-        doings: %w{task3 task4},
-        dones: %w{task1 task2},
-        expected: '2/6|===>       |33%',
+        todos: %w(task5 task6),
+        doings: %w(task3 task4),
+        dones: %w(task1 task2),
+        expected: '2/6|===>       |33%'
       },
       {
         case_no: 2,
         case_title: 'display none progress',
-        todos: %w{task3 task4},
-        doings: %w{task1 task2},
+        todos: %w(task3 task4),
+        doings: %w(task1 task2),
         dones: [],
-        expected: '0/4|>          |0%',
+        expected: '0/4|>          |0%'
       },
       {
         case_no: 3,
         case_title: 'display complete progress',
         todos: [],
         doings: [],
-        dones: %w{task1 task2},
-        expected: '2/2|==========>|100%',
-      },
+        dones: %w(task1 task2),
+        expected: '2/2|==========>|100%'
+      }
     ]
 
     cases.each do |c|
@@ -841,16 +842,17 @@ describe Tudu::Tasks do
       def case_before(c)
         # implement each case before
         Tudu::Core.new.init
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/todos", 'w') { |f|f.puts c[:todos].join("\n") }
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/doings", 'w') { |f|f.puts c[:doings].join("\n") }
-        File.open("./#{Tudu::Tasks::TUDU_DIR}/dones", 'w') { |f|f.puts c[:dones].join("\n") }
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/todos", 'w') { |f|f.puts c[:todos].join("\n") }
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/doings", 'w') { |f|f.puts c[:doings].join("\n") }
+        File.open("./#{Tudu::TuduPaths::TUDU_DIR}/dones", 'w') { |f|f.puts c[:dones].join("\n") }
       end
 
       def case_after(c)
         # implement each case after
-        return unless File.exists? Tudu::Tasks::TUDU_DIR
-        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+        return unless File.exist? Tudu::TuduPaths::TUDU_DIR
+        FileUtils.rm_rf(Tudu::TuduPaths::TUDU_DIR)
       end
     end
   end
 end
+# rubocop:enable LineLength, UnusedMethodArgument