liquidplanner 0.0.1

data/HISTORY

@@ -0,0 +1,3 @@
+0.0.1
+-----
+Initial release

data/README.rdoc

@@ -0,0 +1,24 @@
+= LiquidPlanner
+The LiquidPlanner gem provides a simple way to access LiquidPlanner's API.
+
+To get started, look at the examples directory.  They show how to perform
+some common tasks.
+
+Typically you will want to create an API object:
+  
+  lp = LiquidPlanner::Base.new(:email=>email, :password=>password)
+  
+With the +api+ you can then get the user's account or their workspaces:
+
+  account     = lp.account
+  workspaces  = lp.workspaces
+  
+Tasks can be listed and created by accessing a workspace:
+
+  workspace = lp.workspaces(7)                                # access a workspace by ID
+  tasks     = workspace.tasks                                 # list all the tasks
+  my_tasks  = workspace.tasks(:all, :filter=>'owner_id = me') # use a filter
+  new_task  = workspace.create_task(:name=>'Learn API')       # create and save a new task
+  
+For more information, visit the LiquidPlanner developer pages at
+http://www.liquidplanner.com/developers

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.dirname(__FILE__) + "/lib/liquidplanner.rb"
+
+require 'rubygems'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = "liquidplanner"
+    gemspec.summary     = "LiquidPlanner API client"
+    gemspec.version     = LiquidPlanner::VERSION
+    gemspec.description = "LiquidPlanner API client, using ActiveResource"
+    gemspec.email       = "api@liquidplanner.com"
+    gemspec.homepage    = "http://github.com/liquidplanner/liquidplanner"
+    gemspec.authors     = ["Brett Bender", "Adam Sanderson"]
+    
+    gemspec.files       = FileList["[A-Z]*", "{examples,lib,test}/**/*"]
+    
+    gemspec.add_dependency              'activeresource',   '~> 3.0.0'
+    gemspec.add_dependency              'multipart-post',   '>= 1.0.1'
+
+    # For the examples:
+    gemspec.add_development_dependency  'highline',         '>= 1.5'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+Rake::RDocTask.new do |t|
+  t.main = "README.rdoc"
+  t.rdoc_files.include("README.rdoc")
+  t.rdoc_files.include("lib/**/*.rb")
+end

data/examples/README

@@ -0,0 +1,14 @@
+All of the examples expect you to pass in your account name and workspace id, 
+for instance:
+
+  ruby examples/list_tasks.rb alice@example.com 7
+  
+If you set the VERBOSE environment variable, the examples will print out their
+http requests to the console:
+
+  ruby examples/list_tasks.rb alice@example.com 7 --verbose
+  
+These examples all use highline library for prompting the user.  Install the 
+gem with:
+
+  sudo gem install highline

data/examples/create_task.rb

@@ -0,0 +1,28 @@
+# Require the LiquidPlanner API.
+require File.dirname(__FILE__) + '/../lib/liquidplanner'
+
+# Require support libraries used by this example.
+require 'rubygems'                  
+require 'highline/import'
+require File.dirname(__FILE__) + '/support/helper'
+
+# Get the user's credentials
+email, password, space_id = get_credentials!
+
+# Connect to LiquidPlanner and get the workspace
+lp = LiquidPlanner::Base.new(:email=>email, :password=>password)
+workspace = lp.workspaces(space_id)
+
+# Ask for a task's name and estimate
+say "Add a new task to '#{workspace.name}'"
+name  = ask("New task name")
+low   = ask("Min effort", Float)
+high  = ask("Max effort", Float){|q| q.above = low}
+
+# Submit the task and estimate
+say "Submitting: '#{name}' [#{low} - #{high}] to LiquidPlanner"
+task = workspace.create_task(:name=>name)
+task.create_estimate(:low=>low, :high=>high)
+
+# All done
+say "Added task"

data/examples/list_tasks.rb

