rtmilk 0.0.2 → 0.3.0

data/CHANGELOG.txt

@@ -1,5 +1,28 @@
+2007-03-17  mootoh@gmail.com
+
+	* 0.3.0
+	based on rev36.
+	RTM::Note added.
+	That is used by taskMap.
+
+2007-03-16  mootoh@gmail.com
+
+	* 0.2.0
+	RTM::Task is now creatable/deletable in easy way.
+
+2007-03-10  mootoh@gmail.com
+
+	* CHANGELOG.txt: 
+	all tests passed.
+
+2007-03-08  mootoh@gmail.com
+
+	* CHANGELOG.txt: 
+	architecture totally rewrited.
+	add tasks.notes stuff.
+
 2007-02-05  mootoh@gmail.com
 
 	* CHANGELOG.txt: 
-   packed gem.
+	packed gem.
 

data/Manifest.txt

@@ -1,11 +1,25 @@
-Rakefile
 README.txt
+Rakefile
 CHANGELOG.txt
 Manifest.txt
+History.txt
 setup.rb
+example/get.rb
+lib/rtmilk/api/auth.rb
+lib/rtmilk/api/lists.rb
+lib/rtmilk/api/notes.rb
+lib/rtmilk/api/tasks.rb
+lib/rtmilk/api/timelines.rb
 lib/rtmilk/api.rb
+lib/rtmilk/error.rb
 lib/rtmilk/version.rb
 lib/rtmilk.rb
+test/auth_api_test.rb
+test/error_test.rb
+test/lists_api_test.rb
+test/make_config.rb
+test/notes_api_test.rb
+test/Rakefile
+test/tasks_api_test.rb
 test/test_helper.rb
-test/rtm_test.rb
-test/rtm_api_test.rb
+test/timelines_api_test.rb

data/README.txt

@@ -1,4 +1,3 @@
-README for rtmilk
-=================
+= README for rtmilk
 
