toodledo 1.0.2 → 1.1.0

data/lib/toodledo/command_line/context_formatter.rb

@@ -0,0 +1,9 @@
+module Toodledo
+  module CommandLine    
+    class ContextFormatter
+      def format(context)
+        return "<#{context.server_id}> -- @[#{context.name}]"
+      end
+    end    
+  end
+end

data/lib/toodledo/command_line/delete_command.rb

@@ -1,7 +1,79 @@
 
 module Toodledo
   module CommandLine
-    class DeleteCommand < BaseCommand
+    
+    class DeleteCommand < CmdParse::Command
+      def initialize(client)
+        super('delete', true)
+        self.short_desc = "Deletes a context"
+        
+        self.add_command(DeleteContextCommand.new(client))
+        self.add_command(DeleteGoalCommand.new(client))
+        self.add_command(DeleteFolderCommand.new(client))
+        
+        self.add_command(DeleteTaskCommand.new(client), true)
+      end
+
+    end
+    
+    class DeleteContextCommand < BaseCommand
+      def initialize(client)
+        super(client, 'context', false)
+        self.short_desc = "Deletes a context"
+      end
+
+      def execute(args)       
+        Toodledo.begin(client.logger) do |session|            
+          line = args.join(' ')
+          client.delete_context(session, line)
+        end
+        
+        return 0
+      rescue ItemNotFoundError => e
+        puts e.message
+        return -1
+      end
+    end
+    
+    class DeleteFolderCommand < BaseCommand
+      def initialize(client)
+        super(client, 'folder', false)
+        self.short_desc = "Deletes a folder"
+      end
+
+      def execute(args)       
+        Toodledo.begin(client.logger) do |session|            
+          line = args.join(' ')
+          client.delete_folder(session, line)
+        end
+        
+        return 0
+      rescue ItemNotFoundError => e
+        puts e.message
+        return -1
+      end
+    end
+    
+    class DeleteGoalCommand < BaseCommand
+      def initialize(client)
+        super(client, 'goal', false)
+        self.short_desc = "Deletes a goal"
+      end
+
+      def execute(args)       
+        Toodledo.begin(client.logger) do |session|            
+          line = args.join(' ')
+          client.delete_goal(session, line)
+        end
+        
+        return 0
+      rescue ItemNotFoundError => e
+        puts e.message
+        return -1
+      end
+    end
+    
+    class DeleteTaskCommand < BaseCommand
       def initialize(client)
         super(client, 'delete', false)
         self.short_desc = "Deletes a task"
@@ -20,5 +92,7 @@ module Toodledo
         return -1
       end
     end
+    
+    
   end
 end

data/lib/toodledo/command_line/folder_formatter.rb

@@ -0,0 +1,9 @@
+module Toodledo
+  module CommandLine    
+    class FolderFormatter      
+      def format(folder)
+        return "<#{folder.server_id}> -- *[#{folder.name}]"
+      end
+    end    
+  end
+end

data/lib/toodledo/command_line/goal_formatter.rb

@@ -0,0 +1,26 @@
+require 'toodledo/goal'
+
+module Toodledo
+  module CommandLine
+    class GoalFormatter
+      def format(goal)
+        msg = "<#{goal.server_id}> -- #{readable_level(goal.level)} ^[#{goal.name}]"
+        if (goal.contributes != Goal::NO_GOAL)
+          msg += " (Contributes to: ^[#{goal.contributes.name}])"
+        end
+        return msg
+      end
+      
+      def readable_level(level)
+        case level
+        when Goal::LIFE_LEVEL
+          return 'life'
+        when Goal::MEDIUM_LEVEL
+          return 'medium'
+        when Goal::SHORT_LEVEL
+          return 'short'
+        end
+      end
+    end 
+  end
+end

data/lib/toodledo/command_line/interactive_command.rb

@@ -0,0 +1,43 @@
+require 'toodledo/command_line/parser_helper'
+require 'logger'
+
+module Toodledo
+  
+  module CommandLine
+    # Runs the interactive client.
+    class InteractiveCommand < BaseCommand
+      
+      def initialize(client)
+        super(client, 'interactive', false)
+        self.short_desc = "Interactive client"
+        self.description = "The interactive command line client."
+      end
+      
+      def execute(args)
+        Toodledo.begin(client.logger) do |session|
+          command_loop(session)
+        end
+      end
+      
+      def command_loop(session)
+        loop do
+          begin
+            input = ask("> ") do |q|
+              q.readline = true
+            end
+            
+            input.strip!
+            
+            client.execute_command(session, input)            
+          rescue Toodledo::ItemNotFoundError => infe
+            puts "Item not found: #{infe}"
+          rescue Toodledo::ServerError => se
+            puts "Server Error: #{se}"
+          rescue RuntimeError => re
+            puts "Error: #{re}"      
+          end
+        end # loop    
+      end      
+    end
+  end
+end