@@ -0,0 +1,62 @@
+# Require the LiquidPlanner API.
+require File.dirname(__FILE__) + '/../lib/liquidplanner'
+
+# Require support libraries used by this example.
+require 'rubygems'                  
+require 'highline/import'           
+require 'active_support/all'        
+require File.dirname(__FILE__) + '/support/helper'
+
+# List a set of tasks in a workspace.
+#
+# You will:
+# * Access a workspace
+# * Retrieve the next 5 tasks assigned to you
+# * Display the details of each task
+#
+# This example will use the highline library to handle input and output.
+# You can install it with:
+#     gem install highline
+
+email, password, space_id = get_credentials!
+
+# Create a new LiquidPlanner API object.  It requires the login credentials we gathered above.
+lp = LiquidPlanner::Base.new(:email=>email, :password=>password)
+
+# Fetch the user's workspace, and then print its name.
+workspace = lp.workspaces(space_id)
+say workspace.name
+say "-" * 40
+
+# Fetch up to 5 tasks in the user's workspace, filter to tasks owned by this user
+tasks = workspace.tasks(:all, :limit=>5, :filter=>'owner_id = me')
+
+# Print each task.
+# If the task is done, say when it was completed.
+# Otherwise we will print the appropriate information for the task.
+tasks.each do |task|
+  say task.name
+  if task.is_done
+    say "completed on: #{task.done_on.to_date}"
+  else
+    case task
+      when LiquidPlanner::Resources::Task
+        # Normal tasks should show their promise date, and expected completion date:
+        say "due: #{task.promise_by.to_date}" if task.promise_by
+        say "expected: #{task.expected_finish.to_date}" if task.expected_finish
+        
+      when LiquidPlanner::Resources::Milestone
+        # Milestones should show their date
+        say "date: #{task.date.to_date}"
+        
+      when LiquidPlanner::Resources::Event
+        # Events should show their start to completion date
+        say "from: #{task.start_date.to_date}"
+        say "to: #{task.finish_date.to_date}"
+    end
+  end
+  
+  # Print the description
+  say task.description
+  say "-" * 40
+end

data/examples/support/helper.rb

@@ -0,0 +1,34 @@
+# Turn on request tracking if the `VERBOSE` environment variable is set:
+if ARGV.last == '--verbose'
+  ARGV.pop
+  require File.dirname(__FILE__) + '/../../lib/liquidplanner/debug'
+  LiquidPlanner.watch_requests! do |method, request, payload|
+    say "<%= color('[#{method}] #{request}', :green)%>"
+  end
+end
+
+# This helper is used by the example files to  get a user's email, password, 
+# and workspace id.
+def get_credentials!
+  # Get the user's Email and Workspace ID from the command line arguments.
+  # See usage below for how this should be called.
+  if ARGV.length == 2
+    email     = ARGV.shift
+    space_id  = ARGV.shift.to_i
+  else
+    puts "Usage:"
+    puts "  ruby #{$0} <account> <workspace id>"
+    puts "Example:"
+    puts "  ruby #{$0} alice@example.com 7"
+    exit 1
+  end
+  
+  # Work around a highline bug:
+  HighLine.track_eof = false
+  
+  # We use the highline library here to request the user's password.
+  # Passwords should never be stored in plain text.
+  password  = ask("LiquidPlanner password for #{email}:") {|q| q.echo = false}
+
+  return email, password, space_id
+end

data/examples/track_time.rb

@@ -0,0 +1,55 @@
+# Require the LiquidPlanner API.
+require File.dirname(__FILE__) + '/../lib/liquidplanner'
+
+# Require support libraries used by this example.
+require 'rubygems'                  
+require 'highline/import'
+require File.dirname(__FILE__) + '/support/helper'
+
+# Get the user's credentials
+email, password, space_id = get_credentials!
+
+# Create a new LiquidPlanner API object with the login credentials
+lp = LiquidPlanner::Base.new(:email=>email, :password=>password)
+
+# Get the user's workspace and account, and then print its name.
+workspace   = lp.workspaces(space_id)
+account     = lp.account
+
+say workspace.name
+say "-" * 40
+
+# Get the user's tasks
+tasks = workspace.tasks(:all, :filter=>'owner_id = me', :include_associated=>'activities')
+
+if tasks.empty?
+  say "No tasks are assigned to you."
+  exit
+end
+
+# Pick a task to log time for
+choose do |menu|
+  menu.prompt = "Log time for:"
+  tasks.each do |t|
+    menu.choice(t.name) do
+      say t.name
+      work   = ask("Log how much?    (hours)", Float)
+      low    = ask("New low effort:  (hours)", Float)
+      high   = ask("New high effort: (hours)", Float){|q| q.above = low}
+      
+      activity_id = 0
+      if !t.activities.empty?
+        choose do |activity_menu|
+          activity_menu.prompt = "Use activity:"
+          t.activities.each do |act|
+            activity_menu.choice(act.name) do
+              activity_id = act.id
+            end
+          end
+        end
+      end
+
+      t.track_time :low=>low, :high=>high, :member_id=>account.id, :work=>work, :activity_id=>activity_id
+    end
+  end
+end

