rtmilk 0.0.2 → 0.3.0

data/lib/rtmilk/api/auth.rb

@@ -0,0 +1,62 @@
+#
+# rtm.auth : Auth API
+#
+module RTM
+module Auth
+
+class GetFrob < RTM::API
+   # return frob
+   def parse_result(result)
+      super
+      result['frob'].first
+   end
+
+   def initialize
+      super 'rtm.auth.getFrob'
+   end
+end # GetFrob
+
+class GetToken < RTM::API
+   # return {:token, :perms, :user => {id, name, fullname}}
+   def parse_result(result)
+      super
+      Auth.parse_result_auth(result)
+   end
+
+   def initialize(frob)
+      super 'rtm.auth.getToken'
+      @param = {:frob => frob}
+   end
+end # GetToken
+
+class CheckToken < RTM::API
+   # return {:token, :perms, :user => {id, name, fullname}}
+   def parse_result(result)
+      super
+      Auth.parse_result_auth(result)
+   end
+
+   def initialize(token)
+      super 'rtm.auth.checkToken'
+      @param = {:auth_token => token}
+   end
+end # CheckToken
+
+private
+# return {:token, :perms, :user => {id, name, fullname}}
+def Auth.parse_result_auth(result)
+   auth = result['auth'].first
+   user = auth['user'].first
+   parsed = {
+      :token => auth['token'].first,
+      :perms => auth['perms'].first,
+      :user  => {
+         :id => user['id'],
+         :name => user['username'],
+         :fullname => user['fullname'] }
+   }
+end
+
+end # Auth
+end # RTM
+# vim:fdm=indent

data/lib/rtmilk/api/lists.rb