data/lib/toodledo/command_line/list_folders_command.rb

@@ -0,0 +1,32 @@
+# 
+# 
+# 
+ 
+
+module Toodledo  
+  module CommandLine
+    
+    
+    #
+    # List Folders
+    #
+    class ListFoldersCommand < BaseCommand
+      def initialize(client)
+        super(client, 'folders', false)
+        self.short_desc = "List folders"
+        self.description = "Lists the folders in Toodledo."
+      end
+      
+      def execute(args)
+        
+        Toodledo.begin(client.logger) do |session|            
+          line = args.join(' ')
+          return client.list_folders(session, line)
+        end
+        
+        return 0
+      end
+    end
+   
+  end
+end    

data/lib/toodledo/command_line/list_goals_command.rb

@@ -0,0 +1,31 @@
+# 
+# 
+# 
+ 
+
+module Toodledo  
+  module CommandLine
+    
+    #
+    # List Goals
+    #
+    class ListGoalsCommand < BaseCommand
+      def initialize(client)
+        super(client, 'goals', false)
+        self.short_desc = "List goals"
+        self.description = "Lists the goals in Toodledo."
+      end
+      
+      def execute(args)
+        
+        Toodledo.begin(client.logger) do |session|            
+          line = args.join(' ')
+          return client.list_goals(session, line)
+        end
+        
+        return 0
+      end
+    end
+
+  end
+end

data/lib/toodledo/command_line/{list_command.rb → list_tasks_command.rb}

@@ -1,14 +1,19 @@
 
 module Toodledo  
   module CommandLine
-    class ListCommand < BaseCommand
+    
+    #
+    # Lists the tasks.
+    #
+    class ListTasksCommand < BaseCommand
       def initialize(client)
-        super(client, 'list', false)
+        super(client, 'tasks', false)
         self.short_desc = "List tasks"
         self.description = "Lists the tasks in Toodledo."
       end
       
       def execute(args)
+        
         Toodledo.begin(client.logger) do |session|            
           line = args.join(' ')
           return client.list_tasks(session, line)
@@ -17,5 +22,7 @@ module Toodledo
         return 0
       end
     end
+    
+    
   end
 end

data/lib/toodledo/command_line/parser_helper.rb

@@ -1,18 +1,32 @@
+require 'toodledo/priority'
 
 module Toodledo
   
   module CommandLine
 
-    #
+    # 
     # Methods to parse a string and identify it as a Toodledo symbol.
-    #
+    # 
     module ParserHelper
-  
+      
       FOLDER_REGEXP = /\*((\w+)|\[(.*?)\])/
   
-      GOAL_REGEXP = /\$((\w+)|\[(.*?)\])/
+      GOAL_REGEXP = /\^((\w+)|\[(.*?)\])/
   
       CONTEXT_REGEXP = /\@((\w+)|\[(.*?)\])/
+      
+      PRIORITY_REGEXP = /!(top|high|medium|low|negative)/
+      
+      # Note that level must exist at the beginning of the line
+      LEVEL_REGEXP = /^(life|medium|short)/
+      
+      # Don't include level regexp
+      REGEXP_LIST = [ 
+        FOLDER_REGEXP, 
+        GOAL_REGEXP,
+        CONTEXT_REGEXP, 
+        PRIORITY_REGEXP
+      ]
   
       # Parses a context in the format @Context or @[Spaced Context]
       def parse_context(input)
@@ -28,20 +42,63 @@ module Toodledo
         return strip_brackets(match_data[1])
       end
   
-      # Parses a goal in the format $Goal or $[Spaced Goal]
+      # Parses a goal in the format ^Goal or ^[Spaced Goal]
       def parse_goal(input)
         match_data = GOAL_REGEXP.match(input)
         return match_data if (match_data == nil)    
         return strip_brackets(match_data[1])
       end
   
-      # Returns the bit after we've looked for *Folder, @Context & $Goal
-      def parse_remainder(line)    
+      # Parses priority in the format !priority (top, high, medium, low,
+      # negative)
+      def parse_priority(input)
+        match_data = PRIORITY_REGEXP.match(input)
+        if (match_data == nil)
+          return nil         
+        end
         