data/lib/liquidplanner.rb

@@ -0,0 +1,49 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module LiquidPlanner
+  VERSION      = "0.0.1"
+  API_BASE_URL = "https://app.liquidplanner.com/api"
+end
+
+require "rubygems"
+gem "activeresource", '~> 3.0'
+gem "multipart-post"
+
+require "active_resource"
+require "net/http/post/multipart" # for uploading documents
+
+# could also glob these paths and require all matches...
+require "liquidplanner/base"
+require "liquidplanner/liquidplanner_resource"
+require "liquidplanner/resources/account"
+require "liquidplanner/resources/member"
+require "liquidplanner/resources/workspace"
+
+require "liquidplanner/resources/relative_resource"
+require "liquidplanner/resources/priority"
+require "liquidplanner/resources/order"
+
+require "liquidplanner/resources/item"
+require "liquidplanner/resources/container"
+require "liquidplanner/resources/leaf"
+require "liquidplanner/resources/task"
+require "liquidplanner/resources/event"
+require "liquidplanner/resources/milestone"
+require "liquidplanner/resources/tasklist"
+require "liquidplanner/resources/folder"
+require "liquidplanner/resources/project"
+require "liquidplanner/resources/client"
+
+require "liquidplanner/resources/luggage"
+require "liquidplanner/resources/note"
+require "liquidplanner/resources/comment"
+require "liquidplanner/resources/document"
+require "liquidplanner/resources/link"
+require "liquidplanner/resources/estimate"
+require "liquidplanner/resources/snapshot"
+require "liquidplanner/resources/activity"
+
+require "liquidplanner/ext/hash"
+require "liquidplanner/ext/connection"
+require "liquidplanner/ext/exceptions"

data/lib/liquidplanner/base.rb

@@ -0,0 +1,37 @@
+module LiquidPlanner
+
+  # sets up the URL and credentials for an API "session",
+  # then provides convenience accessors for the account and workspaces
+  #
+  # N.B. since ActiveResource uses class variables to configure endpoint and
+  # auth, you can only have one such "session" active at a time
+  #
+  class Base
+   
+    def initialize(options={})
+      options.assert_valid_keys(:email, :password, :api_base_url)
+      options.assert_required_keys(:email, :password)
+      @email        = options[:email]
+      @password     = options[:password]
+      @api_base_url = options[:api_base_url] || LiquidPlanner::API_BASE_URL
+      configure_base_resource
+    end
+
+    def account
+      LiquidPlanner::Resources::Account.find(:one, :from => "/api/account")
+    end
+
+    def workspaces( scope=:all )
+      LiquidPlanner::Resources::Workspace.find(scope)
+    end
+
+    private
+
+    def configure_base_resource
+      LiquidPlannerResource.site     = @api_base_url
+      LiquidPlannerResource.user     = @email
+      LiquidPlannerResource.password = @password
+    end
+                
+  end
+end

data/lib/liquidplanner/debug.rb

@@ -0,0 +1,16 @@
+module LiquidPlanner
+  # Print out all the outgoing requests from the LiquidPlanner API
+  def self.watch_requests!(&block)
+    ActiveSupport::Notifications.subscribe('active_resource.request') do |name, time, stamp, id, payload|
+      method = payload[:method]
+      request = payload[:request_uri]
+      
+      if block
+        block.call(method, request, payload)
+      else
+        puts "[#{method}] #{request}"
+      end
+      
+    end
+  end
+end

