davetron5000-gliffy 0.1.7 → 0.2.0

data/lib/gliffy.rb

@@ -1 +1,5 @@
 require 'gliffy/handle'
+
+# :include: ../README.rdoc
+module Gliffy
+end

data/lib/gliffy/credentials.rb

@@ -0,0 +1,78 @@
+require 'base64'
+require 'openssl'
+module Gliffy
+
+  # Encapsulates a request token, which is what Gliffy returns when
+  # you request a user's OAuth Token
+  class AccessToken
+    attr_reader :token
+    attr_reader :secret
+
+    # Create a new token
+    # [+token+] the token itself
+    # [+secret+] the token secret, used for signing requests
+    def initialize(token,secret)
+      raise ArgumentError.new('token is required') if token.nil?
+      raise ArgumentError.new('secret is required') if secret.nil?
+      @token = token
+      @secret = secret
+    end
+  end
+
+  # Encapsulates all the information needed to make a request of Gliffy
+  # outside of request-specific information.
+  class Credentials
+    attr_reader :consumer_key
+    attr_reader :consumer_secret
+    attr_reader :access_token
+    attr_reader :username
+    attr_reader :account_id
+    attr_reader :description
+    attr_reader :default_protocol
+
+    # Create a new Credentials object.
+    #
+    # [+consumer_key+] The OAuth consumer key given to you when you signed up
+    # [+consumer_secret+] The OAuth consumer secret given to you when you signed up
+    # [+description+] Description of the application you are writing
+    # [+account_id+] Your account id
+    # [+username+] the Gliffy user name/identifier
+    # [+access_token+] The access token you were given as a AccessToken, or nil if you don't have one yet.  
+    def initialize(consumer_key, consumer_secret, description, account_id, username, default_protocol=:http, access_token = nil)
+      raise ArgumentError.new("consumer_key required") if consumer_key.nil?
+      raise ArgumentError.new("consumer_secret required") if consumer_secret.nil?
+      raise ArgumentError.new("description required") if description.nil? || description.strip == ''
+      raise ArgumentError.new("account_id required") if account_id.nil?
+      raise ArgumentError.new("username required") if username.nil?
+
+      @consumer_key = consumer_key
+      @consumer_secret = consumer_secret
+      @username = username
+      @access_token = access_token
+      @description = description
+      @account_id = account_id
+      @default_protocol = default_protocol
+    end
+
+    def has_access_token?
+      !@access_token.nil?
+    end
+
+    # Update the access token
+    def update_access_token(token)
+      @access_token = token
+      @access_token
+    end
+
+    # Clear the access token if, for some reason, you know the one
+    # you have is bad.
+    def clear_access_token
+      update_access_token(nil)
+    end
+
+    # Return a nonce that hasn't been used before (at least not in this space/time continuum)
+    def nonce
+      Time.now.to_f.to_s
+    end
+  end
+end

data/lib/gliffy/handle.rb

@@ -1,368 +1,347 @@
-require 'gliffy/rest'
+require 'gliffy/request'
 require 'gliffy/response'
-require 'gliffy/user'
-require 'gliffy/diagram'
-require 'gliffy/folder'
-require 'gliffy/account'
-require 'gliffy/config'
+require 'gliffy/credentials'
 
 module Gliffy
   VERSION = '0.1.7'
 
-
   # A "handle" to access Gliffy on a per-user-session basis
   # Since most calls to gliffy require a user-token, this class
   # encapsulates that token and the calls made under it.
   #
-  # The methods here are designed to raise exceptions if there are problems from Gliffy.
-  # These problems usually indicate a programming error or a server-side problem with Gliffy and
-  # are generally unhandleable.  However, if you wish to do something better than simply raise an exception
-  # you may override handle_error to do something else
-  #
   class Handle
 
