ddollar-remember-the-ruby 0.3.2

data/README

@@ -0,0 +1 @@
+This will be a command line interface to Remember the Milk

data/bin/rtr

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'remember-the-ruby'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'rtr'))
+
+require 'pp'
+
+$storage = RememberTheRuby::Storage.new
+$storage[:cache_timeout] ||= 15.minutes
+
+usage_and_exit if ARGV.length < 1
+
+command = ARGV.shift
+options = ARGV.dup
+
+proc = $methods[command.to_sym]
+
+usage_and_exit unless proc
+
+proc.call(options)

data/lib/core_ext/datetime.rb

@@ -0,0 +1,9 @@
+require 'date'
+
+class DateTime
+  
+  def blank?
+    false
+  end
+  
+end

data/lib/core_ext/enumerable.rb

@@ -0,0 +1,7 @@
+module Enumerable
+  
+  def sorted_by(attribute)
+    self.sort_by { |e| e[attribute] }
+  end
+  
+end

data/lib/core_ext/fixnum.rb

@@ -0,0 +1,7 @@
+class Fixnum
+  
+  def minutes
+    self * 60
+  end
+  
+end

data/lib/core_ext/nil.rb

@@ -0,0 +1,7 @@
+class NilClass
+  
+  def blank?
+    true
+  end
+  
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,22 @@
+require 'date'
+require 'rubygems'
+require 'term/ansicolor'
+
+class String
+  
+  include Term::ANSIColor
+  
+  def to_date
+    begin
+      date = DateTime.parse(self)
+    rescue
+      date = nil
+    end
+    date
+  end
+  
+  def blank?
+    self == ""
+  end
+  
+end

data/lib/remember-the-ruby.rb

@@ -0,0 +1,49 @@
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? RememberTheRuby
+
+module RememberTheRuby
+
+  # :stopdoc:
+  VERSION = '0.3.2'
+  LIBPATH = File.expand_path(File.dirname(__FILE__)) + File::SEPARATOR
+  PATH = File.dirname(LIBPATH) + File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, *args)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to(fname)
+    search_me = File.expand_path(File.join(File.dirname(fname), '**', '*.rb'))
+    Dir.glob(search_me).sort.each { |rb| require rb }
+  end
+
+end
+
+RememberTheRuby.require_all_libs_relative_to __FILE__
+
+end  # unless defined?

data/lib/remember-the-ruby/api.rb

@@ -0,0 +1,74 @@
+module RememberTheRuby
+class API
+  
+  def initialize(options={})
+    @transport = RPC::Transport.new(
+      :key    => 'cb877b5c450d216ce9e563394dff6c07', 
+      :secret => '97cbbc48a9b1b54c', 
+      :frob   => options[:frob], 
+      :token  => options[:token]    
+    )
+  end
+  
+  def authorization_url
+    self.frob = @transport.auth.get_frob
+    @transport.auth.get_authorization_url
+  end
+  
+  def authenticate
+    self.token = @transport.auth.get_token
+  end
+  
+  # first-order objects #####################################################
+  
+  def lists
+    @transport.lists.get_list
+  end
+  
+  def settings
+    @transport.settings.get_list
+  end
+  
+  def tasks
+    @transport.tasks.get_list
+  end
+  
+  # derivative objects ######################################################
+
+  def default_list
+    lists.find(settings["defaultlist"])
+  end
+  
+  def tags
+    found_tags = EntityList.new(@transport, Tag)
+    tasks.each do |task|
+      task.tags.each do |tag|
+        found = false
+        found_tags.each do |found_tag|
+          if tag.to_s == found_tag.to_s
+            found = true
+            break
+          end
+        end
+        found_tags << tag unless found
+      end
+    end
+    found_tags
+  end
+  
+  ## accessors ##############################################################
+
+  def frob
+    @transport.frob
+  end
+  
+  def frob=(frob)
+    @transport.frob = frob
+  end
+  
+  def token=(token)
+    @transport.token = token
+  end
+  
+end
+end

data/lib/remember-the-ruby/entity.rb