data/lib/liquidplanner/ext/connection.rb

@@ -0,0 +1,11 @@
+module ActiveResource
+  class Connection
+
+    # get a raw response (not just the decoded response body);
+    # used for non-standard responses (e.g. binary / file data)
+    def get_raw(path, headers = {})
+      with_auth { request(:get, path, build_request_headers(headers, :get, self.site.merge(path))) }
+    end
+
+  end
+end

data/lib/liquidplanner/ext/exceptions.rb

@@ -0,0 +1,25 @@
+module ActiveResource
+  #:nodoc:
+  class ClientError < ActiveResource::ConnectionError
+    
+    # Extend client errors so that they annotate the response message with the details
+    # from a JSON response.  LiquidPlanner sends back useful response bodies, so we might as well
+    # use them if they are available.
+    def initialize(response, message=nil)
+      if !message && response['Content-Type']['application/json']
+        details = ActiveSupport::JSON.decode(response.body)
+        detailed_message = details['message']
+        super response, detailed_message
+      else
+        super response, message
+      end
+    end
+    
+    # Return the default exception message with the extracted API message as well if available
+    def to_s
+      str = super
+      str << "  #{@message}" if @message
+      str
+    end
+  end
+end

data/lib/liquidplanner/ext/hash.rb

@@ -0,0 +1,6 @@
+class Hash
+  def assert_required_keys(*required_keys)
+    missing_keys = required_keys.select {|key| !keys.include?(key)}
+    raise ArgumentError, "Missing required option(s): #{missing_keys.join(", ")}" unless missing_keys.empty?
+  end
+end

data/lib/liquidplanner/liquidplanner_resource.rb

@@ -0,0 +1,58 @@
+module LiquidPlanner
+
+  # generic resource, extended by all LiquidPlanner::Resources
+  class LiquidPlannerResource < ActiveResource::Base
+    self.format               = :json
+    self.include_root_in_json = true
+    
+    # LiquidPlanner does not send back data that is already in the path (prefix_options), so merge
+    # any values that the object already had back into the prefix_options.
+    def load(attributes)
+      initial_prefix_options = @prefix_options.clone
+      super
+      @prefix_options.merge!(initial_prefix_options){|k, old_attr,new_attr| old_attr || new_attr }
+      self
+    end
+    
+    private
+    # Override the default instantiate_record to support polymorphic types
+    # based on the `type` attribute LiquidPlanner returns.
+    def self.instantiate_record(record, prefix_options = {})
+      if record['type']
+        cls = LiquidPlanner::Resources.const_get(record['type'])
+      else
+        cls = self
+      end
+      
+      cls.new(record).tap do |resource|
+        resource.prefix_options = prefix_options
+      end
+    end
+    
+    # Builds a new resource from the current one.
+    def build_new_resource(klass, attributes={})
+      raise ArgumentError, "#{klass} should subclass #{LiquidPlannerResource}" unless klass < LiquidPlannerResource
+      klass.new(attributes).tap do |item|
+        item.prefix_options = self.prefix_options.clone
+      end
+    end
+    
+    # Special handling for creating associated resources.  For instance:
+    #   workspace.create_task(:name=>'new task').create_estimate(:low_effort=>1, :high_effort=>3)
+    def method_missing(name, *args)
+      if name.to_s =~ /^(create|build)_(.+)/
+        operation    = $1.to_sym
+        resource    = $2
+        attributes  = args.shift || {}
+        klass = LiquidPlanner::Resources.const_get(resource.classify)
+        obj = build_new_resource(klass, attributes)
+        obj.save if operation == :create
+        obj
+      else
+        super
+      end
+    end
+    
+  end
+
+end

data/lib/liquidplanner/resources/account.rb

@@ -0,0 +1,12 @@
+module LiquidPlanner
+  module Resources
+    class Account < LiquidPlanner::LiquidPlannerResource
+
+      def self.account
+        find( :one, :from => "/api/account" )
+      end
+
+    end
+  end
+end
+

data/lib/liquidplanner/resources/activity.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Activity < Luggage
+    end
+  end
+end

data/lib/liquidplanner/resources/client.rb