-    # Create a new handle to gliffy for the given user.  Tokens will be requested as needed
-    def initialize(username,token=nil)
-      @username = username
-      @rest = Rest.new
-      @logger = Logger.new(Config.config.log_device)
-      @logger.level = Config.config.log_level
-      if token
-        @rest.current_token = token
-      else
-        update_token(username)
+    # Get access to the logger (useful for controlling log messages)
+    attr_reader :logger
+    # Get access to the Request (useful for hacking or testing)
+    attr_reader :request
+    # Get access to the current token (useful for caching to disk)
+    attr_reader :token
+
+    # Use this to override what happens when an error from Gliffy is received.
+    # The default (or nil) is to raise the exception that was generated.
+    # If you want to override this provide a block that takes the response that was
+    # received (which will be a hash-like object from HTTParty, possibly nil) and
+    # the exception that was generated (the message of which will have been parsed
+    # from Gliffy's XML if that was possible):
+    #     
+    #     # If we got an HTTParty response, try to print out the body and the Gliffy message
+    #     # Otherwise, barf
+    #     handle.response = Proc.new do |response,exception|
+    #       if response && response.respond_to? :body
+    #         puts exception.to_str
+    #         puts response.body
+    #       else
+    #         raise exception
+    #       end
+    #     end
+    attr_writer :error_callback
+
+    # Create a new handle to Gliffy
+    # [+api_root+] root URL (without the protocol) of where to connect to Gliffy
+    # [+edit_api_root+] root URL (without the protocol) of where to connect to Gliffy for the edit link only
+    # [+credentials+] a Credentials object to use for access
+    # [+http+] override of http access class (use at your own risk; must be substituable for HTTPart)
+    # [+logger+] logger instance, if you don't want the default
+    def initialize(api_root,edit_api_root,credentials,http=nil,logger=nil)
+      @credentials = credentials
+      @request = Request.new(api_root,credentials)
+      @edit_link_request = Request.new(edit_api_root,credentials)
+      @request.http = http if !http.nil?
+      @logger = logger || Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+      @request.logger = @logger
+      if !@credentials.has_access_token?
+        update_token
       end
+      @error_callback = nil
     end
 
-    # Run an arbitrary rest call against gliffy, parsing the result.  This allows you
-    # essentially direct access to the underlying Gliffy::Rest, without having to worry about
-    # setting it up.
-    #
-    # [+method+] a rest method, :get, :put, :post, :delete
-    # [+url+] url to request, relative to Gliffy::Config#gliffy_root
-    # [+params+] hash of parameters
-    # [+headers+] hash of HTTP headers
-    #
-    # This will return a Gliffy::Response *if* the method you called returned XML.
-    # If that is not what you want, you should use Gliffy::Rest.
-    def rest_free(method,url,params={},headers={})
-      Response.from_xml(do_simple_rest(method,url,"rest_free",params,headers))
-    end
-
-    # Adds a new user explicitly.  
-    def add_user(username)
-      do_user(:put,username)
-    end
-
-    # Deletes the user from this account.  May not be the user who owns the token for this
-    # session (i.e. was passed to the constructor).  <b>This cannot be undone</b>.
-    def delete_user(username)
-      do_user(:delete,username)
+    # Updates the token being used if there isn't one in the 
+    # credentials, or by forcing
+    # [+force+] always attempt to update the token
+    def update_token(force=false)
+      if !@credentials.has_access_token? || force
+        @logger.debug("Requesting new token " + (force ? " by force " : " since we have none "))
+        response = @request.create(token_url,
+                                   :description => @credentials.description,
+                                   :protocol_override => :https)
+        @token = Response.from_http_response(response)
+        @credentials.update_access_token(@token)
+      end
     end
 
-    # Allows +username+ to access +folder_path+ and all its child folders
-    def add_user_to_folder(username,folder_path)
-      do_user_folder(:put,username,folder_path)
+    # Delete the current token
+    def delete_token
+      make_request(:delete,token_url)
+      @credentials.clear_access_token
     end
 
-    # Revokes +username+ access to +folder_path+
-    def remove_user_from_folder(username,folder_path)
-      do_user_folder(:delete,username,folder_path)
+    # Get admins of your account.  Returns users
+    def account_admins
+      make_request(:get,"#{account_url}/admins.xml")
     end
 