@@ -0,0 +1,57 @@
+module RememberTheRuby
+class Entity < Hash
+  
+  def initialize(transport, data={})
+    @transport = transport
+    self.merge!(data)
+  end
+  
+  def self.from_element(transport, element)
+    data = element.attributes.keys.inject({}) do |memo, key|
+      memo[key] = element.attributes[key]
+      memo
+    end
+    self.new(transport, data)
+  end
+  
+  def self.list_from_elements(transport, rsp, element)
+    EntityList.from_element(transport, self, rsp, element)
+  end
+  
+  def method_missing(method_name)
+    self[method_name]
+  end
+  
+  def hydrate_from(&blk)
+    entity = yield blk
+    entity.each do |key, value|
+      self[key] = value
+    end
+  end
+  
+  alias_method :regular_reader, :[]
+  alias_method :regular_writer, :[]=
+
+  undef id
+  
+  def [](key)
+    regular_reader(key.to_s)
+  end
+  
+  def []=(key, value)
+    regular_writer(key.to_s, value)
+  end
+
+  alias_method :original_lookup, :[]
+
+  def [](key)
+    value = self
+    parts = key.to_s.split('/')
+    parts.each do |part|
+      value = value.original_lookup(part)
+    end
+    value
+  end
+    
+end
+end

data/lib/remember-the-ruby/entity_list.rb

@@ -0,0 +1,58 @@
+module RememberTheRuby
+class EntityList < Array
+  
+  attr_accessor :defaults
+  
+  def initialize(transport, type)
+    @transport = transport
+    @type      = type
+    @defaults  = {}
+  end
+  
+  def new
+    entity = @type.new(@transport)
+    @defaults.each do |key, value|
+      entity[key] = value
+    end
+    entity
+  end
+  
+  def find(options)
+
+    case options
+      when String, Integer then 
+        params = { 'id' => options.to_s }
+        amount = :one
+      when Hash then 
+        params = options
+        amount = :many
+      else 
+        params = {}
+        amount = :many
+    end
+    
+    matches = EntityList.new(@transport, @type)
+    self.each do |entity|
+      matched = true
+      params.each do |key, value|
+        unless entity[key] == value
+          matched = false
+          break
+        end
+      end
+      matches << entity if matched
+    end
+    
+    amount == :many ? matches : matches.first
+  end
+  
+  def self.from_element(transport, type, rsp, xpath)
+    entity_list = EntityList.new(transport, type)
+    rsp.get_elements(xpath).map do |element|
+      entity_list << type.from_element(transport, element)
+    end
+    entity_list
+  end
+
+end
+end

data/lib/remember-the-ruby/list.rb

@@ -0,0 +1,11 @@
+module RememberTheRuby
+class List < Entity
+
+  def tasks
+    tasks = @transport.tasks.get_list(:list_id => self['id'])
+    tasks.defaults['list_id'] = self['id']
+    tasks
+  end
+  
+end
+end

data/lib/remember-the-ruby/rpc.rb