@@ -0,0 +1,177 @@
+#
+# rtm.lists : Lists API
+#
+
+module RTM
+#
+# rtm.lists : Lists API
+#
+module Lists
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.add.rtm
+   class Add < RTM::API
+      # return [name, smart, filter?, id, archived, deleted, position, locked]*
+      def parse_result(result)
+         super
+         result['list'].first
+      end
+
+      def initialize(token, name, filter=nil)
+         super 'rtm.lists.add', token, RTM::Timeline.new(token).to_s
+         @param['name'] = name
+         if filter
+            @param['filter'] = filter
+         end
+      end
+   end # Add
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.archive.rtm
+   class Archive < RTM::API
+   end # Archive
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.delete.rtm
+   class Delete < RTM::API
+      # return [name, smart, filter?, id, archived, deleted, position, locked]*
+      def parse_result(result)
+         super
+         result['list'].first
+      end
+
+      def initialize(token, id)
+         super 'rtm.lists.delete', token, RTM::Timeline.new(token).to_s
+         @param['list_id'] = id
+      end
+   end # Delete
+
+   class GetList < RTM::API
+      # return [name, smart, filter?, id, archived, deleted, position, locked]*
+      def parse_result(result)
+         super
+         result['lists'].first['list']
+      end
+
+      def initialize(token)
+         super 'rtm.lists.getList', token
+      end
+   end # GetList
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.setDefaultList.rtm
+   class SetDefaultList < RTM::API
+   end # SetDefaultList
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.setName.rtm
+   class SetName < RTM::API
+      # return [name, smart, filter?, id, archived, deleted, position, locked]*
+      def parse_result(result)
+         super
+         result['list'].first
+      end
+
+      def initialize(token, id, name)
+         super 'rtm.lists.setName', token, RTM::Timeline.new(token).to_s
+         @param['list_id'] = id
+         @param['name'] = name
+      end
+   end # SetName
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.unarchive.rtm
+   class UnArchive < RTM::API
+   end # UnArchive
+end # Lists
+
+# more friendly class.
+class List
+   #attr_reader :name, :smart, :id, :archived, :deleted, :position, :locked
+
+   def initialize(arg)
+      if arg.class == String # name
+         @hash = RTM::Lists::Add.new(RTM::API.token, arg).invoke
+      elsif arg.class == Hash # already constructed 
+         @hash = arg
+      else
+         raise RTM::Error, "invalid argument"
+      end
+   end
+
+   def name; @hash['name']; end
+   def id; @hash['id']; end
+   def position; @hash['position']; end
+   def smart?; @hash['smart'] == '1'; end
+   def archived?; @hash['archived'] == '1'; end
+   def locked?; @hash['locked'] == '1'; end
+   def deleted?; @hash['deleted'] == '1'; end
+
+   def name=(new_name)
+      RTM::API::SetName(RTM::API.token, @id, new_name)
+   end
+
+   # archive this list.
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.archive.rtm
+   def archive
+   end
+
+   # unarchive this list.
+   def unarchive
+   end
+
+   # delete this list.
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.delete.rtm
+   def delete
+      deleted = RTM::Lists::Delete.new(RTM::API.token, @hash['id']).invoke
+   end
+
+   # set this list as default.
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.setDefaultList.rtm
+   def set_default
+   end
+
+   # -----------------------------------------------------------------
+   # class methods
+   #
+
+   # find a List by name.
+   def List.find(name, alive_only=true) # by name
+      lists = RTM::Lists::GetList.new(RTM::API.token).invoke
+      lists.find do |list|
+         if alive_only
+            list['name'] == name && list['archived'] == '0' && list['deleted'] == '0'
+         else
+            list['name'] == name
+         end
+      end
+   end
+
+   # find all Lists.
+   def List.find_all(name, alive_only=true) # by name
+      lists = RTM::Lists::GetList.new(RTM::API.token).invoke
+      lists.find_all do |list|
+         if alive_only
+            list['name'] == name && list['archived'] == '0' && list['deleted'] == '0'
+         else
+            list['name'] == name
+         end
+      end.collect do |x|
+         List.new(x)
+      end
+   end
+
+   # find all alive Lists.
+   def List.alive_all
+      lists = RTM::Lists::GetList.new(RTM::API.token).invoke
+      lists.find_all do |list|
+         list['archived'] == '0' && list['deleted'] == '0'
+      end.collect do |x|
+         List.new(x)
+      end
+   end
+
+   # http://www.rememberthemilk.com/services/api/methods/rtm.lists.getList.rtm
+   def List.get
+   end
+
+   def List.inbox
+      List.find('Inbox')
+   end
+end # List
+
+end # RTM
+# vim:fdm=indent

data/lib/rtmilk/api/notes.rb