-    # Creates a new blank diagram (or based on an existing one)
-    #
-    # [+diagram_name+] the name of the new diagram
-    # [+template_diagram_id+] the id of a diagram to use as a template.  You must have access to this diagram
-    #
-    def create_diagram(diagram_name,template_diagram_id=nil)
-      params = Hash.new
-      params['diagramName'] = diagram_name
-      params['templateDiagramId'] = template_diagram_id if template_diagram_id
-      diagrams = do_simple_rest(:post,'diagrams',"Creating diagram named #{diagram_name}",params)
-      if diagrams.size >= 1
-        return diagrams[0]
+    # Returns all documents in the account
+    # [+show+] if nil, all documents are returned; if :public only public are returned.  
+    def account_documents(show=nil)
+      if show.nil?
+        make_request(:get,"#{account_url}/documents.xml")
       else
-        raise "Got no diagrams, but creation was successful."
+        make_request(:get,"#{account_url}/documents.xml",:public => show == :public)
       end
     end
 
-    # Creates a folder with the given name.  The parent path should already exist
-    def create_folder(folder_path)
-      do_folder(:put,folder_path)
+    # Returns all folders in the account
+    def account_folders
+      make_request(:get,"#{account_url}/folders.xml")
     end
 
-    # deletes the diagram with the given id.  <b>This cannot be undone</b>
-    def delete_diagram(diagram_id)
-      do_simple_rest(:delete,"diagrams/#{diagram_id}","Deleting diagram #{diagram_id}")
+    # Returns account meta data
+    # [+show_users+] if true, include the list of users in this account
+    def account_get(show_users=true)
+      make_request(:get,"#{account_url}.xml", :showUsers => show_users)[0]
     end
 
-    # Deletes a folder, moving all diagrams in it to the default folder. 
-    # The folder must be empty
-    # <b>This cannot be undone</b>
-    def delete_folder(folder_path)
-      folder_path = Folder.encode_path_elements(folder_path)
-      do_simple_rest(:delete,"folders/#{folder_path}","Deleting folder #{folder_path}")
+    # Get users in your account
+    def account_users 
+      make_request(:get,"#{account_url}/users.xml")
     end
 
-    # Returns an array of User objects representing the admins of the account
-    def get_admins
-      do_simple_rest(:get,'admins','Getting admins for account')
-    end
-
-    # Gets the diagram as an image, possibly saving it to a file.
-    #
-    # [+diagram_id+] the id of the diagram to get
-    # [+options+] a hash of options controlling the diagram and how it's fetched
-    #             [<tt>:size</tt>] one of :thumbnail, :small, :medium, or :large (default is :large)
-    #             [<tt>:file</tt>] if present, the diagram is written to the named file
-    #             [<tt>:mime_type</tt>] the mime type to retrie.  You can also use :jpeg, :png and :svg as shortcuts (default is :jpeg)
-    #             [<tt>:version</tt>] if present, the version number to retrieve (default is most recent)
+    # Create a new document
+    # [+name+] Name of the new document
+    # [+folder_path+] Path in which to place the document initially (nil to use default)
+    # [+template_id+] document id of a document to copy when initializing this new document (nil to make a blank one)
+    # [+type+] If Gliffy ever supports other document types, use this
     #