@@ -0,0 +1,7 @@
+module LiquidPlanner
+  module Resources
+    class Client < Container
+      include Order
+    end
+  end
+end

data/lib/liquidplanner/resources/comment.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Comment < Luggage
+    end
+  end
+end

data/lib/liquidplanner/resources/container.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Container < Item
+    end
+  end
+end

data/lib/liquidplanner/resources/document.rb

@@ -0,0 +1,47 @@
+module LiquidPlanner
+  module Resources
+    class Document < Luggage
+
+      def self.upload_document( workspace_id, item_id, attached_file_path, options={} )
+        file_name   = options[:file_name]   || File.basename(attached_file_path)
+        description = options[:description] || ""
+        content_type = options[:content_type] || "application/octet-stream"
+        url         = site + "/api/workspaces/#{workspace_id}/treeitems/#{item_id}/documents"
+        File.open(attached_file_path) do |handle|
+          req = Net::HTTP::Post::Multipart.new( url.path, "document[file_name]"     => file_name,
+                                                          "document[description]"   => description,
+                                                          "document[attached_file]" => UploadIO.new(handle, content_type, attached_file_path)
+                                              )
+          req.basic_auth( user, password )
+          res = nil
+          begin
+            res = Net::HTTP.start(url.host, url.port) do |http|
+              http.use_ssl = true if url.scheme == "https" 
+              http.request(req)
+            end
+          rescue Timeout::Error => e
+            raise TimeoutError.new(e.message)
+          rescue OpenSSL::SSL::SSLError => e
+            raise SSLError.new(e.message)
+          end
+          connection.send(:handle_response, res)
+          doc = new(format.decode(res.body))
+        end
+      end
+
+      def get_raw(custom_method_name, options = {})
+        connection.get_raw(custom_method_element_url(custom_method_name, options), self.class.headers)
+      end
+
+      def download
+        get_raw(:download)
+      end
+
+      def thumbnail
+        get_raw(:thumbnail)
+      end
+
+    end
+  end
+end
+

data/lib/liquidplanner/resources/estimate.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Estimate < Luggage
+    end
+  end
+end

data/lib/liquidplanner/resources/event.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Event < Leaf
+    end
+  end
+end

data/lib/liquidplanner/resources/folder.rb

@@ -0,0 +1,7 @@
+module LiquidPlanner
+  module Resources
+    class Folder < Container
+      include Order
+    end
+  end
+end

data/lib/liquidplanner/resources/item.rb

@@ -0,0 +1,73 @@
+#------------------------------------------------------------------------
+# generic item, could be a task, folder, tasklist, etc.
+#------------------------------------------------------------------------
+module LiquidPlanner
+  module Resources
+    class Item < LiquidPlanner::LiquidPlannerResource
+
+      self.prefix = "/api/workspaces/:workspace_id/"
+
+      def folder
+        Folder.find( :one, :from => "/api/workspaces/#{workspace_id}/folders/#{folder_id}" )
+      end
+
+      def tasklist
+        Tasklist.find( :one, :from => "/api/workspaces/#{workspace_id}/tasklists/#{tasklist_id}" )
+      end
+
+      def note
+        Note.find( :one, :from => "/api/workspaces/#{workspace_id}/#{item_collection}/#{id}/note" ).tap do |n|
+          n.prefix_options = luggage_params
+        end
+      end
+
+      def comments( scope=:all )
+        Comment.find( scope, :params => luggage_params )
+      end
+
+      def documents( scope=:all )
+        Document.find( scope, :params => luggage_params )
+      end
+
+      def attach_document( attached_file_path, options={} )
+        doc = Document.upload_document( workspace_id, id, attached_file_path, options )
+        doc.prefix_options = luggage_params
+        doc
+      end
+
+      def links( scope=:all )
+        Link.find( scope, :params => luggage_params )
+      end
+
+      def estimates( scope=:all )
+        Estimate.find( scope, :params => luggage_params )
+      end
+
+      # LiquidPlanner::Item => 'items'
+      def item_collection
+        self.class.to_s.split('::').last.downcase.pluralize
+      end
+
+      def workspace_id
+        prefix_options[:workspace_id]
+      end
+
+      protected
+      
+      def build_new_resource(klass, attributes={})
+        super(klass, attributes).tap do |item|
+          item.prefix_options = luggage_params
+        end
+      end
+
+      def luggage_params
+        {
+          :workspace_id    => self.workspace_id,
+          :item_collection => self.item_collection,
+          :item_id         => self.id
+        }
+      end
+
+    end
+  end
+end