@@ -0,0 +1,187 @@
+module RememberTheRuby
+module RPC
+
+require 'digest/md5'
+require 'net/http'
+require 'rexml/document'
+
+class Transport
+  
+  TRANSPORT_URI = 'http://api.rememberthemilk.com'
+  
+  attr_accessor :key, :secret, :frob, :token
+  
+  def initialize(params)
+    @key    = params[:key]
+    @secret = params[:secret]
+    @frob   = params[:frob]
+    @token  = params[:token]
+    
+    @transport_http = build_transport_http
+  end
+  
+  public ####################################################################
+
+  def request(method, params={})
+    params[:method] = method
+
+    uri  = URI.encode(rest_path(params))
+    data = @transport_http.get(uri)
+    doc  = REXML::Document.new(data.body)
+
+    doc.elements['rsp']
+  end
+
+  # rpc types ###############################################################
+  
+  def auth
+    @auth ||= Auth.new(self)
+  end
+  
+  def lists
+    @lists ||= Lists.new(self)
+  end
+  
+  def settings
+    @settings ||= Settings.new(self)
+  end
+  
+  def tasks
+    @tasks ||= Tasks.new(self)
+  end
+  
+  def timeline
+    Timelines.new(self).create
+  end
+  
+  # private #################################################################
+  
+  def build_transport_http
+    uri = URI::parse(TRANSPORT_URI)
+    @transport_http = Net::HTTP.start(uri.host, uri.port)
+  end
+  
+  def clear_empty_parameters(params)
+    params.dup.each do |k, v|
+      params.delete(k) if v.nil? || v == ''
+    end
+  end
+  
+  def auth_path(params)
+    self.service_path('auth', params)
+  end
+
+  def rest_path(params)
+    self.service_path('rest', params)
+  end
+
+  def service_path(service, params)
+    params[:frob]       ||= @frob
+    params[:api_key]    ||= @key
+    params[:auth_token] ||= @token
+    
+    clear_empty_parameters(params)
+    
+    params[:api_sig] = sign_parameters(params)
+    "/services/#{service}/?#{flatten_parameters(params)}"
+  end
+
+  def sign_parameters(params)
+    signature  = @secret
+    signature += params.map { |k, v| [k, v].join('') }.sort.join('')
+    Digest::MD5.hexdigest(signature)
+  end
+  
+  def flatten_parameters(params)
+    params.map { |k, v| [k, v].join('=') }.join('&')
+  end
+  
+  def hash_from_element(element)
+    element.attributes
+  end
+  
+end
+
+class Transported
+  
+  def initialize(transport)
+    @transport = transport
+  end
+  
+end
+
+class Auth < Transported
+  
+  def get_authorization_url(params={})
+    params[:perms] ||= 'delete'
+    data = Transport::TRANSPORT_URI + @transport.auth_path(params)
+  end
+  
+  def get_frob
+    rsp = @transport.request('rtm.auth.getFrob')
+    rsp.elements['frob'].text
+  end
+  
+  def get_token
+    rsp = @transport.request('rtm.auth.getToken')
+    rsp.elements['auth/token'].text
+  end
+  
+end
+
+class Lists < Transported
+  
+  def get_list
+    rsp = @transport.request('rtm.lists.getList')
+    List.list_from_elements(@transport, rsp, 'lists/list')
+  end
+  
+end
+
+class Settings < Transported
+  
+  def get_list
+    rsp = @transport.request('rtm.settings.getList')
+    rsp.get_elements('settings').first.inject({}) do |memo, element|
+      memo[element.name] = element.text
+      memo
+    end
+  end
+  
+end
+
+class Tasks < Transported
+  
+  def add(params={})
+    params[:list_id]  ||= nil
+    params[:name]     ||= nil
+    params[:parse]    ||= nil
+    
+    params[:timeline] = @transport.timeline
+    params[:parse]    = params[:parse] ? 1 : 0
+    
+    rsp = @transport.request('rtm.tasks.add', params)
+    Task.from_element(@transport, rsp.get_elements('list/taskseries').first)
+  end
+  
+  def get_list(params={})
+    params[:list_id]   ||= nil
+    params[:filter]    ||= nil
+    params[:last_sync] ||= nil
+    rsp = @transport.request('rtm.tasks.getList', params)
+    Task.list_from_elements(@transport, rsp, 'tasks/list/taskseries')
+  end
+
+end
+
+class Timelines < Transported
+  
+  def create(params={})
+    rsp = @transport.request('rtm.timelines.create', params)
+    rsp.get_elements('timeline').first.text
+  end
+  
+end
+
+end
+end

data/lib/remember-the-ruby/storage.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'preferences'
+
+module RememberTheRuby
+class Storage < Preferences::Manager
+  
+  def initialize
+    super(:remember_the_ruby, :autosave => true)
+  end
+
+  def set_cache_timeout(key, timeout)
+    self[:cache] ||= {}
+    self[:cache][key] ||= Time.now + timeout
+    self.save
+  end
+
+  def cache_timeout_for(key)
+    original_reader(:cache) ? original_reader(:cache)[key] : nil
+  end
+  
+  def purge_cache!
+    return unless self[:cache].is_a?(Enumerable)
+    self[:cache].each do |key, timeout|
+      self.delete(key)
+    end
+    self.delete(:cache)
+    self.save
+  end
+  
+  alias_method :original_reader, :[]
+  
+  def [](key)
+    now     = Time.now
+    timeout = cache_timeout_for(key) || now
+    if timeout < now
+      self.delete(key)
+      self[:cache].delete(key)
+    end
+    super
+  end
+  
+end
+end

data/lib/remember-the-ruby/tag.rb

@@ -0,0 +1,21 @@
+module RememberTheRuby
+class Tag < Entity
+
+  def self.from_element(transport, element)
+    tag = super
+    tag['name'] = element.text
+    tag
+  end
+  
+  def to_s
+    self['name']
+  end
+  
+  def tasks
+    tasks = @transport.tasks.get_list(:filter => "tag:#{self["name"]}")
+    # TODO: add default tag to the tasks list
+    tasks
+  end
+  
+end
+end

data/lib/remember-the-ruby/task.rb

@@ -0,0 +1,20 @@
+module RememberTheRuby
+class Task < Entity
+
+  def self.from_element(transport, element)
+    task = super
+    task["occurrences"] = TaskOccurrence.list_from_elements(transport, element, 'task')
+    task["next"] = task["occurrences"].sorted_by(:due).first
+    task["tags"] = Tag.list_from_elements(transport, element, 'tags/tag')
+    task
+  end
+  
+  def save!(params={})
+    hydrate_from do
+      @transport.tasks.add(:name => self[:name], :parse => params[:parse])
+    end
+    # TODO: apply tags
+  end
+  
+end
+end

data/lib/remember-the-ruby/task_occurrence.rb