-    # returns the bytes of the diagram if file was nil, otherwise, returns true
-    #
-    def get_diagram_as_image(diagram_id,options={:mime_type => :jpeg})
-      params,headers = create_diagram_request_info(options)
-      update_token
-      extension = extension_for(options[:mime_type])
-      extension = ''
-      bytes = @rest.get(url("diagrams/#{diagram_id}#{extension}"),params,headers)
-      response = nil
-      begin
-        response = Response.from_xml(bytes)
-      rescue
-        response = nil
-      end
-
-      if response.respond_to?(:success?) && !response.success?
-        handle_error(response,"While getting bytes of diagram #{diagram_id}")
+    # Returns a document representing the document that was created.
+    def document_create(name,folder_path=nil,template_id=nil,type=:diagram)
+      params = { 
+        :documentName => name,
+        :documentType => type
+      }
+      params[:templateDiagramId] = template_id if !template_id.nil? 
+      params[:folderPath] = normalize_folder_path(folder_path) if !folder_path.nil? 
+      documents = make_request(:create,"#{account_url}/documents.xml",params)
+      return nil if documents.nil? 
+      documents[0]
+    end
+
+    # Delete an existing document
+    def document_delete(document_id)
+      make_request(:delete,document_url(document_id))
+    end
+
+    # Get meta-data about a document.
+    # [+document_id+] identifier of the document
+    # [+show_revisions+] if true, include info about the documents' revision history
+    def document_get_metadata(document_id,show_revisions=false)
+      make_request(:get,document_metadata_url(document_id),:showRevisions => show_revisions)[0]
+    end
+
+    # Get a document; returning the actual bytes
+    # [+document_id+] identifier of the document
+    # [+type+] document type.  Types known to work:
+    #          [+:jpeg+] - JPEG
+    #          [+:png+] - PNG
+    #          [+:svg+] - SVG (for Visio import)
+    #          [+:xml+] - Gliffy proprietary XML format (for archiving)
+    # [+size+] size to show, from biggest to smallest: :L, :M, :S, :T
+    # [+version+] The version to get, or nil to get the most recent
+    def document_get(document_id,type=:jpeg,size=:L,version=nil)
+      params = { :size => size }
+      params[:version] = version if !version.nil?
+      response = make_request(:get,document_url(document_id,type),params,false)
+      if (type == :xml) || (type == :svg)
+        response.body
       else
-        if options[:file]
-          fp = File.new(options[:file],'w')
-          fp.puts bytes
-          fp.close
-          true
-        else
-          bytes
-        end
+        response
       end
     end
 
-    # returns the URL that would get the diagram in question.  Same parameters as get_diagram_as_image
-    def get_diagram_as_url(diagram_id,options={:mime_type => :jpeg})
-      params,headers = create_diagram_request_info(options)
+    # Get a link to a document
+    # [+document_id+] identifier of the document
+    # [+type+] document type.  Types known to work:
+    #          [+:jpg+] - JPEG
+    #          [+:png+] - PNG
+    #          [+:svg+] - SVG (for Visio import)
+    #          [+:xml+] - Gliffy proprietary XML format (for archiving)
+    # [+size+] size to show, from biggest to smallest: :L, :M, :S, :T
+    # [+version+] The version to get, or nil to get the most recent
+    def document_get_url(document_id,type=:jpg,size=:L,version=nil)
+      params = { :size => size }
+      params[:version] = version if !version.nil?
+      make_request(:get,document_url(document_id,type),params,false,true)
+    end
+
+    # Get the link to edit a document
+    def document_edit_link(document_id,return_url,return_text='Return')
       update_token
-      extension = extension_for(options[:mime_type])
-      @rest.create_url(url("diagrams/#{diagram_id}#{extension}"),params)
-    end
-
-    def extension_for(mime_type)
-      case mime_type
-      when :jpeg
-        return ".jpg"
-      when :png
-        return ".png"
-      when :svg
-        return ".svg"
+      @edit_link_request.link_for(:GET,'',{ 
+        :launchDiagramId => document_id, 
+        :returnURL => return_url, 
+        :returnButtonText=> return_text})
+    end
+
+    # Move a document to a different folder
+    def document_move(document_id,new_path)
+      make_request(:move,folders_url(new_path) + "/documents/#{document_id}.xml")
+    end
+
+    # Update a document's meta-data or content
+    # [+document_id+] identifier of document to update
+    # [+options+] data to update; omission of an option will not change it
+    #             [+:name+] change the name
+    #             [+:public+] if false, will remove public statues, if true, will make public
+    #             [+:content+] if present, should be the gliffy XML content to update (don't use this unless it's crucial)
+    def document_update(document_id,options)
+      if (options[:content])
+        make_request(:update,document_url(document_id),{:content => options[:content]})
+      end
+      if (options[:name] || options[:public])
+        params = {}
+        params[:documentName] = options[:name] if options[:name]
+        params[:public] = options[:public] if options[:public]
+        make_request(:update,document_metadata_url(document_id),params)
       end
-      ""
     end
 
