tudu 0.0.1

data/lib/tasks.rb

@@ -0,0 +1,281 @@
+# encoding: utf-8
+
+module Tudu
+  #= Tudu::Tasks
+  class Tasks
+    #== 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]
+
+    #== 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 = {
+      TUDU_FILE_KEY => TUDU_FILE,
+      TUDU_TODO_KEY => TUDU_TODOS_FILE,
+      TUDU_DOING_KEY => TUDU_DOINGS_FILE,
+      TUDU_DONE_KEY => TUDU_DONES_FILE
+    }
+    #== task file names
+    TASK_FILES = {
+      TUDU_TODO_KEY => TUDU_TODOS_FILE,
+      TUDU_DOING_KEY => TUDU_DOINGS_FILE,
+      TUDU_DONE_KEY => TUDU_DONES_FILE
+    }
+
+    #== 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 = {
+      TUDU_FILE_KEY => TUDU_FILE_TEMPLATE,
+      TUDU_TODO_KEY => TUDU_TODOS_FILE_TEMPLATE,
+      TUDU_DOING_KEY => TUDU_DOINGS_FILE_TEMPLATE,
+      TUDU_DONE_KEY => TUDU_DONES_FILE_TEMPLATE
+    }
+
+    #== task type [todo, doing, done]
+    attr_accessor :type
+    #== task name [uniq]
+    attr_accessor :name
+
+    class << self
+      #== add task to todos
+      #=== Params
+      #- task_names : add task name list
+      def add(*task_names)
+        task_names.each do |task_name|
+          if find_tasks(task_name)
+            puts "#{task_name} is already exists."
+            next
+          end
+          File.open(TUDU_TODOS_FILE_PATH, "a:UTF-8") {|f|f.puts task_name}
+          puts "complete add todo '#{task_name}' to tudu/todos"
+        end
+      end
+
+      #== remove task to todo
+      #=== Params
+      #- task_names : remove task name list
+      def remove(*task_names)
+        task_names.each do |task_name|
+          can_find = false
+          TASK_FILES.each_value do |rf|
+            tasks = get_tasks_from_file(rf)
+            next unless has_task?(tasks, task_name)
+            remove_task(tasks, task_name, "./#{TUDU_DIR}/#{rf}")
+            can_find = true
+            break
+          end
+          puts "no such todo '#{task_name}'" unless can_find
+        end
+      end
+
+      #== choose todo => doing task
+      #=== Params
+      #- task_name : target task name
+      def choose(task_name)
+        if get_doings.size > 0
+          puts "before choose, you must done current doings."
+          return
+        end
+
+        task = find_tasks(task_name)
+
+        if task.nil?
+          puts "#{task_name} not exists"
+          return
+        end
+
+        unless task.todo?
+          puts "#{task_name} is not exists in todos. #{task_name} in #{task.type}"
+          return
+        end
+
+        remove task_name
+        File.open(TUDU_DOINGS_FILE_PATH, "w:UTF-8") {|f|f.puts task_name}
+        puts "complete add doings '#{task_name}'"
+      end
+
+      #== doing to done
+      #- if doings size == 0, nothing todo.
+      #- after move doing to done, next todo move to doing.
+      def done
+        return unless doings_to_dones
+        todos_to_doings
+      end
+
+      #== get todos type tasks.
+      #=== Returns
+      # return Array[Tasks]
+      def get_todos
+        get_tasks(TUDU_TODOS_FILE)
+      end
+
+      #== get doings type tasks.
+      #=== Returns
+      # return Array[Tasks]
+      def get_doings
+        get_tasks(TUDU_DOINGS_FILE)
+      end
+
+      #== get dones type tasks.
+      #=== Returns
+      # return Array[Tasks]
+      def get_dones
+        get_tasks(TUDU_DONES_FILE)
+      end
+
+      #== get each type tasks.
+      #=== Params
+      #- type : task type.if use nil, you can get all types task.
+      #=== Returns
+      # return Array[Tasks]
+      def get_tasks(type = nil)
+        type.nil? ? get_all_tasks : get_each_tasks(type)
+      end
+
+      #== get each type tasks from file.
+      #=== Params
+      #- type : task type.
+      #=== Returns
+      # return Array[String]
+      def get_tasks_from_file(file_name)
+        File.read("./#{TUDU_DIR}/#{file_name}").split("\n")
+      end
+
+      #== filter tasklist by search_word.
+      #=== Params
+      #- tasks : task list.
+      #- search_word : filtering word.
+      #=== Returns
+      # return filterd task list
+      def filter_tasks(tasks, search_word)
+        return tasks if search_word.nil?
+        tasks.select {|task|task.name.match /.*#{search_word}.*/}
+      end
+
+      #== find task from all tasks.
+      #=== Params
+      #- task_name : task name.
+      #=== Returns
+      # return task
+      def find_tasks(task_name)
+        tasks = get_tasks
+        tasks.select {|task|task.name == task_name}.first
+      end
+
+      private
+      def get_each_tasks(type)
+        tasks = []
+        get_tasks_from_file(type).each {|task|tasks << Tasks.new(type, task)}
+        tasks
+      end
+
+      def get_all_tasks
+        tasks = []
+        TASK_FILES.each_value {|each_type|tasks += get_each_tasks(each_type)}
+        tasks
+      end
+
+      def has_task?(tasks, task_name)
+        tasks.include? task_name
+      end
+
+      def remove_task(tasks, task_name, file_path)
+        tasks.delete(task_name)
+        File.open(file_path, "w:UTF-8") {|wf|wf.puts tasks.join("\n")}
+        puts "complete remove todo '#{task_name}' from #{file_path}"
+      end
+
+      def doings_to_dones
+        _doings = get_doings
+        if _doings.size == 0
+          puts "there is no doing task.before done, you must choose task."
+          return false
+        end
+        File.open(TUDU_DOINGS_FILE_PATH, "w:UTF-8") {|f|f.print ""}
+        File.open(TUDU_DONES_FILE_PATH, "a:UTF-8") {|f|f.puts _doings.first.name}
+        true
+      end
+
+      def todos_to_doings
+        _todos = get_todos
+        return if _todos.size == 0
+        deleted_todos = _todos.dup
+        deleted_todos.delete_at 0
+        File.open(TUDU_TODOS_FILE_PATH, "w:UTF-8") do |f|
+          deleted_todos.each {|task|f.puts task.name}
+        end
+        File.open(TUDU_DOINGS_FILE_PATH, "w:UTF-8") {|f|f.puts _todos.first.name}
+      end
+    end
+
+    #== init task with setting task type and task name.
+    def initialize(type, name)
+      @type, @name = type, name
+    end
+
+    def todo?
+      @type == "todos"
+    end
+
+    def doing?
+      @type == "doings"
+    end
+
+    def done?
+      @type == "dones"
+    end
+
+    def ==(other)
+      if self.name == other.name
+        if self.type == other.type
+          return true
+        end
+      end
+      false
+    end
+  end
+end

data/lib/tudu/version.rb

@@ -0,0 +1,3 @@
+module Tudu
+  VERSION = "0.0.1"
+end

data/lib/tudu_core.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require "tudu/version"
+require "tasks"
+
+module Tudu
+  # Tudu::Core
+  class Core
+    #== generate files [Tudufile, todos, doings, dones]
+    def init
+      Dir.mkdir Tudu::Tasks::TUDU_DIR unless File.exists? Tudu::Tasks::TUDU_DIR
+      Tudu::Tasks::TUDU_KEYS.each do |key|
+        File.open("./tudu/#{Tudu::Tasks::INIT_FILES[key]}", "w:UTF-8") {|f|f.print Tudu::Tasks::INIT_FILES_TEMPLATE[key]}
+      end
+    end
+
+    #== add task to todo
+    #=== Params
+    #- task_names : add task name list
+    def add(*task_names)
+      Tudu::Tasks.add *task_names
+    end
+
+    #== remove task to todo
+    #=== Params
+    #- task_names : remove task name list
+    def remove(*task_names)
+      Tudu::Tasks.remove *task_names
+    end
+
+    #== choose todo => doing task
+    #=== Params
+    #- task_name : target task name
+    def choose(task_name)
+      Tudu::Tasks.choose task_name
+    end
+
+    #== doing to done
+    #- if doings size == 0, nothing todo.
+    #- after move doing to done, next todo move to doing.
+    def done
+      Tudu::Tasks.done
+    end
+
+    #== search tasks
+    #=== Params
+    #- search_word : search word. enable regexp.
+    def tasks(search_word)
+      Tudu::Tasks.filter_tasks(Tudu::Tasks.get_tasks, search_word).map(&:name)
+    end
+
+    #== search todos
+    #=== Params
+    #- search_word : search word. enable regexp.
+    def todos(search_word)
+      Tudu::Tasks.filter_tasks(Tudu::Tasks.get_todos, search_word).map(&:name)
+    end
+
+    #== search doings
+    #=== Params
+    #- search_word : search word. enable regexp.
+    def doings(search_word)
+      Tudu::Tasks.filter_tasks(Tudu::Tasks.get_doings, search_word).map(&:name)
+    end
+
+    #== search dones
+    #=== Params
+    #- search_word : search word. enable regexp.
+    def dones(search_word)
+      Tudu::Tasks.filter_tasks(Tudu::Tasks.get_dones, search_word).map(&:name)
+    end
+
+    alias :now :doings
+  end
+end

data/lib/tudu_dsl.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require "tudu/version"
+
+module Tudu
+  #= Tudu::Dsl
+  class Dsl
+    #== TARGET_TYPES
+    # notice target types
+    #=== types
+    #- none: no notice
+    #- mail: mail notice
+    TARGET_TYPES = {:none => :none, :mail => :mail}
+    #== notice target type
+    attr_accessor :_target_type
+    #== notice targets
+    attr_accessor :_targets
+
+    #== initialize Dsl 
+    def initialize
+      @_target_type = TARGET_TYPES[:none]
+      @_targets = []
+    end
+
+    #== 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 or _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
+    end
+
+    def targets(_targets)
+      return if _targets.nil?
+      return unless _targets.instance_of? Array
+      @_targets = _targets
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "simplecov"
+SimpleCov.start
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/task_spec.rb

@@ -0,0 +1,762 @@
+# encoding: utf-8
+require "spec_helper"
+require "tudu_core"
+require "tasks"
+
+describe Tudu::Tasks do
+
+  context :todo? do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "todo task",
+        name: "task_name",
+        type: "todos",
+        expected: true,
+      },
+      {
+        case_no: 2,
+        case_title: "not todo task",
+        name: "task_name",
+        type: "doings",
+        expected: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+
+          # -- when --
+          actual = tudu_task.todo?
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+
+  context :doing? do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "doing task",
+        name: "task_name",
+        type: "doings",
+        expected: true,
+      },
+      {
+        case_no: 2,
+        case_title: "not doing task",
+        name: "task_name",
+        type: "todos",
+        expected: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+
+          # -- when --
+          actual = tudu_task.doing?
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+
+  context :done? do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "done task",
+        name: "task_name",
+        type: "dones",
+        expected: true,
+      },
+      {
+        case_no: 2,
+        case_title: "not done task",
+        name: "task_name",
+        type: "doings",
+        expected: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          tudu_task = Tudu::Tasks.new(c[:type], c[:name])
+
+          # -- when --
+          actual = tudu_task.done?
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+
+
+  context :get_tasks_from_file do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "get todos from file",
+        type: "todos",
+        texts: ["task1", "task2", "task3"],
+        expected: ["task1", "task2", "task3"],
+      },
+      {
+        case_no: 2,
+        case_title: "get doings from file",
+        type: "doings",
+        texts: ["task1", "task2", "task3"],
+        expected: ["task1", "task2", "task3"],
+      },
+      {
+        case_no: 3,
+        case_title: "get done from file",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        expected: ["task1", "task2", "task3"],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.get_tasks_from_file(c[:type])
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :get_tasks do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "get todos from file",
+        type: "todos",
+        texts: ["task1", "task2", "task3"],
+        expected: [
+          Tudu::Tasks.new("todos", "task1"),
+          Tudu::Tasks.new("todos", "task2"),
+          Tudu::Tasks.new("todos", "task3"),
+          ],
+      },
+      {
+        case_no: 2,
+        case_title: "get doings from file",
+        type: "doings",
+        texts: ["task1", "task2", "task3"],
+        expected: [
+          Tudu::Tasks.new("doings", "task1"),
+          Tudu::Tasks.new("doings", "task2"),
+          Tudu::Tasks.new("doings", "task3"),
+          ],
+      },
+      {
+        case_no: 3,
+        case_title: "get done from file",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        expected: [
+          Tudu::Tasks.new("dones", "task1"),
+          Tudu::Tasks.new("dones", "task2"),
+          Tudu::Tasks.new("dones", "task3"),
+          ],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.get_tasks(c[:type])
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :get_todos do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "get doings from file",
+        type: "doings",
+        texts: ["task1", "task2", "task3"],
+        expected: [
+          Tudu::Tasks.new("doings", "task1"),
+          Tudu::Tasks.new("doings", "task2"),
+          Tudu::Tasks.new("doings", "task3"),
+          ],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.get_doings
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :get_dones do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "get done from file",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        expected: [
+          Tudu::Tasks.new("dones", "task1"),
+          Tudu::Tasks.new("dones", "task2"),
+          Tudu::Tasks.new("dones", "task3"),
+          ],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.get_dones
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :find_tasks do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "find todos from tasks",
+        type: "todos",
+        texts: ["task1", "task2", "task3"],
+        search_name: "task1",
+        expected: Tudu::Tasks.new("todos", "task1")
+      },
+      {
+        case_no: 2,
+        case_title: "find doings from tasks",
+        type: "doings",
+        texts: ["task1", "task2", "task3"],
+        search_name: "task1",
+        expected: Tudu::Tasks.new("doings", "task1")
+      },
+      {
+        case_no: 3,
+        case_title: "find done from tasks",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        search_name: "task1",
+        expected: Tudu::Tasks.new("dones", "task1")
+      },
+      {
+        case_no: 4,
+        case_title: "not find",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        search_name: "task4",
+        expected: nil
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.find_tasks c[:search_name]
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :choose do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "choose task",
+        type: "todos",
+        texts: ["task1", "task2", "task3"],
+        choose: "task1",
+        expected: [
+          Tudu::Tasks.new("todos", "task2"),
+          Tudu::Tasks.new("todos", "task3"),
+          Tudu::Tasks.new("doings", "task1"),
+        ]
+      },
+      {
+        case_no: 2,
+        case_title: "aleady exists doing",
+        type: "doings",
+        texts: ["task1", "task2", "task3"],
+        choose: "task1",
+        expected: [
+          Tudu::Tasks.new("doings", "task1"),
+          Tudu::Tasks.new("doings", "task2"),
+          Tudu::Tasks.new("doings", "task3"),
+        ]
+      },
+      {
+        case_no: 3,
+        case_title: "not exists task",
+        type: "todos",
+        texts: ["task1", "task2", "task3"],
+        choose: "task4",
+        expected: [
+          Tudu::Tasks.new("todos", "task1"),
+          Tudu::Tasks.new("todos", "task2"),
+          Tudu::Tasks.new("todos", "task3"),
+        ]
+      },
+      {
+        case_no: 4,
+        case_title: "task exists, but dones",
+        type: "dones",
+        texts: ["task1", "task2", "task3"],
+        choose: "task1",
+        expected: [
+          Tudu::Tasks.new("dones", "task1"),
+          Tudu::Tasks.new("dones", "task2"),
+          Tudu::Tasks.new("dones", "task3"),
+        ]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          Tudu::Tasks.choose c[:choose]
+
+          # -- then --
+          expect(Tudu::Tasks.get_tasks).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      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")}
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :done do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "one doing to done, shift todo to doing",
+        task_names: ["task1", "task2", "task3"],
+        choose: "task1",
+        expected: [
+          Tudu::Tasks.new("todos", "task3"),
+          Tudu::Tasks.new("doings", "task2"),
+          Tudu::Tasks.new("dones", "task1"),
+        ]
+      },
+      {
+        case_no: 2,
+        case_title: "one doing to done, not shift todo to doing",
+        task_names: ["task1"],
+        choose: "task1",
+        expected: [
+          Tudu::Tasks.new("dones", "task1"),
+        ]
+      },
+      {
+        case_no: 3,
+        case_title: "no doing",
+        task_names: ["task1"],
+        choose: "",
+        expected: [
+          Tudu::Tasks.new("todos", "task1"),
+        ]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          Tudu::Core.new.init
+          Tudu::Tasks.add *c[:task_names]
+          Tudu::Tasks.choose c[:choose]
+
+          # -- when --
+          Tudu::Tasks.done
+
+          # -- then --
+          expect(Tudu::Tasks.get_tasks).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :add do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "single add",
+        task_names1: "task_name",
+        task_names2: nil,
+        task_names3: nil,
+        expected: [
+          Tudu::Tasks.new("todos", "task_name")
+        ]
+      },
+      {
+        case_no: 2,
+        case_title: "nil add",
+        task_names1: nil,
+        task_names2: nil,
+        task_names3: nil,
+        expected: []
+      },
+      {
+        case_no: 3,
+        case_title: "multi add",
+        task_names1: "task_name1",
+        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")
+        ]
+      },
+      {
+        case_no: 4,
+        case_title: "duplicate add",
+        task_names1: "task_name1",
+        task_names2: "task_name1",
+        task_names3: nil,
+        expected: [
+          Tudu::Tasks.new("todos", "task_name1"), 
+        ]
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          Tudu::Core.new.init
+
+          # -- when --
+          actual = Tudu::Tasks.add c[:task_names1], c[:task_names2], c[:task_names3]
+
+          # -- then --
+          actual = Tudu::Tasks.get_todos
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+
+  context :remove do
+    cases = [
+      {
+        case_no: 1,
+        case_title: "single remove",
+        add_tasks: ["task_name"],
+        remove_tasks: ["task_name"],
+        expected_tasks: [],
+      },
+      {
+        case_no: 2,
+        case_title: "multi remove",
+        add_tasks: ["task_name1", "task_name2", "task_name3"],
+        remove_tasks: ["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")],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          Tudu::Core.new.init
+          Tudu::Tasks.add *c[:add_tasks]
+
+          # -- when --
+          Tudu::Tasks.remove *c[:remove_tasks]
+
+          # -- then --
+          actual = Tudu::Tasks.get_tasks
+          expect(actual).to eq(c[:expected_tasks])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        return unless File.exists? Tudu::Tasks::TUDU_DIR
+        FileUtils.rm_rf(Tudu::Tasks::TUDU_DIR)
+      end
+    end
+  end
+
+  context :filter_tasks do
+    cases = [
+      {
+        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"),
+          ],
+        filter_word: "task1_1",
+        expected: [Tudu::Tasks.new("doings", "task1_1")],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = Tudu::Tasks.filter_tasks(c[:tasks], c[:filter_word])
+
+          # -- then --
+          ret = expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end