@@ -0,0 +1,5 @@
+module RememberTheRuby
+class TaskOccurrence < Entity
+
+end
+end

data/lib/rtr.rb

@@ -0,0 +1,21 @@
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? RTR
+
+module RTR
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to(fname)
+    search_me = File.expand_path(File.join(File.dirname(fname), '**', '*.rb'))
+    Dir.glob(search_me).sort.each { |rb| require rb }
+  end
+
+end
+
+RTR.require_all_libs_relative_to __FILE__
+
+end  # unless defined?

data/lib/rtr/api.rb

@@ -0,0 +1,22 @@
+def api
+  
+  @api ||= begin
+
+    api = RememberTheRuby::API.new(:frob  => $storage[:frob], 
+                                   :token => $storage[:token])
+
+    unless $storage[:frob]
+      system %{open "#{api.authorization_url}"}
+      $storage[:frob] = api.frob
+      exit
+    end
+
+    unless $storage[:token]
+      $storage[:token] = api.authenticate
+    end
+  
+    api
+
+  end
+  
+end

data/lib/rtr/command_helper.rb

@@ -0,0 +1,11 @@
+$methods = {}
+
+def register_method(method, &blk)
+  $methods[method] = blk
+end
+
+def usage_and_exit
+  puts "usage: rtr <command> [options]"
+  exit 1
+end
+  

data/lib/rtr/commands.rb

@@ -0,0 +1,67 @@
+require 'term/ansicolor'
+require 'pp'
+
+module RTR
+class Commands
+  
+  register_method :add do |options|
+    tags, task_name = options.partition { |o| o[0..0] == '@' }
+    task_name = task_name.join(' ')
+    
+    task = api.tasks.new
+
+    task["name"] = task_name
+    task["tags"] = tags.map { |tag| tag[1..-1] }
+    
+    task.save!(:parse => true)
+    
+    $storage.purge_cache!
+  end
+  
+  register_method :tasks do |options|
+
+    puts "Oustanding Tasks".white.bold
+    puts
+    
+    tasks = $storage[:tasks] || api.default_list.tasks
+    
+    tasks.sorted_by('next/due').reverse.each do |task|
+
+      now = DateTime.now
+      
+      due = task['next/due']
+      due = due.to_date unless due.blank?
+      
+      diff = due.blank? ? nil : due - now
+      
+      color = case
+        when diff.nil?                          then :white
+        when diff.abs < 1 && due.day == now.day then :yellow
+        when diff < 0                           then :red
+        else                                         :white
+      end
+      
+      title = task.name
+      title = title.send(color).bold if color
+      
+      prefix = " *"
+      prefix = prefix.send(color).bold if color
+      
+      suffix = task.tags.map { |t| "@#{t.name}" }.join(' ').cyan
+
+      puts "#{prefix} #{title} #{suffix}"
+      
+    end
+    
+    $storage[:tasks] = tasks
+    $storage.set_cache_timeout(:tasks, 30.minutes)
+    
+  end
+  
+  register_method :purge do |options|
+    $storage.purge_cache!
+  end
+  
+  
+end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: ddollar-remember-the-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.3.2
+platform: ruby
+authors: 
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: preferences
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.3
+    version: 
+description: 
+email: ddollar@gmail.com
+executables: 
+- rtr
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/rtr
+- lib/core_ext
+- lib/core_ext/datetime.rb
+- lib/core_ext/enumerable.rb
+- lib/core_ext/fixnum.rb
+- lib/core_ext/nil.rb
+- lib/core_ext/string.rb
+- lib/remember-the-ruby
+- lib/remember-the-ruby/api.rb
+- lib/remember-the-ruby/contact.rb
+- lib/remember-the-ruby/entity.rb
+- lib/remember-the-ruby/entity_list.rb
+- lib/remember-the-ruby/group.rb
+- lib/remember-the-ruby/list.rb
+- lib/remember-the-ruby/location.rb
+- lib/remember-the-ruby/note.rb
+- lib/remember-the-ruby/rpc.rb
+- lib/remember-the-ruby/storage.rb
+- lib/remember-the-ruby/tag.rb
+- lib/remember-the-ruby/task.rb
+- lib/remember-the-ruby/task_occurrence.rb
+- lib/remember-the-ruby.rb
+- lib/rtr
+- lib/rtr/api.rb
+- lib/rtr/command_helper.rb
+- lib/rtr/commands.rb
+- lib/rtr.rb
+- README
+has_rdoc: true
+homepage: http://peervoice.com/software/remember-the-ruby
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: remember-the-ruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Ruby interface to Remember the Milk
+test_files: []
+