@@ -0,0 +1,141 @@
+#
+# rtm.tasks.notes : Notes API
+#
+require 'test/unit/assertions'
+
+module RTM
+module Tasks
+module Notes
+
+class Add < RTM::API
+   def parse_result(result)
+      super
+      [result['note'].first, result['transaction'].first]
+   end
+
+   def initialize(token, timeline, list, taskseries, task, title, text)
+      super 'rtm.tasks.notes.add', token
+      @param[:timeline] = timeline
+      @param[:list_id] = list
+      @param[:taskseries_id] = taskseries
+      @param[:task_id] = task
+      @param[:note_title] = title
+      @param[:note_text] = text
+   end
+end # Add
+
+class Delete < RTM::API
+   def parse_result(result)
+      super
+   end
+
+   def initialize(token, timeline, note)
+      super 'rtm.tasks.notes.delete', token
+      @param[:timeline] = timeline
+      @param[:note_id] = note
+   end
+end # Delete
+
+class Edit < RTM::API
+   def parse_result(result)
+      super
+      [result['note'].first, result['transaction'].first]
+   end
+
+   def initialize(token, timeline, note, title, text)
+      super 'rtm.tasks.notes.edit', token
+      @param[:timeline] = timeline
+      @param[:note_id] = note
+      @param[:note_title] = title
+      @param[:note_text] = text
+   end
+end # Add
+
+end # Notes
+end # Tasks
+
+# = a Note.
+#
+# belongs to Task (TaskSeries).
+#
+# == usage:
+# * n = RTM::Note.new(:task=>_task_, :title=>'yeah', :body=>'you')
+# * n.title = 'newtitle'
+# * n.body = 'newbody'
+# * n.delete
+#
+class Note
+   include Test::Unit::Assertions
+
+   def id; @hash['id']; end
+   def title; @hash['title']; end
+   def modified; @hash['modified']; end
+   def body; @hash['content']; end
+   def created; @hash['created']; end
+
+   def initialize(arg)
+      assert_equal(Hash, arg.class)
+
+      if arg.has_key? :hash # already constructed
+         @hash = arg[:hash]
+      else # from scratch
+         assert(arg.has_key?(:task))
+         assert_equal(RTM::Task, arg[:task].class)
+         assert(arg.has_key?(:title))
+         assert(arg.has_key?(:body))
+
+         @hash, transaction = RTM::Tasks::Notes::Add.new(
+            RTM::API.token, 
+            RTM::Timeline.new(RTM::API.token).to_s,
+            arg[:task].list, arg[:task].id,
+            arg[:task].chunks.first.id, # XXX: Note belongs to TaskSeries, why need Task id ?
+            arg[:title],
+            arg[:body]).invoke
+      end
+   end
+
+   # alter title field.
+   def title=(text)
+      ret, transaction = RTM::Tasks::Notes::Edit.new(
+         RTM::API.token, 
+         RTM::Timeline.new(RTM::API.token).to_s,
+         id,
+         text,
+         body).invoke
+      assert(ret['id'], id)
+      @hash['title'] = text
+   end
+
+   # alter body field.
+   def body=(text)
+      ret, transaction = RTM::Tasks::Notes::Edit.new(
+         RTM::API.token, 
+         RTM::Timeline.new(RTM::API.token).to_s,
+         id,
+         title,
+         text).invoke
+      assert(ret['id'], id)
+      @hash['content'] = text
+   end
+
+   # delete this note.
+   # after deleted, should not touch this object.
+   def delete
+      RTM::Tasks::Notes::Delete.new(
+         RTM::API.token, 
+         RTM::Timeline.new(RTM::API.token).to_s,
+         id).invoke
+   end
+
+   def Note.update(arg)
+      ret, transaction = RTM::Tasks::Notes::Edit.new(
+         RTM::API.token, 
+         RTM::Timeline.new(RTM::API.token).to_s,
+         arg[:id],
+         arg[:title],
+         arg[:body]).invoke
+   end
+end # Note
+
+end # RTM
+# vim:fdm=indent

data/lib/rtmilk/api/tasks.rb