data/lib/liquidplanner/resources/leaf.rb

@@ -0,0 +1,22 @@
+#------------------------------------------------------------------------
+# leaves
+#------------------------------------------------------------------------
+
+module LiquidPlanner
+  module Resources
+    class Leaf < Item
+      include Priority
+      include Order
+
+      TRACK_TIME_KEYS = [ :work, :activity_id, :member_id, :low, :high, :is_done, :done_on, :work_performed_on, :comment ].freeze
+      def track_time( options={} )
+        options.assert_valid_keys( *TRACK_TIME_KEYS )
+        request_body = options.to_json
+        response = post(:track_time, {}, request_body)
+        load( self.class.format.decode( response.body ) )
+      end
+
+    end
+  end
+end
+

data/lib/liquidplanner/resources/link.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Link < Luggage
+    end
+  end
+end

data/lib/liquidplanner/resources/luggage.rb

@@ -0,0 +1,8 @@
+module LiquidPlanner
+  module Resources
+    class Luggage < LiquidPlanner::LiquidPlannerResource
+      self.prefix = "/api/workspaces/:workspace_id/:item_collection/:item_id/"
+    end
+  end
+end
+

data/lib/liquidplanner/resources/member.rb

@@ -0,0 +1,7 @@
+module LiquidPlanner
+  module Resources
+    class Member < LiquidPlanner::LiquidPlannerResource
+      self.prefix = "/api/workspaces/:workspace_id/"
+    end
+  end
+end

data/lib/liquidplanner/resources/milestone.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Milestone < Leaf
+    end
+  end
+end

data/lib/liquidplanner/resources/note.rb

@@ -0,0 +1,21 @@
+module LiquidPlanner
+  module Resources
+    class Note < Luggage
+
+      # an item has either 0 or 1 note; the "collection" is singular in name,
+      # and should be accessed as:
+      #
+      # /api/workspaces/:workspace_id/:items/:item_id/note <= without /ID.json suffix
+      #
+      self.collection_name = 'note'
+
+      def self.element_path(id, prefix_options = {}, query_options = nil)
+        path = super(id, prefix_options, query_options)
+        path.sub!( "/#{id}.#{format.extension}", "" )
+        path
+      end
+
+    end
+  end
+end
+

data/lib/liquidplanner/resources/order.rb

@@ -0,0 +1,13 @@
+module LiquidPlanner
+  # For resources that can be prioritized
+  module Order
+    include RelativeResource
+    def organize_before(item)
+      move_relative_to :organize, :before, item
+    end
+  
+    def organize_after(item)
+      move_relative_to :organize, :after, item
+    end
+  end
+end

data/lib/liquidplanner/resources/priority.rb

@@ -0,0 +1,13 @@
+module LiquidPlanner
+  # For resources that can be prioritized
+  module Priority
+    include RelativeResource
+    def prioritize_before(item)
+      move_relative_to :prioritize, :before, item
+    end
+  
+    def prioritize_after(item)
+      move_relative_to :prioritize, :after, item
+    end
+  end
+end

data/lib/liquidplanner/resources/project.rb

@@ -0,0 +1,7 @@
+module LiquidPlanner
+  module Resources
+    class Project < Item
+      include Order
+    end
+  end
+end

data/lib/liquidplanner/resources/relative_resource.rb

@@ -0,0 +1,12 @@
+module LiquidPlanner
+  module RelativeResource
+    def move_relative_to(tree, relative, other)
+      raise ArgumentError.new("tree must be prioritize or organize")  unless [:prioritize, :organize].include?(tree)
+      raise ArgumentError.new("relative must be before or after")     unless [:before, :after].include?(relative)
+      other_id = other.is_a?(LiquidPlanner::LiquidPlannerResource) ? other.id : other
+      
+      response = post("#{tree}_#{relative}", :other_id=>other_id)
+      load( self.class.format.decode( response.body ) )
+    end
+  end
+end