-    # Returns a Diagram with the diagram's meta data filled in.
-    def get_diagram_metadata(diagram_id)
-      params = {'diagramId' => diagram_id}
-      diagrams = do_simple_rest(:get,'diagrams',"Getting meta data for diagram #{diagram_id}",params)
-      diagrams[0]
+    # Add a user to a folder
+    def folder_add_user(path,username)
+      make_request(:update,folder_users_url(path,username),{:read => true, :write => true})
     end
 
-    # Gets a list of diagrams, either for the given folder, or the entire account
-    def get_diagrams(folder_path=nil)
-      folder_path = Folder.encode_path_elements(folder_path) if folder_path
-      url = (folder_path ? "folders/#{folder_path}/" : "") + "diagrams"
-      do_simple_rest(:get,url,"Get all diagrams in " + (folder_path ? folder_path : "account"))
+    # Create a new folder
+    # [+path+] the path to the folder, each path separated by a forward slash.  If this starts with a forward slash
+    #          it will attempt to make folder with the exact given path. This will probably fail.  If this DOESN'T
+    #          start with a slash, this will make the folder inside ROOT, which is what you want.  So, don't
+    #          start this with a slash.
+    def folder_create(path)
+      make_request(:create,"#{folders_url(path)}.xml")
     end
 
-    # Gets the link that can be used <b>by this user while his token is valid</b> to edit the diagram.
-    #
-    # [+diagram_id+] the id of the diagram to edit
-    # [+return_url+] if present represents the URL to return the user to after they have completed their editing.  You should not urlencode this, it will be done for you
-    # [+return_text+] the text that should be used in Gliffy to represent the "return to the application" button.
-    #
-    # returns a Gliffy::LaunchLink that contains the complete URL to be used to edit the given diagram and behave as described.  The GliffyLaunchLink also contains the diagram name, which can be used for linking.  Note that the url is relative to the Gliffy website
-    def get_edit_diagram_link(diagram_id,return_url=nil,return_text=nil)
-      params = Hash.new
-      params['returnURL'] = CGI::escape(return_url) if return_url
-      params['returnText'] = CGI::escape(return_text) if return_text
-
-      do_simple_rest(:get,"diagrams/#{diagram_id}/launchLink","Getting launch link for diagram #{diagram_id}",params)
+    # Delete a folder
+    # [+path+] the path to the folder.  See folder_create.
+    def folder_delete(path)
+      make_request(:delete,"#{folders_url(path)}.xml")
     end
 
-    # array getFolders ()
-    def get_folders()
-      do_simple_rest(:get,'folders','Getting folders for account')
+    # Get the documents in a folder
+    # [+path+] the path to the folder whose documents to get
+    def folder_documents(path)
+      make_request(:get,"#{folders_url(path)}/documents.xml")
     end
 
-    # Gets the folders that +username+ has access to, in nested form
-    def get_user_folders(username)
-      do_simple_rest(:get,"users/#{username}/folders","Getting folders for user #{username}")
+    # Get users with access to the folder
+    # [+path+] the path to the folder whose users to get
+    def folder_users(path)
+      make_request(:get,"#{folders_url(path)}/users.xml")
     end
 
-    # Gets the users in the given folder, or in the entire account
-    #
-    # [+folder_path+] if present, returns users with access to this folder
-    def get_users(folder_path=nil)
-      url = ''
-      if (folder_path)
-        folder_path = Folder.encode_path_elements(folder_path)
-        url += "folders/#{folder_path}/"
-      end
-      url += 'users'
-      do_simple_rest(:get,url,"Getting users for " + (folder_path ? "folder #{folder_path}" : 'account'))
+    # Remove a user from access to the folder
+    def folder_remove_user(path,username)
+      make_request(:update,folder_users_url(path,username),{:read => false, :write => false})
     end
 
-    # returns the user token if it exists
-    def current_token()
-      @rest.current_token
+    # Create a new user
+    # [+username+] the name to give this user
+    def user_create(username)
+      make_request(:create,"#{account_url}/users.xml",{ :userName => username })
     end
 