@@ -0,0 +1,196 @@
+#
+# rtm.tasks : Tasks API
+#
+require 'test/unit/assertions'
+module RTM
+module Tasks
+
+# get all TaskSeries.
+class GetList < RTM::API
+   # return [list_id, taskseries*]*
+   def parse_result(result)
+      super
+      result['tasks'].first['list']
+   end
+
+   def initialize(token, list_id=nil, filter=nil, last_sync=nil)
+      super 'rtm.tasks.getList', token
+      @param[:list_id] = list_id if list_id
+      @param[:filter] = filter if filter
+      @param[:last_sync] = last_sync if last_sync
+   end
+end # GetList
+
+class Add < RTM::API
+   def parse_result(result)
+      super
+      [result['list'].first, result['transaction']]
+   end
+
+   def initialize(token, timeline, list, name)
+      super 'rtm.tasks.add', token
+      @token  = token
+      @param[:timeline] = timeline
+      @param[:list_id] = list
+      @param[:name] = name
+   end
+end # Add
+
+class Delete < RTM::API
+   def parse_result(result)
+      super
+      [result['list'].first, result['transaction']]
+   end
+
+   def initialize(token, timeline, list, taskseries, task)
+      super 'rtm.tasks.delete', token
+      @param[:timeline] = timeline
+      @param[:list_id] = list
+      @param[:taskseries_id] = taskseries
+      @param[:task_id] = task
+   end
+end # Delete
+
+end # Tasks
+
+
+#
+# Task class.
+# Unfortunately, RTM API defines this object as TaskSeries.
+# That seemes to be unnatural.
+class Task
+   attr_reader :list, :chunks, :notes
+
+   include Test::Unit::Assertions
+
+   def name; @taskseries['name']; end
+   def id; @taskseries['id']; end
+   def modified; @taskseries['modified']; end
+   def tags; @taskseries['tags']; end
+   def participants; @taskseries['participants']; end
+   def url; @taskseries['url']; end
+   def created; @taskseries['created']; end
+   def source; @taskseries['source']; end
+
+   # find a Task by name.
+   def Task.find(arg)
+      all_tasks(arg[:list]).find do |task|
+         task.name =~ /#{arg[:name]}/
+      end
+   end
+
+   # find all tasks by list, and name
+   def Task.find_all(arg)
+      tasks = all_tasks(arg[:list])
+      if arg.has_key? :name
+         tasks.find_all do |task|
+            task['name'] =~ /#{arg[:name]}/
+         end
+      else
+         tasks
+      end
+   end
+
+private
+   def Task.all_tasks(list = nil)
+      result = RTM::Tasks::GetList.new(RTM::API.token, list).invoke
+      ret = []
+
+      result.each do |x|
+         if x.has_key? 'taskseries'
+            x['taskseries'].each do |y|
+               ret.push Task.new(:taskseries => y, :list => x['id'])
+            end
+         end
+      end
+      ret
+   end
+
+public
+   # create a Task.
+   def initialize(arg)
+      assert_equal(Hash, arg.class)
+
+      @list = if arg.has_key? :list
+         arg[:list]
+      else
+         RTM::List.inbox['id']
+      end
+
+      if arg.has_key? :name  # create from scratch
+         result,transaction = RTM::Tasks::Add.new(
+            RTM::API.token,
+            RTM::Timeline.new(RTM::API.token).to_s,
+            @list, arg[:name]).invoke
+         @taskseries = result['taskseries'].first
+         assert(@list, result['id'])
+         create_chunks
+         @notes = []
+      else 
+         assert(arg.has_key?(:taskseries))
+         @taskseries = arg[:taskseries]
+         create_chunks
+         create_notes
+      end
+   end
+
+   # delete a Task and its all chunks.
+   def delete
+      chunks.collect { |chunk| chunk.delete(id, @list) }
+   end
+
+   def addNote(arg)
+      assert_equal(Hash, arg.class)
+
+      n = RTM::Note.new(
+         :task => self,
+         :title => arg[:title], 
+         :body  => arg[:body])
+      @notes.push n
+   end
+
+private
+   def create_chunks
+      @chunks = []
+      @taskseries['task'].each do |t|
+         @chunks.push Chunk.new(t)
+      end
+   end
+
+   def create_notes
+      @notes = []
+      assert_equal(Array, @taskseries['notes'].class)
+      assert_equal(Hash, @taskseries['notes'].first.class)
+      if @taskseries['notes'].first.has_key? 'note'
+         @taskseries['notes'].first['note'].each do |n|
+            @notes.push Note.new(:hash => n)
+         end
+      end
+   end
+end # Task
+
+# correspond to each Task.
+class Chunk
+   def completed; @hash['completed']; end
+   def added; @hash['added']; end
+   def postponed; @hash['postponed']; end # TODO
+   def priority; @hash['priority']; end
+   def id; @hash['id']; end
+   def deleted; @hash['deleted']; end
+   def has_due_time; @hash['has_due_time'] == '1' ; end
+   def estimate; @hash['estimate']; end
+   def due; @hash['due']; end
+
+   def initialize(hash)
+      @hash = hash
+   end
+
+   def delete(series, list)
+      token    = RTM::API.token
+      timeline = RTM::Timeline.new(RTM::API.token).to_s
+      RTM::Tasks::Delete.new(token, timeline, list, series, id).invoke # TODO
+   end
+end # Chunk
+
+end # RTM
+# vim:fdm=indent