+        p = match_data[1]
+        case p
+        when 'top'
+          return Toodledo::Priority::TOP
+        when 'high'
+          return Toodledo::Priority::HIGH
+        when 'medium'
+          return Toodledo::Priority::MEDIUM
+        when 'low'
+          return Toodledo::Priority::LOW
+        when 'negative'
+          return Toodledo::Priority::NEGATIVE
+        else
+          return nil
+        end
+      end
+      
+      def parse_level(input)
+        match_data = LEVEL_REGEXP.match(input)
+        if (match_data == nil)
+          return nil         
+        end
+        
+        p = match_data[1]
+        case p
+        when 'life'
+          return Toodledo::Goal::LIFE_LEVEL
+        when 'medium'
+          return Toodledo::Goal::MEDIUM_LEVEL
+        when 'short'
+          return Toodledo::Goal::SHORT_LEVEL
+        else
+          return nil
+        end
+      end
+  
+      # Returns the bit after we've looked for *Folder, @Context & ^Goal
+      def parse_remainder(line)
         input = line
 
         # Strip out anything that isn't folder, goal or context.
-        for regexp in [ FOLDER_REGEXP, GOAL_REGEXP, CONTEXT_REGEXP]
+        for regexp in REGEXP_LIST
           input = input.sub(regexp, '')
         end
     

data/lib/toodledo/command_line/sTdin_command.rb

@@ -0,0 +1,31 @@
+require 'toodledo/command_line/parser_helper'
+require 'logger'
+
+module Toodledo
+  
+  module CommandLine
+    # Runs the stdin client.
+    class StdinCommand < BaseCommand
+      
+      def initialize(client)
+        super(client, 'stdin', false)
+        self.short_desc = "Takes standard input"
+        self.description = "Useful for pipes and redirected files"
+      end
+      
+      def execute(args)
+        Toodledo.begin(client.logger) do |session|
+          $stdin.each do |line|
+            line.strip!
+            
+            if (line == nil || line.empty?) 
+              return 0
+            end
+            
+            client.execute_command(session, line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toodledo/command_line/task_formatter.rb

@@ -0,0 +1,102 @@
+
+module Toodledo
+  module CommandLine    
+    class TaskFormatter
+      
+      # Formats the task for a command line.
+      def format(task)
+        fancyp = '!' + readable_priority(task.priority)
+  
+        msg = "<#{task.server_id}> -- #{fancyp}"
+  
+        if (task.folder != Folder::NO_FOLDER)
+          msg += " *[#{task.folder.name}]"
+        end
+  
+        if (task.context != Context::NO_CONTEXT)
+          msg += " @[#{task.context.name}]"
+        end
+  
+        if (task.goal != Goal::NO_GOAL)
+          msg += " ^[#{task.goal.name}]"
+        end
+  
+        if (task.repeat != Repeat::NONE)
+          msg += " repeat[#{readable_repeat(task.repeat)}]"
+        end
+  
+        if (task.duedate != nil)
+          fmt = '%m/%d/%Y %I:%M %p'
+          msg += " \#[#{task.duedatemodifier}#{task.duedate.strftime(fmt)}]"
+        end
+  
+        if (task.tag != nil)
+          msg += " tag[#{task.tag}]"
+        end
+        
+        if (task.parent_id != nil)
+          msg += " parent[#{task.parent_id}]"
+        end
+  
+        if (task.length != nil)
+          msg += " length[#{task.length}]"
+        end
+        
+        if (task.timer != nil)
+          msg += " timer[#{task.timer}]"
+        end
+        
+        # Use the highline color library
+        msg += " #{task.title}"
+              
+        if (task.note != nil)
+          msg += "\n      #{task.note}"
+        end
+  
+        return msg
+      end
+      
+      def readable_priority(priority)
+        case priority
+          when Priority::TOP
+            return 'top'
+          when Priority::HIGH
+            return 'high'
+          when Priority::MEDIUM
+            return 'medium'
+          when Priority::LOW
+            return 'low'
+          when Priority::NEGATIVE
+            return 'negative'
+          else
+            return ''
+        end
+      end
+      
+      def readable_repeat(repeat)
+        case repeat
+        when Repeat::NONE
+          ''
+        when Repeat::WEEKLY
+          "weekly"
+        when Repeat::MONTHLY
+          "monthly"
+        when Repeat::YEARLY
+          "yearly"
+        when Repeat::DAILY
+          "daily"
+        when Repeat::BIWEEKLY
+          "biweekly"
+        when Repeat::BIMONTHLY
+          "bimonthly"
+        when Repeat::SEMIANNUALLY
+          "semiannually"
+        when Repeat::QUARTERLY
+          "quarterly"
+        else
+          ''
+        end
+      end
+    end
+  end
+end