-rtmilk is a "Remember the Milk" wrapper library.
+rtmilk is a {Remember the Milk}[http://www.rememberthemilk.com/] wrapper library.

data/Rakefile

@@ -30,6 +30,7 @@ RDOC_OPTS = ['--quiet', '--title', "rtmilk documentation",
     "--opname", "index.html",
     "--line-numbers", 
     "--main", "README.txt",
+    "-diagram",
     "--inline-source"]
 
 class Hoe

data/example/get.rb

@@ -0,0 +1,43 @@
+#
+# simple example for rtm.rb
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+require 'rtmilk'
+
+# -------------------------------------------------------------------
+# API_KEY and SHARED_SECRET are required.
+#
+API_KEY       = 'aaa'
+SHARED_SECRET = 'bbb'
+
+RTM::API.init(API_KEY, SHARED_SECRET)
+
+# -------------------------------------------------------------------
+# get auth url for read
+#
+frob = RTM::Auth::GetFrob.new.invoke
+url = RTM::API.get_auth_url('read', frob)
+
+puts 'access, login, and authenticate following uri on your browser,'
+puts 'then hit return to continue'
+puts '  ' + url
+
+gets
+
+
+res = RTM::Auth::GetToken.new(frob).invoke
+token = res[:token]
+RTM::API.token = token
+
+# -------------------------------------------------------------------
+# get all lists
+#
+#
+lists = RTM::List.alive_all
+lists.each { |l| puts l['name'] }
+
+# -------------------------------------------------------------------
+# get all tasks
+#
+#tasks = RTM::Tasks.new
+#tasks.each { |t| puts t.name }
+

data/lib/rtmilk.rb

@@ -5,191 +5,14 @@
 # $Id: rtm.rb 10 2006-12-30 06:37:24Z takayama $
 #
 
-require 'rtmilk/api.rb'
+require 'rtmilk/error'
+require 'rtmilk/api'
 
 =begin rdoc
 access Remember the Milk REST APIs.
 =end
 module RTM
 
-   def RTM.get_timeline
-      API::TimeLines.create
-   end
-
-   # use frob for Desktop Application.
-   # perm should be one of ['read', 'write', 'delete'].
-   def RTM.get_auth_url(h)
-      raise unless API::PERMS.include?(h[:perm])
-
-      API.auth_uri(API.params, h)
-   end
-
-   def RTM.get_frob
-      API::Auth.getFrob
-   end
-
-
-   class Contact
-      attr_accessor :id, :fullname, :username
-
-      def initialize(id, full=nil, user=nil)
-         @id = id
-         @fullname = full
-         @user = user
-      end
-   end # Contact
-
-   class Group
-      attr_accessor :id, :name
-   end # Group
-
-   class List
-      attr_accessor :id, :name, :deleted, :locked, :archived, :position, :smart, :filter
-
-      def initialize(h)
-         @id = h['id']
-         @name = h['name']
-         @deleted = h['deleted'] == '0'
-         @locked = h['locked'] == '1'
-         @archived = h['archived'] == '1'
-         @position = h['position']
-         @smart = h['smart'] == '1'
-         @filter = h['filter']
-      end
-
-      def setDefault
-      end # setDefault
-
-      def setName(name)
-      end # setName
-
-      def archive
-      end # archive
-
-      def unarchive
-      end # unarchive
-
-      def <=>(other)
-         @name <=> other.name
-      end
-   end # List
-
-   class Lists
-      include Enumerable
-
-      attr_accessor :ls
-
-      def initialize
-         @ls = API::Lists.getList.collect do |x|
-            List.new x
-         end
-      end
-
-      def each
-         @ls.each do |x|
-            yield x
-         end
-      end
-
-      def Lists.add(name, filter=nil)
-         timeline = RTM.get_timeline
-         l = API::Lists.add(timeline, name, filter)
-         List.new l
-      end # add
-
-      def [](i)
-         to_a[i]
-      end
-
-      def size
-         to_a.size
-      end
-   end # Lists
-
-   class TaskSeries
-      attr_accessor :id, :created, :modified, :name, :source,
-         :tags, :participants, :notes, :task
-
-      def initialize(h)
-         @id = h['id'] if h['id']
-         @created = h['created'] if h['created']
-         @modified = h['modified'] if h['modified']
-         @name = h['name'] if h['name']
-         @source = h['source'] if h['source']
-         @tags = h['tags'].first['tag'] if h['tags']
-         @participants = h['participants'].first if h['participants']
-         @notes = h['notes'].first if h['notes']
-
-         if h['task']
-            @task = h['task'].collect do |t|
-               Task.new(t)
-            end.flatten.compact
-         end
-      end
-
-      class Task
-         attr_accessor :id, :due, :has_due_time, :added, :completed,
-            :deleted, :priority, :postponed, :estimate
-
-         def initialize(h)
-            @id = h['id'] if h['id']
-            @due = h['due'] if h['due']
-            @has_due_time = h['has_due_time'] == '1' if h['has_due_time']
-            @added = h['added'] if h['added']
-            @completed = h['completed'] if h['completed']
-            @deleted = h['deleted'] if h['deleted']
-            @priority = h['priority'] if h['priority']
-            @postponed = h['postponed'] if h['postponed']
-            @estimate = h['estimate'] if h['estimate']
-         end
-      end # Task
-   end
-
-   class Tasks
-      include Enumerable
-
-      attr_accessor :ts
-
-      def initialize(list=nil, last=nil)
-         @ts = API::Tasks.getList(list, last).collect do |x|
-            if x['taskseries']
-               x['taskseries'].collect do |t|
-                  TaskSeries.new t
-               end
-            else
-               nil
-            end
-         end.flatten.compact
-      end
-
-      def each
-         @ts.each do |x|
-            yield x
-         end
-      end
-
-      def Tasks.add(name, list)
-         timeline = RTM.get_timeline
-         t = API::Tasks.add(timeline, list, name)
-         TaskSeries.new t
-      end
-
-      def Tasks.delete(series, task, list)
-         timeline = RTM.get_timeline
-         t = API::Tasks.delete(timeline, list, series, task)
-         TaskSeries.new t
-      end
-
-      def [](i)
-         to_a[i]
-      end
-
-      def size
-         to_a.size
-      end
-
-   end # Tasks
-
 end # RTM
 
 # vim:fdm=indent

data/lib/rtmilk/api.rb

@@ -2,8 +2,6 @@
 # for Remember the Milk REST API
 #     http://www.rememberthemilk.com/services/api/overview.rtm
 #
-# $Id: api.rb 11 2007-01-08 04:02:44Z takayama $
-#
 
 require 'net/http'
 require 'digest/md5'
@@ -14,373 +12,110 @@ require 'uri'
 # access the {Remember the Milk}[http://www.rememberthemilk.com/] REST APIs.
 module RTM
 
-# API classes.
+# API class
 class API
+
+private
    RTM_URI   = 'www.rememberthemilk.com'
    REST_PATH = '/services/rest/'
    AUTH_PATH = '/services/auth/'
-
    PERMS = ['read', 'write', 'delete']
 
-   #--
-   # -----------------------------------------------------------------
-   # class methods
-   #++
-   
-   def API.key ; @@key ; end
-   def API.params ; @@params ; end
-   def API.token ; @@token ; end
-
+public
    # initialize the API context.
-   # make sure to call this before using any API calls.
-   def API.init(h)
-      @@key = h[:key] if h.has_key? :key
-      @@sec = h[:secret] if h.has_key? :secret
-      @@frob = h[:frob] if h.has_key? :frob
-      @@token = h[:token] if h.has_key? :token
+   def API.init(key, sec, option=nil)
+      @@key = key
+      @@sec = sec
+
+      if (option)
+         begin
+            @@token = option[:token] if option.has_key? :token
+         rescue => e
+            puts e.message
+         end
+      end
 
-      @@params = { 'api_key' => @@key }
-      @@http = Net::HTTP.new(RTM_URI)
    end
 
-   # tailor parameters into request uri.
-   def API.uri_req(params)
-      r  = REST_PATH + '?' 
-      r += params.collect { |k, v| [k, v].join('=') }.sort.join('&')
-      r += '&api_sig=' + sign(params)
-      URI.escape r
+   def API.token=(token)
+      @@token = token
    end
 
-   # tailor parameters into auth uri.
-   def API.uri_auth(params, h)
-      p = params.dup
-      p[:perms] = h[:perm]
-      p[:frob]  = h[:frob] if h[:frob]
-      p[:callback] = h[:callback] if h[:callback]
+   # getter methods
+   def API.key; @@key; end
+   def API.token; @@token; end
+
+   # invoke a method
+   def invoke
+      response = Net::HTTP.get(RTM_URI, make_url)
+      # puts '--------------------------------------------------'
+      # puts response
+      # puts '--------------------------------------------------'
+      result = XmlSimple.new.xml_in(response)
+      ret = parse_result(result)
+   end
 
-      r  = AUTH_PATH + '?'
-      r += p.collect { |k, v| [k, v].join('=') }.sort.join('&')
+   # get Auth URL (both desktop/webapp)
+   def API.get_auth_url(perms, frob=nil)
+      param = { :api_key => @@key, :perms => perms }
+      if frob
+         param['frob'] = frob
+      end
 
-      r += '&api_sig=' + sign(p)
-      r
-   end
+      sig = API.sign(param)
 
-   # construct auth uri from params.
-   def API.auth_uri(params, h)
-      RTM_URI + uri_auth(params, h)
+      r  = 'http://' + RTM_URI + AUTH_PATH + '?'
+      r += param.collect { |k, v| [k, v].join('=') }.sort.join('&')
+      r += '&api_sig=' + sig
+      r
    end
 
-   # process http request, return response.
-   def API.request(uri)
-      head, body = @@http.get(uri)
-      res = XmlSimple.new.xml_in(body)
-      raise Error, res if 'fail' == res['stat']
-      res
+   def sign
+      API.sign(@param)
    end
 
-   private
-
-   # sign parameters.
-   def API.sign(params)
+private
+   # sign parameters
+   def API.sign(param)
       sig = @@sec
-      sig += params.collect { |k, v| [k, v].join('') }.sort.join('')
-      sig = Digest::MD5.hexdigest(sig)
+      sig += param.collect { |k, v| [k, v].join('') }.sort.join('')
+      Digest::MD5.hexdigest(sig)
    end
-end # API
 
-#--
-# ---------------------------------------------------------------
-# subclasses
-#++
-
-class API
-   # Exception class, takes msg and code.
-   class Error < StandardError
-      def initialize(h)
-         err = h['err'].first
-         @code = err['code'].to_i
-         msg = err['msg'] + ' (error code=' + err['code'] + ')'
-         super(msg)
-      end
+   def initialize(method, token=nil, timeline=nil)
+      @method   = method
+      @token    = token ? token : nil
+      @timeline = timeline ? timeline : nil
+      @param = {}
    end
 
-   # rtm.auth API.
-   class Auth
-      METHOD = 'rtm.auth'
-
-      # see spec[http://www.rememberthemilk.com/services/api/methods/rtm.auth.checkToken.rtm].
-      def Auth.checkToken(token)
-         p = API.params.dup
-         p['method'] = METHOD + '.checkToken'
-         p['auth_token'] = token
-         res = API.request(API.uri_req(p))
-      end
-
-      # see spec[http://www.rememberthemilk.com/services/api/methods/rtm.auth.getFrob.rtm].
-      def Auth.getFrob
-         p = API.params.dup
-         p['method'] = METHOD + '.getFrob'
-
-         res = API.request(API.uri_req(p))
-         res['frob'].first
-      end
-
-      # see {spec}[http://www.rememberthemilk.com/services/api/methods/rtm.auth.getToken.rtm].
-      def Auth.getToken(frob)
-         p = API.params.dup
-         p['method'] = METHOD + '.getToken'
-         p['frob']   = frob
-
-         res = API.request(API.uri_req(p))
-         res['auth'].first['token'].first
-      end
-   end # Auth
-
-   class Contacts
-      def Contacts.add
-      end
-
-      def Contacts.delete
-      end
-
-      def Contacts.getList
-      end
-   end # Contacts
-
-   class Groups
-      def Groups.add
-      end
-
-      def Groups.addContact
-      end
-
-      def Groups.delete
-      end
-
-      def Groups.getList
-      end
-
-      def Groups.removeContact
-      end
-   end # Groups
-
-   class Lists
-      METHOD = 'rtm.lists'
-
-      def Lists.add(timeline, name, filter=nil)
-         p = API.params.dup
-         p['method'] = METHOD + '.add'
-         p['auth_token'] = API.token
-         p['timeline'] = timeline
-         p['name'] = name
-         p['filter'] = filter if filter
-
-         res = API.request(API.uri_req(p))
-      end
-
-      def Lists.archive
-      end
-
-      def Lists.getList(alive_only=true)
-         p = API.params.dup
-         p['method'] = METHOD + '.getList'
-         p['auth_token'] = API.token
-
-         res = API.request(API.uri_req(p))
-         lists = res['lists'].first['list']
-
-         if alive_only
-            lists.collect { |l| l if l['deleted'] == '0' }.compact
-         else
-            lists
-         end
-      end
-
-      def Lists.setDefaultList
-      end
-
-      def Lists.setName
-      end
-
-      def Lists.unarchive
-      end
-   end # Lists
-
-   class Reflection
-      def Reflection.getMethodInfo
-      end
-
-      def Reflection.getMethods
-      end
-   end # Reflection
-
-   class Settings
-      def Settings.getList
-      end
-   end # Settings
-
-   class Tasks
-      METHOD = 'rtm.tasks'
-
-      def Tasks.add(timeline, list, name)
-         p = API.params.dup
-         p['method'] = METHOD + '.add'
-         p['auth_token'] = API.token
-         p['timeline'] = timeline
-         p['name'] = name
-         p['list_id'] = list
-
-         res = API.request(API.uri_req(p))
-         res['list'].first['taskseries'].first
-      end
-
-      def Tasks.addTags
-      end
-
-      def Tasks.complete
-      end
-
-      def Tasks.delete(timeline, list, series, task)
-         p = API.params.dup
-         p['method'] = METHOD + '.delete'
-         p['auth_token'] = API.token
-         p['timeline'] = timeline
-         p['list_id'] = list
-         p['taskseries_id'] = series
-         p['task_id'] = task
-
-         res = API.request(API.uri_req(p))
-         res['list'].first['taskseries'].first
-      end
-
-      def Tasks.getList(list=nil, last_sync=nil)
-         p = API.params.dup
-
-         p['method'] = METHOD + '.getList'
-         p['auth_token'] = API.token
-         p['list_id'] = list if list
-         p['last_sync'] = last_sync if last_sync
-
-         res = API.request(API.uri_req(p))
-         res['tasks'].first['list']
-      end
-
-      def Tasks.moveProiority
-      end
-
-      def Tasks.moveTo
-      end
-
-      def Tasks.postpone
-      end
-
-      def Tasks.removeTags
-      end
-
-      def Tasks.setDueDate
-      end
-
-      def Tasks.setEstimate
-      end
-
-      def Tasks.setName
-      end
-
-      def Tasks.setPriority
-      end
-
-      def Tasks.setRecurrence
-      end
-
-      def Tasks.setTags
-      end
-
-      def Tasks.setURL
-      end
-
-      def Tasks.uncomplete
-      end
-
-      class Notes # TODO
-         def Notes.add # TODO
-         end
-
-         def Notes.delete # TODO
-         end
-
-         def Notes.edit # TODO
-         end
-      end # Notes
-   end # Tasks
-
-   class Test # TODO
-      METHOD = 'rtm.test'
-
-      def Test.echo # TODO
-         req = REST_PATH + '?method=' + METHOD + '.echo' + '&api_key=' + @k
-         puts req
-
-         r, b = @http.get(req)
-         puts r
-         puts b
-      end
-
-      def Test.login # TODO
-         params = {
-            'method' => METHOD + '.login',
-            'api_key' => @k
-         }
-
-         sig = @s
-         sig += params.collect { |k, v| [k, v].join('') }.sort.join('')
-         puts "sig = " + sig
-         sig = Digest::MD5.hexdigest(sig)
-         puts "hexed sig = " + sig
-
-         req = REST_PATH + '?' 
-         req += params.collect { |k, v| [k, v].join('=') }.sort.join('&')
-         req += "&api_sig=" + sig
-
-         puts "\n"
-         puts "req = " + req
-
-         r, b = @http.get(req)
-         puts r
-         puts b
-      end
-   end # Test
-
-   class Time # TODO
-      def Time.convert # TODO
-      end
-
-      def Time.parse # TODO
-      end
-   end # Time
-
-   class TimeLines
-      METHOD = 'rtm.timelines'
-
-      def TimeLines.create
-         p = API.params.dup
-         p['method'] = METHOD + '.create'
-         p['auth_token'] = API.token
-
-         res = API.request(API.uri_req(p))
-         t = res['timeline'].first
-      end
-   end # TimeLines
+   def make_url
+      r  = REST_PATH + '?' 
 
-   class TimeZones # TODO
-      def TimeZones.getList
-      end
-   end # TimeZones
+      @param = {} if @param == nil
+      @param['method'] = @method
+      @param['auth_token'] = @token unless @token == nil
+      @param['timeline'] = @timeline unless @timeline == nil
+      @param['api_key'] = @@key
+      r += @param.collect { |k, v| [k, v].join('=') }.sort.join('&')
+      r += '&api_sig=' + sign
+      URI.escape r
+   end
 
-   class Transactions
-      def Transactions.undo
+protected
+   # parse result
+   def parse_result(result)
+      unless result['stat'] == 'ok'
+         raise RTM::Error, result['err'].first['msg']
       end
-   end # Transactions
+   end
 end # API
 
 end # RTM
+require 'rtmilk/api/auth'
+require 'rtmilk/api/timelines'
+require 'rtmilk/api/lists'
+require 'rtmilk/api/tasks'
+require 'rtmilk/api/notes'
+
 # vim:fdm=indent