data/lib/liquidplanner/resources/snapshot.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Snapshot < Luggage
+    end
+  end
+end

data/lib/liquidplanner/resources/task.rb

@@ -0,0 +1,6 @@
+module LiquidPlanner
+  module Resources
+    class Task < Leaf
+    end
+  end
+end

data/lib/liquidplanner/resources/tasklist.rb

@@ -0,0 +1,7 @@
+module LiquidPlanner
+  module Resources
+    class Tasklist < Container
+      include Priority
+    end
+  end
+end

data/lib/liquidplanner/resources/workspace.rb

@@ -0,0 +1,34 @@
+module LiquidPlanner
+  module Resources
+    class Workspace < LiquidPlanner::LiquidPlannerResource
+
+      def members( scope=:all, options={} )
+        Member.find( scope, :params => { :workspace_id => self.id }.merge(options) )
+      end
+
+      def tasks( scope=:all, options={} )
+        Task.find( scope, :params => { :workspace_id => self.id }.merge(options) )
+      end
+
+      def folders( scope=:all, options={} )
+        Folder.find( scope, :params => { :workspace_id => self.id, :flat => true }.merge(options) )
+      end
+
+      def tasklists( scope=:all, options={} )
+        Tasklist.find( scope, :params => { :workspace_id => self.id, :flat => true }.merge(options) )
+      end
+            
+    protected
+      # create a new instance of klass (Task, Folder, etc.),
+      # with the workspace_id set as a prefix option
+      #
+      # workspace.build_new_resource( LiquidPlanner::Resources::Task, :name => "new task" ).save
+      #
+      def build_new_resource( klass, attributes={} )
+        super(klass, attributes).tap do |item|
+          item.prefix_options[:workspace_id] = self.id
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: liquidplanner
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brett Bender
+- Adam Sanderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: multipart-post
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :development
+  version_requirements: *id003
+description: LiquidPlanner API client, using ActiveResource
+email: api@liquidplanner.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- HISTORY
+- README.rdoc
+- Rakefile
+- examples/README
+- examples/create_task.rb
+- examples/list_tasks.rb
+- examples/support/helper.rb
+- examples/track_time.rb
+- lib/liquidplanner.rb
+- lib/liquidplanner/base.rb
+- lib/liquidplanner/debug.rb
+- lib/liquidplanner/ext/connection.rb
+- lib/liquidplanner/ext/exceptions.rb
+- lib/liquidplanner/ext/hash.rb
+- lib/liquidplanner/liquidplanner_resource.rb
+- lib/liquidplanner/resources/account.rb
+- lib/liquidplanner/resources/activity.rb
+- lib/liquidplanner/resources/client.rb
+- lib/liquidplanner/resources/comment.rb
+- lib/liquidplanner/resources/container.rb
+- lib/liquidplanner/resources/document.rb
+- lib/liquidplanner/resources/estimate.rb
+- lib/liquidplanner/resources/event.rb
+- lib/liquidplanner/resources/folder.rb
+- lib/liquidplanner/resources/item.rb
+- lib/liquidplanner/resources/leaf.rb
+- lib/liquidplanner/resources/link.rb
+- lib/liquidplanner/resources/luggage.rb
+- lib/liquidplanner/resources/member.rb
+- lib/liquidplanner/resources/milestone.rb
+- lib/liquidplanner/resources/note.rb
+- lib/liquidplanner/resources/order.rb
+- lib/liquidplanner/resources/priority.rb
+- lib/liquidplanner/resources/project.rb
+- lib/liquidplanner/resources/relative_resource.rb
+- lib/liquidplanner/resources/snapshot.rb
+- lib/liquidplanner/resources/task.rb
+- lib/liquidplanner/resources/tasklist.rb
+- lib/liquidplanner/resources/workspace.rb
+has_rdoc: true
+homepage: http://github.com/liquidplanner/liquidplanner
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: LiquidPlanner API client
+test_files: 
+- examples/create_task.rb
+- examples/list_tasks.rb
+- examples/support/helper.rb
+- examples/track_time.rb