nozbe-ruby 0.2.0

data/lib/nozbe.rb

@@ -0,0 +1,9 @@
+%w(api_call user project context action note).each do |f|
+  require File.dirname(__FILE__) + "/nozbe/#{f}"
+end
+
+# Nozbe module, that provides a wrapper around the Nozber-API
+module Nozbe
+  
+end
+

data/lib/nozbe/action.rb

@@ -0,0 +1,129 @@
+module Nozbe
+  # Action class
+  # - In Nozbe, an action is a todo task.
+  # - It can be 'done' or not, or be your 'next' action or not.
+  # - It is associated with a Project and a Context
+  class Action
+    attr_accessor :id, :name, :name_show, :done, :done_time, :time, :next, :project, :context
+    
+    # List all actions
+    # - you can specify if you want to retrieve the already-done actions
+    # <b>WARNING !</b>
+    # The Nozbe-API doesn't provide such a method, so we use multiple API calls :
+    # - load all projects
+    # - then, for each project, load all actions
+    def self.list(user_key, showdone = false)
+      Nozbe::Project.list(user_key).inject([]) { |all_actions, project|
+        all_actions + project.get_actions(user_key, showdone)
+      }
+    end
+    
+    # List all 'next' actions
+    def self.list_next(user_key)
+      ActionsListApiCall.new(user_key, {:what => :next}).call
+    end
+    
+    # List all actions for the given Project (using its ID)
+    # - you can specify if you want to retrieve the already-done actions
+    def self.list_for_project(user_key, project_id, showdone = false)
+      params = {:what => :project, :id => project_id}
+      params[:showdone] = "1" if showdone
+      ActionsListApiCall.new(user_key, params).call
+    end
+    
+    # List all actions for the given Context (using its ID)
+    # - you can specify if you want to retrieve the already-done actions
+    def self.list_for_context(user_key, context_id, showdone = false)
+      params = {:what => :context, :id => context_id}
+      params[:showdone] = "1" if showdone
+      ActionsListApiCall.new(user_key, params).call
+    end
+    
+    # Mark all given Action instances as 'done'
+    # - return true or false
+    def self.done!(user_key, actions = [])
+      return false if actions.empty?
+      ActionCheckApiCall.new(user_key, actions.collect{|action|action.id}).call
+    end
+    
+    # Mark the current Action instance as 'done'
+    # - return true or false
+    def done!(user_key)
+      self.class.done!(user_key, [self])
+    end
+    
+    # Save the current Action instance
+    # - used to create a new action, not to save an already existing but modified action.
+    # - return the instance, with its new ID set
+    def save!(user_key)
+      ActionNewApiCall.new(user_key, self).call
+    end
+  end
+  
+  # This class is used internaly by the Action class 
+  # to make the API call that list all actions
+  class ActionsListApiCall < Nozbe::ApiCall
+    action :actions
+    # Parse the JSON response, and return an Array of Action instances, 
+    # or an empty array if no actions are found.
+    def parse(json)
+      actions = super(json)
+      return [] if actions.nil?
+      actions.collect do |raw_action|
+        action = Action.new
+        action.id = raw_action["id"]
+        action.name = raw_action["name"]
+        action.name_show = raw_action["name_show"]
+        action.done = raw_action["done"] == 1
+        action.done_time = raw_action["done_time"]
+        action.time = raw_action["time"]
+        action.next = raw_action["next"] == "next"
+        action.project = Nozbe::Project.new
+        action.project.id = raw_action["project_id"]
+        action.project.name = raw_action["project_name"]
+        action.context = Nozbe::Context.new
+        action.context.id = raw_action["context_id"]
+        action.context.name = raw_action["context_name"]
+        action.context.icon = raw_action["context_icon"]
+        action
+      end
+    end
+  end
+  
+  # This class is used internaly by the Action class 
+  # to make the API call that mark some actions as 'done'
+  class ActionCheckApiCall < Nozbe::ApiCall
+    action :check
+    def initialize(user_key, actions_ids = [])
+      super(user_key, {:ids => actions_ids})
+    end
+    # Parse the JSON response, and return true or false
+    def parse(json)
+      res = super(json)
+      res["response"] == "ok"
+    end
+  end
+  
+  # This class is used internaly by the Action class 
+  # to make the API call that create a new action
+  class ActionNewApiCall < Nozbe::ApiCall
+    action :newaction
+    def initialize(user_key, action)
+      params = {
+        :name => url_encode(action.name), 
+        :project_id => action.project.id, 
+        :context_id => action.context.id,
+        :time => action.time}
+      params[:next] = "true" if action.next
+      super(user_key, params)
+      @action = action
+    end
+    # Parse the JSON response, and return the action instance with its ID set
+    def parse(json)
+      res = super(json)
+      @action.id = res["response"]
+      @action
+    end
+  end
+  
+end