-    # move diagram +diagram_id+ to folder path +folder_path+
-    def move_diagram(diagram_id,folder_path)
-      folder_path = Folder.encode_path_elements(folder_path)
-      do_simple_rest(:put,"folders/#{folder_path}/diagrams/#{diagram_id}","Moving #{diagram_id} to folder #{folder_path}")
+    # Delete an existing user
+    def user_delete(username)
+      make_request(:delete,"#{user_url(username)}.xml")
     end
 
-    # Updates the user.
-    #
-    # [+username+] user to update
-    # [+attributes+] has of attributes to change.
-    #                [<tt>:email</tt>] email address
-    #                [<tt>:password</tt>] password for logging into Gliffy Online
-    #                [<tt>:admin</tt>] true to make them an admin, false to revoke their admin-ness
-    # 
-    def update_user(username,attributes)
-      params = Hash.new
-      params['admin'] = attributes[:admin].to_s if attributes.has_key? :admin
-      params['email'] = attributes[:email] if attributes[:email]
-      params['password'] = attributes[:password] if attributes[:password]
-      do_simple_rest(:put,"users/#{username}","Updating #{username}",params)
-    end
-
-    # Updates the user's token, if he needs it
-    #
-    #   [+force+] if true, the token is updated regardless
-    def update_token(force=false)
-      if force || !@rest.current_token || @rest.current_token.expired?
-        @logger.debug('Forcing a new token') if force
-        @logger.debug('No current token') if !@rest.current_token
-        @rest.current_token = nil
-        token = Response.from_xml(@rest.get(url("users/#{@username}/token")))
-        if (token.success?)
-          @logger.info("User #{@username} assigned token #{token.token} from Gliffy")
-          @rest.current_token = token
-        else
-          handle_error(token)
-        end
-      else
-        @logger.debug('Not getting a new token')
-      end
+    # Get the documents a user has access to (this is potentially expensive, as it results
+    # in multiple calls to gliffy)
+    # [username] if provided, get documents for the given username, otherwise get them for the logged-in user
+    def user_documents(username='$username')
+      return user_documents_helper(username,user_folders(username))
     end
 
-    # Override this if you want error handling that doesn't rasie an exception
-    #
-    # [+error_response+] an Error object that holds the error from Gliffy
-    # [+action_cause+] a string describing the action being taken when the error ocurred
-    def handle_error(error_response,action_cause=nil)
-      msg = ""
-      msg += "While #{action_cause}: " if action_cause
-      msg += error_response.to_s
-      raise msg
+    # Get the folders a user has access to
+    # [username] if provided, get folders for the given username, otherwise get them for the logged-in user
+    def user_folders(username='$username')
+      make_request(:get,"#{user_url(username)}/folders.xml")
     end
 
-    private
-
-    def do_user(method,username)
-      do_simple_rest(method,"users/#{username}","#{rest_to_text(method)} user #{username}")
+    # Update a user's meta-data
+    # [+username+] the username to operate on
+    # [+options+] the options for updating their info.  Any omitted option will not change that value on the server.
+    #             [+:email+] sets their email address
+    #             [+:password+] sets their password for logging into gliffy.com
+    #             [+:admin+] if true, sets them to be an admin; if false, revokes their admin privs
+    def user_update(username,options)
+      make_request(:update,user_url(username),options)
     end
 
-    def do_folder(method,folder_path)
-      folder_path = Folder.encode_path_elements(folder_path)
-      do_simple_rest(method,"folders/#{folder_path}","#{rest_to_text(method)} folder #{folder_path}")
+    def anything(method,url,params={},parse=false,link=false)
+      make_request(method,url,params,parse,link)
     end
 
-    def do_user_folder(method,username,folder_path)
-      folder_path = Folder.encode_path_elements(folder_path)
-      do_simple_rest(method,"folders/#{folder_path}/users/#{username}","#{rest_to_text(method)} #{username} to #{folder_path}")
+    private 
+
+    def account_url; 'accounts/$account_id'; end
+    def user_url(username='$username'); "#{account_url}/users/#{username}"; end
+    def token_url; "#{user_url}/oauth_token.xml"; end
+    def document_url(id,type=:xml); "#{account_url}/documents/#{id}.#{type.to_s}"; end
+    def document_metadata_url(id); "#{account_url}/documents/#{id}/meta-data.xml"; end
+    def folders_url(path=''); 
+      path = normalize_folder_path(path)
+      "#{account_url}/folders/#{path}"; 
+    end
+    def folder_users_url(path,username)
+      folders_url(path) + "/users/#{username}.xml"
     end
 
-    def create_diagram_request_info(options)
-      mime_type = options[:mime_type]
-      params = Hash.new
-      params['size'] = size_to_param(options[:size]) if options[:size]
-      params['version'] = options[:version] if options[:version]
-      headers = Hash.new
-      if mime_type.is_a? Symbol
-        headers['Accept'] = mime_type_to_header(mime_type)
-      else
-        headers['Accept'] = mime_type
+    def user_documents_helper(username,folders)
+      documents = []
+      return documents if folders.nil?
+      folders.each do |one_folder|
+        docs = folder_documents(one_folder.path)
+        if docs
+          docs.each do |doc|
+            documents << doc
+          end
+        end
+        rest = user_documents_helper(username,one_folder.child_folders)
+        rest.each { |d| documents << d} if rest
       end
-      [params,headers]
+      return documents
     end
 
-    def do_simple_rest_helper(method,url_fragment,description,params=nil,headers={},first=false)
+    # Handles the mechanics of making the request
+    # [+method+] the gliffy "action"
+    # [+url+] the url, relative to the gliffy API root, no params/query string stuff
+    # [+params+] hash of parameters
+    # [+parse+] if true, request is parsed; set to false to get the raw result back
+    # [+link_only+] don't make a request just send the full link (useful for <img> tags)
+    def make_request(method,url,params=nil,parse=true,link_only=false)
       update_token
-      response = Response.from_xml(@rest.send(method,url(url_fragment),params,headers))
-      if !response.success?
-        if first
-          @logger.warn("Possible token problem, try again after updating token")
-          update_token true
-          response = do_simple_rest_helper(method,url_fragment,description,params,headers,false)
+      if link_only
+        @request.link_for(method,url,params)
+      else
+        @logger.debug("Requesting #{url} with {#params.inspect}")
+        response = @request.send(method,url,params)
+        @logger.debug("Got back #{response.body}")
+        if parse
+          Response.from_http_response(response,@error_callback)
         else
-          handle_error(response,description)
+          response
         end
       end
-      response
-    end
-
-    def do_simple_rest(method,url_fragment,description,params=nil,headers={})
-      do_simple_rest_helper(method,url_fragment,description,params,headers,true)
-    end
-    
-
-    def url(fragment)
-      "/accounts/#{Config.config.account_name}/#{fragment}"
-    end
-
-    def mime_type_to_header(mime_type_symbol)
-      case mime_type_symbol
-      when :jpeg: 'image/jpeg'
-      when :jpg: 'image/jpg'
-      when :png: 'image/png'
-      when :svg: 'image/svg+xml'
-      else raise "#{mime_type_symbol} is not a known mime type"
-      end
-    end
-    def size_to_param(size)
-      return nil if !size
-      case size 
-      when :thumbnail: 'T'
-      when :small: 'S'
-      when :medium: 'M'
-      when :large: 'L'
-      else raise "#{size} is not a supported size"
-      end
     end
 
-    def rest_to_text(method)
-      case method
-      when :put : 'Creating'
-      when :delete : 'Deleting'
-      when :post : 'Updating'
-      when :get : 'Getting'
-      else
-        raise "Unknown method #{method.to_s}"
+    ROOT_FOLDER = 'ROOT'
+    # Prepends the path with "ROOT" if the path doesn't start with a slash
+    def normalize_folder_path(path)
+      return '' if path.nil? || path == ''
+      if !(path =~ /^\//) && !(path =~ /^#{ROOT_FOLDER}$/) && !(path =~ /^#{ROOT_FOLDER}\//)
+        path = "#{ROOT_FOLDER}/" + path 
       end
+      path
     end
-
-
   end
 end