data/lib/nozbe/api_call.rb

@@ -0,0 +1,82 @@
+require 'rubygems'
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Nozbe
+  # Base class for all API call
+  # - The Nozbe API is based on JSON responses
+  # - This class is inspired by the deliciousr project
+  class ApiCall
+    API_BASE_URL = 'http://www.nozbe.com:80/api'
+    
+    attr_accessor :action, :parameters
+    attr_reader :required_parameters
+
+    # define the action to call ('new_project', 'actions', and so on...)
+    # - Sub-classes MUST define this !!
+    def self.action(action)
+      define_method :action do
+        action.to_sym
+      end
+    end
+
+    # define the user_key and all parameters for the API-call
+    # - Sub-classes should override this method to provide a more user-friendly signature
+    def initialize(key, parameters={})
+      @parameters = parameters
+      @parameters["key"] = key if key
+    end
+
+    # execute the API-Call, and return the parsed reponse
+    def call()
+      json = do_request()
+      parse(json)
+    end
+
+    # low-level method that do the request, and return the body response (without any parsing)
+    def do_request()
+      uri = URI.parse(API_BASE_URL + build_request_path())
+      response = Net::HTTP.get_response(uri)
+      response.body
+    end
+
+    # method provides a default parsing strategy for the JSON-response
+    # - Sub-classes should override this method to provide a specific parsing of the response
+    def parse(json)
+      JSON.parse(json) rescue nil
+    end
+
+    # build the request path based on the given action and built query string
+    def build_request_path()
+      path = "/#{self.action}"
+      if query_string = build_query_string
+        path += "/#{query_string}"
+      end
+      path
+    end
+    
+    # build the query string based on the given parameters
+    # - the Nozbe-API convention is to use '.../paramkey-paramvalue/...'
+    def build_query_string()
+      unless parameters.nil? || parameters.empty?
+        query_strings = parameters.keys.sort {|a,b|
+          a.to_s <=> b.to_s
+        }.inject([]) do |result, element|
+          value = parameters[element]
+          value = value.join(";") if value.class == Array
+          result << "#{element.to_s}-#{value.to_s}"
+        end
+        query_strings.join('/')
+      else
+        nil
+      end
+    end
+    
+    # helper method that 'url-encode' the given parameter and return it
+    def url_encode(param)
+      URI.escape(param, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+    
+  end
+end

data/lib/nozbe/context.rb

@@ -0,0 +1,95 @@
+module Nozbe
+  # Context class
+  # - In Nozbe, a context is used to group Action (or Note) together
+  # - Some pre-defined contexts are already set
+  # - The number of user-specific contexts is limited by the Nozbe-account
+  class Context
+    DEFAULT_CONTEXT_NAME = "No context"
+
+    attr_accessor :id, :name, :icon, :body, :body_show, :count
+    
+    # return the default Context instance : 
+    # the context with its name set to DEFAULT_CONTEXT_NAME
+    def self.get_default_context(user_key)
+      get_from_name(user_key, DEFAULT_CONTEXT_NAME)
+    end
+    
+    # return a Context instance from the given context_name
+    # - it may return nil if there is no matches
+    # <b>WARNING</b> :
+    # the Nozbe-API doesn't provide such a method, 
+    # so we load all contexts and compare the names with the given name
+    # - the comparison is case-insensitive (use 'downcase' on all names)
+    def self.get_from_name(user_key, context_name)
+      return nil if context_name.nil?
+      contexts = list(user_key)
+      selected_contexts = contexts.select { |c| c.name.downcase == context_name.downcase }
+      selected_contexts.first rescue nil
+    end
+    
+    # List all contexts
+    def self.list(user_key)
+      ContextsListApiCall.new(user_key).call
+    end
+    
+    # load more infos (body) for the current context
+    def load_info(user_key)
+      ContextInfoApiCall.new(user_key, self).call
+    end
+    
+    # List all actions associated with the current context
+    # - you can specify if you want to retrieve the already-done actions
+    def get_actions(user_key, showdone = false)
+      Nozbe::Action.list_for_context(user_key, id, showdone).collect { |action|
+        action.context = self
+        action
+      }
+    end
+    
+    # List all notes associated with the current context
+    def get_notes(user_key)
+      Nozbe::Note.list_for_context(user_key, id).collect { |note|
+        note.context = self
+        note
+      }
+    end
+  end
+  
+  # This class is used internaly by the Context class 
+  # to make the API call that list all contexts
+  class ContextsListApiCall < Nozbe::ApiCall
+    action :contexts
+    # Parse the JSON response, and return an Array of Context instances
+    def parse(json)
+      contexts = super(json)
+      contexts.collect do |raw_context|
+        context = Context.new
+        context.id = raw_context["id"]
+        context.name = raw_context["name"]
+        context.count = raw_context["count"]
+        context.count = raw_context["icon"]
+        context
+      end
+    end
+  end
+  
+  # This class is used internaly by the Context class 
+  # to make the API call that retrieve the infos of a context
+  class ContextInfoApiCall < Nozbe::ApiCall
+    action :info
+    def initialize(user_key, context)
+      super(user_key, {:what => :context, :id => context.id})
+      @context = context
+    end
+    # Parse the JSON response, and return the context instance with its infos set
+    def parse(json)
+      raw_context = super(json)
+      @context.name = raw_context["name"]
+      @context.body = raw_context["body"]
+      @context.body_show = raw_context["body_show"]
+      @context.icon = raw_context["icon"]
+      @context
+    end
+  end
+  
+end

data/lib/nozbe/note.rb

@@ -0,0 +1,84 @@
+module Nozbe
+  # Note class
+  # - It is associated with a Project and a Context
+  class Note
+    attr_accessor :id, :name, :body, :body_show, :date, :project, :context
+    
+    # List all notes
+    # <b>WARNING !</b>
+    # The Nozbe-API doesn't provide such a method, so we use multiple API calls :
+    # - load all projects
+    # - then, for each project, load all notes
+    def self.list(user_key)
+      Nozbe::Project.list(user_key).inject([]) { |all_notes, project|
+        all_notes + project.get_notes(user_key)
+      }
+    end
+    
+    # List all notes for the given Project (using its ID)
+    def self.list_for_project(user_key, project_id)
+      NotesListApiCall.new(user_key, {:what => :project, :id => project_id}).call
+    end
+    
+    # List all notes for the given Context (using its ID)
+    def self.list_for_context(user_key, context_id)
+      NotesListApiCall.new(user_key, {:what => :context, :id => context_id}).call
+    end
+    
+    # Save the current Note instance
+    # - used to create a new note, not to save an already existing but modified note.
+    # - return the instance, with its new ID set
+    def save!(user_key)
+      NoteNewApiCall.new(user_key, self).call
+    end
+  end
+  
+  # This class is used internaly by the Note class 
+  # to make the API call that list all notes
+  class NotesListApiCall < Nozbe::ApiCall
+    action :notes
+    # Parse the JSON response, and return an Array of Note instances, 
+    # or an empty array if no notes are found.
+    def parse(json)
+      notes = super(json)
+      return [] if notes.nil?
+      notes.collect do |raw_note|
+        note = Note.new
+        note.id = raw_note["id"]
+        note.name = raw_note["name"]
+        note.body = raw_note["body"]
+        note.body_show = raw_note["body_show"]
+        note.date = raw_note["date"]
+        note.project = Nozbe::Project.new
+        note.project.id = raw_note["project_id"]
+        note.project.name = raw_note["project_name"]
+        note.context = Nozbe::Context.new
+        note.context.id = raw_note["context_id"]
+        note.context.name = raw_note["context_name"]
+        note.context.icon = raw_note["context_icon"]
+        note
+      end
+    end
+  end
+  
+  # This class is used internaly by the Note class 
+  # to make the API call that create a new note
+  class NoteNewApiCall < Nozbe::ApiCall
+    action :newnote
+    def initialize(user_key, note)
+      super(user_key, {
+          :name => url_encode(note.name), 
+          :body => url_encode(note.body), 
+          :project_id => note.project.id, 
+          :context_id => note.context.id,})
+      @note = note
+    end
+    # Parse the JSON response, and return the note instance with its ID set
+    def parse(json)
+      res = super(json)
+      @note.id = res["response"]
+      @note
+    end
+  end
+  
+end

data/lib/nozbe/project.rb

@@ -0,0 +1,117 @@
+module Nozbe
+  # Project class
+  # - In Nozbe, a project is used to group Action (or Note) together
+  # - The number of projects is limited by the Nozbe-account (for a free account : 5)
+  class Project
+    DEFAULT_PROJECT_NAME = "Inbox"
+    
+    attr_accessor :id, :name, :body, :body_show, :count
+    
+    # return the default Project instance : 
+    # the project with its name set to DEFAULT_PROJECT_NAME
+    def self.get_default_project(user_key)
+      get_from_name(user_key, DEFAULT_PROJECT_NAME)
+    end
+    
+    # return a Project instance from the given project_name
+    # - it may return nil if there is no matches
+    # <b>WARNING</b> :
+    # the Nozbe-API doesn't provide such a method, 
+    # so we load all projects and compare the names with the given name
+    # - the comparison is case-insensitive (use 'downcase' on all names)
+    def self.get_from_name(user_key, project_name)
+      return nil if project_name.nil?
+      projects = list(user_key)
+      selected_projects = projects.select { |p| p.name.downcase == project_name.downcase }
+      selected_projects.first rescue nil
+    end
+    
+    # List all projects
+    def self.list(user_key)
+      ProjectsListApiCall.new(user_key).call
+    end
+    
+    # load more infos (body) for the current project
+    def load_info(user_key)
+      ProjectInfoApiCall.new(user_key, self).call
+    end
+    
+    # List all actions associated with the current project
+    # - you can specify if you want to retrieve the already-done actions
+    def get_actions(user_key, showdone = false)
+      Nozbe::Action.list_for_project(user_key, id, showdone).collect { |action|
+        action.project = self
+        action
+      }
+    end
+    
+    # List all notes associated with the current project
+    def get_notes(user_key)
+      Nozbe::Note.list_for_project(user_key, id).collect { |note|
+        note.project = self
+        note
+      }
+    end
+    
+    # Save the current Project instance
+    # - used to create a new project, not to save an already existing but modified project.
+    # - return the instance, with its new ID set
+    def save!(user_key)
+      ProjectNewApiCall.new(user_key, self).call
+    end
+  end
+  
+  # This class is used internaly by the Project class 
+  # to make the API call that list all projects
+  class ProjectsListApiCall < Nozbe::ApiCall
+    action :projects
+    # Parse the JSON response, and return an Array of Project instances
+    def parse(json)
+      projects = super(json)
+      projects.collect do |raw_project|
+        project = Project.new
+        project.id = raw_project["id"]
+        project.name = raw_project["name"]
+        project.count = raw_project["count"]
+        project
+      end
+    end
+  end
+  
+  # This class is used internaly by the Project class 
+  # to make the API call that retrieve the infos of a project
+  class ProjectInfoApiCall < Nozbe::ApiCall
+    action :info
+    def initialize(user_key, project)
+      super(user_key, {:what => :project, :id => project.id})
+      @project = project
+    end
+    # Parse the JSON response, and return the project instance with its infos set
+    def parse(json)
+      raw_project = super(json)
+      @project.name = raw_project["name"]
+      @project.body = raw_project["body"]
+      @project.body_show = raw_project["body_show"]
+      @project
+    end
+  end
+  
+  # This class is used internaly by the Project class 
+  # to make the API call that create a new project
+  class ProjectNewApiCall < Nozbe::ApiCall
+    action :newproject
+    def initialize(user_key, project)
+      super(user_key, {
+          :name => url_encode(project.name), 
+          :body => url_encode(project.body)})
+      @project = project
+    end
+    # Parse the JSON response, and return the project instance with its ID set
+    def parse(json)
+      res = super(json)
+      @project.id = res["response"]
+      @project
+    end
+  end
+  
+end

data/lib/nozbe/user.rb

@@ -0,0 +1,42 @@
+module Nozbe
+  # User class
+  # - Represents a Nozbe-User
+  # - Used to login (= get a user_key from the email and the password)
+  class User
+    attr_accessor :email, :password, :key
+
+    # Default constructor, that used the user email and password
+    def initialize(email, password)
+      @email = email
+      @password = password
+      @key = nil
+    end
+    
+    # Log into Nozbe :
+    # - retrieve the user_key from the email and password, and return it
+    def login()
+      @key = LoginApiCall.new(self).call
+    end
+    
+    # Is the user currently logged_in ?
+    # - return true if the user_key is set (= not nil)
+    def logged_in?()
+      not @key.nil?
+    end
+  end
+  
+  # This class is used internaly by the User class 
+  # to make the API call that login the user
+  class LoginApiCall < Nozbe::ApiCall
+    action :login
+    def initialize(user)
+      super(nil, {:email => user.email, :password => user.password})
+    end
+    # Parse the JSON response, and return the user_key (may be nil)
+    def parse(json)
+      res = super(json)
+      res["key"]
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: nozbe-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2008-04-21 00:00:00 +02:00
+summary: Ruby wrapper around the JSON-based Nozbe API (Nozbe is a GTD webapp)
+require_paths: 
+- lib
+email: v.behar@free.fr
+homepage: http://nozbe-ruby.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Vincent Behar
+files: 
+- lib/nozbe
+- lib/nozbe/user.rb
+- lib/nozbe/context.rb
+- lib/nozbe/note.rb
+- lib/nozbe/api_call.rb
+- lib/nozbe/project.rb
+- lib/nozbe/action.rb
+- lib/nozbe.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: